* Copyright (C) The Apache Software Foundation. All rights reserved.        *

* ------------------------------------------------------------------------- *

* This software is published under the terms of the Apache Software License *

* version 1.1, a copy of which has been included with this distribution in  *

* the LICENSE file.                                                         *

*****************************************************************************/

* This class represents a SVG viewer swing frame.

*

* @author <a href="mailto:stephane@hillion.org">Stephane Hillion</a>

* @version $Id: JSVGViewerFrame.java,v 1.94 2003/06/17 01:37:56 deweese Exp $

*/

    extends    JFrame

    implements ActionMap,

               SVGDocumentLoaderListener,

               GVTTreeBuilderListener,

               SVGLoadEventDispatcherListener,

               GVTTreeRendererListener,

               LinkActivationListener,

               UpdateManagerListener {

    /**

     * Kind of ugly, but we need to know if we are running before

     * or after 1.4...

     */

    protected static boolean priorJDK1_4 = true;

    /**

     * If the following class can be found (it appeared in JDK 1.4),

     * then we know we are post JDK 1.4.

     */

    protected static final String JDK_1_4_PRESENCE_TEST_CLASS

        = "java.util.logging.LoggingPermission";

    static {

        Class cl = null;

        try {

            cl = Class.forName(JDK_1_4_PRESENCE_TEST_CLASS);

        } catch (ClassNotFoundException e){

        }

        if (cl != null) {

            priorJDK1_4 = false;

        }

    }

    /**

     * The gui resources file name

     */

    public final static String RESOURCES =

        "org.apache.batik.apps.svgbrowser.resources.GUI";

    // The actions names.

    public final static String ABOUT_ACTION = "AboutAction";

    public final static String OPEN_ACTION = "OpenAction";

    public final static String OPEN_LOCATION_ACTION = "OpenLocationAction";

    public final static String NEW_WINDOW_ACTION = "NewWindowAction";

    public final static String RELOAD_ACTION = "ReloadAction";

    public final static String BACK_ACTION = "BackAction";

    public final static String FORWARD_ACTION = "ForwardAction";

    public final static String FULL_SCREEN_ACTION = "FullScreenAction";

    public final static String PRINT_ACTION = "PrintAction";

    public final static String EXPORT_AS_JPG_ACTION = "ExportAsJPGAction";

    public final static String EXPORT_AS_PNG_ACTION = "ExportAsPNGAction";

    public final static String EXPORT_AS_TIFF_ACTION = "ExportAsTIFFAction";

    public final static String PREFERENCES_ACTION = "PreferencesAction";

    public final static String CLOSE_ACTION = "CloseAction";

    public final static String VIEW_SOURCE_ACTION = "ViewSourceAction";

    public final static String EXIT_ACTION = "ExitAction";

    public final static String RESET_TRANSFORM_ACTION = "ResetTransformAction";

    public final static String ZOOM_IN_ACTION = "ZoomInAction";

    public final static String ZOOM_OUT_ACTION = "ZoomOutAction";

    public final static String PREVIOUS_TRANSFORM_ACTION = "PreviousTransformAction";

    public final static String NEXT_TRANSFORM_ACTION = "NextTransformAction";

    public final static String USE_STYLESHEET_ACTION = "UseStylesheetAction";

    public final static String PLAY_ACTION = "PlayAction";

    public final static String PAUSE_ACTION = "PauseAction";

    public final static String STOP_ACTION = "StopAction";

    public final static String MONITOR_ACTION = "MonitorAction";

    public final static String DOM_VIEWER_ACTION = "DOMViewerAction";

    public final static String SET_TRANSFORM_ACTION = "SetTransformAction";

    public final static String FIND_DIALOG_ACTION = "FindDialogAction";

    public final static String THUMBNAIL_DIALOG_ACTION = "ThumbnailDialogAction";

    public final static String FLUSH_ACTION = "FlushAction";

    /**

     * The cursor indicating that an operation is pending.

     */

    public final static Cursor WAIT_CURSOR =

        new Cursor(Cursor.WAIT_CURSOR);

    /**

     * The default cursor.

     */

    public final static Cursor DEFAULT_CURSOR =

        new Cursor(Cursor.DEFAULT_CURSOR);

    /**

     * Name for the os-name property

     */

    public final static String PROPERTY_OS_NAME

        = Resources.getString("JSVGViewerFrame.property.os.name");

    /**

     * Name for the os.name default

     */

    public final static String PROPERTY_OS_NAME_DEFAULT

        = Resources.getString("JSVGViewerFrame.property.os.name.default");

    /**

     * Name for the os.name property prefix we are looking

     * for in OpenAction to work around JFileChooser bug

     */

    public final static String PROPERTY_OS_WINDOWS_PREFIX

        = Resources.getString("JSVGViewerFrame.property.os.windows.prefix");

    /**

     * The input handlers

     */

    protected static Vector handlers;

    /**

     * The default input handler

     */

    protected static SquiggleInputHandler defaultHandler = new SVGInputHandler();

    /**

     * The resource bundle

     */

    protected static ResourceBundle bundle;

    /**

     * The resource manager

     */

    protected static ResourceManager resources;

    static {

        bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());

        resources = new ResourceManager(bundle);

    }

    /**

     * The current application.

     */

    protected Application application;

    /**

     * The JSVGCanvas.

     */

    protected JSVGCanvas svgCanvas;

    /**

     * The panel where the svgCanvas is displayed

     */

    protected JPanel svgCanvasPanel;

    /**

     * A window used for full screen display

     */

    protected JWindow window;

    /**

     * The memory monitor frame.

     */

    protected static JFrame memoryMonitorFrame;

    /**

     * The current path.

     */

    protected File currentPath = new File("");;

    /**

     * The current export path.

     */

    protected File currentExportPath = new File("");

    /**

     * The back action

     */

    protected BackAction backAction = new BackAction();

    /**

     * The forward action

     */

    protected ForwardAction forwardAction = new ForwardAction();

    /**

     * The play action

     */

    protected PlayAction playAction = new PlayAction();

    /**

     * The pause action

     */

    protected PauseAction pauseAction = new PauseAction();

    /**

     * The stop action

     */

    protected StopAction stopAction = new StopAction();

    /**

     * The previous transform action

     */

    protected PreviousTransformAction previousTransformAction =

        new PreviousTransformAction();

    /**

     * The next transform action

     */

    protected NextTransformAction nextTransformAction =

        new NextTransformAction();

    /**

     * The use (author) stylesheet action

     */

    protected UseStylesheetAction useStylesheetAction =

        new UseStylesheetAction();

    /**

     * The debug flag.

     */

    protected boolean debug;

    /**

     * The auto adjust flag.

     */

    protected boolean autoAdjust = true;

    /**

     * Whether the update manager was stopped.

     */

    protected boolean managerStopped;

    /**

     * The SVG user agent.

     */

    protected SVGUserAgent userAgent = new UserAgent();

    /**

     * The current document.

     */

    protected SVGDocument svgDocument;

    /**

     * The URI chooser.

     */

    protected URIChooser uriChooser;

    /**

     * The DOM viewer.

     */

    protected DOMViewer domViewer;

    /**

     * The Find dialog.

     */

    protected FindDialog findDialog;

    /**

     * The Find dialog.

     */

    protected ThumbnailDialog thumbnailDialog;

    /**

     * The transform dialog

     */

    protected JAffineTransformChooser.Dialog transformDialog;

    /**

     * The location bar.

     */

    protected LocationBar locationBar;

    /**

     * The status bar.

     */

    protected StatusBar statusBar;

    /**

     * The initial frame title.

     */

    protected String title;

    /**

     * The local history.

     */

    protected LocalHistory localHistory;

    /**

     * The transform history.

     */

    protected TransformHistory transformHistory = new TransformHistory();

    /**

     * The alternate style-sheet title.

     */

    protected String alternateStyleSheet;

    /**

     * Creates a new SVG viewer frame.

     */

    public JSVGViewerFrame(Application app) {

        application = app;

        addWindowListener(new WindowAdapter() {

            public void windowClosing(WindowEvent e) {

                application.closeJSVGViewerFrame(JSVGViewerFrame.this);

            }

        });

        //

        // Set the frame's maximum size so that content

        // bigger than the screen does not cause the creation

        // of unnecessary large images.

        //

        svgCanvas = new JSVGCanvas(userAgent, true, true){

                Dimension screenSize;

               

                {

                    screenSize = Toolkit.getDefaultToolkit().getScreenSize();

                    setMaximumSize(screenSize);

                }

               

                public Dimension getPreferredSize(){

                    Dimension s = super.getPreferredSize();

                    if (s.width > screenSize.width) s.width =screenSize.width;

                    if (s.height > screenSize.height) s.height = screenSize.height;

                    return s;

                }

               

                /**

                 * This method is called when the component knows the desired

                 * size of the window (based on width/height of outermost SVG

                 * element). We override it to immediately pack this frame.

                 */

                public void setMySize(Dimension d) {

                    setPreferredSize(d);

                    invalidate();

                    if (JSVGViewerFrame.this.autoAdjust) {

                        JSVGViewerFrame.this.pack();

                    }

                }

            };

       

        javax.swing.ActionMap map = svgCanvas.getActionMap();

        map.put(FULL_SCREEN_ACTION, new FullScreenAction());

        javax.swing.InputMap imap = svgCanvas.getInputMap(JComponent.WHEN_FOCUSED);

        KeyStroke key = KeyStroke.getKeyStroke(KeyEvent.VK_F11, 0);

        imap.put(key, FULL_SCREEN_ACTION);

        svgCanvas.setDoubleBufferedRendering(true);

        listeners.put(ABOUT_ACTION, new AboutAction());

        listeners.put(OPEN_ACTION, new OpenAction());

        listeners.put(OPEN_LOCATION_ACTION, new OpenLocationAction());

        listeners.put(NEW_WINDOW_ACTION, new NewWindowAction());

        listeners.put(RELOAD_ACTION, new ReloadAction());

        listeners.put(BACK_ACTION, backAction);

        listeners.put(FORWARD_ACTION, forwardAction);

        listeners.put(PRINT_ACTION, new PrintAction());

        listeners.put(EXPORT_AS_JPG_ACTION, new ExportAsJPGAction());

        listeners.put(EXPORT_AS_PNG_ACTION, new ExportAsPNGAction());

        listeners.put(EXPORT_AS_TIFF_ACTION, new ExportAsTIFFAction());

        listeners.put(PREFERENCES_ACTION, new PreferencesAction());

        listeners.put(CLOSE_ACTION, new CloseAction());

        listeners.put(EXIT_ACTION, application.createExitAction(this));

        listeners.put(VIEW_SOURCE_ACTION, new ViewSourceAction());

        javax.swing.ActionMap cMap = svgCanvas.getActionMap();

        listeners.put(RESET_TRANSFORM_ACTION,

                      cMap.get(JSVGCanvas.RESET_TRANSFORM_ACTION));

        listeners.put(ZOOM_IN_ACTION,

                      cMap.get(JSVGCanvas.ZOOM_IN_ACTION));

        listeners.put(ZOOM_OUT_ACTION,

                      cMap.get(JSVGCanvas.ZOOM_OUT_ACTION));

        listeners.put(PREVIOUS_TRANSFORM_ACTION, previousTransformAction);

        key = KeyStroke.getKeyStroke(KeyEvent.VK_K, KeyEvent.CTRL_MASK);

        imap.put(key, previousTransformAction);

        listeners.put(NEXT_TRANSFORM_ACTION, nextTransformAction);

        key = KeyStroke.getKeyStroke(KeyEvent.VK_L, KeyEvent.CTRL_MASK);

        imap.put(key, nextTransformAction);

        listeners.put(USE_STYLESHEET_ACTION, useStylesheetAction);

        listeners.put(PLAY_ACTION, playAction);

        listeners.put(PAUSE_ACTION, pauseAction);

        listeners.put(STOP_ACTION, stopAction);

        listeners.put(MONITOR_ACTION, new MonitorAction());

        listeners.put(DOM_VIEWER_ACTION, new DOMViewerAction());

        listeners.put(SET_TRANSFORM_ACTION, new SetTransformAction());

        listeners.put(FIND_DIALOG_ACTION, new FindDialogAction());

        listeners.put(THUMBNAIL_DIALOG_ACTION, new ThumbnailDialogAction());

        listeners.put(FLUSH_ACTION, new FlushAction());

        JPanel p = null;

        try {

            // Create the menu

            MenuFactory mf = new MenuFactory(bundle, this);

            JMenuBar mb = mf.createJMenuBar("MenuBar");

            setJMenuBar(mb);

            localHistory = new LocalHistory(mb, this);

            String uri[] = application.getVisitedURIs();

            for (int i=0; i<uri.length; i++) {

                if (uri[i] != null && !"".equals(uri[i])) {

                    localHistory.update(uri[i]);

                }

            }

            p = new JPanel(new BorderLayout());

            // Create the toolbar

            ToolBarFactory tbf = new ToolBarFactory(bundle, this);

            JToolBar tb = tbf.createJToolBar("ToolBar");

            tb.setFloatable(false);

            getContentPane().add(p, BorderLayout.NORTH);

            p.add(tb, BorderLayout.NORTH);

            p.add(new javax.swing.JSeparator(), BorderLayout.CENTER);

            p.add(locationBar = new LocationBar(), BorderLayout.SOUTH);

        } catch (MissingResourceException e) {

            System.out.println(e.getMessage());

            System.exit(0);

        }

        svgCanvasPanel = new JPanel(new BorderLayout());

        svgCanvasPanel.setBorder(BorderFactory.createEtchedBorder());

        svgCanvasPanel.add(svgCanvas, BorderLayout.CENTER);

        p = new JPanel(new BorderLayout());

        p.add(svgCanvasPanel, BorderLayout.CENTER);

        p.add(statusBar = new StatusBar(), BorderLayout.SOUTH);

        getContentPane().add(p, BorderLayout.CENTER);

        svgCanvas.addSVGDocumentLoaderListener(this);

        svgCanvas.addGVTTreeBuilderListener(this);

        svgCanvas.addSVGLoadEventDispatcherListener(this);

        svgCanvas.addGVTTreeRendererListener(this);

        svgCanvas.addLinkActivationListener(this);

        svgCanvas.addUpdateManagerListener(this);

        svgCanvas.addMouseMotionListener(new MouseMotionAdapter() {

                public void mouseMoved(MouseEvent e) {

                    if (svgDocument == null) {

                        statusBar.setXPosition(e.getX());

                        statusBar.setYPosition(e.getY());

                    } else {

                        try {

                            AffineTransform at;

                            at = svgCanvas.getViewBoxTransform();

                            if (at != null) {

                                at = at.createInverse();

                                Point2D p2d =

                                    at.transform(new Point2D.Float(e.getX(), e.getY()),

                                                 null);

                                statusBar.setXPosition((float)p2d.getX());

                                statusBar.setYPosition((float)p2d.getY());

                                return;

                            }

                        } catch (NoninvertibleTransformException ex) {

                        }

                        statusBar.setXPosition(e.getX());

                        statusBar.setYPosition(e.getY());

                    }

                }

            });

        svgCanvas.addMouseListener(new MouseAdapter() {

                public void mouseExited(MouseEvent e) {

                    Dimension dim = svgCanvas.getSize();

                    if (svgDocument == null) {

                        statusBar.setWidth(dim.width);

                        statusBar.setHeight(dim.height);

                    } else {

                        try {

                            AffineTransform at;

                            at = svgCanvas.getViewBoxTransform();

                            if (at != null) {

                                at = at.createInverse();

                                Point2D o =

                                    at.transform(new Point2D.Float(0, 0),

                                                 null);

                                Point2D p2d =

                                    at.transform(new Point2D.Float(dim.width,

                                                                   dim.height),

                                                 null);

                                statusBar.setWidth((float)(p2d.getX() - o.getX()));

                                statusBar.setHeight((float)(p2d.getY() - o.getY()));

                                return;

                            }

                        } catch (NoninvertibleTransformException ex) {

                        }

                        statusBar.setWidth(dim.width);

                        statusBar.setHeight(dim.height);

                    }

                }

            });

        svgCanvas.addComponentListener(new ComponentAdapter() {

                public void componentResized(ComponentEvent e) {

                    Dimension dim = svgCanvas.getSize();

                    if (svgDocument == null) {

                        statusBar.setWidth(dim.width);

                        statusBar.setHeight(dim.height);

                    } else {

                        try {

                            AffineTransform at;

                            at = svgCanvas.getViewBoxTransform();

                            if (at != null) {

                                at = at.createInverse();

                                Point2D o =

                                    at.transform(new Point2D.Float(0, 0),

                                                 null);

                                Point2D p2d =

                                    at.transform(new Point2D.Float(dim.width,

                                                                   dim.height),

                                                 null);

                                statusBar.setWidth((float)(p2d.getX() - o.getX()));

                                statusBar.setHeight((float)(p2d.getY() - o.getY()));

                                return;

                            }

                        } catch (NoninvertibleTransformException ex) {

                        }

                        statusBar.setWidth(dim.width);

                        statusBar.setHeight(dim.height);

                    }

                }

            });

        locationBar.addActionListener(new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                String st = locationBar.getText().trim();

                int i = st.indexOf("#");

                String t = "";

                if (i != -1) {

                    t = st.substring(i + 1);

                    st = st.substring(0, i);

                }

                if (!st.equals("")) {

                    try{

                        File f = new File(st);

                        if (f.exists()) {

                            if (f.isDirectory()) {

                                st = null;

                            } else {

                                try {

                                    st = f.getCanonicalPath();

                                    if (st.startsWith("/")) {

                                        st = "file:" + st;

                                    } else {

                                        st = "file:/" + st;

                                    }

                                } catch (IOException ex) {

                                }

                            }

                        }

                    }catch(SecurityException se){

                        // Could not patch the file URI for security

                        // reasons (e.g., when run as an unsigned

                        // JavaWebStart jar): file access is not

                        // allowed. Loading will fail, but there is

                        // nothing more to do at this point.

                    }

                    if (st != null) {

                        if (svgDocument != null) {

                            SVGOMDocument doc = (SVGOMDocument)svgDocument;

                            ParsedURL docPURL

                                = new ParsedURL(svgDocument.getURL());

                            ParsedURL purl = new ParsedURL(docPURL, st);

                            String fi = svgCanvas.getFragmentIdentifier();

                            fi = (fi == null) ? "" : fi;

                            if (docPURL.equals(purl) && t.equals(fi)) {

                                return;

                            }

                        }

                        if (t.length() != 0) {

                            st += "#" + t;

                        }

                        locationBar.setText(st);

                        locationBar.addToHistory(st);

                        showSVGDocument(st);

                    }

                }

            }

        });

    }

    /**

     * Whether to show the debug traces.

     */

    public void setDebug(boolean b) {

        debug = b;

    }

    /**

     * Whether to auto adjust the canvas to the size of the document.

     */

    public void setAutoAdjust(boolean b) {

        autoAdjust = b;

    }

    /**

     * Returns the main JSVGCanvas of this frame.

     */

    public JSVGCanvas getJSVGCanvas() {

        return svgCanvas;

    }

    /**

     * Needed to work-around JFileChooser bug with abstract Files

     */

    private static File makeAbsolute(File f){

        if(!f.isAbsolute()){

            return f.getAbsoluteFile();

        }

        return f;

    }

    /**

     * To show the about dialog

     */

    public class AboutAction extends AbstractAction {

        public AboutAction(){

        }

        public void actionPerformed(ActionEvent e){

            AboutDialog dlg = new AboutDialog(JSVGViewerFrame.this);

            dlg.setSize(dlg.getPreferredSize()); // Work around pack() bug on some platforms

            dlg.setLocationRelativeTo(JSVGViewerFrame.this);

            dlg.show();

            dlg.toFront();

        }

    }

    /**

     * To open a new file.

     */

    public class OpenAction extends AbstractAction {

        public OpenAction() {

        }

        public void actionPerformed(ActionEvent e) {

            JFileChooser fileChooser = null;

            // Apply work around Windows problem when security is enabled,

            // and when prior to JDK 1.4.

            String os = System.getProperty(PROPERTY_OS_NAME, PROPERTY_OS_NAME_DEFAULT);

            SecurityManager sm = System.getSecurityManager();

           

            if ( priorJDK1_4 && sm != null && os.indexOf(PROPERTY_OS_WINDOWS_PREFIX) != -1 ){

                fileChooser = new JFileChooser(makeAbsolute(currentPath),

                                               new WindowsAltFileSystemView());

            } else {

                fileChooser = new JFileChooser(makeAbsolute(currentPath));

            }

            fileChooser.setFileHidingEnabled(false);

            fileChooser.setFileSelectionMode

                (JFileChooser.FILES_ONLY);

            //

            // Add file filters from the handlers map

            //

            Iterator iter = getHandlers().iterator();

            while (iter.hasNext()) {

                SquiggleInputHandler handler

                    = (SquiggleInputHandler)iter.next();

                fileChooser.addChoosableFileFilter

                    (new SquiggleInputHandlerFilter(handler));

            }

           

            int choice = fileChooser.showOpenDialog(JSVGViewerFrame.this);

            if (choice == JFileChooser.APPROVE_OPTION) {

                File f = fileChooser.getSelectedFile();

               

                currentPath = f;

                try {

                    String furl = f.toURL().toString();

                    showSVGDocument(furl);

                } catch (MalformedURLException ex) {

                    if (userAgent != null) {

                        userAgent.displayError(ex);

                    }

                }

            }

        }

    }

    /**

     * Shows the given document into the viewer frame

     */

    public void showSVGDocument(String uri){

        try {

            ParsedURL purl = new ParsedURL(uri);

            SquiggleInputHandler

                handler = getInputHandler(purl);

           

            handler.handle(purl,

                           JSVGViewerFrame.this);

        } catch (Exception e) {

            if (userAgent != null) {

                userAgent.displayError(e);

            }

        }

    }

    /**

     * Returns the input handler for the given URI

     */

    public SquiggleInputHandler getInputHandler(ParsedURL purl) throws IOException {

        Iterator iter = getHandlers().iterator();

        SquiggleInputHandler handler = null;

        while (iter.hasNext()) {

            SquiggleInputHandler curHandler =

                (SquiggleInputHandler)iter.next();

            if (curHandler.accept(purl)) {

                handler = curHandler;

                break;

            }

        }

        // No handler found, use the default one.

        if (handler == null) {

            handler = defaultHandler;

        }

        return handler;

    }

    /**

     * Returns the list of input file handler.

     */

    protected static Vector getHandlers() {

        if (handlers != null) {

            return handlers;

        }

        handlers = new Vector();

        registerHandler(new SVGInputHandler());

       

        Iterator iter = Service.providers(SquiggleInputHandler.class);

        while (iter.hasNext()) {

            SquiggleInputHandler handler

                = (SquiggleInputHandler)iter.next();

            registerHandler(handler);

        }

        return handlers;

    }

    /**

     * Registers an input file handler by adding it to the handlers map.

     * @param handler the new input handler to register.

     */

    public static synchronized

        void registerHandler(SquiggleInputHandler handler) {

        Vector handlers = getHandlers();

        handlers.addElement(handler);

    }

    /**

     * To open a new document.

     */

    public class OpenLocationAction extends AbstractAction {

        public OpenLocationAction() {}

        public void actionPerformed(ActionEvent e) {

            if (uriChooser == null) {