diff options
Diffstat (limited to 'libjava/java')
| -rw-r--r-- | libjava/java/awt/BorderLayout.java | 5 | ||||
| -rw-r--r-- | libjava/java/awt/CardLayout.java | 14 | ||||
| -rw-r--r-- | libjava/java/awt/Component.java | 99 | ||||
| -rw-r--r-- | libjava/java/awt/Container.java | 144 | ||||
| -rw-r--r-- | libjava/java/awt/Font.java | 14 | ||||
| -rw-r--r-- | libjava/java/awt/GraphicsEnvironment.java | 5 | ||||
| -rw-r--r-- | libjava/java/awt/GridBagLayout.java | 403 | ||||
| -rw-r--r-- | libjava/java/awt/Window.java | 15 | ||||
| -rw-r--r-- | libjava/java/awt/image/AffineTransformOp.java | 278 | ||||
| -rw-r--r-- | libjava/java/awt/image/BufferedImage.java | 9 |
10 files changed, 775 insertions, 211 deletions
diff --git a/libjava/java/awt/BorderLayout.java b/libjava/java/awt/BorderLayout.java index 7f2b1a0..38e4de7 100644 --- a/libjava/java/awt/BorderLayout.java +++ b/libjava/java/awt/BorderLayout.java @@ -592,12 +592,13 @@ layoutContainer(Container target) int x1 = i.left; int x2 = x1 + w.width + hgap; - int x3 = t.width - i.right - e.width; + int x3 = Math.max(x2 + w.width + hgap, t.width - i.right - e.width); int ww = t.width - i.right - i.left; int y1 = i.top; int y2 = y1 + n.height + vgap; - int y3 = t.height - i.bottom - s.height; + int midh = Math.max(e.height, Math.max(w.height, c.height)); + int y3 = Math.max(y2 + midh + vgap, t.height - i.bottom - s.height); int hh = y3-y2-vgap; setBounds(center, x2, y2, x3-x2-hgap, hh); diff --git a/libjava/java/awt/CardLayout.java b/libjava/java/awt/CardLayout.java index c3c9f53..fa4f4ec 100644 --- a/libjava/java/awt/CardLayout.java +++ b/libjava/java/awt/CardLayout.java @@ -103,6 +103,11 @@ public class CardLayout implements LayoutManager2, Serializable public void addLayoutComponent (String name, Component comp) { tab.put (name, comp); + // First component added is the default component. + if (tab.size() == 1) + comp.setVisible(true); + else + comp.setVisible(false); } /** Cause the first component in the container to be displayed. @@ -243,6 +248,8 @@ public class CardLayout implements LayoutManager2, Serializable if (tab.get (key) == comp) { tab.remove (key); + Container parent = comp.getParent(); + next(parent); break; } } @@ -311,6 +318,13 @@ public class CardLayout implements LayoutManager2, Serializable int num = parent.ncomponents; // This is more efficient than calling getComponents(). Component[] comps = parent.component; + + if (num == 1) + { + comps[0].setVisible(true); + return; + } + int choice = -1; if (what == FIRST) diff --git a/libjava/java/awt/Component.java b/libjava/java/awt/Component.java index 3d2afc9..8c75ba0 100644 --- a/libjava/java/awt/Component.java +++ b/libjava/java/awt/Component.java @@ -876,10 +876,16 @@ public abstract class Component // case lightweight components are not initially painted -- // Container.paint first calls isShowing () before painting itself // and its children. - this.visible = true; - if (peer != null) - peer.setVisible(true); - invalidate(); + if(!isVisible()) + { + this.visible = true; + if (peer != null) + peer.setVisible(true); + invalidate(); + ComponentEvent ce = + new ComponentEvent(this,ComponentEvent.COMPONENT_SHOWN); + getToolkit().getSystemEventQueue().postEvent(ce); + } } /** @@ -903,10 +909,16 @@ public abstract class Component */ public void hide() { - if (peer != null) - peer.setVisible(false); - this.visible = false; - invalidate(); + if (isVisible()) + { + if (peer != null) + peer.setVisible(false); + this.visible = false; + invalidate(); + ComponentEvent ce = + new ComponentEvent(this,ComponentEvent.COMPONENT_HIDDEN); + getToolkit().getSystemEventQueue().postEvent(ce); + } } /** @@ -974,8 +986,11 @@ public abstract class Component */ public void setBackground(Color c) { + // If c is null, inherit from closest ancestor whose bg is set. + if (c == null && parent != null) + c = parent.getBackground(); firePropertyChange("background", background, c); - if (peer != null) + if (peer != null && c != null) peer.setBackground(c); background = c; } @@ -1022,6 +1037,7 @@ public abstract class Component firePropertyChange("font", font, f); if (peer != null) peer.setFont(f); + invalidate(); font = f; } @@ -1150,6 +1166,9 @@ public abstract class Component */ public void move(int x, int y) { + int oldx = this.x; + int oldy = this.y; + if (this.x == x && this.y == y) return; invalidate (); @@ -1157,6 +1176,20 @@ public abstract class Component this.y = y; if (peer != null) peer.setBounds (x, y, width, height); + + // Erase old bounds and repaint new bounds for lightweights. + if (isLightweight() && width != 0 && height !=0) + { + parent.repaint(oldx, oldy, width, height); + repaint(); + } + + if (oldx != x || oldy != y) + { + ComponentEvent ce = new ComponentEvent(this, + ComponentEvent.COMPONENT_MOVED); + getToolkit().getSystemEventQueue().postEvent(ce); + } } /** @@ -1220,6 +1253,9 @@ public abstract class Component */ public void resize(int width, int height) { + int oldwidth = this.width; + int oldheight = this.height; + if (this.width == width && this.height == height) return; invalidate (); @@ -1227,6 +1263,22 @@ public abstract class Component this.height = height; if (peer != null) peer.setBounds (x, y, width, height); + + // Erase old bounds and repaint new bounds for lightweights. + if (isLightweight()) + { + if (oldwidth != 0 && oldheight != 0 && parent != null) + parent.repaint(x, y, oldwidth, oldheight); + if (width != 0 && height != 0) + repaint(); + } + + if (oldwidth != width || oldheight != height) + { + ComponentEvent ce = + new ComponentEvent(this, ComponentEvent.COMPONENT_RESIZED); + getToolkit().getSystemEventQueue().postEvent(ce); + } } /** @@ -1315,6 +1367,11 @@ public abstract class Component */ public void reshape(int x, int y, int width, int height) { + int oldx = this.x; + int oldy = this.y; + int oldwidth = this.width; + int oldheight = this.height; + if (this.x == x && this.y == y && this.width == width && this.height == height) return; @@ -1325,6 +1382,28 @@ public abstract class Component this.height = height; if (peer != null) peer.setBounds (x, y, width, height); + + // Erase old bounds and repaint new bounds for lightweights. + if (isLightweight()) + { + if (oldwidth != 0 && oldheight != 0 && parent != null) + parent.repaint(oldx, oldy, oldwidth, oldheight); + if (width != 0 && height != 0) + repaint(); + } + + if (oldx != x || oldy != y) + { + ComponentEvent ce = new ComponentEvent(this, + ComponentEvent.COMPONENT_MOVED); + getToolkit().getSystemEventQueue().postEvent(ce); + } + if (oldwidth != width || oldheight != height) + { + ComponentEvent ce = new ComponentEvent(this, + ComponentEvent.COMPONENT_RESIZED); + getToolkit().getSystemEventQueue().postEvent(ce); + } } /** @@ -4172,6 +4251,8 @@ p * <li>the set of backward traversal keys case MouseEvent.MOUSE_EXITED: case MouseEvent.MOUSE_PRESSED: case MouseEvent.MOUSE_RELEASED: + case MouseEvent.MOUSE_MOVED: + case MouseEvent.MOUSE_DRAGGED: return (mouseListener != null || mouseMotionListener != null || (eventMask & AWTEvent.MOUSE_EVENT_MASK) != 0); diff --git a/libjava/java/awt/Container.java b/libjava/java/awt/Container.java index ff1dde1..d666559 100644 --- a/libjava/java/awt/Container.java +++ b/libjava/java/awt/Container.java @@ -502,6 +502,20 @@ public class Container extends Component } /** + * Recursively invalidates the container tree. + */ + private void invalidateTree() + { + for (int i = 0; i < ncomponents; i++) + { + Component comp = component[i]; + comp.invalidate(); + if (comp instanceof Container) + ((Container) comp).invalidateTree(); + } + } + + /** * Recursively validates the container tree, recomputing any invalid * layouts. */ @@ -546,7 +560,10 @@ public class Container extends Component public void setFont(Font f) { super.setFont(f); - // FIXME, should invalidate all children with font == null + // FIXME: Although it might make more sense to invalidate only + // those children whose font == null, Sun invalidates all children. + // So we'll do the same. + invalidateTree(); } /** @@ -1234,6 +1251,7 @@ public class Container extends Component Rectangle oldClip = gfx.getClipBounds(); if (oldClip == null) oldClip = bounds; + Rectangle clip = oldClip.intersection(bounds); if (clip.isEmpty()) return; @@ -1337,10 +1355,10 @@ public class Container extends Component // If we're not lightweight, and we just got a lightweight // child, we need a lightweight dispatcher to feed it events. - if (! this.isLightweight() - && dispatcher == null) + if (! this.isLightweight()) { - dispatcher = new LightweightDispatcher (this); + if (dispatcher == null) + dispatcher = new LightweightDispatcher (this); dispatcher.enableEvents (component[i].eventMask); } @@ -1536,6 +1554,9 @@ class LightweightDispatcher implements Serializable private long eventMask; private transient Component mouseEventTarget; + private transient Component pressedComponent; + private transient Component lastComponentEntered; + private transient int pressCount; LightweightDispatcher(Container c) { @@ -1551,46 +1572,37 @@ class LightweightDispatcher implements Serializable { int x = me.getX (); int y = me.getY (); - Component candidate = mouseEventTarget; - - while(candidate != null) - { - if (candidate.isShowing()) - { - // Convert our point to the candidate's parent's space. - Point cp = SwingUtilities.convertPoint(nativeContainer, x, y, candidate); - - // If the event lands inside candidate, we have a hit. - if (candidate.contains(cp.x, cp.y)) - { - // If candidate has children, we refine the hit. - if (candidate instanceof Container && - ((Container)candidate).getComponentCount() > 0) - candidate = SwingUtilities.getDeepestComponentAt(candidate, cp.x, cp.y); - break; - } - } - // If candidate isn't showing or doesn't contain point, we back out a level. - candidate = candidate.getParent(); - } - - if (candidate == null) + + // Find the candidate which should receive this event. + Component parent = nativeContainer; + Component candidate = null; + Point p = me.getPoint(); + while (candidate == null && parent != null) { - // We either lost, or never had, a candidate; acquire from our native. - candidate = - SwingUtilities.getDeepestComponentAt(nativeContainer, x, y); + candidate = + SwingUtilities.getDeepestComponentAt(parent, p.x, p.y); + if (candidate == null) + { + p = SwingUtilities.convertPoint(parent, p.x, p.y, parent.parent); + parent = parent.parent; + } } + // If the only candidate we found was the native container itself, + // don't dispatch any event at all. We only care about the lightweight + // children here. + if (candidate == nativeContainer) + candidate = null; // If our candidate is new, inform the old target we're leaving. - if (mouseEventTarget != null - && mouseEventTarget.isShowing() - && mouseEventTarget != candidate) + if (lastComponentEntered != null + && lastComponentEntered.isShowing() + && lastComponentEntered != candidate) { Point tp = SwingUtilities.convertPoint(nativeContainer, - x, y, mouseEventTarget); - MouseEvent exited = new MouseEvent (mouseEventTarget, + x, y, lastComponentEntered); + MouseEvent exited = new MouseEvent (lastComponentEntered, MouseEvent.MOUSE_EXITED, me.getWhen (), me.getModifiers (), @@ -1598,22 +1610,23 @@ class LightweightDispatcher implements Serializable me.getClickCount (), me.isPopupTrigger (), me.getButton ()); - mouseEventTarget.dispatchEvent (exited); - mouseEventTarget = null; + lastComponentEntered.dispatchEvent (exited); + lastComponentEntered = null; } // If we have a candidate, maybe enter it. if (candidate != null) { + mouseEventTarget = candidate; if (candidate.isLightweight() && candidate.isShowing() && candidate != nativeContainer - && candidate != mouseEventTarget) + && candidate != lastComponentEntered) { - mouseEventTarget = candidate; + lastComponentEntered = mouseEventTarget; Point cp = SwingUtilities.convertPoint(nativeContainer, - x, y, candidate); - MouseEvent entered = new MouseEvent (mouseEventTarget, + x, y, lastComponentEntered); + MouseEvent entered = new MouseEvent (lastComponentEntered, MouseEvent.MOUSE_ENTERED, me.getWhen (), me.getModifiers (), @@ -1621,9 +1634,29 @@ class LightweightDispatcher implements Serializable me.getClickCount (), me.isPopupTrigger (), me.getButton ()); - mouseEventTarget.dispatchEvent (entered); + lastComponentEntered.dispatchEvent (entered); } } + + if (me.getID() == MouseEvent.MOUSE_RELEASED + || me.getID() == MouseEvent.MOUSE_PRESSED && pressCount > 0 + || me.getID() == MouseEvent.MOUSE_DRAGGED) + // If any of the following events occur while a button is held down, + // they should be dispatched to the same component to which the + // original MOUSE_PRESSED event was dispatched: + // - MOUSE_RELEASED + // - MOUSE_PRESSED: another button pressed while the first is held down + // - MOUSE_DRAGGED + mouseEventTarget = pressedComponent; + else if (me.getID() == MouseEvent.MOUSE_CLICKED) + { + // Don't dispatch CLICKED events whose target is not the same as the + // target for the original PRESSED event. + if (candidate != pressedComponent) + mouseEventTarget = null; + else if (pressCount == 0) + pressedComponent = null; + } } boolean handleEvent(AWTEvent e) @@ -1634,17 +1667,36 @@ class LightweightDispatcher implements Serializable if (e instanceof MouseEvent) { MouseEvent me = (MouseEvent) e; - acquireComponentForMouseEvent(me); - // Avoid dispatching an ENTERED event twice. + acquireComponentForMouseEvent(me); + + // Avoid dispatching ENTERED and EXITED events twice. if (mouseEventTarget != null && mouseEventTarget.isShowing() - && e.getID() != MouseEvent.MOUSE_ENTERED) + && e.getID() != MouseEvent.MOUSE_ENTERED + && e.getID() != MouseEvent.MOUSE_EXITED) { MouseEvent newEvt = SwingUtilities.convertMouseEvent(nativeContainer, me, mouseEventTarget); mouseEventTarget.dispatchEvent(newEvt); + + switch (e.getID()) + { + case MouseEvent.MOUSE_PRESSED: + if (pressCount++ == 0) + pressedComponent = mouseEventTarget; + break; + + case MouseEvent.MOUSE_RELEASED: + // Clear our memory of the original PRESSED event, only if + // we're not expecting a CLICKED event after this. If + // there is a CLICKED event after this, it will do clean up. + if (--pressCount == 0 + && mouseEventTarget != pressedComponent) + pressedComponent = null; + break; + } } } else if (e instanceof KeyEvent && focus != null) diff --git a/libjava/java/awt/Font.java b/libjava/java/awt/Font.java index 517d332..42f9f7b 100644 --- a/libjava/java/awt/Font.java +++ b/libjava/java/awt/Font.java @@ -330,16 +330,20 @@ private static final long serialVersionUID = -4206021311591459213L; } public Font (Map attrs) -{ - this.peer = getPeerFromToolkit (null, attrs); -} + { + this(null, attrs); + } /* This extra constructor is here to permit ClasspathToolkit and to build a font with a "logical name" as well as attrs. */ public Font (String name, Map attrs) -{ + { + // If attrs is null, setting it to an empty HashMap will give this + // Font default attributes. + if (attrs == null) + attrs = new HashMap(); this.peer = getPeerFromToolkit (name, attrs); -} + } /*************************************************************************/ diff --git a/libjava/java/awt/GraphicsEnvironment.java b/libjava/java/awt/GraphicsEnvironment.java index 63e23e2..2b4ce51 100644 --- a/libjava/java/awt/GraphicsEnvironment.java +++ b/libjava/java/awt/GraphicsEnvironment.java @@ -40,6 +40,7 @@ package java.awt; import java.awt.image.BufferedImage; import java.util.Locale; +import gnu.java.awt.ClasspathToolkit; /** * This descibes the collection of GraphicsDevice and Font objects available @@ -70,7 +71,9 @@ public abstract class GraphicsEnvironment */ public static GraphicsEnvironment getLocalGraphicsEnvironment() { - throw new Error("not implemented"); + ClasspathToolkit tk; + tk = ((ClasspathToolkit) Toolkit.getDefaultToolkit ()); + return tk.getLocalGraphicsEnvironment (); } /** diff --git a/libjava/java/awt/GridBagLayout.java b/libjava/java/awt/GridBagLayout.java index 5b009de..301e713 100644 --- a/libjava/java/awt/GridBagLayout.java +++ b/libjava/java/awt/GridBagLayout.java @@ -39,6 +39,7 @@ exception statement from your version. */ package java.awt; import java.io.Serializable; +import java.util.ArrayList; import java.util.Hashtable; import java.util.HashMap; @@ -468,8 +469,15 @@ public class GridBagLayout HashMap lastInRow = new HashMap(); HashMap lastInCol = new HashMap(); - // STEP 1: first we figure out how many rows/columns Component[] components = parent.getComponents(); + + // Components sorted by gridwidths/heights, + // smallest to largest, with REMAINDER and RELATIVE at the end. + // These are useful when determining sizes and weights. + ArrayList sortedByWidth = new ArrayList(components.length); + ArrayList sortedByHeight = new ArrayList(components.length); + + // STEP 1: first we figure out how many rows/columns for (int i = 0; i < components.length; i++) { Component component = components [i]; @@ -578,6 +586,9 @@ public class GridBagLayout max_y = Math.max(max_y, constraints.gridy + Math.max(1, constraints.gridheight)); + sortBySpan(component, constraints.gridwidth, sortedByWidth, true); + sortBySpan(component, constraints.gridheight, sortedByHeight, false); + // Update our reference points for RELATIVE gridx and gridy. if(constraints.gridwidth == GridBagConstraints.REMAINDER) { @@ -621,10 +632,27 @@ public class GridBagLayout } } // end of STEP 1 - boolean[] colIsOccupied = new boolean[max_x]; - boolean[] rowIsOccupied = new boolean[max_y]; + GridBagLayoutInfo info = new GridBagLayoutInfo(max_x, max_y); - // STEP 2: Determine which cells the components occupy. + // Check if column widths and row heights are overridden. + + for (int x = 0; x < max_x; x++) + { + if(columnWidths != null && columnWidths.length > x) + info.colWidths[x] = columnWidths[x]; + if(columnWeights != null && columnWeights.length > x) + info.colWeights[x] = columnWeights[x]; + } + + for (int y = 0; y < max_y; y++) + { + if(rowHeights != null && rowHeights.length > y) + info.rowHeights[y] = rowHeights[y]; + if(rowWeights != null && rowWeights.length > y) + info.rowWeights[y] = rowWeights[y]; + } + + // STEP 2: Fix up any cells with width/height as REMAINDER/RELATIVE. for (int i = 0; i < components.length; i++) { Component component = components [i]; @@ -635,104 +663,87 @@ public class GridBagLayout GridBagConstraints constraints = lookupInternalConstraints (component); - // Fix up any REMAINDER and RELATIVE cells. - if(constraints.gridwidth == GridBagConstraints.REMAINDER) + if(constraints.gridwidth == GridBagConstraints.REMAINDER || constraints.gridwidth == GridBagConstraints.RELATIVE) { - for (int y = constraints.gridy; y < constraints.gridy + Math.max(1, constraints.gridheight); y++) + if(constraints.gridwidth == GridBagConstraints.REMAINDER) { - if (lastInRow.containsKey(new Integer(y))) + for (int y = constraints.gridy; y < constraints.gridy + Math.max(1, constraints.gridheight); y++) { - Component lastComponent = (Component) lastInRow.get(new Integer(y)); - GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); - - if (lastConstraints.gridwidth == GridBagConstraints.RELATIVE) - { - constraints.gridx = max_x - 1; - break; - } - else + if (lastInRow.containsKey(new Integer(y))) { - constraints.gridx = Math.max (constraints.gridx, - lastConstraints.gridx + Math.max (1, lastConstraints.gridwidth)); + Component lastComponent = (Component) lastInRow.get(new Integer(y)); + GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); + + if (lastConstraints.gridwidth == GridBagConstraints.RELATIVE) + { + constraints.gridx = max_x - 1; + break; + } + else + { + constraints.gridx = Math.max (constraints.gridx, + lastConstraints.gridx + Math.max (1, lastConstraints.gridwidth)); + } } } + constraints.gridwidth = max_x - constraints.gridx; } - constraints.gridwidth = max_x - constraints.gridx; - } - else if (constraints.gridwidth == GridBagConstraints.RELATIVE) - { - constraints.gridwidth = max_x - constraints.gridx - 1; + else if (constraints.gridwidth == GridBagConstraints.RELATIVE) + { + constraints.gridwidth = max_x - constraints.gridx - 1; + } + + // Re-sort + sortedByWidth.remove(sortedByWidth.indexOf(component)); + sortBySpan(component, constraints.gridwidth, sortedByWidth, true); } - if(constraints.gridheight == GridBagConstraints.REMAINDER) + if(constraints.gridheight == GridBagConstraints.REMAINDER || constraints.gridheight == GridBagConstraints.RELATIVE) { - for (int x = constraints.gridx; x < constraints.gridx + Math.max(1, constraints.gridwidth); x++) + if(constraints.gridheight == GridBagConstraints.REMAINDER) { - if (lastInCol.containsKey(new Integer(x))) + for (int x = constraints.gridx; x < constraints.gridx + Math.max(1, constraints.gridwidth); x++) { - Component lastComponent = (Component) lastInRow.get(new Integer(x)); - GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); - - if (lastConstraints.gridheight == GridBagConstraints.RELATIVE) + if (lastInCol.containsKey(new Integer(x))) { - constraints.gridy = max_y - 1; - break; - } - else - { - constraints.gridy = Math.max (constraints.gridy, - lastConstraints.gridy + Math.max (1, lastConstraints.gridheight)); + Component lastComponent = (Component) lastInRow.get(new Integer(x)); + GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); + + if (lastConstraints.gridheight == GridBagConstraints.RELATIVE) + { + constraints.gridy = max_y - 1; + break; + } + else + { + constraints.gridy = Math.max (constraints.gridy, + lastConstraints.gridy + Math.max (1, lastConstraints.gridheight)); + } } } + constraints.gridheight = max_y - constraints.gridy; + } + else if (constraints.gridheight == GridBagConstraints.RELATIVE) + { + constraints.gridheight = max_y - constraints.gridy - 1; } - constraints.gridheight = max_y - constraints.gridy; - } - else if (constraints.gridheight == GridBagConstraints.RELATIVE) - { - constraints.gridheight = max_y - constraints.gridy - 1; - } - // For now, a row or a column is "occupied" iff a component - // both begins and ends in that row or column. - if (constraints.gridwidth == 1) - colIsOccupied[constraints.gridx] = true; - if (constraints.gridheight == 1) - rowIsOccupied[constraints.gridy] = true; + // Re-sort + sortedByHeight.remove(sortedByHeight.indexOf(component)); + sortBySpan(component, constraints.gridheight, sortedByHeight, false); + } } // end of STEP 2 - GridBagLayoutInfo info = new GridBagLayoutInfo(max_x, max_y); - - // Check if column widths and row heights are overridden. - - for (int x = 0; x < max_x; x++) - { - if(columnWidths != null && columnWidths.length > x) - info.colWidths[x] = columnWidths[x]; - if(columnWeights != null && columnWeights.length > x) - info.colWeights[x] = columnWeights[x]; - } - - for (int y = 0; y < max_y; y++) + // STEP 3: Determine sizes and weights for columns. + for (int i = 0; i < sortedByWidth.size(); i++) { - if(rowHeights != null && rowHeights.length > y) - info.rowHeights[y] = rowHeights[y]; - if(rowWeights != null && rowWeights.length > y) - info.rowWeights[y] = rowWeights[y]; - } - - // STEP 3: Distribute the weights and min sizes among rows/columns. - for (int i = 0; i < components.length; i++) - { - Component component = components [i]; + Component component = (Component) sortedByWidth.get(i); // If component is not visible we dont have to care about it. if (!component.isVisible()) continue; GridBagConstraints constraints = lookupInternalConstraints (component); - GridBagConstraints originalConstraints = lookupConstraints (component); - - // Distribute the width. int width = (sizeflag == PREFERREDSIZE) ? component.getPreferredSize().width : @@ -743,35 +754,24 @@ public class GridBagLayout width += constraints.ipadx; - int occupiedCols = constraints.gridwidth; - int lastOccupiedCol = -1; - - for(int w = constraints.gridx; w < constraints.gridx + constraints.gridwidth; w++) - { - if(colIsOccupied[w]) - lastOccupiedCol = w; - else - occupiedCols--; - } - - // A component needs to occupy at least one column. - if(occupiedCols == 0) - { - colIsOccupied[constraints.gridx + constraints.gridwidth - 1] = true; - lastOccupiedCol = constraints.gridx + constraints.gridwidth - 1; - } - - for(int w = constraints.gridx; w < constraints.gridx + constraints.gridwidth - 1; w++) - { - if(colIsOccupied[w]) - width -= info.colWidths[w]; - } - - info.colWidths[lastOccupiedCol] = Math.max(info.colWidths[lastOccupiedCol], width); - info.colWeights[lastOccupiedCol] = Math.max(info.colWeights[lastOccupiedCol], constraints.weightx); + distributeSizeAndWeight(width, + constraints.weightx, + constraints.gridx, + constraints.gridwidth, + info.colWidths, + info.colWeights); + } // end of STEP 3 + // STEP 4: Determine sizes and weights for rows. + for (int i = 0; i < sortedByHeight.size(); i++) + { + Component component = (Component) sortedByHeight.get(i); + + // If component is not visible we dont have to care about it. + if (!component.isVisible()) + continue; - // Distribute the height. + GridBagConstraints constraints = lookupInternalConstraints (component); int height = (sizeflag == PREFERREDSIZE) ? component.getPreferredSize().height : @@ -782,34 +782,13 @@ public class GridBagLayout height += constraints.ipady; - int occupiedRows = constraints.gridheight; - int lastOccupiedRow = -1; - - for(int h = constraints.gridy; h < constraints.gridy + constraints.gridheight; h++) - { - if(rowIsOccupied[h]) - lastOccupiedRow = h; - else - occupiedRows--; - } - - // A component needs to occupy at least one row. - if(occupiedRows == 0) - { - rowIsOccupied[constraints.gridy + constraints.gridheight - 1] = true; - lastOccupiedRow = constraints.gridy + constraints.gridheight - 1; - } - - for(int h = constraints.gridy; h < constraints.gridy + constraints.gridheight; h++) - { - if(rowIsOccupied[h]) - height -= info.rowHeights[h]; - } - - info.rowHeights[lastOccupiedRow] = Math.max(info.rowHeights[lastOccupiedRow], height); - info.rowWeights[lastOccupiedRow] = Math.max(info.rowWeights[lastOccupiedRow], constraints.weighty); - - } // end of STEP 3 + distributeSizeAndWeight(height, + constraints.weighty, + constraints.gridy, + constraints.gridheight, + info.rowHeights, + info.rowWeights); + } // end of STEP 4 calcCellSizes (info.colWidths, info.colWeights, parentDim.width); calcCellSizes (info.rowHeights, info.rowWeights, parentDim.height); @@ -847,17 +826,155 @@ public class GridBagLayout return GetMinSize (parent, info); } - private void calcCellSizes (int[] sizes, double[] weights, int range) + /** + * Helper method used by GetLayoutInfo to keep components sorted, either + * by gridwidth or gridheight. + * + * @param component Component to add to the sorted list. + * @param span Either the component's gridwidth or gridheight. + * @param list <code>ArrayList</code> of components, sorted by + * their span. + * @param sortByWidth Flag indicating sorting index. If true, sort by + * width. Otherwise, sort by height. + * FIXME: Use a better sorting algorithm. + */ + private void sortBySpan (Component component, int span, ArrayList list, boolean sortByWidth) { - int totalSize = sumIntArray (sizes); - double totalWeight = sumDoubleArray (weights); + if (span == GridBagConstraints.REMAINDER + || span == GridBagConstraints.RELATIVE) + { + // Put all RELATIVE and REMAINDER components at the end. + list.add(component); + } + else + { + int i = 0; + if (list.size() > 0) + { + GridBagConstraints gbc = lookupInternalConstraints((Component) list.get(i)); + int otherspan = sortByWidth ? + gbc.gridwidth : + gbc.gridheight; + while (otherspan != GridBagConstraints.REMAINDER + && otherspan != GridBagConstraints.RELATIVE + && span >= otherspan) + { + i++; + if (i < list.size()) + { + gbc = lookupInternalConstraints((Component) list.get(i)); + otherspan = sortByWidth ? + gbc.gridwidth : + gbc.gridheight; + } + else + break; + } + } + list.add(i, component); + } + } - // Rows or columns with size 0 should not be weighted in the calculation. - for (int i = 0; i < weights.length; i++) + /** + * Helper method used by GetLayoutInfo to distribute a component's size + * and weight. + * + * @param size Preferred size of component, with inset and padding + * already added. + * @param weight Weight of component. + * @param start Starting position of component. Either + * constraints.gridx or gridy. + * @param span Span of component. either contraints.gridwidth or + * gridheight. + * @param sizes Sizes of rows or columns. + * @param weights Weights of rows or columns. + */ + private void distributeSizeAndWeight (int size, double weight, + int start, int span, + int[] sizes, double[] weights) + { + if (span == 1) + { + sizes[start] = Math.max(sizes[start], size); + weights[start] = Math.max(weights[start], weight); + } + else + { + int numOccupied = span; + int lastOccupied = -1; + + for(int i = start; i < start + span; i++) + { + if (sizes[i] == 0.0) + numOccupied--; + else + { + size -= sizes[i]; + lastOccupied = i; + } + } + + // A component needs to occupy at least one row. + if(numOccupied == 0) + sizes[start + span - 1] = size; + else if (size > 0) + sizes[lastOccupied] += size; + + calcCellWeights(weight, weights, start, span); + } + } + + /** + * Helper method used by GetLayoutInfo to calculate weight distribution. + * @param weight Weight of component. + * @param weights Weights of rows/columns. + * @param start Starting position of component in grid (gridx/gridy). + * @param span Span of component (gridwidth/gridheight). + */ + private void calcCellWeights (double weight, double[] weights, int start, int span) + { + double totalWeight = 0.0; + for(int k = start; k < start + span; k++) + totalWeight += weights[k]; + + if(weight > totalWeight) { - if (sizes[i] == 0) - totalWeight -= weights[i]; + if (totalWeight == 0.0) + { + weights[start + span - 1] += weight; + } + else + { + double diff = weight - totalWeight ; + double remaining = diff; + + for(int k = start; k < start + span; k++) + { + double extraWeight = diff * weights[k] / totalWeight; + weights[k] += extraWeight; + remaining -= extraWeight; + } + + if (remaining > 0.0 && weights[start + span - 1] != 0.0) + { + weights[start + span - 1] += remaining; + } + } } + } + + /** + * Helper method used by GetLayoutInfo to distribute extra space + * based on weight distribution. + * + * @param sizes Sizes of rows/columns. + * @param weights Weights of rows/columns. + * @param range Dimension of container. + */ + private void calcCellSizes (int[] sizes, double[] weights, int range) + { + int totalSize = sumIntArray (sizes); + double totalWeight = sumDoubleArray (weights); int diff = range - totalSize; @@ -866,14 +983,10 @@ public class GridBagLayout for (int i = 0; i < sizes.length; i++) { - // A row or column with zero size cannot all of a sudden gain size. - if (sizes[i] != 0.0) - { - int newsize = (int) (sizes[i] + (((double) diff) * weights [i] / totalWeight )); + int newsize = (int) (sizes[i] + (((double) diff) * weights [i] / totalWeight )); - if (newsize > 0) - sizes[i] = newsize; - } + if (newsize > 0) + sizes[i] = newsize; } } diff --git a/libjava/java/awt/Window.java b/libjava/java/awt/Window.java index 70d452b..81e37fc 100644 --- a/libjava/java/awt/Window.java +++ b/libjava/java/awt/Window.java @@ -38,6 +38,7 @@ exception statement from your version. */ package java.awt; +import java.awt.event.ComponentEvent; import java.awt.event.WindowEvent; import java.awt.event.WindowFocusListener; import java.awt.event.WindowListener; @@ -784,9 +785,23 @@ public class Window extends Container implements Accessible if (this.x == x && this.y == y && width == w && height == h) return; invalidate(); + boolean resized = width != w || height != h; + boolean moved = this.x != x || this.y != y; this.x = x; this.y = y; width = w; height = h; + if (resized) + { + ComponentEvent ce = + new ComponentEvent(this, ComponentEvent.COMPONENT_RESIZED); + getToolkit().getSystemEventQueue().postEvent(ce); + } + if (moved) + { + ComponentEvent ce = + new ComponentEvent(this, ComponentEvent.COMPONENT_MOVED); + getToolkit().getSystemEventQueue().postEvent(ce); + } } } diff --git a/libjava/java/awt/image/AffineTransformOp.java b/libjava/java/awt/image/AffineTransformOp.java new file mode 100644 index 0000000..ca66213 --- /dev/null +++ b/libjava/java/awt/image/AffineTransformOp.java @@ -0,0 +1,278 @@ +/* AffineTransformOp.java -- This class performs affine + * transformation between two images or rasters in 2 + * dimensions. Copyright (C) 2004 Free Software Foundation + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package java.awt.image; + +import java.awt.*; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.geom.*; + + +/** + * This class performs affine transformation between two images or + * rasters in 2 dimensions. + * + * @author Olga Rodimina <rodimina@redhat.com> + */ + +public class AffineTransformOp implements BufferedImageOp, RasterOp +{ + + public static final int TYPE_BILINEAR = 0; + public static final int TYPE_NEAREST_NEIGHBOR = 1; + + private AffineTransform transform; + private RenderingHints hints; + + + /** + * Construct AffineTransformOp with the given xform and interpolationType. + * Interpolation type can be either TYPE_BILINEAR or TYPE_NEAREST_NEIGHBOR. + * + * @param xform AffineTransform that will applied to the source image + * @param interpolationType type of interpolation used + */ + + AffineTransformOp (AffineTransform xform, int interpolationType) + { + this.transform = xform; + + if (interpolationType == 0) + hints = new RenderingHints (RenderingHints.KEY_INTERPOLATION, + RenderingHints.VALUE_INTERPOLATION_BILINEAR); + + else + hints = new RenderingHints (RenderingHints.KEY_INTERPOLATION, + RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR); + + } + + /** + * Construct AffineTransformOp with the given xform and rendering hints. + * + * @param xform AffineTransform that will applied to the source image + * @param hints rendering hints that will be used during transformation + */ + + AffineTransformOp (AffineTransform xform, RenderingHints hints) + { + this.transform = xform; + this.hints = hints; + } + + /** + * Creates empty BufferedImage with the size equal to that of the + * transformed image and correct number of bands. The newly created + * image is created with the specified ColorModel. + * If the ColorModel is equal to null, then image is created + * with the ColorModel of the source image. + * + * @param src source image + * @param destCM color model for the destination image + * @return new compatible destination image + */ + + public BufferedImage createCompatibleDestImage (BufferedImage src, + ColorModel destCM) + { + + // if destCm is not specified, use color model of the source image + + if (destCM == null) + destCM = src.getColorModel (); + + return new BufferedImage (destCM, + createCompatibleDestRaster (src.getRaster ()), + src.isAlphaPremultiplied (), + null); + + } + + /** + * Creates empty WritableRaster with the size equal to the transformed + * source raster and correct number of bands + * + * @param src source raster + * @throws RasterFormatException if resulting width or height of raster is 0 + * @return new compatible raster + */ + + public WritableRaster createCompatibleDestRaster (Raster src) + { + Rectangle rect = (Rectangle) getBounds2D (src); + + // throw RasterFormatException if resulting width or height of the + // transformed raster is 0 + + if (rect.getWidth () == 0 || rect.getHeight () == 0) + throw new RasterFormatException("width or height is 0"); + + return src.createCompatibleWritableRaster ((int) rect.getWidth (), + (int) rect.getHeight ()); + } + + /** + * Transforms source image using transform specified at the constructor. + * The resulting transformed image is stored in the destination image. + * + * @param src source image + * @param dst destination image + * @return transformed source image + */ + + public BufferedImage filter (BufferedImage src, BufferedImage dst) + { + + if (dst == src) + throw new IllegalArgumentException ("src image cannot be the same as the dst image"); + + // If the destination image is null, then BufferedImage is + // created with ColorModel of the source image + + if (dst == null) + dst = createCompatibleDestImage(src, src.getColorModel ()); + + // FIXME: Must check if color models of src and dst images are the same. + // If it is not, then source image should be converted to color model + // of the destination image + + Graphics2D gr = (Graphics2D) dst.createGraphics (); + gr.setRenderingHints (hints); + gr.drawImage (src, transform, null); + return dst; + + } + + /** + * Transforms source raster using transform specified at the constructor. + * The resulting raster is stored in the destination raster. + * + * @param src source raster + * @param dst destination raster + * @return transformed raster + */ + + public WritableRaster filter (Raster src, WritableRaster dst) + { + throw new UnsupportedOperationException ("not implemented yet"); + } + + /** + * Transforms source image using transform specified at the constructor and + * returns bounds of the transformed image. + * + * @param src image to be transformed + * @return bounds of the transformed image. + */ + + public Rectangle2D getBounds2D (BufferedImage src) + { + return getBounds2D (src.getRaster()); + } + + /** + * Returns bounds of the transformed raster. + * + * @param src raster to be transformed + * @return bounds of the transformed raster. + */ + + public Rectangle2D getBounds2D (Raster src) + { + // determine new size for the transformed raster. + // Need to calculate transformed coordinates of the lower right + // corner of the raster. The upper left corner is always (0,0) + + double x2 = (double) src.getWidth () + src.getMinX (); + double y2 = (double) src.getHeight () + src.getMinY (); + Point2D p2 = getPoint2D (new Point2D.Double (x2,y2), null); + + Rectangle2D rect = new Rectangle (0, 0, (int) p2.getX (), (int) p2.getY ()); + return rect.getBounds (); + } + + /** + * Returns interpolation type used during transformations + * + * @return interpolation type + */ + + public int getInterpolationType () + { + if(hints.containsValue (RenderingHints.VALUE_INTERPOLATION_BILINEAR)) + return TYPE_BILINEAR; + else + return TYPE_NEAREST_NEIGHBOR; + } + + /** + * Returns location of the transformed source point. The resulting point + * is stored in the dstPt if one is specified. + * + * @param srcPt point to be transformed + * @param dstPt destination point + * @return the location of the transformed source point. + */ + + public Point2D getPoint2D (Point2D srcPt, Point2D dstPt) + { + return transform.transform (srcPt, dstPt); + } + + /** Returns rendering hints that are used during transformation. + * + * @return rendering hints + */ + + public RenderingHints getRenderingHints () + { + return hints; + } + + /** Returns transform used in transformation between source and destination + * image. + * + * @return transform + */ + + public AffineTransform getTransform () + { + return transform; + } +} diff --git a/libjava/java/awt/image/BufferedImage.java b/libjava/java/awt/image/BufferedImage.java index 52006c0..547301d 100644 --- a/libjava/java/awt/image/BufferedImage.java +++ b/libjava/java/awt/image/BufferedImage.java @@ -39,6 +39,7 @@ package java.awt.image; import java.awt.Graphics; import java.awt.Graphics2D; +import java.awt.GraphicsEnvironment; import java.awt.Image; import java.awt.Point; import java.awt.Rectangle; @@ -255,7 +256,8 @@ public class BufferedImage extends Image public WritableRaster copyData(WritableRaster dest) { if (dest == null) - dest = raster.createCompatibleWritableRaster(); + dest = raster.createCompatibleWritableRaster(getMinX(), getMinY(), + getWidth(),getHeight()); int x = dest.getMinX(); int y = dest.getMinY(); @@ -282,8 +284,9 @@ public class BufferedImage extends Image public Graphics2D createGraphics() { - throw new UnsupportedOperationException("not implemented"); - // will require a lot of effort to implement + GraphicsEnvironment env; + env = GraphicsEnvironment.getLocalGraphicsEnvironment (); + return env.createGraphics (this); } public void flush() { |