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