git.phpeclipse.com Git - phpeclipse.git/blob

   1 package net.sourceforge.phpeclipse.phpmanual.views;
   2
   3 import java.io.BufferedReader;
   4 import java.io.FileNotFoundException;
   5 import java.io.FileReader;
   6 import java.io.IOException;
   7 import java.io.InputStream;
   8 import java.net.URL;
   9 import java.util.ArrayList;
  10 import java.util.zip.ZipEntry;
  11 import java.util.zip.ZipFile;
  12
  13 import net.sourceforge.phpdt.internal.ui.text.JavaWordFinder;
  14 import net.sourceforge.phpdt.internal.ui.viewsupport.ISelectionListenerWithAST;
  15 import net.sourceforge.phpdt.internal.ui.viewsupport.SelectionListenerWithASTManager;
  16 import net.sourceforge.phpdt.phphelp.PHPHelpPlugin;
  17 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  18 import net.sourceforge.phpeclipse.phpeditor.PHPEditor;
  19 import net.sourceforge.phpeclipse.phpmanual.PHPManualUIPlugin;
  20
  21 import org.eclipse.core.runtime.FileLocator;
  22 import org.eclipse.core.runtime.Path;
  23 import org.eclipse.core.runtime.Platform;
  24 import org.eclipse.jface.text.IDocument;
  25 import org.eclipse.jface.text.IRegion;
  26 import org.eclipse.jface.text.ITextSelection;
  27 import org.eclipse.jface.viewers.ISelection;
  28 import org.eclipse.swt.SWT;
  29 import org.eclipse.swt.browser.Browser;
  30 import org.eclipse.swt.browser.LocationAdapter;
  31 import org.eclipse.swt.browser.LocationEvent;
  32 import org.eclipse.swt.widgets.Composite;
  33 import org.eclipse.swt.widgets.Display;
  34 import org.eclipse.ui.IEditorPart;
  35 import org.eclipse.ui.INullSelectionListener;
  36 import org.eclipse.ui.IWorkbenchPart;
  37 import org.eclipse.ui.part.ViewPart;
  38 import org.htmlparser.Node;
  39 import org.htmlparser.Parser;
  40 import org.htmlparser.tags.Div;
  41 import org.htmlparser.util.ParserException;
  42 import org.htmlparser.visitors.TagFindingVisitor;
  43 import org.osgi.framework.Bundle;
  44
  45 /**
  46  * This ViewPart is the implementation of the idea of having the
  47  * PHP Manual easily accessible while coding. It shows the
  48  * under-cursor function's reference inside a browser.
  49  * <p>
  50  * The view listens to selection changes both in the (1)workbench, to
  51  * know when the user changes between the instances of the PHPEditor
  52  * or when a new instance is created; and in the (2)PHPEditor, to know
  53  * when the user changes the cursor position. This explains the need
  54  * to implement both ISelectionListener and ISelectionListenerWithAST.
  55  * <p>
  56  * Up to now, the ViewPart show reference pages from HTML stored in the
  57  * doc.zip file from the net.sourceforge.phpeclipse.phphelp plugin. It
  58  * also depends on net.sourceforge.phpeclipse.phpmanual.htmlparser to
  59  * parse these HTML files.
  60  * <p>
  61  * @author scorphus
  62  */
  63 public class PHPManualView extends ViewPart implements INullSelectionListener, ISelectionListenerWithAST {
  64
  65         /**
  66          * The ViewPart's browser
  67          */
  68         private Browser browser;
  69
  70         /**
  71          * A reference to store last active editor to know when we've
  72          * got a new instance of the PHPEditor
  73          */
  74         private PHPEditor lastEditor;
  75
  76         /**
  77          * String that stores the last selected word
  78          */
  79         private String lastOccurrence = null;
  80
  81         /**
  82          * The path to the doc.zip file containing the PHP Manual
  83          * in HTML format
  84          */
  85         private final Path docPath = new Path("doc.zip");
  86
  87         /**
  88          * The constructor.
  89          */
  90         public PHPManualView() {
  91         }
  92
  93         /**
  94          * This method initializes the ViewPart. It instantiates components
  95          * and add listeners
  96          *
  97          * @param parent The parent control
  98          */
  99         public void createPartControl(Composite parent) {
 100                 browser = new Browser(parent, SWT.NONE);
 101                 browser.addLocationListener(new LocationAdapter() {
 102                         public void changing(LocationEvent event) {
 103                                 String loc = event.location.toString();
 104                                 if(!loc.equalsIgnoreCase("about:blank") && !loc.startsWith("jar:")) {
 105                                         String func = loc.replaceAll("file:///", "");
 106                                         func = func.replaceAll("#.+$", "");
 107                                         String[] afunc = loc.split("\\.");
 108                                         if(!afunc[1].equalsIgnoreCase(lastOccurrence)) {
 109                                                 lastOccurrence = afunc[1];
 110                                                 showLinkReference(func);
 111                                                 event.doit = false;
 112                                         }
 113                                 }
 114                         }
 115                 });
 116                 parent.pack();
 117                 if ((lastEditor = getJavaEditor()) != null) {
 118                         SelectionListenerWithASTManager.getDefault().addListener(lastEditor, this);
 119                 }
 120                 getSite().getWorkbenchWindow().getSelectionService()
 121                                 .addPostSelectionListener(PHPeclipsePlugin.EDITOR_ID, this);
 122         }
 123
 124         /**
 125          * Cleanup to remove the selection listener
 126          */
 127         public void dispose() {
 128                 getSite().getWorkbenchWindow().getSelectionService()
 129                                 .removePostSelectionListener(PHPeclipsePlugin.EDITOR_ID, this);
 130         }
 131
 132         /**
 133          * Passing the focus request to the viewer's control.
 134          */
 135         public void setFocus() {
 136                 browser.setFocus();
 137         }
 138
 139         /**
 140          * Treats selection changes from the PHPEditor
 141          */
 142         public void selectionChanged(IEditorPart part, ITextSelection selection) {
 143                 IDocument document = ((PHPEditor)part).getViewer().getDocument();
 144                 int offset = selection.getOffset();
 145                 IRegion iRegion = JavaWordFinder.findWord(document, offset);
 146                 if (document != null && iRegion != null) {
 147                         try {
 148                                 final String wordStr = document.get(iRegion.getOffset(),
 149                                                 iRegion.getLength());
 150                                 if (!wordStr.equalsIgnoreCase(lastOccurrence)) {
 151                                         showReference(wordStr);
 152                                         lastOccurrence = wordStr;
 153                                 }
 154                         } catch (Exception e) {
 155                                 e.printStackTrace();
 156                         }
 157                 }
 158         }
 159
 160         /**
 161          * Treats selection changes from the workbench. When part is new
 162          * instance of PHPEditor it gets a listener attached
 163          */
 164         public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 165                 if (part != null && !((PHPEditor)part).equals(lastEditor)) {
 166                         SelectionListenerWithASTManager.getDefault().addListener((PHPEditor)part, this);
 167                         lastEditor = (PHPEditor)part;
 168                 } else {
 169                         System.out.println(part);
 170                 }
 171         }
 172
 173         /**
 174          * Updates the browser with the reference page for a given function
 175          *
 176          * @param funcName Function name
 177          */
 178         private void showReference(final String funcName) {
 179                 new Thread(new Runnable() {
 180                         public void run() {
 181                                 Display.getDefault().asyncExec(new Runnable() {
 182                                         public void run() {
 183                                                 String html = getHtmlSource(funcName);
 184                                                 browser.setText(html);
 185                                         }
 186                                 });
 187                         }
 188                 }).start();
 189         }
 190
 191         /**
 192          * Updates the browser with the reference page for a given function
 193          *
 194          * @param funcName Function name
 195          */
 196         private void showLinkReference(final String funcName) {
 197                 new Thread(new Runnable() {
 198                         public void run() {
 199                                 Display.getDefault().asyncExec(new Runnable() {
 200                                         public void run() {
 201                                                 String html = getLinkHtmlSource(funcName);
 202                                                 browser.setText(html);
 203                                         }
 204                                 });
 205                         }
 206                 }).start();
 207         }
 208
 209         /**
 210          * Filters the function's reference page extracting only parts of it
 211          *
 212          * @param source HTML source of the reference page
 213          * @return HTML source of reference page
 214          */
 215         private String filterIniHtmlSource(String source) {
 216                 try {
 217                         Parser parser = new Parser(source);
 218                         String [] tagsToBeFound = {"DIV"};
 219                         ArrayList classList = new ArrayList(8);
 220                         classList.add("section");
 221                         classList.add("title");
 222                         classList.add("refsect1 parameters");
 223                         classList.add("refsect1 returnvalues");
 224                         classList.add("refsect1 examples");
 225                         classList.add("refsect1 seealso");
 226                         classList.add("refsect1 u");
 227                         TagFindingVisitor visitor = new TagFindingVisitor(tagsToBeFound);
 228                         parser.visitAllNodesWith(visitor);
 229                         Node [] allPTags = visitor.getTags(0);
 230                         StringBuffer output = new StringBuffer();
 231                         for (int i = 0; i < allPTags.length; i++) {
 232                                 String tagClass = ((Div)allPTags[i]).getAttribute("class");
 233                                 if (classList.contains(tagClass)) {
 234                                         output.append(allPTags[i].toHtml());
 235                                 }
 236                         }
 237                         return output.toString().replaceAll("—", "-");
 238                         //.replace("<h3 class=\"title\">Description</h3>", " ");
 239                 } catch (ParserException e) {
 240                         e.printStackTrace();
 241                 }
 242                 return "";
 243         }
 244
 245         /**
 246          * Filters the function's reference page extracting only parts of it
 247          *
 248          * @param source HTML source of the reference page
 249          * @return HTML source of reference page
 250          */
 251         private String filterLangHtmlSource(String source) {
 252                 try {
 253                         Parser parser = new Parser(source);
 254                         String [] tagsToBeFound = {"DIV"};
 255                         ArrayList classList = new ArrayList(8);
 256                         classList.add("sect1");
 257                         classList.add("title");
 258                         classList.add("refsect1 parameters");
 259                         classList.add("refsect1 returnvalues");
 260                         classList.add("refsect1 examples");
 261                         classList.add("refsect1 seealso");
 262                         classList.add("refsect1 u");
 263                         TagFindingVisitor visitor = new TagFindingVisitor(tagsToBeFound);
 264                         parser.visitAllNodesWith(visitor);
 265                         Node [] allPTags = visitor.getTags(0);
 266                         StringBuffer output = new StringBuffer();
 267                         for (int i = 0; i < allPTags.length; i++) {
 268                                 String tagClass = ((Div)allPTags[i]).getAttribute("class");
 269                                 if (classList.contains(tagClass)) {
 270                                         output.append(allPTags[i].toHtml());
 271                                 }
 272                         }
 273                         return output.toString().replaceAll("—", "-");
 274                         //.replace("<h3 class=\"title\">Description</h3>", " ");
 275                 } catch (ParserException e) {
 276                         e.printStackTrace();
 277                 }
 278                 return "";
 279         }
 280
 281         /**
 282          * Filters the function's reference page extracting only parts of it
 283          *
 284          * @param source HTML source of the reference page
 285          * @return HTML source of reference page
 286          */
 287         private String filterRefHtmlSource(String source) {
 288                 try {
 289                         Parser parser = new Parser(source);
 290                         String [] tagsToBeFound = {"DIV"};
 291                         ArrayList classList = new ArrayList(8);
 292                         classList.add("partintro");
 293                         classList.add("section");
 294                         classList.add("title");
 295                         classList.add("refsect1 parameters");
 296                         classList.add("refsect1 returnvalues");
 297                         classList.add("refsect1 examples");
 298                         classList.add("refsect1 seealso");
 299                         classList.add("refsect1 u");
 300                         TagFindingVisitor visitor = new TagFindingVisitor(tagsToBeFound);
 301                         parser.visitAllNodesWith(visitor);
 302                         Node [] allPTags = visitor.getTags(0);
 303                         StringBuffer output = new StringBuffer();
 304                         for (int i = 0; i < allPTags.length; i++) {
 305                                 String tagClass = ((Div)allPTags[i]).getAttribute("class");
 306                                 if (classList.contains(tagClass)) {
 307                                         output.append(allPTags[i].toHtml());
 308                                 }
 309                         }
 310                         return output.toString().replaceAll("—", "-");
 311                         //.replace("<h3 class=\"title\">Description</h3>", " ");
 312                 } catch (ParserException e) {
 313                         e.printStackTrace();
 314                 }
 315                 return "";
 316         }
 317
 318         /**
 319          * Filters the function's reference page extracting only parts of it
 320          *
 321          * @param source HTML source of the reference page
 322          * @return HTML source of reference page
 323          */
 324         private String filterHtmlSource(String source) {
 325                 try {
 326                         Parser parser = new Parser(source);
 327                         String [] tagsToBeFound = {"DIV"};
 328                         ArrayList classList = new ArrayList(8);
 329                         classList.add("refnamediv");
 330                         classList.add("refsect1 description");
 331                         classList.add("refsect1 parameters");
 332                         classList.add("refsect1 returnvalues");
 333                         classList.add("refsect1 examples");
 334                         classList.add("refsect1 seealso");
 335                         classList.add("refsect1 u");
 336                         TagFindingVisitor visitor = new TagFindingVisitor(tagsToBeFound);
 337                         parser.visitAllNodesWith(visitor);
 338                         Node [] allPTags = visitor.getTags(0);
 339                         StringBuffer output = new StringBuffer();
 340                         for (int i = 0; i < allPTags.length; i++) {
 341                                 String tagClass = ((Div)allPTags[i]).getAttribute("class");
 342                                 if (classList.contains(tagClass)) {
 343                                         output.append(allPTags[i].toHtml());
 344                                 }
 345                         }
 346                         return output.toString().replaceAll("—", "-");
 347                         //.replace("<h3 class=\"title\">Description</h3>", " ");
 348                 } catch (ParserException e) {
 349                         e.printStackTrace();
 350                 }
 351                 return "";
 352         }
 353         /**
 354          * Reads the template that defines the style of the reference page
 355          * shown inside the view's browser
 356          *
 357          * @return HTML source of the template
 358          */
 359         public String getRefPageTemplate() {
 360                 Bundle bundle = Platform.getBundle(PHPManualUIPlugin.PLUGIN_ID);
 361                 URL fileURL = FileLocator.find(bundle, new Path("templates"), null);
 362                 StringBuffer contents = new StringBuffer();
 363                 BufferedReader input = null;
 364                 try {
 365                         URL resolve = FileLocator.resolve(fileURL);
 366                         input = new BufferedReader(new FileReader(resolve.getPath()+"/refpage.html"));
 367                         String line = null;
 368                         while ((line = input.readLine()) != null){
 369                                 contents.append(line);
 370                         }
 371                 }
 372                 catch (FileNotFoundException e) {
 373                         e.printStackTrace();
 374                 } catch (IOException e) {
 375                         e.printStackTrace();
 376                 }
 377                 finally {
 378                         try {
 379                                 if (input!= null) {
 380                                         input.close();
 381                                 }
 382                         }
 383                         catch (IOException ex) {
 384                                 ex.printStackTrace();
 385                         }
 386                 }
 387                 return contents.toString();
 388         }
 389
 390         /**
 391          * Replaces each substring of source string that matches the
 392          * given pattern string with the given replace string
 393          *
 394          * @param source The source string
 395          * @param pattern The pattern string
 396          * @param replace The replace string
 397          * @return The resulting String
 398          */
 399         public static String replace(String source, String pattern, String replace) {
 400                 if (source != null) {
 401                         final int len = pattern.length();
 402                         StringBuffer sb = new StringBuffer();
 403                         int found = -1;
 404                         int start = 0;
 405                         while ((found = source.indexOf(pattern, start)) != -1) {
 406                                 sb.append(source.substring(start, found));
 407                                 sb.append(replace);
 408                                 start = found + len;
 409                         }
 410                         sb.append(source.substring(start));
 411                         return sb.toString();
 412                 } else {
 413                         return "";
 414                 }
 415         }
 416
 417         /**
 418          * Looks for the function's reference page inside the doc.zip file and
 419          * returns a filtered HTML source of it embedded in the template
 420          *
 421          * @param funcName
 422          *            Function name
 423          * @return HTML source of reference page
 424          */
 425         public String getHtmlSource(String funcName) {
 426                 Bundle bundle = Platform.getBundle(PHPHelpPlugin.PLUGIN_ID);
 427                 URL fileURL = FileLocator.find(bundle, docPath, null);
 428                 ZipEntry entry;
 429                 byte[] b = null;
 430                 try {
 431                         URL resolve = FileLocator.resolve(fileURL);
 432                         ZipFile docFile = new ZipFile(resolve.getPath());
 433                         entry = docFile.getEntry("doc/function."+funcName.replace('_', '-')+".html");
 434                         if(entry == null){
 435                                 entry = docFile.getEntry("doc/ini."+funcName.replace('_', '-')+".html");
 436                         }
 437                         InputStream ref = docFile.getInputStream(entry);
 438                         b = new byte[(int)entry.getSize()];
 439                         ref.read(b, 0, (int)entry.getSize());
 440                         if (b != null) {
 441                                 String reference = filterHtmlSource(new String(b));
 442                                 String refPageTpl = getRefPageTemplate();
 443                                 refPageTpl = refPageTpl.replaceAll("%title%", funcName);
 444                                 refPageTpl = replace(refPageTpl, "%reference%", reference);
 445                                 return refPageTpl;
 446                         }
 447                 } catch (IOException e) {
 448                         return "<html></html>";
 449                 } catch (Exception e) {
 450                         return null;
 451                 }
 452                 return "<html></html>";
 453         }
 454
 455         /**
 456          * Looks for the function's reference page inside the doc.zip file and
 457          * returns a filtered HTML source of it embedded in the template
 458          *
 459          * @param funcName
 460          *            Function name
 461          * @return HTML source of reference page
 462          */
 463         public String getLinkHtmlSource(String funcName) {
 464                 Bundle bundle = Platform.getBundle(PHPHelpPlugin.PLUGIN_ID);
 465                 URL fileURL = FileLocator.find(bundle, docPath, null);
 466                 ZipEntry entry;
 467                 byte[] b = null;
 468                 try {
 469                         URL resolve = FileLocator.resolve(fileURL);
 470                         ZipFile docFile = new ZipFile(resolve.getPath());
 471                         entry = docFile.getEntry("doc/"+funcName);
 472                         InputStream ref = docFile.getInputStream(entry);
 473                         b = new byte[(int)entry.getSize()];
 474                         ref.read(b, 0, (int)entry.getSize());
 475                         if (b != null) {
 476                                 String reference = null;
 477                                 String aFuncName = funcName.toString();
 478                                 if(aFuncName.startsWith("function")){
 479                                         reference = filterHtmlSource(new String(b));
 480                                 } else if (aFuncName.startsWith("ini")){
 481                                         reference = filterIniHtmlSource(new String(b));
 482                                 } else if (aFuncName.startsWith("install")){
 483                                         reference = filterIniHtmlSource(new String(b));
 484                                 } else if (aFuncName.startsWith("language")){
 485                                         reference = filterLangHtmlSource(new String(b));
 486                                 } else if (aFuncName.startsWith("ref")){
 487                                         reference = filterRefHtmlSource(new String(b));
 488                                 }
 489                                 String refPageTpl = getRefPageTemplate();
 490                                 refPageTpl = refPageTpl.replaceAll("%title%", funcName);
 491                                 refPageTpl = replace(refPageTpl, "%reference%", reference);
 492                                 return refPageTpl;
 493                         }
 494                 } catch (IOException e) {
 495                         return "<html></html>";
 496                 } catch (Exception e) {
 497                         return null;
 498                 }
 499                 return "<html></html>";
 500         }
 501         /**
 502          * Returns the currently active java editor, or <code>null</code> if it
 503          * cannot be determined.
 504          *
 505          * @return the currently active java editor, or <code>null</code>
 506          */
 507         private PHPEditor getJavaEditor() {
 508                 try {
 509                         IEditorPart part = PHPeclipsePlugin.getActivePage().getActiveEditor();
 510                         if (part instanceof PHPEditor)
 511                                 return (PHPEditor) part;
 512                         else
 513                                 return null;
 514                 } catch (Exception e) {
 515                         return null;
 516                 }
 517         }
 518
 519 }