1) Added setting of syntax properties to italic, underline and strike through.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / ui / text / JavaTextTools.java
1 package net.sourceforge.phpdt.ui.text;
2
3 /*
4  * (c) Copyright IBM Corp. 2000, 2001.
5  * All Rights Reserved.
6  */
7
8 import net.sourceforge.phpdt.internal.ui.text.FastJavaPartitionScanner;
9 import net.sourceforge.phpdt.internal.ui.text.IPHPPartitions;
10 import net.sourceforge.phpdt.internal.ui.text.JavaColorManager;
11 import net.sourceforge.phpdt.internal.ui.text.phpdoc.PHPDocCodeScanner;
12 import net.sourceforge.phpeclipse.IPreferenceConstants;
13 import net.sourceforge.phpeclipse.phpeditor.php.HTMLPartitionScanner;
14 import net.sourceforge.phpeclipse.phpeditor.php.PHPCodeScanner;
15 import net.sourceforge.phpeclipse.phpeditor.php.PHPDocumentPartitioner;
16 import net.sourceforge.phpeclipse.phpeditor.php.PHPPartitionScanner;
17 import net.sourceforge.phpeclipse.phpeditor.php.SmartyCodeScanner;
18 import net.sourceforge.phpeclipse.phpeditor.php.SmartyDocCodeScanner;
19 import net.sourceforge.phpeclipse.xml.ui.XMLPlugin;
20 import net.sourceforge.phpeclipse.xml.ui.text.XMLTextTools;
21
22 import org.eclipse.core.runtime.Preferences;
23 import org.eclipse.jface.preference.IPreferenceStore;
24 import org.eclipse.jface.text.IDocument;
25 import org.eclipse.jface.text.IDocumentExtension3;
26 import org.eclipse.jface.text.IDocumentPartitioner;
27 //import org.eclipse.jface.text.rules.DefaultPartitioner;
28 import org.eclipse.jface.text.rules.FastPartitioner;
29 //import org.eclipse.jface.text.rules.RuleBasedScanner;
30 import org.eclipse.jface.util.IPropertyChangeListener;
31 import org.eclipse.jface.util.PropertyChangeEvent;
32
33 //
34 // import org.phpeclipse.phpdt.internal.ui.text.FastJavaPartitionScanner;
35 // import org.phpeclipse.phpdt.internal.ui.text.JavaColorManager;
36 // import org.phpeclipse.phpdt.internal.ui.text.JavaPartitionScanner;
37 // import org.phpeclipse.phpdt.internal.ui.text.SingleTokenJavaScanner;
38 // import org.phpeclipse.phpdt.internal.ui.text.php.JavaCodeScanner;
39 // import org.phpeclipse.phpdt.internal.ui.text.phpdoc.JavaDocScanner;
40
41 /**
42  * Tools required to configure a Java text viewer. The color manager and all
43  * scanner exist only one time, i.e. the same instances are returned to all
44  * clients. Thus, clients share those tools.
45  * <p>
46  * This class may be instantiated; it is not intended to be subclassed.
47  * </p>
48  */
49 public class JavaTextTools implements IPHPPartitions {
50         // private static final String[] TOKENS = {
51         // JSPScriptScanner.JSP_DEFAULT,
52         // JSPScriptScanner.JSP_BRACKET };
53         private final static String[] LEGAL_CONTENT_TYPES = new String[] {
54                         PHP_PHPDOC_COMMENT, 
55                         PHP_MULTILINE_COMMENT, 
56                         PHP_SINGLELINE_COMMENT,
57                         PHP_STRING_DQ, 
58                         PHP_STRING_SQ, 
59                         PHP_STRING_HEREDOC };
60
61         // private static XMLPartitionScanner HTML_PARTITION_SCANNER = null;
62
63         // private static FastJavaPartitionScanner PHP_PARTITION_SCANNER = null;
64
65         private static HTMLPartitionScanner SMARTY_PARTITION_SCANNER = null;
66
67         // private static XMLPartitionScanner XML_PARTITION_SCANNER = null;
68
69         // private final static String[] TYPES= new String[] {
70         // PHPPartitionScanner.PHP, PHPPartitionScanner.JAVA_DOC,
71         // PHPPartitionScanner.JAVA_MULTILINE_COMMENT };
72         // private final static String[] TYPES = new String[] {
73         // IPHPPartitions.PHP_PARTITIONING,
74         // IPHPPartitions.PHP_PHPDOC_COMMENT,
75         // // IPHPPartitions.HTML,
76         // // IPHPPartitions.HTML_MULTILINE_COMMENT,
77         // IPHPPartitions.JAVASCRIPT,
78         // IPHPPartitions.CSS,
79         // IPHPPartitions.SMARTY,
80         // IPHPPartitions.SMARTY_MULTILINE_COMMENT };
81
82         /**
83          * This tools' preference listener.
84          */
85         private class PreferenceListener implements IPropertyChangeListener,
86                         Preferences.IPropertyChangeListener {
87                 public void propertyChange(PropertyChangeEvent event) {
88                         adaptToPreferenceChange(event);
89                 }
90
91                 public void propertyChange(Preferences.PropertyChangeEvent event) {
92                         adaptToPreferenceChange(new PropertyChangeEvent(event.getSource(),
93                                         event.getProperty(), event.getOldValue(), event
94                                                         .getNewValue()));
95                 }
96         };
97
98         // /** The color manager */
99         private JavaColorManager colorManager;
100
101         /** The PHP source code scanner */
102         private PHPCodeScanner fCodeScanner;
103
104         /** The PHP multiline comment scanner */
105         private SingleTokenPHPScanner fMultilineCommentScanner;
106
107         /** The Java singleline comment scanner */
108         private SingleTokenPHPScanner fSinglelineCommentScanner;
109
110         /** The PHP double quoted string scanner */
111         // private SingleTokenPHPScanner fStringDQScanner;
112         /** The PHP single quoted string scanner */
113         // private SingleTokenPHPScanner fStringSQScanner;
114         /** The PHPDoc scanner */
115         private PHPDocCodeScanner fPHPDocScanner;
116
117         /** The HTML scanner */
118         // private HTMLCodeScanner fHTMLScanner;
119         /** The Smarty scanner */
120         private SmartyCodeScanner fSmartyScanner;
121
122         /** The SmartyDoc scanner */
123         private SmartyDocCodeScanner fSmartyDocScanner;
124
125         /** The Java partitions scanner. */
126         private FastJavaPartitionScanner fPartitionScanner;
127
128         /** The preference store */
129         private IPreferenceStore fPreferenceStore;
130
131         /** The XML Language text tools */
132         private XMLTextTools xmlTextTools;
133
134         /**
135          * The core preference store.
136          * 
137          * @since 2.1
138          */
139         private Preferences fCorePreferenceStore;
140
141         /** The preference change listener */
142         private PreferenceListener fPreferenceListener = new PreferenceListener();
143
144         /** The JSP partitions scanner */
145         private PHPPartitionScanner jspPartitionScanner = null;
146
147         /** The JSP script subpartitions scanner */
148         // private JSPScriptScanner jspScriptScanner;
149         /** The PHP plain text scanner */
150         // private RuleBasedScanner jspTextScanner;
151         /** The PHP brackets scanner */
152         // private RuleBasedScanner jspBracketScanner;
153         /**
154          * Creates a new Java text tools collection.
155          * 
156          * @param store
157          *            the preference store to initialize the text tools. The text
158          *            tool instance installs a listener on the passed preference
159          *            store to adapt itself to changes in the preference store. In
160          *            general <code>PreferenceConstants.
161          *                      getPreferenceStore()</code>
162          *            should be used to initialize the text tools.
163          * @param coreStore
164          *            optional preference store to initialize the text tools. The
165          *            text tool instance installs a listener on the passed
166          *            preference store to adapt itself to changes in the preference
167          *            store.
168          * @see net.sourceforge.phpdt.ui.PreferenceConstants#getPreferenceStore()
169          * @since 2.1
170          */
171         public JavaTextTools(IPreferenceStore store, Preferences coreStore) {
172                 this(store, coreStore, true);
173         }
174
175         /**
176          * Creates a new Java text tools collection.
177          * 
178          * @param store
179          *            the preference store to initialize the text tools. The text
180          *            tool instance installs a listener on the passed preference
181          *            store to adapt itself to changes in the preference store. In
182          *            general <code>PreferenceConstants.
183          *                      getPreferenceStore()</code>
184          *            shoould be used to initialize the text tools.
185          * @param coreStore
186          *            optional preference store to initialize the text tools. The
187          *            text tool instance installs a listener on the passed
188          *            preference store to adapt itself to changes in the preference
189          *            store.
190          * @param autoDisposeOnDisplayDispose
191          *            if <code>true</code> the color manager automatically
192          *            disposes all managed colors when the current display gets
193          *            disposed and all calls to
194          *            {@link org.eclipse.jface.text.source.ISharedTextColors#dispose()}are
195          *            ignored.
196          * @see net.sourceforge.phpdt.ui.PreferenceConstants#getPreferenceStore()
197          * @since 2.1
198          */
199         public JavaTextTools(IPreferenceStore store, Preferences coreStore,
200                         boolean autoDisposeOnDisplayDispose) {
201                 // super(store, TOKENS, );
202                 // REVISIT: preference store
203                 xmlTextTools = new XMLTextTools(XMLPlugin.getDefault()
204                                 .getPreferenceStore());
205
206                 colorManager = new JavaColorManager(autoDisposeOnDisplayDispose);
207                 fPreferenceStore = store;
208                 fPreferenceStore.addPropertyChangeListener(fPreferenceListener);
209
210                 fCorePreferenceStore = coreStore;
211                 if (fCorePreferenceStore != null)
212                         fCorePreferenceStore.addPropertyChangeListener(fPreferenceListener);
213
214                 fCodeScanner = new PHPCodeScanner((JavaColorManager) colorManager,
215                                 store);
216                 fMultilineCommentScanner = new SingleTokenPHPScanner(
217                                 (JavaColorManager) colorManager, store,
218                                 IPreferenceConstants.PHP_MULTILINE_COMMENT);
219                 fSinglelineCommentScanner = new SingleTokenPHPScanner(
220                                 (JavaColorManager) colorManager, store,
221                                 IPreferenceConstants.PHP_SINGLELINE_COMMENT);
222                 // fStringDQScanner = new SingleTokenPHPScanner((JavaColorManager)
223                 // colorManager, store, IPreferenceConstants.PHP_STRING);
224                 // fStringSQScanner = new SingleTokenPHPScanner((JavaColorManager)
225                 // colorManager, store, IPreferenceConstants.PHP_STRING);
226
227                 fPHPDocScanner = new PHPDocCodeScanner((JavaColorManager) colorManager,
228                                 store);
229                 // fHTMLScanner = new HTMLCodeScanner((JavaColorManager)fColorManager,
230                 // store);
231                 fSmartyScanner = new SmartyCodeScanner((JavaColorManager) colorManager,
232                                 store);
233                 fSmartyDocScanner = new SmartyDocCodeScanner(
234                                 (JavaColorManager) colorManager, store);
235
236                 fPartitionScanner = new FastJavaPartitionScanner();
237
238                 // jspScriptScanner = new JSPScriptScanner();
239                 // fPartitionScanner = new FastJavaPartitionScanner();
240                 // fPartitionScanner = new PHPPartitionScanner();
241
242                 // jspBracketScanner = new RuleBasedScanner();
243                 // jspBracketScanner.setDefaultReturnToken(new
244                 // Token(JSPScriptScanner.JSP_BRACKET));
245                 // jspTextScanner = new RuleBasedScanner();
246                 // jspTextScanner.setDefaultReturnToken(new
247                 // Token(JSPScriptScanner.JSP_DEFAULT));
248         }
249
250         /**
251          * 
252          */
253         public XMLTextTools getXMLTextTools() {
254                 return xmlTextTools;
255         }
256
257         /**
258          * Disposes all the individual tools of this tools collection.
259          */
260         public void dispose() {
261
262                 fCodeScanner = null;
263                 fMultilineCommentScanner = null;
264                 fSinglelineCommentScanner = null;
265                 // fStringDQScanner = null;
266                 // fStringSQScanner = null;
267                 fPHPDocScanner = null;
268                 // fPartitionScanner = null;
269
270                 if (colorManager != null) {
271                         colorManager.dispose();
272                         colorManager = null;
273                 }
274
275                 if (fPreferenceStore != null) {
276                         fPreferenceStore.removePropertyChangeListener(fPreferenceListener);
277                         fPreferenceStore = null;
278
279                         if (fCorePreferenceStore != null) {
280                                 fCorePreferenceStore
281                                                 .removePropertyChangeListener(fPreferenceListener);
282                                 fCorePreferenceStore = null;
283                         }
284
285                         fPreferenceListener = null;
286                 }
287         }
288
289         /**
290          * Returns the color manager which is used to manage any Java-specific
291          * colors needed for such things like syntax highlighting.
292          * 
293          * @return the color manager to be used for Java text viewers
294          */
295         public JavaColorManager getColorManager() {
296                 return (JavaColorManager) colorManager;
297         }
298
299         /**
300          * Returns a scanner which is configured to scan Java source code.
301          * 
302          * @return a Java source code scanner
303          */
304 //      public RuleBasedScanner getCodeScanner() {
305 //              return fCodeScanner;
306 //      }
307
308         /**
309          * Returns a scanner which is configured to scan Java multiline comments.
310          * 
311          * @return a Java multiline comment scanner
312          * 
313          * @since 2.0
314          */
315 //      public RuleBasedScanner getMultilineCommentScanner() {
316 //              return fMultilineCommentScanner;
317 //      }
318
319         /**
320          * Returns a scanner which is configured to scan HTML code.
321          * 
322          * @return a HTML scanner
323          * 
324          * @since 2.0
325          */
326         // public RuleBasedScanner getHTMLScanner() {
327         // return fHTMLScanner;
328         // }
329         /**
330          * Returns a scanner which is configured to scan Smarty code.
331          * 
332          * @return a Smarty scanner
333          * 
334          * @since 2.0
335          */
336 //      public RuleBasedScanner getSmartyScanner() {
337 //              return fSmartyScanner;
338 //      }
339
340         /**
341          * Returns a scanner which is configured to scan Smarty code.
342          * 
343          * @return a Smarty scanner
344          * 
345          * @since 2.0
346          */
347 //      public RuleBasedScanner getSmartyDocScanner() {
348 //              return fSmartyDocScanner;
349 //      }
350
351         /**
352          * Returns a scanner which is configured to scan Java singleline comments.
353          * 
354          * @return a Java singleline comment scanner
355          * 
356          * @since 2.0
357          */
358 //      public RuleBasedScanner getSinglelineCommentScanner() {
359 //              return fSinglelineCommentScanner;
360 //      }
361
362         /**
363          * Returns a scanner which is configured to scan Java strings.
364          * 
365          * @return a Java string scanner
366          * 
367          * @since 2.0
368          */
369         // public RuleBasedScanner getStringScanner() {
370         // return fStringDQScanner;
371         // }
372         /**
373          * Returns a scanner which is configured to scan JavaDoc compliant comments.
374          * Notes that the start sequence "/**" and the corresponding end sequence
375          * are part of the JavaDoc comment.
376          * 
377          * @return a JavaDoc scanner
378          */
379 //      public RuleBasedScanner getJavaDocScanner() {
380 //              return fPHPDocScanner;
381 //      }
382
383         /**
384          * Returns a scanner which is configured to scan Java-specific partitions,
385          * which are multi-line comments, JavaDoc comments, and regular Java source
386          * code.
387          * 
388          * @return a Java partition scanner
389          */
390         // public IPartitionTokenScanner getPartitionScanner() {
391         // return fPartitionScanner;
392         // }
393         /**
394          * Factory method for creating a PHP-specific document partitioner using
395          * this object's partitions scanner. This method is a convenience method.
396          * 
397          * @return a newly created Java document partitioner
398          */
399         public IDocumentPartitioner createDocumentPartitioner() {
400                 return createDocumentPartitioner(".php");
401         }
402
403         /**
404          * Factory method for creating a PHP-specific document partitioner using
405          * this object's partitions scanner. This method is a convenience method.
406          * 
407          * @return a newly created Java document partitioner
408          */
409         public IDocumentPartitioner createDocumentPartitioner(String extension) {
410
411                 // String[] types =
412                 // new String[] {
413                 // FastJavaPartitionScanner.JAVA_DOC,
414                 // FastJavaPartitionScanner.JAVA_MULTI_LINE_COMMENT,
415                 // FastJavaPartitionScanner.JAVA_SINGLE_LINE_COMMENT,
416                 // FastJavaPartitionScanner.JAVA_STRING };
417                 //
418                 // return new DefaultPartitioner(getPartitionScanner(), types);
419                 IDocumentPartitioner partitioner = null;
420                 // System.out.println(extension);
421                 if (extension.equalsIgnoreCase(".html")
422                                 || extension.equalsIgnoreCase(".htm")) {
423                         // html
424                         partitioner = createHTMLPartitioner();
425                         partitioner = createJSPPartitioner();
426                 } else if (extension.equalsIgnoreCase(".xml")) {
427                         // xml
428                         partitioner = createXMLPartitioner();
429                         // } else if (extension.equalsIgnoreCase(".js")) {
430                         // // javascript
431                         // partitioner = createJavaScriptPartitioner();
432                         // } else if (extension.equalsIgnoreCase(".css")) {
433                         // // cascading style sheets
434                         // partitioner = createCSSPartitioner();
435                 } else if (extension.equalsIgnoreCase(".tpl")) {
436                         // smarty ?
437                         partitioner = createSmartyPartitioner();
438                         // } else if (extension.equalsIgnoreCase(".inc")) {
439                         // // php include files ?
440                         // partitioner = createIncludePartitioner();
441                 }
442
443                 if (partitioner == null) {
444                         partitioner = createJSPPartitioner();
445                 }
446
447                 return partitioner;
448         }
449
450         /**
451          * Sets up the Java document partitioner for the given document for the
452          * given partitioning.
453          * 
454          * @param document
455          *            the document to be set up
456          * @param partitioning
457          *            the document partitioning
458          * @param element
459          *            TODO
460          * 
461          * @since 3.0
462          */
463         // public void setupJavaDocumentPartitioner(IDocument document, String
464         // partitioning, Object element) {
465         // IDocumentPartitioner partitioner = createDocumentPartitioner(".php");
466         //
467         // // if (document instanceof IDocumentExtension3) {
468         // // IDocumentExtension3 extension3= (IDocumentExtension3) document;
469         // // extension3.setDocumentPartitioner(partitioning, partitioner);
470         // // } else {
471         // document.setDocumentPartitioner(partitioner);
472         // // }
473         // partitioner.connect(document);
474         // }
475         public void setupHTMLDocumentPartitioner(IDocument document,
476                         String partitioning, Object element) {
477                 IDocumentPartitioner partitioner = createDocumentPartitioner(".html");
478
479                 // if (document instanceof IDocumentExtension3) {
480                 // IDocumentExtension3 extension3= (IDocumentExtension3) document;
481                 // extension3.setDocumentPartitioner(partitioning, partitioner);
482                 // } else {
483                 document.setDocumentPartitioner(partitioner);
484                 // }
485                 partitioner.connect(document);
486         }
487
488         public void setupSmartyDocumentPartitioner(IDocument document,
489                         String partitioning, Object element) {
490                 IDocumentPartitioner partitioner = createDocumentPartitioner(".tpl");
491
492                 // if (document instanceof IDocumentExtension3) {
493                 // IDocumentExtension3 extension3= (IDocumentExtension3) document;
494                 // extension3.setDocumentPartitioner(partitioning, partitioner);
495                 // } else {
496                 document.setDocumentPartitioner(partitioner);
497                 // }
498                 partitioner.connect(document);
499         }
500
501         /**
502          * Returns the names of the document position categories used by the
503          * document partitioners created by this object to manage their partition
504          * information. If the partitioners don't use document position categories,
505          * the returned result is <code>null</code>.
506          * 
507          * @return the partition managing position categories or <code>null</code>
508          *         if there is none
509          */
510 //      public String[] getPartitionManagingPositionCategories() {
511 //              return new String[] { DefaultPartitioner.CONTENT_TYPES_CATEGORY };
512 //      }
513
514         /**
515          * Determines whether the preference change encoded by the given event
516          * changes the behavior of one its contained components.
517          * 
518          * @param event
519          *            the event to be investigated
520          * @return <code>true</code> if event causes a behavioral change
521          * @since 2.0
522          * @deprecated As of 3.0, replaced by
523          *             {@link net.sourceforge.phpdt.ui.text.JavaSourceViewerConfiguration#affectsTextPresentation(PropertyChangeEvent)}
524          */
525         // public boolean affectsBehavior(PropertyChangeEvent event) {
526         // return fCodeScanner.affectsBehavior(event)
527         // || fMultilineCommentScanner.affectsBehavior(event)
528         // || fSinglelineCommentScanner.affectsBehavior(event)
529         // || fStringDQScanner.affectsBehavior(event)
530         // || fPHPDocScanner.affectsBehavior(event);
531         // }
532         /**
533          * Adapts the behavior of the contained components to the change encoded in
534          * the given event.
535          * 
536          * @param event
537          *            the event to which to adapt
538          * @since 2.0
539          */
540         protected void adaptToPreferenceChange(PropertyChangeEvent event) {
541                 if (fCodeScanner.affectsBehavior(event))
542                         fCodeScanner.adaptToPreferenceChange(event);
543                 if (fMultilineCommentScanner.affectsBehavior(event))
544                         fMultilineCommentScanner.adaptToPreferenceChange(event);
545                 if (fSinglelineCommentScanner.affectsBehavior(event))
546                         fSinglelineCommentScanner.adaptToPreferenceChange(event);
547                 // if (fStringDQScanner.affectsBehavior(event))
548                 // fStringDQScanner.adaptToPreferenceChange(event);
549                 if (fPHPDocScanner.affectsBehavior(event))
550                         fPHPDocScanner.adaptToPreferenceChange(event);
551                 // if (fHTMLScanner.affectsBehavior(event))
552                 // fHTMLScanner.adaptToPreferenceChange(event);
553                 if (fSmartyScanner.affectsBehavior(event))
554                         fSmartyScanner.adaptToPreferenceChange(event);
555                 if (fSmartyDocScanner.affectsBehavior(event))
556                         fSmartyDocScanner.adaptToPreferenceChange(event);
557                 // if (XMLPlugin.getDefault().getXMLTextTools().affectsBehavior(event))
558                 // {
559                 // XMLPlugin.getDefault().getXMLTextTools().adaptToPreferenceChange(event);
560                 // }
561         }
562
563         /**
564          * Return a partitioner for .html files.
565          */
566         public IDocumentPartitioner createHTMLPartitioner() {
567                 // return new DefaultPartitioner(getHTMLPartitionScanner(), TYPES);
568                 return xmlTextTools.createXMLPartitioner();
569         }
570
571         // private static IDocumentPartitioner createIncludePartitioner() {
572         // // return new DefaultPartitioner(getPHPPartitionScanner(), TYPES);
573         // return new DefaultPartitioner(getPHPPartitionScanner(),
574         // FastJavaPartitionScanner.PHP_PARTITION_TYPES);
575         //
576         // }
577
578         // private static IDocumentPartitioner createJavaScriptPartitioner() {
579         // return new DefaultPartitioner(getHTMLPartitionScanner(), TYPES);
580         // }
581
582         /**
583          * Return a partitioner for .php files.
584          */
585         public IDocumentPartitioner createPHPPartitioner() {
586                 // return new DefaultPartitioner(getPHPPartitionScanner(), TYPES);
587                 return new /*DefaultPartitioner*/FastPartitioner(getPHPPartitionScanner(),
588                                 LEGAL_CONTENT_TYPES);
589         }
590
591         private IDocumentPartitioner createJSPPartitioner() {
592                 return new PHPDocumentPartitioner(getJSPPartitionScanner());
593                 // return new JSPDocumentPartitioner(getJSPPartitionScanner(),
594                 // jspScriptScanner);
595         }
596
597         /**
598          * 
599          */
600         // public IPartitionTokenScanner getJSPScriptScanner() {
601         // return jspScriptScanner;
602         // }
603         private IDocumentPartitioner createSmartyPartitioner() {
604                 return new /*DefaultPartitioner*/FastPartitioner(getSmartyPartitionScanner(),
605                                 XMLTextTools.TYPES);
606         }
607
608         private IDocumentPartitioner createXMLPartitioner() {
609                 // return new DefaultPartitioner(getXMLPartitionScanner(),
610                 // XMLTextTools.TYPES);
611                 return xmlTextTools.createXMLPartitioner();
612         }
613
614         // private IDocumentPartitioner createCSSPartitioner() {
615         // return new DefaultPartitioner(getHTMLPartitionScanner(),
616         // XMLTextTools.TYPES);
617         // }
618
619         /**
620          * Return a scanner for creating html partitions.
621          */
622         // private static XMLPartitionScanner getHTMLPartitionScanner() {
623         // // if (HTML_PARTITION_SCANNER == null)
624         // // HTML_PARTITION_SCANNER = new
625         // HTMLPartitionScanner(IPHPPartitions.HTML_FILE);
626         // // return HTML_PARTITION_SCANNER;^
627         // if (HTML_PARTITION_SCANNER == null)
628         // HTML_PARTITION_SCANNER = new XMLPartitionScanner(false);
629         // return HTML_PARTITION_SCANNER;
630         // }
631         /**
632          * Return a scanner for creating php partitions.
633          */
634         private FastJavaPartitionScanner getPHPPartitionScanner() {
635                 // if (PHP_PARTITION_SCANNER == null)
636                 // PHP_PARTITION_SCANNER = new FastJavaPartitionScanner(); //new
637                 // PHPPartitionScanner(IPHPPartitions.PHP_FILE);
638                 // return PHP_PARTITION_SCANNER;
639                 return fPartitionScanner;
640         }
641
642         /**
643          * Returns a scanner which is configured to scan plain text in JSP.
644          * 
645          * @return a JSP text scanner
646          */
647         // public RuleBasedScanner getJSPTextScanner() {
648         // return jspTextScanner;
649         // }
650         /**
651          * Returns a scanner which is configured to scan plain text in JSP.
652          * 
653          * @return a JSP text scanner
654          */
655         // public RuleBasedScanner getJSPBracketScanner() {
656         // return jspBracketScanner;
657         // }
658         /**
659          * Return a scanner for creating smarty partitions.
660          */
661         private static HTMLPartitionScanner getSmartyPartitionScanner() {
662                 if (SMARTY_PARTITION_SCANNER == null)
663                         SMARTY_PARTITION_SCANNER = new HTMLPartitionScanner(
664                                         IPHPPartitions.SMARTY_FILE);
665                 return SMARTY_PARTITION_SCANNER;
666         }
667
668         /**
669          * Return a scanner for creating xml partitions.
670          */
671         // private static XMLPartitionScanner getXMLPartitionScanner() {
672         // // if (XML_PARTITION_SCANNER == null)
673         // // XML_PARTITION_SCANNER = new
674         // HTMLPartitionScanner(IPHPPartitions.XML_FILE);
675         // // return XML_PARTITION_SCANNER;
676         // if (XML_PARTITION_SCANNER == null)
677         // XML_PARTITION_SCANNER = new XMLPartitionScanner(false);
678         // return XML_PARTITION_SCANNER;
679         // }
680         private PHPPartitionScanner getJSPPartitionScanner() {
681                 if (jspPartitionScanner == null)
682                         jspPartitionScanner = new PHPPartitionScanner();
683                 return jspPartitionScanner;
684         }
685
686         /**
687          * Sets up the Java document partitioner for the given document for the
688          * default partitioning.
689          * 
690          * @param document
691          *            the document to be set up
692          * @since 3.0
693          */
694         public void setupJavaDocumentPartitioner(IDocument document) {
695                 setupJavaDocumentPartitioner(document,
696                                 IDocumentExtension3.DEFAULT_PARTITIONING);
697         }
698
699         /**
700          * Sets up the Java document partitioner for the given document for the
701          * given partitioning.
702          * 
703          * @param document
704          *            the document to be set up
705          * @param partitioning
706          *            the document partitioning
707          * @since 3.0
708          */
709         public void setupJavaDocumentPartitioner(IDocument document,
710                         String partitioning) {
711                 IDocumentPartitioner partitioner = createDocumentPartitioner();
712                 if (document instanceof IDocumentExtension3) {
713                         IDocumentExtension3 extension3 = (IDocumentExtension3) document;
714                         extension3.setDocumentPartitioner(partitioning, partitioner);
715                 } else {
716                         document.setDocumentPartitioner(partitioner);
717                 }
718                 partitioner.connect(document);
719         }
720
721         /**
722          * Returns this text tool's preference store.
723          * 
724          * @return the preference store
725          * @since 3.0
726          */
727         protected IPreferenceStore getPreferenceStore() {
728                 return fPreferenceStore;
729         }
730
731         /**
732          * Returns this text tool's core preference store.
733          * 
734          * @return the core preference store
735          * @since 3.0
736          */
737 //      protected Preferences getCorePreferenceStore() {
738 //              return fCorePreferenceStore;
739 //      }
740 }