workbench.java

java写的crawler

     *   Command handling
     * * * * * * * * * * * * * * * * * * * * * * */
    
    protected void finalize () {
        // FIX: dispose of frames
    }
    
    void close () {
        if (!allowExit)
            return;
        
        // FIX: dispose of frames

        if (Context.isApplication()) {
            //#ifdef JDK1.1
            Runtime.runFinalizersOnExit (true);
            //#endif JDK1.1
            System.exit (0);
        }
    }

    public void refresh () {
        graph.updateClosure (crawler.getCrawledRoots ());
        outline.updateClosure (crawler.getCrawledRoots ());
    }

    void connectVisualization (Crawler crawler, Object viz, boolean linksToo) {
        if (viz instanceof CrawlListener)
            crawler.addCrawlListener ((CrawlListener)viz);
        if (linksToo && viz instanceof LinkListener)
            crawler.addLinkListener ((LinkListener)viz);
    }

    void disconnectVisualization (Crawler crawler, Object viz, boolean linksToo) {
        if (viz instanceof CrawlListener)
            crawler.removeCrawlListener ((CrawlListener)viz);
        if (linksToo && viz instanceof LinkListener)
            crawler.removeLinkListener ((LinkListener)viz);
    }


    void showVisualization (Object viz) {
        if (viz == graph)
            graph.start ();
    }
    
    void hideVisualization (Object viz) {
        if (viz == graph)
            graph.stop ();
    }

    void tearoffVisualizations () {
        if (tornOff)
            return;
            
        if (vizFrame == null) {
            Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
            vizFrame = new WorkbenchVizFrame (this);
            vizFrame.setForeground (getForeground());
            vizFrame.setBackground (getBackground());
            vizFrame.setFont (getFont());
            vizFrame.setTitle ("Visualization: " + 
                               (crawler != null ? crawler.getName() : ""));
            vizFrame.setLayout (new GridLayout (1,1));
            vizFrame.reshape (0, 0,
                              Math.min (550, screen.width), 
                              screen.height/2);
        }
        
        remove (vizPanel);
        setLayout (new GridLayout (1,1));
        validate ();

        vizFrame.add (vizPanel);
        setVisible (vizFrame, true);

        vizPanel.tearoffButton.setLabel ("Glue Back");
        
        tornOff = true;
    }

    void dockVisualizations () {
        if (!tornOff)
            return;
            
        setVisible (vizFrame, false);
        vizFrame.remove (vizPanel);
        
        setLayout (new GridLayout (2, 1));
        add (vizPanel);
        validate ();
        
        vizPanel.tearoffButton.setLabel ("Tear Off");
        
        tornOff = false;
    }

    void newCrawler () {
        setCrawler (makeDefaultCrawler ());
        currentFilename = "";
    }
    
    void createCrawler (String className) {
        if (className == null || className.length() == 0) {
            className = PopupDialog.ask (workbenchPanel,
                                         "New Crawler",
                                         "Create a Crawler of class:",
                                         crawler.getClass().getName()
                                         );
            if (className == null)
                return;
        }
        
        try {
            Class crawlerClass = (Class)Class.forName (className);
            Crawler newCrawler = (Crawler)crawlerClass.newInstance ();
            
            setCrawler (newCrawler);
            currentFilename = "";
        } catch (Exception e) {
            PopupDialog.warn (workbenchPanel, 
                              "Error", 
                              e.toString());
            return;
        }        
    }

    
    //#ifdef JDK1.1
    void openCrawler () {
        String fn = PopupDialog.askFilename (workbenchPanel, "Open Crawler", "", true);
        if (fn != null)
            openCrawler (fn);
    }

    void openCrawler (String filename) {
        try {
            setCrawler (loadCrawler (Access.getAccess ().readFile (new File (filename))));
            currentFilename = filename;
        } catch (Exception e) {
            PopupDialog.warn (workbenchPanel, 
                              "Error", 
                              e.toString());
        } 
    }

    void openCrawler (URL url) {
        try {
            setCrawler (loadCrawler (Access.getAccess ().openConnection (url).getInputStream ()));
            currentFilename = "";
        } catch (Exception e) {
            PopupDialog.warn (workbenchPanel, 
                              "Error", 
                              e.toString());
        } 
    }
    
    static Crawler loadCrawler (InputStream stream) throws Exception {
        ObjectInputStream in = new ObjectInputStream (stream);
        Crawler loadedCrawler = (Crawler)in.readObject ();
        in.close ();
        return loadedCrawler;
    }

    void saveCrawler () {
        String fn = PopupDialog.askFilename (workbenchPanel, "Save Crawler As", currentFilename, true);
        if (fn != null)
            saveCrawler (fn);
    }

    void saveCrawler (String filename) {       
        configureCrawler ();
        
        try {
            ObjectOutputStream out = 
                new ObjectOutputStream (Access.getAccess ().writeFile (new File (filename), false));
            out.writeObject ((Object)crawler);
            out.close ();

            currentFilename = filename;
        } catch (Exception e) {
            PopupDialog.warn (workbenchPanel, 
                              "Error", 
                              e.toString());
        } 
    }
    //#endif JDK1.1

    void configureCrawler () {
        if (advancedMode) {
            crawlerEditor.getCrawler ();
            classifierListEditor.getCrawler ();
            crawler.setDownloadParameters (downloadParametersEditor.getDownloadParameters ());
            if (advancedMode) {
                crawler.setLinkPredicate (linkPredicateEditor.getLinkPredicate ());
                crawler.setPagePredicate (pagePredicateEditor.getPagePredicate ());
                crawler.setAction (actionEditor.getAction());
            }
        }
        else
            simpleCrawlerEditor.getCrawler ();
    }

    void enableButtons (boolean fStart, boolean fPause, boolean fStop, boolean fClear) {
        setEnabled (startButton, fStart);
        setEnabled (pauseButton, fPause);
        setEnabled (stopButton, fStop);
        setEnabled (clearButton, fClear);
    }        

    /* * * * * * * * * * * * * * * * * * * * * * *
     *   Changing the crawler 
     * * * * * * * * * * * * * * * * * * * * * * */
            
    public void setCrawler (Crawler _crawler) {
        if (crawler != _crawler) {
            if (crawler != null) {
                clear ();
                disconnectVisualization (crawler, this, false);
                disconnectVisualization (crawler, graph, true);
                disconnectVisualization (crawler, outline, true);
                disconnectVisualization (crawler, statistics, false);
                disconnectVisualization (crawler, logger, true);
            }
        
            connectVisualization (_crawler, this, false);
            connectVisualization (_crawler, graph, true);
            connectVisualization (_crawler, outline, true);
            connectVisualization (_crawler, statistics, false);
            connectVisualization (_crawler, logger, true);
        }

        crawler = _crawler;

        // set all window titles
        String name = crawler.getName ();
        if (workbenchFrame != null)
            workbenchFrame.setTitle ("Crawler Workbench: " + name);
        if (vizFrame != null)
            vizFrame.setTitle ("Visualization: " + name);

        // set configuration
        
        if (advancedMode) {
            crawlerEditor.setCrawler (crawler);
            classifierListEditor.setCrawler (crawler);
            downloadParametersEditor.setDownloadParameters (crawler.getDownloadParameters ());
            if (advancedMode) {
                linkPredicateEditor.setLinkPredicate (crawler.getLinkPredicate ());
                pagePredicateEditor.setPagePredicate (crawler.getPagePredicate ());
                actionEditor.setAction (crawler.getAction ());
            }
        }
        else
            simpleCrawlerEditor.setCrawler (crawler);
            
        if (advancedMode)
            showAdvancedTabs ();
        else
            showSimpleTabs ();
    }
    
    public Crawler getCrawler () {
        return crawler;
    }


    private void showAdvancedTabs () {
        if (configPanel.countTabs () != 5) {
            configPanel.removeAllTabPanels ();
            configPanel.addTabPanel ("Crawl", true, crawlPanel);
            configPanel.addTabPanel ("Links", true, linksPanel);
            configPanel.addTabPanel ("Pages", true, actionPanel);
            configPanel.addTabPanel ("Classifiers", true, classifiersPanel);
            configPanel.addTabPanel ("Limits", true, limitsPanel);
        }
    }

    private void showSimpleTabs () {
        if (configPanel.countTabs () != 1) {
            configPanel.removeAllTabPanels ();
            configPanel.addTabPanel ("Crawl", true, simplePanel);
        }
    }        

    /* * * * * * * * * * * * * * * * * * * * * * *
     *   Running the crawler
     * * * * * * * * * * * * * * * * * * * * * * */
            
    public void start () {
        configureCrawler ();

        if (crawler.getState () == CrawlEvent.STOPPED)
            crawler.clear ();

        Thread thread = new Thread (crawler, crawler.getName ());
        thread.setDaemon (true);
        thread.start ();
    }
    
    public void stop () {
        crawler.stop ();
    }
    
    public void pause () {
        crawler.pause ();
    }
    
    public void clear () {
        crawler.clear ();
    }

    /**
     * Notify that the crawler started
     */
    public void started (CrawlEvent event) {
        enableButtons (false, true, true, false);
    }

    /**
     * Notify that the crawler ran out of links to crawl
     */
    public void stopped (CrawlEvent event) {
        enableButtons (true, false, false, true);
    }

    /**
     * Notify that the crawler's state was cleared.
     */
    public void cleared (CrawlEvent event) {
        enableButtons (true, false, false, false);
    }

    /**
     * Notify that the crawler timed out.
     */
    public void timedOut (CrawlEvent event) {
        enableButtons (true, false, false, true);
    }

    /**
     * Notify that the crawler was paused.
     */
    public void paused (CrawlEvent event) {
        enableButtons (true, false, true, true);
    }
        
    public static void main (String[] args) throws Exception {
        Workbench w = (args.length == 0)
            ? new Workbench ()
            : new Workbench (args[0]);
        w.setAllowExit (true);

        Frame f = w.makeFrame ();
        f.show ();
    }
}

class WorkbenchFrame extends ClosableFrame
{
    Workbench workbench;

    public WorkbenchFrame (Workbench workbench) {
        super ();
        this.workbench = workbench;
    }
    
    public void close () {
        workbench.close ();
    }

    public boolean handleEvent (Event event) {
        if (workbench.doEvent (event))
            return true;
        else
            return super.handleEvent (event);
    }
}

class WorkbenchVizFrame extends ClosableFrame
{
    Workbench workbench;

    public WorkbenchVizFrame (Workbench workbench) {
        super (true);
        this.workbench = workbench;
    }
    
    public void close () {
        workbench.dockVisualizations ();
        super.close ();
    }

    public boolean handleEvent (Event event) {
        if (workbench.doEvent (event))
            return true;
        else
            return super.handleEvent (event);
    }
}

class WorkbenchTabPanel extends TabPanel {
    Button advancedButton;

    public WorkbenchTabPanel () {
        super ();
        add (advancedButton = new Button ("Advanced >>"));
    }
}

class WorkbenchVizPanel extends TabPanel {
    Workbench workbench;
    Button optionsButton;
    Button tearoffButton;

    public WorkbenchVizPanel (Workbench workbench) {
        this.workbench = workbench;
        add (optionsButton = new Button ("Options..."));
        add (tearoffButton = new Button ("Tear Off"));
    }

    public void select (int num) {
        Component prior = getSelectedComponent ();

        super.select (num);

        Component now = getSelectedComponent ();

        if (prior == now)
            return;

        if (prior != null)
            workbench.hideVisualization (prior);

        if (now != null) {
            workbench.showVisualization (now);
            now.requestFocus ();
        }
    }
}