committing phphelp to Plug-ins for feature to fix build dependence for phpmanual.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / PHPeclipsePlugin.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  **********************************************************************/
9 package net.sourceforge.phpeclipse;
10
11 import java.io.File;
12 import java.io.IOException;
13 import java.io.InputStream;
14 import java.util.ArrayList;
15 import java.util.Collection;
16 import java.util.Enumeration;
17 import java.util.HashMap;
18 import java.util.HashSet;
19 import java.util.Iterator;
20 import java.util.List;
21 import java.util.PropertyResourceBundle;
22 import java.util.Set;
23
24 import net.sourceforge.phpdt.core.IBuffer;
25 import net.sourceforge.phpdt.core.IBufferFactory;
26 import net.sourceforge.phpdt.core.ICompilationUnit;
27 import net.sourceforge.phpdt.core.IJavaElement;
28 import net.sourceforge.phpdt.core.JavaCore;
29 import net.sourceforge.phpdt.core.WorkingCopyOwner;
30 import net.sourceforge.phpdt.internal.core.BatchOperation;
31 import net.sourceforge.phpdt.internal.core.JavaModelManager;
32 import net.sourceforge.phpdt.internal.core.util.Util;
33 import net.sourceforge.phpdt.internal.corext.template.php.CodeTemplateContextType;
34 import net.sourceforge.phpdt.internal.corext.template.php.HTMLContextType;
35 import net.sourceforge.phpdt.internal.corext.template.php.JavaContextType;
36 import net.sourceforge.phpdt.internal.corext.template.php.JavaDocContextType;
37 import net.sourceforge.phpdt.internal.ui.IJavaStatusConstants;
38 import net.sourceforge.phpdt.internal.ui.JavaElementAdapterFactory;
39 import net.sourceforge.phpdt.internal.ui.ResourceAdapterFactory;
40 import net.sourceforge.phpdt.internal.ui.preferences.MembersOrderPreferenceCache;
41 import net.sourceforge.phpdt.internal.ui.preferences.MockupPreferenceStore;
42 import net.sourceforge.phpdt.internal.ui.text.PreferencesAdapter;
43 import net.sourceforge.phpdt.internal.ui.text.folding.JavaFoldingStructureProviderRegistry;
44 import net.sourceforge.phpdt.internal.ui.text.java.hover.JavaEditorTextHoverDescriptor;
45 import net.sourceforge.phpdt.internal.ui.viewsupport.ImageDescriptorRegistry;
46 import net.sourceforge.phpdt.internal.ui.viewsupport.ProblemMarkerManager;
47 import net.sourceforge.phpdt.ui.IContextMenuConstants;
48 import net.sourceforge.phpdt.ui.IWorkingCopyManager;
49 import net.sourceforge.phpdt.ui.PreferenceConstants;
50 import net.sourceforge.phpdt.ui.text.JavaTextTools;
51 import net.sourceforge.phpeclipse.builder.ExternalEditorInput;
52 import net.sourceforge.phpeclipse.builder.ExternalStorageDocumentProvider;
53 import net.sourceforge.phpeclipse.builder.FileStorage;
54 import net.sourceforge.phpeclipse.builder.IdentifierIndexManager;
55 import net.sourceforge.phpeclipse.phpeditor.CustomBufferFactory;
56 import net.sourceforge.phpeclipse.phpeditor.DocumentAdapter;
57 import net.sourceforge.phpeclipse.phpeditor.ICompilationUnitDocumentProvider;
58 import net.sourceforge.phpeclipse.phpeditor.PHPDocumentProvider;
59 import net.sourceforge.phpeclipse.phpeditor.PHPSyntaxRdr;
60 import net.sourceforge.phpeclipse.phpeditor.WorkingCopyManager;
61 import net.sourceforge.phpeclipse.phpeditor.util.PHPColorProvider;
62
63 import org.eclipse.core.resources.IFile;
64 import org.eclipse.core.resources.IProject;
65 import org.eclipse.core.resources.IResource;
66 import org.eclipse.core.resources.IResourceChangeEvent;
67 import org.eclipse.core.resources.ISavedState;
68 import org.eclipse.core.resources.IWorkspace;
69 import org.eclipse.core.resources.IWorkspaceRunnable;
70 import org.eclipse.core.resources.ResourcesPlugin;
71 import org.eclipse.core.resources.WorkspaceJob;
72 import org.eclipse.core.runtime.CoreException;
73 import org.eclipse.core.runtime.IAdapterManager;
74 import org.eclipse.core.runtime.IConfigurationElement;
75 import org.eclipse.core.runtime.IPath;
76 import org.eclipse.core.runtime.IProgressMonitor;
77 import org.eclipse.core.runtime.IStatus;
78 import org.eclipse.core.runtime.Path;
79 import org.eclipse.core.runtime.Platform;
80 import org.eclipse.core.runtime.Status;
81 import org.eclipse.core.runtime.jobs.ISchedulingRule;
82 import org.eclipse.core.runtime.jobs.Job;
83 import org.eclipse.jface.action.GroupMarker;
84 import org.eclipse.jface.action.IMenuManager;
85 import org.eclipse.jface.action.Separator;
86 import org.eclipse.jface.preference.IPreferenceStore;
87 import org.eclipse.jface.preference.PreferenceConverter;
88 import org.eclipse.jface.resource.JFaceResources;
89 import org.eclipse.jface.text.BadLocationException;
90 import org.eclipse.jface.text.IDocument;
91 import org.eclipse.jface.text.templates.ContextTypeRegistry;
92 import org.eclipse.jface.text.templates.persistence.TemplateStore;
93 import org.eclipse.jface.util.IPropertyChangeListener;
94 import org.eclipse.jface.util.PropertyChangeEvent;
95 import org.eclipse.swt.graphics.RGB;
96 import org.eclipse.swt.widgets.Display;
97 import org.eclipse.swt.widgets.Shell;
98 import org.eclipse.ui.IEditorDescriptor;
99 import org.eclipse.ui.IEditorInput;
100 import org.eclipse.ui.IEditorPart;
101 import org.eclipse.ui.IEditorRegistry;
102 import org.eclipse.ui.IWorkbench;
103 import org.eclipse.ui.IWorkbenchPage;
104 import org.eclipse.ui.IWorkbenchWindow;
105 import org.eclipse.ui.PlatformUI;
106 import org.eclipse.ui.editors.text.EditorsUI;
107 import org.eclipse.ui.editors.text.templates.ContributionContextTypeRegistry;
108 import org.eclipse.ui.editors.text.templates.ContributionTemplateStore;
109 import org.eclipse.ui.ide.IDE;
110 import org.eclipse.ui.plugin.AbstractUIPlugin;
111 import org.eclipse.ui.texteditor.ChainedPreferenceStore;
112 import org.eclipse.ui.texteditor.ConfigurationElementSorter;
113 import org.eclipse.ui.texteditor.IDocumentProvider;
114 import org.eclipse.ui.texteditor.ITextEditor;
115 import org.eclipse.ui.texteditor.MarkerAnnotationPreferences;
116 import org.osgi.framework.BundleContext;
117
118 /**
119  * The main plugin class to be used in the desktop.
120  */
121 public class PHPeclipsePlugin extends AbstractUIPlugin implements
122                 IPreferenceConstants {
123         /**
124          * The id of the PHP plugin (value <code>"net.sourceforge.phpeclipse"</code>).
125          */
126         public static final String PLUGIN_ID = "net.sourceforge.phpeclipse"; //$NON-NLS-1$
127
128         public static final String EDITOR_ID = PHPeclipsePlugin.PLUGIN_ID
129                         + ".PHPUnitEditor";
130
131         public static final String ID_PERSPECTIVE = "net.sourceforge.phpeclipse.PHPPerspective"; //$NON-NLS-1$
132
133         IWorkspace w;
134
135         /**
136          * id of builder - matches plugin.xml (concatenate pluginid.builderid)
137          */
138         public static final String BUILDER_PARSER_ID = PLUGIN_ID + ".parserbuilder";
139
140         // public static final String BUILDER_INDEX_ID = PLUGIN_ID +
141         // ".indexbuilder";
142         /** General debug flag */
143
144         public static final boolean DEBUG = false;
145
146         /**
147          * The maximum number of allowed proposals by category
148          */
149         public final static int MAX_PROPOSALS = 200;
150
151         /**
152          * The key to store customized templates.
153          * 
154          * @since 3.0
155          */
156         private static final String TEMPLATES_KEY = "net.sourceforge.phpdt.ui.text.custom_templates"; //$NON-NLS-1$
157
158         /**
159          * The key to store customized code templates.
160          * 
161          * @since 3.0
162          */
163         private static final String CODE_TEMPLATES_KEY = "net.sourceforge.phpdt.ui.text.custom_code_templates"; //$NON-NLS-1$
164
165         public static final String PHP_CODING_ACTION_SET_ID = PLUGIN_ID
166                         + ".ui.CodingActionSet"; //$NON-NLS-1$
167
168         public final static String PHP_NATURE_ID = PLUGIN_ID + ".phpnature";
169
170         public static final String PHPPARSER_ORIGINAL = "net.sourceforge.phpdt.internal.compiler.parser.Parser";
171
172         public static final String PHPPARSER_NEW = "test.PHPParser";
173
174         /** Change this if you want to switch PHP Parser. */
175         public static final String PHPPARSER = PHPPARSER_ORIGINAL;
176
177         // The shared instance.
178         private static PHPeclipsePlugin plugin;
179
180         /**
181          * The template context type registry for the java editor.
182          * 
183          * @since 3.0
184          */
185         private ContextTypeRegistry fContextTypeRegistry;
186
187         /**
188          * The code template context type registry for the java editor.
189          * 
190          * @since 3.0
191          */
192         private ContextTypeRegistry fCodeTemplateContextTypeRegistry;
193
194         /**
195          * The template store for the java editor.
196          * 
197          * @since 3.0
198          */
199         private TemplateStore fTemplateStore;
200
201         /**
202          * The coded template store for the java editor.
203          * 
204          * @since 3.0
205          */
206         private TemplateStore fCodeTemplateStore;
207
208         /** Windows 9x */
209         private static final int WINDOWS_9x = 6;
210
211         /** Windows NT */
212         private static final int WINDOWS_NT = 5;
213
214         private ImageDescriptorRegistry fImageDescriptorRegistry;
215
216         private HashMap fIndexManagerMap = new HashMap();
217
218         private IWorkingCopyManager fWorkingCopyManager;
219
220         private IBufferFactory fBufferFactory;
221
222         private ICompilationUnitDocumentProvider fCompilationUnitDocumentProvider;
223
224         private JavaTextTools fJavaTextTools;
225
226         private ProblemMarkerManager fProblemMarkerManager;
227
228         private MembersOrderPreferenceCache fMembersOrderPreferenceCache;
229
230         private IFile fLastEditorFile = null;
231
232         private JavaEditorTextHoverDescriptor[] fJavaEditorTextHoverDescriptors;
233
234         private JavaElementAdapterFactory fJavaElementAdapterFactory;
235
236         // private MarkerAdapterFactory fMarkerAdapterFactory;
237         // private EditorInputAdapterFactory fEditorInputAdapterFactory;
238         private ResourceAdapterFactory fResourceAdapterFactory;
239
240         // private LogicalPackageAdapterFactory fLogicalPackageAdapterFactory;
241         private IPropertyChangeListener fFontPropertyChangeListener;
242
243         /**
244          * Property change listener on this plugin's preference store.
245          * 
246          * @since 3.0
247          */
248         // private IPropertyChangeListener fPropertyChangeListener;
249         /**
250          * The combined preference store.
251          * 
252          * @since 3.0
253          */
254         private IPreferenceStore fCombinedPreferenceStore;
255
256         /**
257          * The extension point registry for the
258          * <code>net.sourceforge.phpdt.ui.javaFoldingStructureProvider</code>
259          * extension point.
260          * 
261          * @since 3.0
262          */
263         private JavaFoldingStructureProviderRegistry fFoldingStructureProviderRegistry;
264
265         /**
266          * Mockup preference store for firing events and registering listeners on
267          * project setting changes. FIXME: Temporary solution.
268          * 
269          * @since 3.0
270          */
271         private MockupPreferenceStore fMockupPreferenceStore;
272
273         /**
274          * The constructor.
275          */
276         public PHPeclipsePlugin() {
277                 super();
278                 plugin = this;
279                 // externalTools = new ExternalToolsPlugin();
280
281                 // try {
282                 // resourceBundle =
283                 // ResourceBundle.getBundle("net.sourceforge.PHPeclipsePluginResources");
284                 // } catch (MissingResourceException x) {
285                 // resourceBundle = null;
286                 // }
287         }
288
289         // /**
290         // * Returns all Java editor text hovers contributed to the workbench.
291         // *
292         // * @return an array of JavaEditorTextHoverDescriptor
293         // * @since 2.1
294         // */
295         // public JavaEditorTextHoverDescriptor[]
296         // getJavaEditorTextHoverDescriptors()
297         // {
298         // if (fJavaEditorTextHoverDescriptors == null)
299         // fJavaEditorTextHoverDescriptors = JavaEditorTextHoverDescriptor
300         // .getContributedHovers();
301         // return fJavaEditorTextHoverDescriptors;
302         // }
303         /**
304          * Returns all Java editor text hovers contributed to the workbench.
305          * 
306          * @return an array of JavaEditorTextHoverDescriptor
307          * @since 2.1
308          */
309         public JavaEditorTextHoverDescriptor[] getJavaEditorTextHoverDescriptors() {
310                 if (fJavaEditorTextHoverDescriptors == null) {
311                         fJavaEditorTextHoverDescriptors = JavaEditorTextHoverDescriptor
312                                         .getContributedHovers();
313                         ConfigurationElementSorter sorter = new ConfigurationElementSorter() {
314                                 /*
315                                  * @see org.eclipse.ui.texteditor.ConfigurationElementSorter#getConfigurationElement(java.lang.Object)
316                                  */
317                                 public IConfigurationElement getConfigurationElement(
318                                                 Object object) {
319                                         return ((JavaEditorTextHoverDescriptor) object)
320                                                         .getConfigurationElement();
321                                 }
322                         };
323                         sorter.sort(fJavaEditorTextHoverDescriptors);
324
325                         // The Problem hover has to be the first and the Annotation hover
326                         // has to
327                         // be the last one in the JDT UI's hover list
328                         int length = fJavaEditorTextHoverDescriptors.length;
329                         int first = -1;
330                         int last = length - 1;
331                         int problemHoverIndex = -1;
332                         int annotationHoverIndex = -1;
333                         for (int i = 0; i < length; i++) {
334                                 if (!fJavaEditorTextHoverDescriptors[i].getId().startsWith(
335                                                 PLUGIN_ID)) {
336                                         if (problemHoverIndex == -1 || annotationHoverIndex == -1)
337                                                 continue;
338                                         else {
339                                                 last = i - 1;
340                                                 break;
341                                         }
342                                 }
343                                 if (first == -1)
344                                         first = i;
345
346                                 if (fJavaEditorTextHoverDescriptors[i].getId().equals(
347                                                 "net.sourceforge.phpdt.ui.AnnotationHover")) { //$NON-NLS-1$
348                                         annotationHoverIndex = i;
349                                         continue;
350                                 }
351                                 if (fJavaEditorTextHoverDescriptors[i].getId().equals(
352                                                 "net.sourceforge.phpdt.ui.ProblemHover")) { //$NON-NLS-1$
353                                         problemHoverIndex = i;
354                                         continue;
355                                 }
356                         }
357
358                         JavaEditorTextHoverDescriptor hoverDescriptor = null;
359
360                         if (first > -1 && problemHoverIndex > -1
361                                         && problemHoverIndex != first) {
362                                 // move problem hover to beginning
363                                 hoverDescriptor = fJavaEditorTextHoverDescriptors[first];
364                                 fJavaEditorTextHoverDescriptors[first] = fJavaEditorTextHoverDescriptors[problemHoverIndex];
365                                 fJavaEditorTextHoverDescriptors[problemHoverIndex] = hoverDescriptor;
366
367                                 // update annotation hover index if needed
368                                 if (annotationHoverIndex == first)
369                                         annotationHoverIndex = problemHoverIndex;
370                         }
371
372                         if (annotationHoverIndex > -1 && annotationHoverIndex != last) {
373                                 // move annotation hover to end
374                                 hoverDescriptor = fJavaEditorTextHoverDescriptors[last];
375                                 fJavaEditorTextHoverDescriptors[last] = fJavaEditorTextHoverDescriptors[annotationHoverIndex];
376                                 fJavaEditorTextHoverDescriptors[annotationHoverIndex] = hoverDescriptor;
377                         }
378
379                         // Move Best Match hover to front
380                         for (int i = 0; i < fJavaEditorTextHoverDescriptors.length - 1; i++) {
381                                 if (PreferenceConstants.ID_BESTMATCH_HOVER
382                                                 .equals(fJavaEditorTextHoverDescriptors[i].getId())) {
383                                         hoverDescriptor = fJavaEditorTextHoverDescriptors[i];
384                                         for (int j = i; j > 0; j--)
385                                                 fJavaEditorTextHoverDescriptors[j] = fJavaEditorTextHoverDescriptors[j - 1];
386                                         fJavaEditorTextHoverDescriptors[0] = hoverDescriptor;
387                                         break;
388                                 }
389
390                         }
391                 }
392
393                 return fJavaEditorTextHoverDescriptors;
394         }
395
396         /**
397          * Resets the Java editor text hovers contributed to the workbench.
398          * <p>
399          * This will force a rebuild of the descriptors the next time a client asks
400          * for them.
401          * </p>
402          * 
403          * @return an array of JavaEditorTextHoverDescriptor
404          * @since 2.1
405          */
406         public void resetJavaEditorTextHoverDescriptors() {
407                 fJavaEditorTextHoverDescriptors = null;
408         }
409
410         /**
411          * Creates the PHP plugin standard groups in a context menu.
412          */
413         public static void createStandardGroups(IMenuManager menu) {
414                 if (!menu.isEmpty())
415                         return;
416                 menu.add(new Separator(IContextMenuConstants.GROUP_NEW));
417                 menu.add(new GroupMarker(IContextMenuConstants.GROUP_GOTO));
418                 menu.add(new Separator(IContextMenuConstants.GROUP_OPEN));
419                 menu.add(new GroupMarker(IContextMenuConstants.GROUP_SHOW));
420                 menu.add(new Separator(IContextMenuConstants.GROUP_REORGANIZE));
421                 menu.add(new Separator(IContextMenuConstants.GROUP_GENERATE));
422                 menu.add(new Separator(IContextMenuConstants.GROUP_SEARCH));
423                 menu.add(new Separator(IContextMenuConstants.GROUP_BUILD));
424                 menu.add(new Separator(IContextMenuConstants.GROUP_ADDITIONS));
425                 menu.add(new Separator(IContextMenuConstants.GROUP_VIEWER_SETUP));
426                 menu.add(new Separator(IContextMenuConstants.GROUP_PROPERTIES));
427         }
428
429         public static IWorkbenchPage getActivePage() {
430                 return getDefault().internalGetActivePage();
431         }
432
433         public static Shell getActiveWorkbenchShell() {
434                 return getActiveWorkbenchWindow().getShell();
435         }
436
437         /**
438          * Returns an array of all editors that have an unsaved content. If the
439          * identical content is presented in more than one editor, only one of those
440          * editor parts is part of the result.
441          * 
442          * @return an array of all dirty editor parts.
443          */
444         public static IEditorPart[] getDirtyEditors() {
445                 Set inputs = new HashSet();
446                 List result = new ArrayList(0);
447                 IWorkbench workbench = getDefault().getWorkbench();
448                 IWorkbenchWindow[] windows = workbench.getWorkbenchWindows();
449                 for (int i = 0; i < windows.length; i++) {
450                         IWorkbenchPage[] pages = windows[i].getPages();
451                         for (int x = 0; x < pages.length; x++) {
452                                 IEditorPart[] editors = pages[x].getDirtyEditors();
453                                 for (int z = 0; z < editors.length; z++) {
454                                         IEditorPart ep = editors[z];
455                                         IEditorInput input = ep.getEditorInput();
456                                         if (!inputs.contains(input)) {
457                                                 inputs.add(input);
458                                                 result.add(ep);
459                                         }
460                                 }
461                         }
462                 }
463                 return (IEditorPart[]) result.toArray(new IEditorPart[result.size()]);
464         }
465
466         public static IWorkbenchWindow getActiveWorkbenchWindow() {
467                 return getDefault().getWorkbench().getActiveWorkbenchWindow();
468         }
469
470         /**
471          * Returns the shared instance.
472          */
473         public static PHPeclipsePlugin getDefault() {
474                 return plugin;
475         }
476
477         public static ImageDescriptorRegistry getImageDescriptorRegistry() {
478                 return getDefault().internalGetImageDescriptorRegistry();
479         }
480
481         static IPath getInstallLocation() {
482                 return new Path(getDefault().getBundle().getEntry("/").getFile());
483         }
484
485         // public static int getJVM() {
486         // return jvm;
487         // }
488
489         public static String getPluginId() {
490                 return getDefault().getBundle().getSymbolicName();
491         }
492
493         /**
494          * Returns the standard display to be used. The method first checks, if the
495          * thread calling this method has an associated display. If so, this display
496          * is returned. Otherwise the method returns the default display.
497          */
498         public static Display getStandardDisplay() {
499                 Display display = Display.getCurrent();
500                 if (display == null) {
501                         display = Display.getDefault();
502                 }
503                 return display;
504         }
505
506         // public static ExternalToolsPlugin getExternalTools() {
507         // return externalTools;
508         // }
509         /**
510          * Returns the workspace instance.
511          */
512         public static IWorkspace getWorkspace() {
513                 return ResourcesPlugin.getWorkspace();
514         }
515
516         public static boolean isDebug() {
517                 return getDefault().isDebugging();
518         }
519
520         // public static void logErrorMessage(String message) {
521         // log(new Status(IStatus.ERROR, getPluginId(),
522         // JavaStatusConstants.INTERNAL_ERROR, message, null));
523         // }
524         //
525         // public static void logErrorStatus(String message, IStatus status) {
526         // if (status == null) {
527         // logErrorMessage(message);
528         // return;
529         // }
530         // MultiStatus multi= new MultiStatus(getPluginId(),
531         // JavaStatusConstants.INTERNAL_ERROR, message, null);
532         // multi.add(status);
533         // log(multi);
534         // }
535         //
536         // public static void log(Throwable e) {
537         // log(new Status(IStatus.ERROR, getPluginId(),
538         // JavaStatusConstants.INTERNAL_ERROR,
539         // JavaUIMessages.getString("JavaPlugin.internal_error"), e)); //$NON-NLS-1$
540         // }
541         public static void log(int severity, String message) {
542                 Status status = new Status(severity, PLUGIN_ID, IStatus.OK, message,
543                                 null);
544                 log(status);
545         }
546
547         public static void log(IStatus status) {
548                 getDefault().getLog().log(status);
549         }
550
551         public static void log(Throwable t) {
552                 log(error(t));
553         }
554
555         public static void log(String message, Throwable t) {
556                 log(error(message, t));
557         }
558
559         public static void logErrorMessage(String message) {
560                 log(new Status(IStatus.ERROR, getPluginId(),
561                                 IJavaStatusConstants.INTERNAL_ERROR, message, null));
562         }
563
564         public static IStatus error(Throwable t) {
565                 return error("PHPeclipsePlugin.internalErrorOccurred", t); //$NON-NLS-1$
566         }
567
568         public static IStatus error(String message, Throwable t) {
569                 return new Status(IStatus.ERROR, PLUGIN_ID, IStatus.ERROR, message, t);
570         }
571
572         // private static void setJVM() {
573         // String osName = System.getProperty("os.name");
574         // if (osName.startsWith("Mac OS")) {
575         // String mrjVersion = System.getProperty("mrj.version");
576         // String majorMRJVersion = mrjVersion.substring(0, 3);
577         // jvm = OTHER;
578         // try {
579         // double version = Double.valueOf(majorMRJVersion).doubleValue();
580         // if (version == 2) {
581         // jvm = MRJ_2_0;
582         // } else if (version >= 2.1 && version < 3) {
583         // jvm = MRJ_2_1;
584         // } else if (version == 3.0) {
585         // jvm = MRJ_3_0;
586         // } else if (version >= 3.1) {
587         // jvm = MRJ_3_1;
588         // }
589         // } catch (NumberFormatException nfe) {
590         // }
591         // } else if (osName.startsWith("Windows")) {
592         // if (osName.indexOf("9") != -1) {
593         // jvm = WINDOWS_9x;
594         // } else {
595         // jvm = WINDOWS_NT;
596         // }
597         // }
598         // }
599
600         // TODO: refactor this into a better method name !
601         public synchronized ICompilationUnitDocumentProvider getCompilationUnitDocumentProvider() {
602                 if (fCompilationUnitDocumentProvider == null)
603                         fCompilationUnitDocumentProvider = new PHPDocumentProvider();
604                 return fCompilationUnitDocumentProvider;
605         }
606
607         /**
608          * Get the identifier index manager for the given project
609          * 
610          * @param iProject
611          *            the current project
612          * @return
613          */
614         public IdentifierIndexManager getIndexManager(IProject iProject) {
615                 IPath path = iProject.getWorkingLocation(PHPeclipsePlugin.PLUGIN_ID);
616                 path = path.append("project.index");
617                 String indexFilename = path.toString();
618                 // try {
619                 // IdentDB db = IdentDB.getInstance();
620                 // } catch (ClassNotFoundException e) {
621                 // e.printStackTrace();
622                 // } catch (SQLException e) {
623                 // e.printStackTrace();
624                 // }
625                 IdentifierIndexManager indexManager = (IdentifierIndexManager) fIndexManagerMap
626                                 .get(indexFilename);
627                 if (indexManager == null) {
628                         indexManager = new IdentifierIndexManager(indexFilename);
629                         fIndexManagerMap.put(indexFilename, indexManager);
630                 }
631                 return indexManager;
632         }
633
634         public synchronized IWorkingCopyManager getWorkingCopyManager() {
635                 if (fWorkingCopyManager == null) {
636                         ICompilationUnitDocumentProvider provider = getCompilationUnitDocumentProvider();
637                         fWorkingCopyManager = new WorkingCopyManager(provider);
638                 }
639                 return fWorkingCopyManager;
640         }
641
642         public synchronized MembersOrderPreferenceCache getMemberOrderPreferenceCache() {
643                 if (fMembersOrderPreferenceCache == null)
644                         fMembersOrderPreferenceCache = new MembersOrderPreferenceCache();
645                 return fMembersOrderPreferenceCache;
646         }
647
648         /**
649          * Returns the mockup preference store for firing events and registering
650          * listeners on project setting changes. Temporary solution.
651          */
652         public MockupPreferenceStore getMockupPreferenceStore() {
653                 if (fMockupPreferenceStore == null)
654                         fMockupPreferenceStore = new MockupPreferenceStore();
655
656                 return fMockupPreferenceStore;
657         }
658
659         public synchronized ProblemMarkerManager getProblemMarkerManager() {
660                 if (fProblemMarkerManager == null)
661                         fProblemMarkerManager = new ProblemMarkerManager();
662                 return fProblemMarkerManager;
663         }
664
665         // public synchronized JavaTextTools getJavaTextTools() {
666         // if (fJavaTextTools == null)
667         // fJavaTextTools = new JavaTextTools(getPreferenceStore());
668         // return fJavaTextTools;
669         // }
670         public synchronized JavaTextTools getJavaTextTools() {
671                 if (fJavaTextTools == null)
672                         fJavaTextTools = new JavaTextTools(getPreferenceStore(), JavaCore
673                                         .getPlugin().getPluginPreferences());
674                 return fJavaTextTools;
675         }
676
677         public IFile getLastEditorFile() {
678                 return fLastEditorFile;
679         }
680
681         /**
682          * Returns the string from the plugin's resource bundle, or 'key' if not
683          * found.
684          */
685         // public static String getResourceString(String key) {
686         // ResourceBundle bundle =
687         // PHPeclipsePlugin.getDefault().getResourceBundle();
688         // try {
689         // return bundle.getString(key);
690         // } catch (MissingResourceException e) {
691         // return key;
692         // }
693         // }
694         /**
695          * Returns the plugin's resource bundle,
696          */
697         // public ResourceBundle getResourceBundle() {
698         // return resourceBundle;
699         // }
700         protected void initializeDefaultPreferences(IPreferenceStore store) {
701                 String operatingSystem = Platform.getOS();
702                 // maxosx, linux, solaris, win32,...
703                 try {
704                         InputStream is = getDefault()
705                                         .openStream(
706                                                         new Path("prefs/default_" + operatingSystem
707                                                                         + ".properties"));
708                         PropertyResourceBundle resourceBundle = new PropertyResourceBundle(
709                                         is);
710                         Enumeration e = resourceBundle.getKeys();
711                         String key;
712                         while (e.hasMoreElements()) {
713                                 key = (String) e.nextElement();
714                                 store.setDefault(key, resourceBundle.getString(key));
715                         }
716                 } catch (Exception e) {
717                         // no default properties found
718                         if (operatingSystem.equals(Platform.OS_WIN32)) {
719                                 // store.setDefault(PHP_RUN_PREF, "c:\\apache\\php\\php.exe");
720                                 // store.setDefault(EXTERNAL_PARSER_PREF, "c:\\apache\\php\\php
721                                 // -l -f {0}");
722                                 // store.setDefault(MYSQL_RUN_PREF,
723                                 // "c:\\apache\\mysql\\bin\\mysqld-nt.exe");
724                                 // store.setDefault(APACHE_RUN_PREF, "c:\\apache\\apache.exe");
725                                 // store.setDefault(XAMPP_START_PREF,
726                                 // "c:\\xampp\\xampp_start.exe");
727                                 // store.setDefault(XAMPP_STOP_PREF,
728                                 // "c:\\xampp\\xampp_stop.exe");
729                                 // store.setDefault(
730                                 // ETC_HOSTS_PATH_PREF,
731                                 // "c:\\windows\\system32\\drivers\\etc\\hosts");
732                         } else {
733                                 // store.setDefault(PHP_RUN_PREF, "/apache/php/php");
734                                 // store.setDefault(EXTERNAL_PARSER_PREF, "/apache/php/php -l -f
735                                 // {0}");
736                                 // store.setDefault(MYSQL_RUN_PREF, "/apache/mysql/bin/mysqld");
737                                 // store.setDefault(APACHE_RUN_PREF, "/apache/apache");
738                                 // store.setDefault(XAMPP_START_PREF, "xamp/xampp_start");
739                                 // store.setDefault(XAMPP_STOP_PREF, "xampp/xampp_stop");
740                         }
741                         // store.setDefault(MYSQL_PREF, "--standalone");
742                         // store.setDefault(APACHE_START_PREF, "-c \"DocumentRoot
743                         // \"{0}\"\"");
744                         // store.setDefault(APACHE_STOP_PREF, "-k shutdown");
745                         // store.setDefault(APACHE_RESTART_PREF, "-k restart");
746                         // store.setDefault(MYSQL_START_BACKGROUND, "true");
747                         // store.setDefault(APACHE_START_BACKGROUND, "true");
748                         // store.setDefault(APACHE_STOP_BACKGROUND, "true");
749                         // store.setDefault(APACHE_RESTART_BACKGROUND, "true");
750                 }
751
752                 // php syntax highlighting
753                 store.setDefault(PHP_USERDEF_XMLFILE, "");
754                 PreferenceConverter.setDefault(store, PHP_TAG, PHPColorProvider.TAG);
755                 PreferenceConverter.setDefault(store, PHP_KEYWORD,
756                                 PHPColorProvider.KEYWORD);
757                 PreferenceConverter.setDefault(store, PHP_VARIABLE,
758                                 PHPColorProvider.VARIABLE);
759                 PreferenceConverter.setDefault(store, PHP_VARIABLE_DOLLAR,
760                                 PHPColorProvider.VARIABLE);
761                 PreferenceConverter.setDefault(store, PHP_FUNCTIONNAME,
762                                 PHPColorProvider.FUNCTION_NAME);
763                 PreferenceConverter.setDefault(store, PHP_CONSTANT,
764                                 PHPColorProvider.CONSTANT);
765                 PreferenceConverter.setDefault(store, PHP_TYPE, PHPColorProvider.TYPE);
766                 PreferenceConverter.setDefault(store, PHP_DEFAULT,
767                                 PHPColorProvider.DEFAULT);
768                 PreferenceConverter.setDefault(store, PHPDOC_KEYWORD,
769                                 PHPColorProvider.PHPDOC_KEYWORD);
770                 PreferenceConverter.setDefault(store, PHPDOC_TAG,
771                                 PHPColorProvider.PHPDOC_TAG);
772                 PreferenceConverter.setDefault(store, PHPDOC_LINK,
773                                 PHPColorProvider.PHPDOC_LINK);
774                 PreferenceConverter.setDefault(store, PHPDOC_DEFAULT,
775                                 PHPColorProvider.PHPDOC_DEFAULT);
776
777                 PreferenceConverter.setDefault(store, EDITOR_PHP_KEYWORD_RETURN_COLOR,
778                                 new RGB(127, 0, 85));
779                 store.setDefault(EDITOR_PHP_KEYWORD_RETURN_BOLD, true);
780                 store.setDefault(EDITOR_PHP_KEYWORD_RETURN_ITALIC, false);
781
782                 PreferenceConverter.setDefault(store, EDITOR_PHP_OPERATOR_COLOR,
783                                 new RGB(0, 0, 0));
784                 store.setDefault(EDITOR_PHP_OPERATOR_BOLD, false);
785                 store.setDefault(EDITOR_PHP_OPERATOR_ITALIC, false);
786
787                 PreferenceConverter.setDefault(store, EDITOR_PHP_BRACE_OPERATOR_COLOR,
788                                 new RGB(0, 0, 0));
789                 store.setDefault(EDITOR_PHP_BRACE_OPERATOR_BOLD, false);
790                 store.setDefault(EDITOR_PHP_BRACE_OPERATOR_ITALIC, false);
791
792                 // this will initialize the static fields in the syntaxrdr class
793                 new PHPSyntaxRdr();
794                 JavaCore.initializeDefaultPluginPreferences();
795                 PreferenceConstants.initializeDefaultValues(store);
796                 // externalTools.initializeDefaultPreferences(store);
797                 // MarkerAnnotationPreferences.initializeDefaultValues(store);
798         }
799
800         private IWorkbenchPage internalGetActivePage() {
801                 IWorkbenchWindow window = getWorkbench().getActiveWorkbenchWindow();
802                 if (window != null)
803                         return window.getActivePage();
804                 return null;
805         }
806
807         private ImageDescriptorRegistry internalGetImageDescriptorRegistry() {
808                 if (fImageDescriptorRegistry == null)
809                         fImageDescriptorRegistry = new ImageDescriptorRegistry();
810                 return fImageDescriptorRegistry;
811         }
812
813         /**
814          * Open a file in the Workbench that may or may not exist in the workspace.
815          * Must be run on the UI thread.
816          * 
817          * @param filename
818          * @throws CoreException
819          */
820         public ITextEditor openFileInTextEditor(String filename)
821                         throws CoreException {
822                 // reject directories
823                 if (new File(filename).isDirectory())
824                         return null;
825                 IWorkbench workbench = PlatformUI.getWorkbench();
826                 IWorkbenchWindow window = workbench.getWorkbenchWindows()[0];
827                 IWorkbenchPage page = window.getActivePage();
828                 IPath path = new Path(filename);
829                 // If the file exists in the workspace, open it
830                 IFile file = getWorkspace().getRoot().getFileForLocation(path);
831                 IEditorPart editor;
832                 ITextEditor textEditor;
833                 if (file != null && file.exists()) {
834                         editor = IDE.openEditor(page, file, true);
835                         textEditor = (ITextEditor) editor.getAdapter(ITextEditor.class);
836                 } else {
837                         // Otherwise open the stream directly
838                         if (page == null)
839                                 return null;
840                         FileStorage storage = new FileStorage(path);
841                         IEditorRegistry registry = getWorkbench().getEditorRegistry();
842                         IEditorDescriptor desc = registry.getDefaultEditor(filename);
843                         if (desc == null) {
844                                 desc = registry
845                                                 .findEditor(IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID);
846                                 // desc = registry.getDefaultEditor();
847                         }
848                         IEditorInput input = new ExternalEditorInput(storage);
849                         editor = page.openEditor(input, desc.getId());
850                         textEditor = (ITextEditor) editor.getAdapter(ITextEditor.class);
851                         // If the storage provider is not ours, we can't guarantee
852                         // read/write.
853                         if (textEditor != null) {
854                                 IDocumentProvider documentProvider = textEditor
855                                                 .getDocumentProvider();
856                                 if (!(documentProvider instanceof ExternalStorageDocumentProvider)) {
857                                         storage.setReadOnly();
858                                 }
859                         }
860                 }
861                 return textEditor;
862         }
863
864         /**
865          * Open a file in the Workbench that may or may not exist in the workspace.
866          * Must be run on the UI thread.
867          * 
868          * @param filename
869          * @param line
870          * @throws CoreException
871          */
872         public void openFileAndGotoLine(String filename, int line)
873                         throws CoreException {
874                 ITextEditor textEditor = openFileInTextEditor(filename);
875                 if (textEditor != null) {
876                         // If a line number was given, go to it
877                         if (line > 0) {
878                                 try {
879                                         line--; // document is 0 based
880                                         IDocument document = textEditor.getDocumentProvider()
881                                                         .getDocument(textEditor.getEditorInput());
882                                         textEditor.selectAndReveal(document.getLineOffset(line),
883                                                         document.getLineLength(line));
884                                 } catch (BadLocationException e) {
885                                         // invalid text position -> do nothing
886                                 }
887                         }
888                 }
889         }
890
891         /**
892          * Open a file in the Workbench that may or may not exist in the workspace.
893          * Must be run on the UI thread.
894          * 
895          * @param filename
896          * @param offset
897          * @throws CoreException
898          */
899         public void openFileAndGotoOffset(String filename, int offset, int length)
900                         throws CoreException {
901                 ITextEditor textEditor = openFileInTextEditor(filename);
902                 if (textEditor != null) {
903                         // If a line number was given, go to it
904                         if (offset >= 0) {
905                                 IDocument document = textEditor.getDocumentProvider()
906                                                 .getDocument(textEditor.getEditorInput());
907                                 textEditor.selectAndReveal(offset, length);
908                         }
909                 }
910         }
911
912         public void openFileAndFindString(String filename, String findString)
913                         throws CoreException {
914                 ITextEditor textEditor = openFileInTextEditor(filename);
915                 if (textEditor != null) {
916                         // If a string was given, go to it
917                         if (findString != null) {
918                                 try {
919                                         IDocument document = textEditor.getDocumentProvider()
920                                                         .getDocument(textEditor.getEditorInput());
921                                         int offset = document.search(0, findString, true, false,
922                                                         true);
923                                         textEditor.selectAndReveal(offset, findString.length());
924                                 } catch (BadLocationException e) {
925                                         // invalid text position -> do nothing
926                                 }
927                         }
928                 }
929         }
930
931         public void setLastEditorFile(IFile textEditor) {
932                 this.fLastEditorFile = textEditor;
933         }
934
935         /*
936          * @see org.eclipse.core.runtime.Plugin#stop
937          */
938         public void stop(BundleContext context) throws Exception {
939                 try {
940                         // JavaCore.stop(this, context);
941                         plugin.savePluginPreferences();
942                         IWorkspace workspace = ResourcesPlugin.getWorkspace();
943                         workspace.removeResourceChangeListener(JavaModelManager
944                                         .getJavaModelManager().deltaState);
945                         workspace.removeSaveParticipant(plugin);
946
947                         JavaModelManager.getJavaModelManager().shutdown();
948
949                         // save the information from the php index files if necessary
950                         Collection collection = fIndexManagerMap.values();
951                         Iterator iterator = collection.iterator();
952                         IdentifierIndexManager indexManager = null;
953                         while (iterator.hasNext()) {
954                                 indexManager = (IdentifierIndexManager) iterator.next();
955                                 indexManager.writeFile();
956                         }
957                         if (fImageDescriptorRegistry != null)
958                                 fImageDescriptorRegistry.dispose();
959
960                         // AllTypesCache.terminate();
961
962                         if (fImageDescriptorRegistry != null)
963                                 fImageDescriptorRegistry.dispose();
964
965                         unregisterAdapters();
966
967                         // if (fASTProvider != null) {
968                         // fASTProvider.dispose();
969                         // fASTProvider= null;
970                         // }
971
972                         if (fWorkingCopyManager != null) {
973                                 fWorkingCopyManager.shutdown();
974                                 fWorkingCopyManager = null;
975                         }
976
977                         if (fCompilationUnitDocumentProvider != null) {
978                                 fCompilationUnitDocumentProvider.shutdown();
979                                 fCompilationUnitDocumentProvider = null;
980                         }
981
982                         if (fJavaTextTools != null) {
983                                 fJavaTextTools.dispose();
984                                 fJavaTextTools = null;
985                         }
986                         // JavaDocLocations.shutdownJavadocLocations();
987
988                         uninstallPreferenceStoreBackwardsCompatibility();
989
990                         // RefactoringCore.getUndoManager().shutdown();
991                 } finally {
992                         super.stop(context);
993                 }
994         }
995
996         /**
997          * Installs backwards compatibility for the preference store.
998          */
999         private void installPreferenceStoreBackwardsCompatibility() {
1000
1001                 /*
1002                  * Installs backwards compatibility: propagate the Java editor font from
1003                  * a pre-2.1 plug-in to the Platform UI's preference store to preserve
1004                  * the Java editor font from a pre-2.1 workspace. This is done only
1005                  * once.
1006                  */
1007                 String fontPropagatedKey = "fontPropagated"; //$NON-NLS-1$
1008                 if (getPreferenceStore().contains(JFaceResources.TEXT_FONT)
1009                                 && !getPreferenceStore().isDefault(JFaceResources.TEXT_FONT)) {
1010                         if (!getPreferenceStore().getBoolean(fontPropagatedKey))
1011                                 PreferenceConverter
1012                                                 .setValue(PlatformUI.getWorkbench()
1013                                                                 .getPreferenceStore(),
1014                                                                 PreferenceConstants.EDITOR_TEXT_FONT,
1015                                                                 PreferenceConverter.getFontDataArray(
1016                                                                                 getPreferenceStore(),
1017                                                                                 JFaceResources.TEXT_FONT));
1018                 }
1019                 getPreferenceStore().setValue(fontPropagatedKey, true);
1020
1021                 /*
1022                  * Backwards compatibility: set the Java editor font in this plug-in's
1023                  * preference store to let older versions access it. Since 2.1 the Java
1024                  * editor font is managed by the workbench font preference page.
1025                  */
1026                 PreferenceConverter.putValue(getPreferenceStore(),
1027                                 JFaceResources.TEXT_FONT, JFaceResources.getFontRegistry()
1028                                                 .getFontData(PreferenceConstants.EDITOR_TEXT_FONT));
1029
1030                 fFontPropertyChangeListener = new IPropertyChangeListener() {
1031                         public void propertyChange(PropertyChangeEvent event) {
1032                                 if (PreferenceConstants.EDITOR_TEXT_FONT.equals(event
1033                                                 .getProperty()))
1034                                         PreferenceConverter.putValue(getPreferenceStore(),
1035                                                         JFaceResources.TEXT_FONT,
1036                                                         JFaceResources.getFontRegistry().getFontData(
1037                                                                         PreferenceConstants.EDITOR_TEXT_FONT));
1038                         }
1039                 };
1040                 JFaceResources.getFontRegistry().addListener(
1041                                 fFontPropertyChangeListener);
1042         }
1043
1044         /**
1045          * Uninstalls backwards compatibility for the preference store.
1046          */
1047         private void uninstallPreferenceStoreBackwardsCompatibility() {
1048                 JFaceResources.getFontRegistry().removeListener(
1049                                 fFontPropertyChangeListener);
1050                 // getPreferenceStore().removePropertyChangeListener(fPropertyChangeListener);
1051         }
1052
1053         /*
1054          * (non - Javadoc) Method declared in Plugin
1055          */
1056         public void start(BundleContext context) throws Exception {
1057                 super.start(context);
1058
1059                 // JavaCore.start(this, context);
1060                 final JavaModelManager modelManager = JavaModelManager
1061                                 .getJavaModelManager();
1062                 try {
1063                         modelManager.configurePluginDebugOptions();
1064
1065                         // request state folder creation (workaround 19885)
1066                         getStateLocation();
1067                         // retrieve variable values
1068                         PHPeclipsePlugin.getDefault().getPluginPreferences()
1069                                         .addPropertyChangeListener(
1070                                                         new JavaModelManager.PluginPreferencesListener());
1071                         // manager.loadVariablesAndContainers();
1072
1073                         final IWorkspace workspace = ResourcesPlugin.getWorkspace();
1074                         workspace.addResourceChangeListener(modelManager.deltaState,
1075                                         IResourceChangeEvent.PRE_BUILD
1076                                                         | IResourceChangeEvent.POST_BUILD
1077                                                         | IResourceChangeEvent.POST_CHANGE
1078                                                         | IResourceChangeEvent.PRE_DELETE
1079                                                         | IResourceChangeEvent.PRE_CLOSE);
1080
1081                         ISavedState savedState = workspace.addSaveParticipant(
1082                                         PHPeclipsePlugin.this, modelManager);
1083
1084                         // process deltas since last activated in indexer thread so that
1085                         // indexes are up-to-date.
1086                         // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38658
1087 // This causes timeout at EclipseLazyStarter
1088 //                      Job processSavedState = new Job(Util.bind("savedState.jobName")) { //$NON-NLS-1$
1089 //                              protected IStatus run(IProgressMonitor monitor) {
1090 //                                      try {
1091 //                                              // add save participant and process delta atomically
1092 //                                              // see
1093 //                                              // https://bugs.eclipse.org/bugs/show_bug.cgi?id=59937
1094 //                                              workspace.run(new IWorkspaceRunnable() {
1095 //                                                      public void run(IProgressMonitor progress)
1096 //                                                                      throws CoreException {
1097 //                                                              ISavedState savedState = workspace
1098 //                                                                              .addSaveParticipant(
1099 //                                                                                              PHPeclipsePlugin.this,
1100 //                                                                                              modelManager);
1101 //                                                              if (savedState != null) {
1102 //                                                                      // the event type coming from the saved
1103 //                                                                      // state is always POST_AUTO_BUILD
1104 //                                                                      // force it to be POST_CHANGE so that the
1105 //                                                                      // delta processor can handle it
1106 //                                                                      modelManager.deltaState.getDeltaProcessor().overridenEventType = IResourceChangeEvent.POST_CHANGE;
1107 //                                                                      savedState
1108 //                                                                                      .processResourceChangeEvents(modelManager.deltaState);
1109 //                                                              }
1110 //                                                      }
1111 //                                              }, monitor);
1112 //                                      } catch (CoreException e) {
1113 //                                              return e.getStatus();
1114 //                                      }
1115 //                                      return Status.OK_STATUS;
1116 //                              }
1117 //                      };
1118 // Replace Job + IWorkspace.run() to WorkspaceJob
1119                         WorkspaceJob processSavedState = new WorkspaceJob(
1120                                         Util.bind("savedState.jobName")) { //$NON-NLS-1$
1121                                 public IStatus runInWorkspace(IProgressMonitor monitor)
1122                                                 throws CoreException {
1123                                         ISavedState savedState = workspace.addSaveParticipant(
1124                                                         PHPeclipsePlugin.this, modelManager);
1125                                         if (savedState != null) {
1126                                                 modelManager.deltaState.getDeltaProcessor().overridenEventType
1127                                                                 = IResourceChangeEvent.POST_CHANGE;
1128                                                 savedState.processResourceChangeEvents(modelManager.deltaState);
1129                                         }
1130                                         return Status.OK_STATUS;
1131                                 }
1132                         };
1133                         processSavedState.setSystem(true);
1134                         processSavedState.setPriority(Job.SHORT); // process asap
1135                         processSavedState.schedule();
1136                 } catch (RuntimeException e) {
1137                         modelManager.shutdown();
1138                         throw e;
1139                 }
1140
1141                 registerAdapters();
1142
1143                 // if (USE_WORKING_COPY_OWNERS) {
1144                 WorkingCopyOwner.setPrimaryBufferProvider(new WorkingCopyOwner() {
1145                         public IBuffer createBuffer(ICompilationUnit workingCopy) {
1146                                 ICompilationUnit original = workingCopy.getPrimary();
1147                                 IResource resource = original.getResource();
1148                                 if (resource instanceof IFile)
1149                                         return new DocumentAdapter(workingCopy, (IFile) resource);
1150                                 return DocumentAdapter.NULL;
1151                         }
1152                 });
1153                 // }
1154
1155                 installPreferenceStoreBackwardsCompatibility();
1156
1157         }
1158
1159         private void registerAdapters() {
1160                 fJavaElementAdapterFactory = new JavaElementAdapterFactory();
1161                 fResourceAdapterFactory = new ResourceAdapterFactory();
1162
1163                 IAdapterManager manager = Platform.getAdapterManager();
1164                 manager
1165                                 .registerAdapters(fJavaElementAdapterFactory,
1166                                                 IJavaElement.class);
1167                 manager.registerAdapters(fResourceAdapterFactory, IResource.class);
1168         }
1169
1170         private void unregisterAdapters() {
1171                 IAdapterManager manager = Platform.getAdapterManager();
1172                 manager.unregisterAdapters(fJavaElementAdapterFactory);
1173                 manager.unregisterAdapters(fResourceAdapterFactory);
1174         }
1175
1176         /**
1177          * Returns a combined preference store, this store is read-only.
1178          * 
1179          * @return the combined preference store
1180          * 
1181          * @since 3.0
1182          */
1183         public IPreferenceStore getCombinedPreferenceStore() {
1184                 if (fCombinedPreferenceStore == null) {
1185                         IPreferenceStore generalTextStore = EditorsUI.getPreferenceStore();
1186                         fCombinedPreferenceStore = new ChainedPreferenceStore(
1187                                         new IPreferenceStore[] {
1188                                                         getPreferenceStore(),
1189                                                         new PreferencesAdapter(PHPeclipsePlugin
1190                                                                         .getDefault().getPluginPreferences()),
1191                                                         generalTextStore });
1192                 }
1193                 return fCombinedPreferenceStore;
1194         }
1195
1196         public synchronized IBufferFactory getBufferFactory() {
1197                 if (fBufferFactory == null)
1198                         fBufferFactory = new CustomBufferFactory();
1199                 return fBufferFactory;
1200         }
1201
1202         /**
1203          * Returns the registry of the extensions to the
1204          * <code>net.sourceforge.phpdt.ui.javaFoldingStructureProvider</code>
1205          * extension point.
1206          * 
1207          * @return the registry of contributed
1208          *         <code>IJavaFoldingStructureProvider</code>
1209          * @since 3.0
1210          */
1211         public synchronized JavaFoldingStructureProviderRegistry getFoldingStructureProviderRegistry() {
1212                 if (fFoldingStructureProviderRegistry == null)
1213                         fFoldingStructureProviderRegistry = new JavaFoldingStructureProviderRegistry();
1214                 return fFoldingStructureProviderRegistry;
1215         }
1216
1217         /**
1218          * Runs the given action as an atomic Java model operation.
1219          * <p>
1220          * After running a method that modifies java elements, registered listeners
1221          * receive after-the-fact notification of what just transpired, in the form
1222          * of a element changed event. This method allows clients to call a number
1223          * of methods that modify java elements and only have element changed event
1224          * notifications reported at the end of the entire batch.
1225          * </p>
1226          * <p>
1227          * If this method is called outside the dynamic scope of another such call,
1228          * this method runs the action and then reports a single element changed
1229          * event describing the net effect of all changes done to java elements by
1230          * the action.
1231          * </p>
1232          * <p>
1233          * If this method is called in the dynamic scope of another such call, this
1234          * method simply runs the action.
1235          * </p>
1236          * 
1237          * @param action
1238          *            the action to perform
1239          * @param monitor
1240          *            a progress monitor, or <code>null</code> if progress
1241          *            reporting and cancellation are not desired
1242          * @exception CoreException
1243          *                if the operation failed.
1244          * @since 2.1
1245          */
1246         public static void run(IWorkspaceRunnable action, IProgressMonitor monitor)
1247                         throws CoreException {
1248                 run(action, ResourcesPlugin.getWorkspace().getRoot(), monitor);
1249         }
1250
1251         /**
1252          * Runs the given action as an atomic Java model operation.
1253          * <p>
1254          * After running a method that modifies java elements, registered listeners
1255          * receive after-the-fact notification of what just transpired, in the form
1256          * of a element changed event. This method allows clients to call a number
1257          * of methods that modify java elements and only have element changed event
1258          * notifications reported at the end of the entire batch.
1259          * </p>
1260          * <p>
1261          * If this method is called outside the dynamic scope of another such call,
1262          * this method runs the action and then reports a single element changed
1263          * event describing the net effect of all changes done to java elements by
1264          * the action.
1265          * </p>
1266          * <p>
1267          * If this method is called in the dynamic scope of another such call, this
1268          * method simply runs the action.
1269          * </p>
1270          * <p>
1271          * The supplied scheduling rule is used to determine whether this operation
1272          * can be run simultaneously with workspace changes in other threads. See
1273          * <code>IWorkspace.run(...)</code> for more details.
1274          * </p>
1275          * 
1276          * @param action
1277          *            the action to perform
1278          * @param rule
1279          *            the scheduling rule to use when running this operation, or
1280          *            <code>null</code> if there are no scheduling restrictions
1281          *            for this operation.
1282          * @param monitor
1283          *            a progress monitor, or <code>null</code> if progress
1284          *            reporting and cancellation are not desired
1285          * @exception CoreException
1286          *                if the operation failed.
1287          * @since 3.0
1288          */
1289         public static void run(IWorkspaceRunnable action, ISchedulingRule rule,
1290                         IProgressMonitor monitor) throws CoreException {
1291                 IWorkspace workspace = ResourcesPlugin.getWorkspace();
1292                 if (workspace.isTreeLocked()) {
1293                         new BatchOperation(action).run(monitor);
1294                 } else {
1295                         // use IWorkspace.run(...) to ensure that a build will be done in
1296                         // autobuild mode
1297                         workspace.run(new BatchOperation(action), rule,
1298                                         IWorkspace.AVOID_UPDATE, monitor);
1299                 }
1300         }
1301
1302         /**
1303          * Returns the template context type registry for the java plugin.
1304          * 
1305          * @return the template context type registry for the java plugin
1306          * @since 3.0
1307          */
1308         public ContextTypeRegistry getTemplateContextRegistry() {
1309                 if (fContextTypeRegistry == null) {
1310                         fContextTypeRegistry = new ContributionContextTypeRegistry();
1311
1312                         fContextTypeRegistry.addContextType(new JavaContextType());
1313                         fContextTypeRegistry.addContextType(new JavaDocContextType());
1314                         fContextTypeRegistry.addContextType(new HTMLContextType());
1315                 }
1316
1317                 return fContextTypeRegistry;
1318         }
1319
1320         /**
1321          * Returns the template store for the java editor templates.
1322          * 
1323          * @return the template store for the java editor templates
1324          * @since 3.0
1325          */
1326         public TemplateStore getTemplateStore() {
1327                 if (fTemplateStore == null) {
1328                         fTemplateStore = new ContributionTemplateStore(
1329                                         getTemplateContextRegistry(), getPreferenceStore(),
1330                                         TEMPLATES_KEY);
1331                         try {
1332                                 fTemplateStore.load();
1333                         } catch (IOException e) {
1334                                 log(e);
1335                         }
1336                 }
1337
1338                 return fTemplateStore;
1339         }
1340
1341         /**
1342          * Returns the template context type registry for the code generation
1343          * templates.
1344          * 
1345          * @return the template context type registry for the code generation
1346          *         templates
1347          * @since 3.0
1348          */
1349         public ContextTypeRegistry getCodeTemplateContextRegistry() {
1350                 if (fCodeTemplateContextTypeRegistry == null) {
1351                         fCodeTemplateContextTypeRegistry = new ContributionContextTypeRegistry();
1352
1353                         CodeTemplateContextType
1354                                         .registerContextTypes(fCodeTemplateContextTypeRegistry);
1355                 }
1356
1357                 return fCodeTemplateContextTypeRegistry;
1358         }
1359
1360         /**
1361          * Returns the template store for the code generation templates.
1362          * 
1363          * @return the template store for the code generation templates
1364          * @since 3.0
1365          */
1366         public TemplateStore getCodeTemplateStore() {
1367                 if (fCodeTemplateStore == null) {
1368                         fCodeTemplateStore = new ContributionTemplateStore(
1369                                         getCodeTemplateContextRegistry(), getPreferenceStore(),
1370                                         CODE_TEMPLATES_KEY);
1371                         try {
1372                                 fCodeTemplateStore.load();
1373                         } catch (IOException e) {
1374                                 log(e);
1375                         }
1376                 }
1377
1378                 return fCodeTemplateStore;
1379         }
1380 }