/branches/v2_0_0_prep/frameworks/_fwAndami/src/com/iver/andami/ui/mdiManager/WindowInfo.java - Diff - | gvSIG desktop 1 - gvSIG

Revision 25519 branches/v2_0_0_prep/frameworks/_fwAndami/src/com/iver/andami/ui/mdiManager/WindowInfo.java

      * The <code>set</code> methods (<code>setX</code>, <code>setY</code>,
      * <code>setHeight</code>, etc) are immediately reflected on the
      * window.
+     *
+     *
      * The <code>update</code> methods doesn't update the window, because
      * they are used to update the WindowInfo object when the associated
      * window was modified by user interaction.
-...
          * JDesktopPane.PALETTE_LAYER
          */
         private boolean palette = false;
         private String additionalInfo = null;
         /** These properties store the dimension and position of the frame */
-...
         private int normalY = 0;
         private int normalHeight = -1;
         private int normalWidth = -1;
         /** The minimum allowed size for this window. */
         private Dimension minSize = null;
         /* Whether the window is maximized */
         private boolean isMaximized = false;
         private boolean visible = true;
-...
          * <li>WindowInfo.ICONIFIABLE</li>
          * <li>WindowInfo.RESIZABLE</li>
          * <li>WindowInfo.MAXIMIZABLE</li>
+         *
+         *
          * <p>Properties can be set together by using the binary OR operator
          * "<b>|</b>". For example:</p>
+         *
          * <p><code>WindowInfo wi = new WindowInfo(WindowInfo.MODELESSDIALOG
+         *
          * <p><code>WindowInfo wi = new WindowInfo(WindowInfo.MODELESSDIALOG
          *   |WindowInfo.ICONIFIABLE|WindowInfo.RESIZABLE).</code></p>
+         *
+         *
          * <p>The WindowInfo.MODELESSDIALOG and WindowInfo.MODALDIALOG properties
          * cannot be set at the same time</p>
          * cannot be set at the same time</p>
+         *
          * @param code Bit-or of the window properties.
+         *
-...
         public WindowInfo(){
+        }
         /**
          * Returns the current x coordinate of the window's origin
          * (left-upper corner of the window).
-...
         	if (!isMaximized)
         		this.normalX = x;
+        }
         /**
          * Updates the value of the x coordinate for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * setX for that).
+         *
+         *
          * @param x The value (in pixels) of the x coordinate
          */
         public void updateX(int x) {
-...
          * 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() {
-...
          * 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) {
-...
             if (!isMaximized)
             	this.normalY = y;
+        }
         /**
          * Updates the value of the y coordinate for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * setY for that).
+         *
+         *
          * @param y The value (in pixels) of the y coordinate
          */
         public void updateY(int y) {
-...
             if (!isMaximized)
             	this.normalHeight = height;
+        }
         /**
          * Updates the height property for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * <code>setHeight</code> for that).
+         *
+         *
          * @param height The height value for this WindowInfo object
          */
         public void updateHeight(int height) {
-...
             if (!isMaximized)
             	this.normalWidth = w;
+        }
         /**
          * Updates the width property for for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * <code>setWidth</code> for that).
+         *
+         *
          * @param height The height value for this WindowInfo object
          */
         public void updateWidth(int width) {
-...
         	support.firePropertyChange("title", this.title, title);
             this.title = title;
+        }
         /**
          * Updates the title property for for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * <code>setTitle</code> for that).
+         *
+         *
          * @param title The title value for this WindowInfo object
          */
         public void updateTitle(String title) {
-...
         /**
          * Sets the window's ID.
+         *
+         *
          * @param id An integer to identify the window. Different
          * windows must have different IDs.
          */
-...
         /**
          * Gets the window ID.
+         *
+         *
          * @return id An integer to identify the window. Different
          * windows must have different IDs.
          */
-...
          * 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.
          */
-...
         	this.isClosed = vi.isClosed;
         	this.persistWindow = vi.persistWindow;
+        }
         /**
          * Sets whether the window is in palette mode or is in docked mode.
          * 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){
-...
         /**
          * Gets the list of selected tools for this window.
+         *
+         *
          * @return A HashMap containing pairs (group, actionCommand), which
          * are the selected tools for this window.
          * are the selected tools for this window.
          */
         public HashMap getSelectedTools() {
             return selectedTools;
+        }
         /**
          * Use {@link setSelectedTools(HashMap selectedTool)}
+         *
          * Use {@link setSelectedTools(HashMap selectedTool)}
+         *
          * @param selectedTool
          * @deprecated
          */
-...
             if (selectedTool != null)
                 selectedTools.put(defaultGroup ,selectedTool);
+        }
         /**
          * Sets the list of selected tools for this window.
          * @param selectedTools  A HashMap containing pairs
          * (group, actionCommand), which will be set as the selected tools
          * for this window.
          * for this window.
          */
         public void setSelectedTools(HashMap selectedTools) {
             if (selectedTools != null)
-...
          * Updates the closed property for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * <code>setClosed</code> for that).
+         *
+         *
          * @param closed The new closed property for this WindowInfo object
          */
         public void updateClosed(boolean closed) {
         	this.isClosed = closed;
+        }
         /**
          * Sets the normalX property for this WindowInfo object. This sets the X
          * position that the window would have when it gets restored from the
          * maximized state.
+         *
+         *
          * @param normalX The new normalX property for this WindowInfo object
          */
         public void setNormalX(int normalX) {
-...
         		this.normalX = normalX;
+        	}
+        }
         /**
          * Updates the normalX property for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * <code>setNormalX</code> for that).
+         *
+         *
          * @param normalX The new normalX property for this WindowInfo object
          */
         public void updateNormalX(int normalX) {
-...
          * Sets the normalY property for this WindowInfo object. This sets the Y
          * position that the window would have when it gets restored from the
          * maximized state.
+         *
+         *
          * @param normalY The new normalY property for this WindowInfo object
          */
         public void setNormalY(int normalY) {
-...
         		this.normalY = normalY;
+        	}
+        }
         /**
          * Updates the normalY property for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * <code>setNormalY</code> for that).
+         *
+         *
          * @param normalY The new normalY property for this WindowInfo object
          */
         public void updateNormalY(int normalY) {
-...
          * Sets the normalHeight property for this WindowInfo object. This sets the height
          * position that the window would have when it gets restored from the
          * maximized state.
+         *
+         *
          * @param normalY The new normalHeight property for this WindowInfo object
          */
         public void setNormalHeight(int normalHeight) {
-...
         		this.normalHeight = normalHeight;
+        	}
+        }
         /**
          * Updates the normalHeight property for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * <code>setNormalHeight</code> for that).
+         *
+         *
          * @param normalHeight The new normalHeight property for this WindowInfo object
          */
         public void updateNormalHeight(int normalHeight) {
-...
          * Sets the normalWidth property for this WindowInfo object. This sets the width
          * position that the window would have when it gets restored from the
          * maximized state.
+         *
+         *
          * @param normalY The new normalWidth property for this WindowInfo object
          */
         public void setNormalWidth(int normalWidth) {
-...
         		this.normalWidth = normalWidth;
+        	}
+        }
         /**
          * Sets the minimum allowed size for the associated window. If null is provided,
          * the minimum size is disabled (and thus
          * the window can be resized to any size).
+         *
+         *
          * @param minSize The minimum allowed size for the associated window.
          */
         public void setMinimumSize(Dimension minSize) {
-...
         /**
          * Updates the minimum allowed size for the associated window. It doesn't
          * get reflected on the window (use <code>setMinimumSize</code> for that).
+         *
+         *
          * @param minSize The minimum allowed size for the associated window.
          */
         public void updateMinimumSize(Dimension minSize) {
         	this.minSize = minSize;
+        }
         /**
          * Gets the minimum allowed size for the associated window.
+         *
+         *
          * @return minSize The minimum allowed size for the associated window.
          */
         public Dimension getMinimumSize() {
         	return minSize;
+        }
         /**
          * Updates the normalWidth property for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * <code>setNormalWidth</code> for that).
+         *
+         *
          * @param normalWidth The new normalHeight property for this WindowInfo object
          */
         public void updateNormalWidth(int normalWidth) {
-...
         /**
          * Maximize the associated window
+         *
+         *
          * @param maximized
          */
         public void setMaximized(boolean maximized) {
         	support.firePropertyChange("maximized", this.isMaximized, maximized);
         	this.isMaximized = maximized;
+        }
         /**
          * Updates the maximized property for this WindowInfo
          * object. It doesn't get reflected on the window (use
          * <code>setMaximized</code> for that).
+         *
+         *
          * @param maximized The new maximized property for this WindowInfo object
          */
         public void updateMaximized(boolean maximized) {
-...
         /**
          * Sets the bounds of the associated window.
+         *
+         *
          * @param x
          * @param y
          * @param width
-...
         	setWidth(width);
         	setHeight(height);
+        }
         /**
          * Updates the bounds for this WindowInfo object. It doesn't get reflected
          * on the window (use <code>setBounds</code> for that).
+         *
+         *
          * @param x
          * @param y
          * @param width
-...
          * Sets the normal bounds of the associated window. This sets the bounds
          * that the window would have when it gets restored from the
          * maximized state.
+         *
+         *
          * @param x
          * @param y
          * @param width
-...
         	setNormalWidth(width);
         	setNormalHeight(height);
+        }
         /**
          * Updates the normal bounds for this WindowInfo object. It doesn't get
          * reflected on the window (use <code>setNormalBounds</code> for that).
+         *
+         *
          * @param x
          * @param y
          * @param width
-...
          * Gets the normal bounds of the associated window. This gets the bounds
          * that the window would have when it gets restored from the
          * maximized state.
+         *
+         *
          * @return The normal bounds of the associated window.
          */
         public Rectangle getNormalBounds() {
-...
          * Sets the normal bounds of the associated window. This sets the bounds
          * that the window would have when it gets restored from the
          * maximized state.
+         *
+         *
          * @param normalBounds
          */
         public void setNormalBounds(Rectangle normalBounds) {
         	setNormalBounds(normalBounds.x, normalBounds.y, normalBounds.width, normalBounds.height);
+        }
         /**
          * Updates the normal bounds for this WindowInfo object. It doesn't get
          * reflected on the window (use <code>setNormalBounds</code> for that).
+         *
+         *
          * @param normalBounds
          */
         public void updateNormalBounds(Rectangle normalBounds) {
         	updateNormalBounds(normalBounds.x, normalBounds.y, normalBounds.width, normalBounds.height);
+        }
         /**
          * Sets the bounds of the associated window.
+         *
+         *
          * @param bounds
          */
         public void setBounds(Rectangle bounds) {
         	setBounds(bounds.x, bounds.y, bounds.width, bounds.height);
+        }
         /**
          * Updates the bounds for this WindowInfo object. It doesn't get reflected
          * on the window (use <code>setBounds</code> for that).
+         *
+         *
          * @param bounds
          */
         public void updateBounds(Rectangle bounds) {
-...
         /**
          * Gets the bounds of the associated window.
+         *
+         *
          * @return The bounds of the associated window.
          */
         public Rectangle getBounds() {
-...
          * 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() {
-...
          * 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() {
-...
          * 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() {
-...
         /**
          * Determines whether the window is maximized or not
+         *
+         *
          * @return true if the window is maximized, false otherwise
          */
         public boolean isMaximized() {
-...
     		xml.putProperty("isModal", this.isModal(), false);
     		xml.putProperty("isModeless", this.isModeless(), false);
     		xml.putProperty("isClosed", this.isClosed(), false);
     		xml.putProperty("ParentName", this.getAdditionalInfo(), false);
     		xml.putProperty("AdditionalInfo", this.getAdditionalInfo(), false);
     		if (this.isMaximized()==true) {
     			xml.putProperty("isMaximized", this.isMaximized(), false);
     			xml.putProperty("normalX", this.getNormalX(), false);
-...
     	/**
     	 * 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
     	 * specified in the XMLEntity parameters
     	 */
     	public static WindowInfo createFromXMLEntity(XMLEntity xml)
+    	{
-...
     	/**
     	 * 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)

Also available in: Unified diff