7f91e31c1442cb116448985b85178320b9581be5
[phpeclipse.git] / net.sourceforge.phpeclipse.ui / src / net / sourceforge / phpdt / internal / ui / text / java / JavaReconcilingStrategy.java
1 /***********************************************************************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made
3  * available under the terms of the Common Public License v1.0 which accompanies this distribution, and is available at
4  * http://www.eclipse.org/legal/cpl-v10.html
5  * 
6  * Contributors: IBM Corporation - initial API and implementation
7  **********************************************************************************************************************************/
8
9 package net.sourceforge.phpdt.internal.ui.text.java;
10
11 import net.sourceforge.phpdt.core.ICompilationUnit;
12 import net.sourceforge.phpdt.core.JavaModelException;
13 import net.sourceforge.phpdt.ui.IWorkingCopyManager;
14 import net.sourceforge.phpeclipse.ui.WebUI;
15 //import net.sourceforge.phpeclipse.PHPeclipsePlugin;
16
17 import org.eclipse.core.runtime.IProgressMonitor;
18 import org.eclipse.core.runtime.NullProgressMonitor;
19 import org.eclipse.jface.text.IDocument;
20 import org.eclipse.jface.text.IRegion;
21 import org.eclipse.jface.text.reconciler.DirtyRegion;
22 import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
23 import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
24 import org.eclipse.jface.text.source.IAnnotationModel;
25 import org.eclipse.ui.texteditor.IDocumentProvider;
26 import org.eclipse.ui.texteditor.ITextEditor;
27
28 public class JavaReconcilingStrategy implements IReconcilingStrategy,
29                 IReconcilingStrategyExtension {
30
31         private ITextEditor fEditor;
32
33         private IWorkingCopyManager fManager;
34
35         private IDocumentProvider fDocumentProvider;
36
37         private IProgressMonitor fProgressMonitor;
38
39         private boolean fNotify = true;
40
41         private IJavaReconcilingListener fJavaReconcilingListener;
42
43         private boolean fIsJavaReconcilingListener;
44
45         public JavaReconcilingStrategy(ITextEditor editor) {
46                 fEditor = editor;
47                 fManager = WebUI.getDefault().getWorkingCopyManager();
48                 fDocumentProvider = WebUI.getDefault()
49                                 .getCompilationUnitDocumentProvider();
50                 fIsJavaReconcilingListener = fEditor instanceof IJavaReconcilingListener;
51                 if (fIsJavaReconcilingListener)
52                         fJavaReconcilingListener = (IJavaReconcilingListener) fEditor;
53         }
54
55         private IProblemRequestorExtension getProblemRequestorExtension() {
56                 IAnnotationModel model = fDocumentProvider.getAnnotationModel(fEditor
57                                 .getEditorInput());
58                 if (model instanceof IProblemRequestorExtension)
59                         return (IProblemRequestorExtension) model;
60                 return null;
61         }
62
63         private void reconcile() {
64                 // // try {
65                 //
66                 // /* fix for missing cancel flag communication */
67                 // IProblemRequestorExtension extension =
68                 // getProblemRequestorExtension();
69                 // if (extension != null)
70                 // extension.setProgressMonitor(fProgressMonitor);
71                 //
72                 // // reconcile
73                 // // synchronized (unit) {
74                 // // unit.reconcile(true, fProgressMonitor);
75                 // // }
76                 //
77                 // Parser parser = new Parser();
78                 // parser.initializeScanner();
79                 // // actualParser.setFileToParse(fileToParse);
80                 // String text =
81                 // fEditor.getDocumentProvider().getDocument(fEditor.getEditorInput()).get();
82                 // parser.init(text);
83                 // parser.reportSyntaxError();
84                 // // checkAndReportBracketAnomalies(parser.problemReporter());
85                 //
86                 // /* fix for missing cancel flag communication */
87                 // if (extension != null)
88                 // extension.setProgressMonitor(null);
89                 //
90                 // // update participants
91                 // try {
92                 // if (fEditor instanceof IReconcilingParticipant && fNotify &&
93                 // !fProgressMonitor.isCanceled()) {
94                 // IReconcilingParticipant p = (IReconcilingParticipant) fEditor;
95                 // p.reconciled();
96                 // }
97                 // } finally {
98                 // fNotify = true;
99                 // }
100
101                 // JDT implementation:
102                 try {
103                         ICompilationUnit unit = fManager.getWorkingCopy(fEditor
104                                         .getEditorInput());
105                         if (unit != null) {
106                                 try {
107
108                                         /* fix for missing cancel flag communication */
109                                         IProblemRequestorExtension extension = getProblemRequestorExtension();
110                                         if (extension != null)
111                                                 extension.setProgressMonitor(fProgressMonitor);
112
113                                         // reconcile
114                                         synchronized (unit) {
115                                                 unit.reconcile(true, fProgressMonitor);
116                                         }
117
118                                         /* fix for missing cancel flag communication */
119                                         if (extension != null)
120                                                 extension.setProgressMonitor(null);
121
122                                         // update participants
123                                         try {
124                                                 if (fEditor instanceof IReconcilingParticipant
125                                                                 && fNotify && !fProgressMonitor.isCanceled()) {
126                                                         IReconcilingParticipant p = (IReconcilingParticipant) fEditor;
127                                                         p.reconciled();
128                                                 }
129                                         } finally {
130                                                 fNotify = true;
131                                         }
132
133                                 } catch (JavaModelException x) {
134                                         // swallow exception
135                                 }
136                         }
137                 } finally {
138                         // Always notify listeners, see
139                         // https://bugs.eclipse.org/bugs/show_bug.cgi?id=55969 for the final
140                         // solution
141                         try {
142                                 if (fIsJavaReconcilingListener) {
143                                         IProgressMonitor pm = fProgressMonitor;
144                                         if (pm == null)
145                                                 pm = new NullProgressMonitor();
146                                         fJavaReconcilingListener.reconciled(null, !fNotify, pm);
147                                 }
148                         } finally {
149                                 fNotify = true;
150                         }
151
152                 }
153         }
154
155         /*
156          * @see IReconcilingStrategy#reconcile(IRegion)
157          */
158         public void reconcile(IRegion partition) {
159                 reconcile();
160         }
161
162         /*
163          * @see IReconcilingStrategy#reconcile(DirtyRegion, IRegion)
164          */
165         public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
166                 reconcile();
167         }
168
169         /*
170          * @see IReconcilingStrategy#setDocument(IDocument)
171          */
172         public void setDocument(IDocument document) {
173         }
174
175         /*
176          * @see IReconcilingStrategyExtension#setProgressMonitor(IProgressMonitor)
177          */
178         public void setProgressMonitor(IProgressMonitor monitor) {
179                 fProgressMonitor = monitor;
180         }
181
182         /*
183          * @see IReconcilingStrategyExtension#initialReconcile()
184          */
185         public void initialReconcile() {
186                 reconcile();
187         }
188
189         /**
190          * Tells this strategy whether to inform its participants.
191          * 
192          * @param notify
193          *            <code>true</code> if participant should be notified
194          */
195         public void notifyParticipants(boolean notify) {
196                 fNotify = notify;
197         }
198
199         /**
200          * Tells this strategy whether to inform its listeners.
201          * 
202          * @param notify
203          *            <code>true</code> if listeners should be notified
204          */
205         public void notifyListeners(boolean notify) {
206                 fNotify = notify;
207         }
208
209         /**
210          * Called before reconciling is started.
211          * 
212          * @since 3.0
213          */
214         public void aboutToBeReconciled() {
215                 if (fIsJavaReconcilingListener)
216                         fJavaReconcilingListener.aboutToBeReconciled();
217         }
218 }