Replace deprecated org.eclipse.jface.text.rules.DefaultPartitioner with org.eclipse...
[phpeclipse.git] / net.sourceforge.phpeclipse.ui / src / net / sourceforge / phpeclipse / phpeditor / php / PHPAutoIndentStrategy.java
1 /**********************************************************************
2  Copyright (c) 2000, 2002 IBM Corp. and others.
3  All rights reserved. This program and the accompanying materials
4  are made available under the terms of the Common Public License v1.0
5  which accompanies this distribution, and is available at
6  http://www.eclipse.org/legal/cpl-v10.html
7
8  Contributors:
9  IBM Corporation - Initial implementation
10  www.phpeclipse.de
11  **********************************************************************/
12 package net.sourceforge.phpeclipse.phpeditor.php;
13
14 import org.eclipse.jface.text.BadLocationException;
15 import org.eclipse.jface.text.DefaultIndentLineAutoEditStrategy;
16 import org.eclipse.jface.text.DocumentCommand;
17 import org.eclipse.jface.text.IDocument;
18
19 /**
20  * Auto indent strategy sensitive to brackets.
21  */
22 public class PHPAutoIndentStrategy extends DefaultIndentLineAutoEditStrategy {
23
24         public PHPAutoIndentStrategy() {
25         }
26
27         /*
28          * (non-Javadoc) Method declared on IAutoIndentStrategy
29          */
30         public void customizeDocumentCommand(IDocument d, DocumentCommand c) {
31                 if (c.length == 0 && c.text != null && endsWithDelimiter(d, c.text))
32                         smartIndentAfterNewLine(d, c);
33                 else if ("}".equals(c.text)) {
34                         smartInsertAfterBracket(d, c);
35                 }
36         }
37
38         /**
39          * Returns whether or not the text ends with one of the given search
40          * strings.
41          */
42         private boolean endsWithDelimiter(IDocument d, String txt) {
43
44                 String[] delimiters = d.getLegalLineDelimiters();
45
46                 for (int i = 0; i < delimiters.length; i++) {
47                         if (txt.endsWith(delimiters[i]))
48                                 return true;
49                 }
50
51                 return false;
52         }
53
54         /**
55          * Returns the line number of the next bracket after end.
56          * 
57          * @returns the line number of the next matching bracket after end
58          * @param document -
59          *            the document being parsed
60          * @param line -
61          *            the line to start searching back from
62          * @param end -
63          *            the end position to search back from
64          * @param closingBracketIncrease -
65          *            the number of brackets to skip
66          */
67         protected int findMatchingOpenBracket(IDocument document, int line,
68                         int end, int closingBracketIncrease) throws BadLocationException {
69
70                 int start = document.getLineOffset(line);
71                 int brackcount = getBracketCount(document, start, end, false)
72                                 - closingBracketIncrease;
73
74                 // sum up the brackets counts of each line (closing brackets count
75                 // negative,
76                 // opening positive) until we find a line the brings the count to zero
77                 while (brackcount < 0) {
78                         line--;
79                         if (line < 0) {
80                                 return -1;
81                         }
82                         start = document.getLineOffset(line);
83                         end = start + document.getLineLength(line) - 1;
84                         brackcount += getBracketCount(document, start, end, false);
85                 }
86                 return line;
87         }
88
89         /**
90          * Returns the bracket value of a section of text. Closing brackets have a
91          * value of -1 and open brackets have a value of 1.
92          * 
93          * @returns the line number of the next matching bracket after end
94          * @param document -
95          *            the document being parsed
96          * @param start -
97          *            the start position for the search
98          * @param end -
99          *            the end position for the search
100          * @param ignoreCloseBrackets -
101          *            whether or not to ignore closing brackets in the count
102          */
103         private int getBracketCount(IDocument document, int start, int end,
104                         boolean ignoreCloseBrackets) throws BadLocationException {
105
106                 int begin = start;
107                 int bracketcount = 0;
108                 while (begin < end) {
109                         char curr = document.getChar(begin);
110                         begin++;
111                         switch (curr) {
112                         case '/':
113                                 if (begin < end) {
114                                         char next = document.getChar(begin);
115                                         if (next == '*') {
116                                                 // a comment starts, advance to the comment end
117                                                 begin = getCommentEnd(document, begin + 1, end);
118                                         } else if (next == '/') {
119                                                 // '//'-comment: nothing to do anymore on this line
120                                                 begin = end;
121                                         }
122                                 }
123                                 break;
124                         case '*':
125                                 if (begin < end) {
126                                         char next = document.getChar(begin);
127                                         if (next == '/') {
128                                                 // we have been in a comment: forget what we read before
129                                                 bracketcount = 0;
130                                                 begin++;
131                                         }
132                                 }
133                                 break;
134                         case '{':
135                                 bracketcount++;
136                                 ignoreCloseBrackets = false;
137                                 break;
138                         case '}':
139                                 if (!ignoreCloseBrackets) {
140                                         bracketcount--;
141                                 }
142                                 break;
143                         case '"':
144                         case '\'':
145                                 begin = getStringEnd(document, begin, end, curr);
146                                 break;
147                         default:
148                         }
149                 }
150                 return bracketcount;
151         }
152
153         /**
154          * Returns the end position a comment starting at pos.
155          * 
156          * @returns the end position a comment starting at pos
157          * @param document -
158          *            the document being parsed
159          * @param position -
160          *            the start position for the search
161          * @param end -
162          *            the end position for the search
163          */
164         private int getCommentEnd(IDocument document, int position, int end)
165                         throws BadLocationException {
166                 int currentPosition = position;
167                 while (currentPosition < end) {
168                         char curr = document.getChar(currentPosition);
169                         currentPosition++;
170                         if (curr == '*') {
171                                 if (currentPosition < end
172                                                 && document.getChar(currentPosition) == '/') {
173                                         return currentPosition + 1;
174                                 }
175                         }
176                 }
177                 return end;
178         }
179
180         /**
181          * Returns the String at line with the leading whitespace removed.
182          * 
183          * @returns the String at line with the leading whitespace removed.
184          * @param document -
185          *            the document being parsed
186          * @param line -
187          *            the line being searched
188          */
189         protected String getIndentOfLine(IDocument document, int line)
190                         throws BadLocationException {
191                 if (line > -1) {
192                         int start = document.getLineOffset(line);
193                         int end = start + document.getLineLength(line) - 1;
194                         int whiteend = findEndOfWhiteSpace(document, start, end);
195                         return document.get(start, whiteend - start);
196                 } else {
197                         return ""; //$NON-NLS-1$
198                 }
199         }
200
201         /**
202          * Returns the position of the character in the document after position.
203          * 
204          * @returns the next location of character.
205          * @param document -
206          *            the document being parsed
207          * @param position -
208          *            the position to start searching from
209          * @param end -
210          *            the end of the document
211          * @param character -
212          *            the character you are trying to match
213          */
214         private int getStringEnd(IDocument document, int position, int end,
215                         char character) throws BadLocationException {
216                 int currentPosition = position;
217                 while (currentPosition < end) {
218                         char currentCharacter = document.getChar(currentPosition);
219                         currentPosition++;
220                         if (currentCharacter == '\\') {
221                                 // ignore escaped characters
222                                 currentPosition++;
223                         } else if (currentCharacter == character) {
224                                 return currentPosition;
225                         }
226                 }
227                 return end;
228         }
229
230         /**
231          * Set the indent of a new line based on the command provided in the
232          * supplied document.
233          * 
234          * @param document -
235          *            the document being parsed
236          * @param command -
237          *            the command being performed
238          */
239         protected void smartIndentAfterNewLine(IDocument document,
240                         DocumentCommand command) {
241
242                 int docLength = document.getLength();
243                 if (command.offset == -1 || docLength == 0)
244                         return;
245
246                 try {
247                         int p = (command.offset == docLength ? command.offset - 1
248                                         : command.offset);
249                         int line = document.getLineOfOffset(p);
250
251                         StringBuffer buf = new StringBuffer(command.text);
252                         if (command.offset < docLength
253                                         && document.getChar(command.offset) == '}') {
254                                 int indLine = findMatchingOpenBracket(document, line,
255                                                 command.offset, 0);
256                                 if (indLine == -1) {
257                                         indLine = line;
258                                 }
259                                 buf.append(getIndentOfLine(document, indLine));
260                         } else {
261                                 int start = document.getLineOffset(line);
262                                 int whiteend = findEndOfWhiteSpace(document, start,
263                                                 command.offset);
264                                 int offset = -1;
265                                 // if (command.offset > 0 && command.offset < docLength &&
266                                 // document.getChar(command.offset-1) == '{') {
267                                 // offset = command.offset;
268                                 // }
269                                 buf.append(document.get(start, whiteend - start));
270                                 if (getBracketCount(document, start, command.offset, true) > 0) {
271                                         buf.append('\t');
272                                 }
273                                 // if (offset >= 0) {
274                                 // buf.append('}');
275                                 // }
276                         }
277                         command.text = buf.toString();
278
279                 } catch (BadLocationException excp) {
280                         System.out.println(PHPEditorMessages
281                                         .getString("AutoIndent.error.bad_location_1")); //$NON-NLS-1$
282                 }
283         }
284
285         /**
286          * Set the indent of a bracket based on the command provided in the supplied
287          * document.
288          * 
289          * @param document -
290          *            the document being parsed
291          * @param command -
292          *            the command being performed
293          */
294         protected void smartInsertAfterBracket(IDocument document,
295                         DocumentCommand command) {
296                 if (command.offset == -1 || document.getLength() == 0)
297                         return;
298
299                 try {
300                         int p = (command.offset == document.getLength() ? command.offset - 1
301                                         : command.offset);
302                         int line = document.getLineOfOffset(p);
303                         int start = document.getLineOffset(line);
304                         int whiteend = findEndOfWhiteSpace(document, start, command.offset);
305
306                         // shift only when line does not contain any text up to the closing
307                         // bracket
308                         if (whiteend == command.offset) {
309                                 // evaluate the line with the opening bracket that matches out
310                                 // closing bracket
311                                 int indLine = findMatchingOpenBracket(document, line,
312                                                 command.offset, 1);
313                                 if (indLine != -1 && indLine != line) {
314                                         // take the indent of the found line
315                                         StringBuffer replaceText = new StringBuffer(
316                                                         getIndentOfLine(document, indLine));
317                                         // add the rest of the current line including the just added
318                                         // close bracket
319                                         replaceText.append(document.get(whiteend, command.offset
320                                                         - whiteend));
321                                         replaceText.append(command.text);
322                                         // modify document command
323                                         command.length = command.offset - start;
324                                         command.offset = start;
325                                         command.text = replaceText.toString();
326                                 }
327                         }
328                 } catch (BadLocationException excp) {
329                         System.out.println(PHPEditorMessages
330                                         .getString("AutoIndent.error.bad_location_2")); //$NON-NLS-1$
331                 }
332         }
333 }