25 	private final IAction refreshAction = new Action("Refresh") {

    30     private final IAction refreshAction = new Action("Refresh") {

    26 		public void run() {

    31         public void run() {

    27 			refresh(true);

    32             refresh(true);

    28 		};

    33         };

    29 	};

    34     };

    30 	private final IAction toggleRefresh = new Action("Toggle Refresh", IAction.AS_RADIO_BUTTON) {

    35     private final IAction toggleRefresh = new Action("Toggle Refresh", IAction.AS_RADIO_BUTTON) {

    31 		public void run() {

    36         public void run() {

    32 			toggleRefresh();

    37             toggleRefresh();

    33 		};

    38         };

    34 	};

    39     };

    35 

    40 

    36     protected final IProject project;

    41     protected IProject project;

    37 	private Browser browser;

    42     private Browser browser;

    38 	private boolean toggleState = true;

    43     private boolean toggleState = true;

    39 	private final PreviewView previewView;

    44     private final PreviewView previewView;

    40 	private boolean needsRefresh = false;

    45     private boolean needsRefresh = false;

    41 

    46     private Composite pane;

    42 	public AbstractPreviewPage(IProject project, PreviewView previewView) {

    47 

    43 		this.project = project;

    48     public AbstractPreviewPage(IProject project, PreviewView previewView) {

    44 		this.previewView = previewView;

    49         this.project = project;

    45 	}

    50         this.previewView = previewView;

    46 

    51     }

    47 	protected void toggleRefresh() {

    52 

    48 		toggleState = !toggleState;

    53     protected void toggleRefresh() {

    49 		toggleRefresh.setChecked(toggleState);

    54         toggleState = !toggleState;

    50 		previewView.setProjectAutorefresh(project, toggleState);

    55         toggleRefresh.setChecked(toggleState);

    51 		toggleRefresh.setToolTipText(getToggleActionTooltip());

    56         previewView.setProjectAutorefresh(project, toggleState);

    52 		if (toggleState && needsRefresh) {

    57         toggleRefresh.setToolTipText(getToggleActionTooltip());

    53 			refresh(true);

    58         if (toggleState && needsRefresh) {

    54 		}

    59             refresh(true);

    55 	}

    60         }

    56 

    61     }

    57 	

    62 

    58 	@Override

    63     @Override

    59 	public void createControl(Composite parent) {

    64     public void createControl(Composite parent) {

    60 		browser = createBrowser(parent);

    65         pane = new Composite(parent, SWT.EMBEDDED);

    61 		browser.setUrl(getURI().toASCIIString());

    66         GridLayout layout = new GridLayout();

    62 	}

    67         layout.marginWidth = 0;

    63 

    68         layout.marginHeight = 0;

    64 	protected abstract Browser createBrowser(Composite parent);

    69         pane.setLayout(layout);

    65 

    70         addBrowser();

    66 	private URI getURI() {

    71     }

    67 		return PreviewerPlugin.getDefault().getHttpPreviewer().previewProject(project);

    72 

    68 	}

    73     private void addBrowser() {

    69 

    74         browser = createBrowser(pane);

    70 	@Override

    75         browser.setLayoutData(new GridData(GridData.FILL_BOTH));

    71 	public Control getControl() {

    76         browser.setUrl(getURI().toASCIIString());

    72 		return browser;

    77         pane.layout();

    73 	}

    78     }

    74 

    79 

    75 	@Override

    80     protected abstract Browser createBrowser(Composite parent);

    76 	public void setFocus() {

    81 

    77 		if (browser != null && !browser.isDisposed()) {

    82     private URI getURI() {

    78 			browser.setFocus();

    83         return PreviewerPlugin.getDefault().getHttpPreviewer().previewProject(project);

    79 		}

    84     }

    80 	}

    85 

    81 	

    86     @Override

    82 	private boolean refreshScheduled = false;

    87     public Control getControl() {

    83 

    88         return pane;

    84 	public synchronized void process(Collection<IFile> files) {

    89     }

    85 		if (!refreshScheduled && needsRefresh(files)) {

    90 

    86 			asyncExec(new Runnable() {

    91     @Override

    87 				public void run() {

    92     public void setFocus() {

    88 					refreshBrowser();

    93         if (browser != null && !browser.isDisposed()) {

    89 				}

    94             browser.setFocus();

    90 			});

    95         }

    91 			refreshScheduled = true;

    96     }

    92 		}

    97 

    93 	}

    98     private boolean refreshScheduled = false;

    94 

    99 

    95 	protected void promptIfNeeded() {

   100     public synchronized void process(Collection<IFile> files) {

    96 		if (toggleState) {

   101         if (!refreshScheduled && needsRefresh(files)) {

    97 			toggleState = previewView.promptUserToToggle(project, toggleState);

   102             asyncExec(new Runnable() {

    98 			toggleRefresh.setChecked(toggleState);

   103                 public void run() {

    99 		}

   104                     refreshBrowser();

   100 	}

   105                 }

   101 

   106             });

   102 	private void asyncExec(Runnable runnable) {

   107             refreshScheduled = true;

   103 		getControl().getDisplay().asyncExec(runnable);

   108         }

   104 	}

   109     }

   105 

   110 

   106 	private boolean needsRefresh(Collection<IFile> files) {

   111     protected void promptIfNeeded() {

   107 		for (IFile iFile : files) {

   112         if (toggleState) {

   108 			if (iFile.getProject().equals(project)) {

   113             toggleState = previewView.promptUserToToggle(project, toggleState);

   109 				return true;

   114             toggleRefresh.setChecked(toggleState);

   110 			}

   115         }

   111 		}

   116     }

   112 		return false;

   117 

   113 	}

   118     private void asyncExec(Runnable runnable) {

   114 

   119         getControl().getDisplay().asyncExec(runnable);

   115 	protected synchronized void refresh(boolean manual) {

   120     }

   116 		try {

   121 

   117 			if (!browser.isDisposed()) {

   122     private boolean needsRefresh(Collection<IFile> files) {

   118 				final Control focusControl = browser.getDisplay().getFocusControl();

   123         for (IFile iFile : files) {

   119 				browser.refresh();

   124             if (iFile.getProject().equals(project)) {

   120 				refreshAction.setImageDescriptor(PreviewerPlugin.getImageDescriptor(Images.GREEN_SYNC));

   125                 return true;

   121 				if (!manual && focusControl != null) {

   126             }

   122 					asyncExec(new Runnable() {

   127         }

   123 						public void run() {

   128         return false;

   124 							focusControl.setFocus();

   129     }

   125 						}

   130 

   126 					});

   131     protected synchronized void refresh(boolean manual) {

   127 				}

   132         try {

   128 				refreshAction.setToolTipText("Refresh the preview browser");

   133             if (!isDisposed()) {

   129 			}

   134                 final Control focusControl = browser.getDisplay().getFocusControl();

   130 			needsRefresh = false;

   135                 browser.refresh();

   131 		} finally {

   136                 refreshAction.setImageDescriptor(PreviewerPlugin.getImageDescriptor(Images.GREEN_SYNC));

   132 			refreshScheduled = false;

   137                 if (!manual && focusControl != null) {

   133 		}

   138                     asyncExec(new Runnable() {

   134 	}

   139                         public void run() {

   135 

   140                             focusControl.setFocus();

   136 	@Override

   141                         }

   137 	public void init(IPageSite pageSite) {

   142                     });

   138 		super.init(pageSite);

   143                 }

   139 		IToolBarManager toolBar = pageSite.getActionBars().getToolBarManager();

   144                 refreshAction.setToolTipText("Refresh the preview browser");

   145             }

   146             needsRefresh = false;

   147         } finally {

   148             refreshScheduled = false;

   149         }

   150     }

   151 

   152     @Override

   153     public void init(IPageSite pageSite) {

   154         super.init(pageSite);

   155         IToolBarManager toolBar = pageSite.getActionBars().getToolBarManager();

   143 		refreshAction.setImageDescriptor(PreviewerPlugin.getImageDescriptor(Images.GREEN_SYNC));

   159         refreshAction.setImageDescriptor(PreviewerPlugin.getImageDescriptor(Images.GREEN_SYNC));

   144 		refreshAction.setToolTipText("Refresh the preview browser");

   160         refreshAction.setToolTipText("Refresh the preview browser");

   145 		toolBar.add(refreshAction);

   161         toolBar.add(refreshAction);

   146 		

   162 

   147 		toggleState = previewView.getProjectAutorefresh(project);

   163         toggleState = previewView.getProjectAutorefresh(project);

   148 		

   164 

   149 		toggleRefresh.setImageDescriptor(PreviewerPlugin.getImageDescriptor(Images.YELLOW_SYNC));

   165         toggleRefresh.setImageDescriptor(PreviewerPlugin.getImageDescriptor(Images.YELLOW_SYNC));

   150 		toggleRefresh.setToolTipText(getToggleActionTooltip());

   166         toggleRefresh.setToolTipText(getToggleActionTooltip());

   151 		toggleRefresh.setChecked(toggleState);

   167         toggleRefresh.setChecked(toggleState);

   152 		toolBar.add(toggleRefresh);

   168         toolBar.add(toggleRefresh);

   153 		

   169 

   154 		pageSite.getActionBars().setGlobalActionHandler(ActionFactory.REFRESH.getId(), refreshAction);

   170         pageSite.getActionBars().setGlobalActionHandler(ActionFactory.REFRESH.getId(), refreshAction);

   155 		getSite().setSelectionProvider(this);

   171         getSite().setSelectionProvider(this);

   156 	}

   172     }

   163 		return toggleState ? "Disable preview autorefresh" : "Enable preview autorefresh";

   179         return toggleState ? "Disable preview autorefresh" : "Enable preview autorefresh";

   164 	}

   180     }

   165 

   181 

   166 	public void addSelectionChangedListener(ISelectionChangedListener listener) {

   182     public void addSelectionChangedListener(ISelectionChangedListener listener) {

   167 		// Do nothing

   183         // Do nothing

   168 	}

   184     }

   169 

   185 

   170 	public ISelection getSelection() {

   186     public ISelection getSelection() {

   171 		return new StructuredSelection(project);

   187         return new StructuredSelection(project);

   172 	}

   188     }

   173 

   189 

   174 	public void removeSelectionChangedListener(

   190     public void removeSelectionChangedListener(ISelectionChangedListener listener) {

   175 			ISelectionChangedListener listener) {

   191         // Do nothing

   176 		// Do nothing

   192     }

   177 	}

   193 

   178 

   194     public void setSelection(ISelection selection) {

   179 	public void setSelection(ISelection selection) {

   195         // Do nothing

   180 		// Do nothing

   196     }

   181 	}

   197 

   182 

   198     public boolean isDisposed() {

   183 	public boolean isDisposed() {

   199         return browser != null && browser.isDisposed();

   184 		return browser != null && browser.isDisposed();

   200     }

   185 	}

   201 

   186 

   202     private synchronized void refreshBrowser() {

   187 	private synchronized void refreshBrowser() {

   203         if (toggleState) {

   188 		if (toggleState) {

   204             promptIfNeeded();

   189 			promptIfNeeded();

   205         }

   190 		}

   206         if (toggleState) {

   191 		if (toggleState) {

   207             refresh(false);

   192 			refresh(false);

   208         } else {

   193 		} else {

   209             needsRefresh = true;

   194 			needsRefresh = true;

   210             refreshAction.setImageDescriptor(PreviewerPlugin.getImageDescriptor(Images.RED_SYNC));

   195 			refreshAction.setImageDescriptor(PreviewerPlugin.getImageDescriptor(Images.RED_SYNC));

   211             refreshAction.setToolTipText("Refresh the preview browser (there are updated files)");

   196 			refreshAction.setToolTipText("Refresh the preview browser (there are updated files)");

   212         }

   197 		}

   213     }

   198 	}

   214 

   215     public IProject getProject() {

   216         return project;

   217     }

   218 

   219     public synchronized void projectRenamed(IPath newPath) {

   220         project = ResourcesPlugin.getWorkspace().getRoot().getProject(newPath.lastSegment());

   221         asyncExec(new Runnable() {

   222             public void run() {

   223                 browser.dispose();

   224                 addBrowser();

   225             }

   226         });

   227     }