/branches/v10/frameworks/_fwAndami/src/com/iver/andami/ui/mdiManager/WindowInfo.java - Diff - Application: gvSIG desktop - gvSIG

Revision 11989 branches/v10/frameworks/_fwAndami/src/com/iver/andami/ui/mdiManager/WindowInfo.java

     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
      * Copyright (C) 2004-2007 IVER T.I. and Generalitat Valenciana.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
-...
     import java.beans.PropertyChangeListener;
     import java.beans.PropertyChangeSupport;
     import org.exolab.castor.xml.XMLException;
     import com.iver.andami.PluginServices;
     import com.iver.utiles.XMLEntity;
     /**
      * DOCUMENT ME!
+     *
      * This class represents the state of the associated window.
      * The <code>set</code> methods (<code>setX</code>, <code>setY</code>,
      * <code>setHeight</code>, etc) are immediately reflected on the
      * window.
+     *
      * @author Fernando Gonz?lez Cort?s
      */
     public class WindowInfo {
         /** DOCUMENT ME! */
     	/** Specifies that the window is resizable  */
         public static final int RESIZABLE = 1;
         /** DOCUMENT ME! */
         /** Specifies that the window is maximizable */
         public static final int MAXIMIZABLE = 2;
         /** DOCUMENT ME! */
         /** Specifies that the window is iconifiable */
         public static final int ICONIFIABLE = 4;
         /** DOCUMENT ME! */
         /** Specifies that the window is modal */
         public static final int MODALDIALOG = 8;
         /** Specifies that the window is modeless (it's on the top but doesn't block any other window) */
         public static final int MODELESSDIALOG = 16;
         /** Specifies that the window may be docked inside another window */
         public static final int PALETTE = 32;
         private PropertyChangeSupport support = new PropertyChangeSupport(this);
-...
         /** DOCUMENT ME! */
         private boolean modal = false;
         private boolean modeless = false;
         /**
          * Do we want to persist the geometry of this window in the project file?
          */
-...
         /** These properties store the dimension and position of the frame */
         private int width = -1;
         private int height = -1;
         private int x = -1;
         private int y = -1;
         private int x = 0;
         private int y = 0;
         /**
          * These properties store the position and dimension of the frame when it is not maximized
          * (so that it can be restored to its original size). They are equal to the not-normal properties
-...
         private String selectedTool;
         /**
          * DOCUMENT ME!
          * Returns the current x coordinate of the window's origin
          * (left-upper corner of the window).
+         *
          * @return Returns the x.
          * @return Returns the value (in pixels) of the x coordinate
          * of the window's origin.
          */
         public int getX() {
             return x;
+        }
         /**
          * DOCUMENT ME!
          * Sets the x coordinate of the window's origin
          * (left-upper corner of the window).
+         *
          * @param x The x to set.
          * @param x	The value (in pixels) of the x coordinate to set.
          */
         public void setX(int x) {
         	support.firePropertyChange("x", this.x, x);
-...
+        }
         /**
          * DOCUMENT ME!
+         *
          * @return Returns the y.
          * Gets the value of the y coordinate for the origin
          * (left-upper corner of the window) of the associated
          * window.
+         *
          * @return Returns the y coordinate (in pixels).
          */
         public int getY() {
             return y;
+        }
         /**
          * DOCUMENT ME!
+         *
          * @param y The y to set.
          * Sets the value of the y coordinate for the origin
          * (left-upper corner of the window) of the associated
          * window.
+         *
          * @param y The value (in pixels) of the y coordinate
          */
         public void setY(int y) {
         	support.firePropertyChange("y", this.y, y);
-...
+        }
         /**
          * Si es iconificable
          * Determines whether the associated window is iconifiable or not
+         *
          * @return
          */
-...
+        }
         /**
          * Si es maximizable
          * Determines whether the associated window is maximizable or not
+         *
          * @return
          */
-...
+        }
         /**
          * Si es resizable
          * Determines whether the associated window is resizable or not
+         *
          * @return
          */
-...
+        }
         /**
          * Devuelve si el di?logo es modal
          * Determines whether the associated window is modal or not
+         *
          * @return
          */
-...
+        }
         /**
          * Obtiene la altura de la vista
          * Gets the window height.
+         *
          * @return
          * @return The window height (in pixels).
          */
         public int getHeight() {
             return height;
+        }
         /**
          * Obtiene la anchura de la vista
          * Gets the window width.
+         *
          * @return
          * @return The window width (in pixels).
          */
         public int getWidth() {
             return width;
+        }
         /**
          * establece la propiedad altura
          * Sets the window height.
+         *
          * @param h
          * @param The window height (in pixels)
          */
         public void setHeight(int h) {
         	if (h!=-1)
-...
+        }
         /**
          * establece la propiedad anchura
          * Sets the width property for the associated Window.
+         *
          * @param i
          * @param w The new width.
          */
         public void setWidth(int w) {
         	if (w!=-1)
-...
+        }
         /**
          * obtiene la propiedad titulo
          * Gets the title property
+         *
          * @return
          */
-...
+        }
         /**
          * establece la propiedad titulo
          * Sets the title property.
+         *
          * @param string
          * @param title The new title.
          */
         public void setTitle(String string) {
         	support.firePropertyChange("title", this.title, string);
-...
+        }
         /**
          * DOCUMENT ME!
          * Determines whether the associated window is modeless
          * (it is on the top but does not block any other window)
+         *
          * @return
          */
         public boolean isModeless() {
          */boolean isModeless() {
             return modeless;
+        }
         /**
          * DOCUMENT ME!
+         *
          * @return
          */
          /**
           * Determines whether the associated window is visible
+          *
           * @return true if the associated window is visible, false
           * if it is hidden
           */
         public boolean isVisible() {
             return visible;
+        }
         /**
          * Determines whether the associated dockable window is
          * currently in palette status or docked.
+         *
          * @return true if the window is currently in palette status,
          * false if it is docked in another window
          */
         public boolean isPalette()
+        {
             return palette;
+        }
         /**
          * Sets the window's ID.
+         *
          * @param id An integer to identify the window. Different
          * windows must have different IDs.
          */
         public void setId(int id){
         	this.id = id;
+        }
         /**
          * Gets the window ID.
+         *
          * @return id An integer to identify the window. Different
          * windows must have different IDs.
          */
         public int getId(){
         	return id;
+        }
         /**
          * Updates all the properties in this object so that
          * they match the properties of the provided
          * <code>wi</code> object. The changes are not reflected on the
          * window, just the WindowInfo object is updated.
+         *
          * @param vi A WindowInfo object containing the new
          * properties of the window.
          */
         public void setWindowInfo(WindowInfo vi){
         	this.resizable = vi.resizable;
         	this.maximizable = vi.maximizable;
-...
         	this.isClosed = vi.isClosed;
         	this.persistWindow = vi.persistWindow;
+        }
         /**
          * Sets whether the window is in palette mode or is in docked mode.
          * This method <b>does not</b> update the window status, it just
          * updates the WindowInfo object. Use the IWindowTransform interface
          * to actually change the window status.
+         *
          * @param b
          */
         public void toPalette(boolean b){
         	this.palette=b;
+        }
         /**
          * Gets the actionCommand of the currently selected tool for this
          * window.
          * @return
          */
         public String getSelectedTool() {
             return selectedTool;
+        }
         /**
          * Sets the actionCommand of the currently selected tool for this
          * window.
          * @param selectedTool The actionCommand of the tool which is
          * going to be selected for this window.
          */
         public void setSelectedTool(String selectedTool) {
             if (selectedTool != null)
                 this.selectedTool = selectedTool;
+        }
         /* Finds out whether a view is open (showing) or closed */
         /**
          *  Finds out whether a window is open (showing) or closed
          */
         public boolean isClosed() {
         	return isClosed;
+        }
         /* Specifies whether a view is open (showing) or closed */
         /**
          *  Specifies whether a window is open (showing) or closed
          */
         public void setClosed(boolean closed) {
         	support.firePropertyChange("closed", this.isClosed, closed);
         	this.isClosed = closed;
+        }
         /**
          * Sets the x coordinate of the window's origin
          * when the window is not maximized. When the window is maximized,
          * it does not change the current window's position, but the
          * window will have this x coordinate when it gets restored.
+         *
          * @param normalX	The value (in pixels) of the x coordinate to set.
          */
         public void setNormalX(int normalX) {
         	support.firePropertyChange("normalX", this.normalX, normalX);
         	this.normalX = normalX;
+        }
         /**
          * Sets the y coordinate of the window's origin
          * when the window is not maximized. When the window is maximized,
          * it does not change the current window's position, but the
          * window will have this y coordinate when it gets restored.
+         *
          * @param normalY	The value (in pixels) of the y coordinate to set.
          */
         public void setNormalY(int normalY) {
         	support.firePropertyChange("normalY", this.normalY, normalY);
         	this.normalY = normalY;
+        }
         /**
          * Sets the height of the window
          * when the window is not maximized. When the window is maximized,
          * it does not change the current window's height, but the
          * window will have this height when it gets restored.
+         *
          * @param normalHeight	The height (in pixels) to set.
          */
         public void setNormalHeight(int normalHeight) {
         	support.firePropertyChange("normalHeight", this.normalHeight, normalHeight);
         	this.normalHeight = normalHeight;
+        }
         /**
          * Sets the width of the window
          * when the window is not maximized. When the window is maximized,
          * it does not change the current window's width, but the
          * window will have this width when it gets restored.
+         *
          * @param normalWidth	The width (in pixels) to set.
          */
         public void setNormalWidth(int normalWidth) {
         	support.firePropertyChange("normalWidth", this.normalWidth, normalWidth);
         	this.normalWidth = normalWidth;
+        }
         /**
          * Specifies whether the window is maximized or not.
          */
         public void setMaximized(boolean maximized) {
         	support.firePropertyChange("maximized", this.isMaximized, maximized);
         	this.isMaximized = maximized;
+        }
         /**
          * Specifies whether the window is maximizable or not.
          */
         public void setMaximizable(boolean maximizable) {
         	this.maximizable = maximizable;
+        }
-...
         	support.firePropertyChange("height", this.height, height);
         	this.height = height;
+        }
         /**
          * Sets the bounds of the window
          * when the window is not maximized. When the window is maximized,
          * it does not change the current window's bounds, but the
          * window will have this bounds when it gets restored.
+         *
          * @param x	The normal x (in pixels) to set.
          * @param y	The normal y (in pixels) to set.
          * @param width	The normal width (in pixels) to set.
          * @param height	The normal height (in pixels) to set.
          */
         public void setNormalBounds(int x, int y, int width, int height) {
         	support.firePropertyChange("normalX", this.normalX, x);
         	this.normalX = x;
-...
         	support.firePropertyChange("normalWeight", this.normalHeight, height);
         	this.normalHeight = height;
+        }
         /**
          * Gets the bounds of the window
          * when the window is not maximized. When the window is maximized,
          * it gets the bounds that the window will have when it gets restored.
+         *
          * @return the bounds of the window when the window is not maximized,
          * or if it is maximized, the bounds that the window will have when
          * it gets restored
          */
         public Rectangle getNormalBounds() {
         	return new Rectangle(getNormalX(), getNormalY(), getNormalWidth(), getNormalHeight());
+        }
         /**
          * Sets the bounds of the window
          * when the window is not maximized. When the window is maximized,
          * it does not change the current window's bounds, but the
          * window will have this bounds when it gets restored.
+         *
          * @param normalBounds The normal bounds to set
          */
         public void setNormalBounds(Rectangle normalBounds) {
         	Rectangle oldBounds = new Rectangle(this.normalX, this.normalY,
         	Rectangle oldBounds = new Rectangle(this.normalX, this.normalY,
         			this.normalWidth, this.normalHeight);
         	support.firePropertyChange("normalBounds", oldBounds, normalBounds);
         	support.firePropertyChange("normalX", this.normalX, normalBounds.x);
-...
         	normalWidth = normalBounds.width;
+        }
         /**
          * Set the bounds of the window.
+         *
          * @param bounds The bounds to set.
          */
         public void setBounds(Rectangle bounds) {
         	support.firePropertyChange("x", this.x, bounds.x);
         	x = bounds.x;
-...
         	width = bounds.width;
+        }
         /**
          * Gets the bounds of the window.
+         *
          * @return the bounds of the window.
          */
         public Rectangle getBounds() {
         	return new Rectangle(x, y, width, height);
+        }
         /**
          * Gets the x coordinate of the window's origin when the window is not
          * maximized. When the window is maximized, gets the x coordinate that
          * it will have when it gets restored
+         *
          * @return the normal x coordinate of the window's origin
          */
         public int getNormalX() {
         	if (normalX!=0)
         		return this.normalX;
-...
         		return x;
+        }
         /**
          * Gets the x coordinate of the window's origin when the window is not
          * maximized. When the window is maximized, gets the y coordinate that
          * it will have when it gets restored
+         *
          * @return the normal y coordinate of the window's origin
          */
         public int getNormalY() {
         	if (normalY!=0)
         		return this.normalY;
-...
         		return y;
+        }
         /**
          * Gets the height of the window's origin when the window is not
          * maximized. When the window is maximized, gets the height that
          * it will have when it gets restored
+         *
          * @return the normal height of the window
          */
         public int getNormalHeight() {
         	if (normalHeight!=0)
         		return this.normalHeight;
-...
         		return height;
+        }
         /**
          * Gets the width of the window's origin when the window is not
          * maximized. When the window is maximized, gets the width that
          * it will have when it gets restored
+         *
          * @return the normal width of the window
          */
         public int getNormalWidth() {
         	if (normalWidth!=0)
         		return this.normalWidth;
-...
         		return width;
+        }
         /**
          * Determines whether the window is maximized or not
+         *
          * @return true if the window is maximized, false otherwise
          */
         public boolean isMaximized() {
         	return this.isMaximized;
+        }
         /**
          * Checks if the geometry of this window should be persisted in the
          * project file. This is set by the persistWindow(boolean) method,
          * and the default value is true.
+         *
+         *
          * @return True if the geometry of this window should be persisted
          * in the project files, false otherwise.
          */
         public boolean checkPersistence() {
         	return this.persistWindow;
+        }
         /**
          * Set whether the geometry of this window should be persisted in the
          * project files.
+         *
+         *
          * @param persist
          */
         public void setPersistence(boolean persist) {
         	this.persistWindow = persist;
+        }
         /**
     	 * Gets the window properties in an XMLEntity object, suitable
     	 * for persistence.
-...
     	 * not persistent
          * @throws SaveException
     	 * @throws XMLException
     	 * @throws SaveException
     	 */
     	public XMLEntity getXMLEntity() {
     		XMLEntity xml = new XMLEntity();
-...
+    		}
     		return xml;
+    	}
     	/**
     	 * Creates a WindowInfo object from an XMLEntity containing the
     	 * window properties.
+    	 *
     	 * @param xml An XMLEntity object containing the window properties
+    	 *
     	 * @return A new WindowInfo object, containing the properties
     	 * specified in the XMLEntity parameters
     	 */
     	public static WindowInfo createFromXMLEntity(XMLEntity xml)
+    	{
     		WindowInfo result = new WindowInfo();
-...
     		return result;
+    	}
     	/**
     	 * Updates this WindowInfo object according to the properties
     	 * provided by the XMLEntity parameter.
+    	 *
     	 * @param xml An XMLEntity object containing the window properties
     	 */
     	public void getPropertiesFromXMLEntity(XMLEntity xml)
+    	{
     		this.x = xml.getIntProperty("X");

Also available in: Unified diff