2003/08/14 05:16:08
authormegacz <megacz@xwt.org>
Fri, 30 Jan 2004 07:04:25 +0000 (07:04 +0000)
committermegacz <megacz@xwt.org>
Fri, 30 Jan 2004 07:04:25 +0000 (07:04 +0000)
darcs-hash:20040130070425-2ba56-3571f75cdd9bb4108e37155cb8cdf7c9c8422a25.gz

src/org/xwt/Box.java.pp
src/org/xwt/Platform.java
src/org/xwt/Surface.java

index 822f7a0..8b8e2f8 100644 (file)
@@ -115,8 +115,8 @@ public final class Box extends JS.Scope {
     // computed during reflow
     LENGTH x = 0;
     LENGTH y = 0;
-    LENGTH width = 0;
-    LENGTH height = 0;
+    public LENGTH width = 0;
+    public LENGTH height = 0;
     private int row = 0;  // FIXME short
     private int col = 0;  // FIXME short
     private LENGTH contentwidth = 0;             // == max(minwidth, textwidth, sum(child.contentwidth) + pad)
@@ -1070,9 +1070,7 @@ public final class Box extends JS.Scope {
                     public void put(Box b, Object value) {
                         b.width = stoi(value);
                         if (b.parent == null && b.surface != null) {
-                            // FIXME this gets hosed...
-                            //b.surface.setSize(max(Surface.scarPicture.getWidth(), b.width),
-                            //max(Surface.scarPicture.getHeight(), b.height));
+                            b.surface.setSize();
                             MARK_FOR_REFLOW_b;
                         } else {
                             b.minwidth = b.maxwidth = b.width;
@@ -1288,7 +1286,7 @@ public final class Box extends JS.Scope {
                     public void put(Box b, Object value) {
                         if (b.parent == null && b.surface != null) {
                             b.surface.hscar = stoi(value);
-                            b.surface.dirty(0, 0, b.surface.width, b.surface.height);
+                            b.surface.dirty(0, 0, b.width, b.height);
                             b.surface.Refresh();
                         }
                     }
index a64a515..c7ace6a 100644 (file)
@@ -391,7 +391,7 @@ public class Platform {
         if (refreshable) {
             Surface.refreshableSurfaceWasCreated = true;
             Surface.allSurfaces.addElement(ret);
-            ret.dirty(0, 0, ret.width, ret.height);
+            ret.dirty(0, 0, b.width, b.height);
             ret.Refresh();
         }
         return ret;
index 68bbdde..d044eee 100644 (file)
@@ -51,9 +51,6 @@ public abstract class Surface {
     /** true iff all surfaces created from now on should be scarred */
     public static boolean scarAllSurfacesFromNowOn = false;
 
-
-    // Public Members and State Variables /////////////////////////////////////////////////////////
-
     /** false if the surface has never been rendered; used to determine if the surface should be repositioned to be centered on the screen */
     public boolean centerSurfaceOnRender = true;
 
@@ -74,18 +71,15 @@ public abstract class Surface {
      */
     public String cursor = "default";
 
-    /** The width of the surface's drawable area, in real time */
-    public int width = 0;
-
-    /** The height of the surface's drawable area, in real time */
-    public int height = 0;
-
     /** The Box at the root of this surface */
     public Box root;
 
     /** The number of SizeChange/PosChange traps triggered since the last successful render -- used to detect infinite loops */
     public int sizePosChangesSinceLastRender = 0;
 
+
+    // Used For Simulating Clicks and DoubleClicks /////////////////////////////////////////////////
+
     /** the x-position of the mouse the last time a Press message was enqueued */
     int last_press_x = Integer.MAX_VALUE;
 
@@ -275,23 +269,21 @@ public abstract class Surface {
         }});
     }
 
-    protected final void SizeChange(int width, int height) {
-        this.width = width;
-        this.height = height;
-        root.width = width;
-        root.height = height;
-        root.needs_reflow = true;
+    protected final void SizeChange(final int width, final int height) {
+        MessageQueue.add(new Message() { public void perform() {
+            if (width == root.width && height == root.height) return;
+            root.width = width;
+            root.height = height;
+            root.needs_reflow = true;
+        }});
         abort = true;
-        long lastResizeTime = System.currentTimeMillis();
-        lastResizeTimeTop = (int)(lastResizeTime >> 32);
-        lastResizeTimeBottom = (int)(lastResizeTime & 0xffffffff);
-        Refresh();
     }
 
-    protected final void PosChange(int x, int y) {
-        if (x != root.x) root.put("x", new Integer(x));
-        if (y != root.y) root.put("y", new Integer(y));
-        new SimpleMessage("PosChange", Boolean.TRUE, root);
+    protected final void PosChange(final int x, final int y) {
+        MessageQueue.add(new Message() { public void perform() {
+            root.put("x", new Integer(x));
+            root.put("y", new Integer(y));
+        }});
     }
 
     protected final void Close() { new SimpleMessage("Close", Boolean.TRUE, root); }
@@ -302,14 +294,8 @@ public abstract class Surface {
 
     // the following value is split into two int's to work around GCJ bug java/6393
 
-    /** used in conjunction with Platform.supressDirtyOnResize() */
-    private int lastResizeTimeTop = 0;
-    private int lastResizeTimeBottom = 0;
-
     /** This is how subclasses signal a 'shallow dirty', indicating that although the backbuffer is valid, the screen is not */
     public final void Dirty(int x, int y, int w, int h) {
-        long lastResizeTime = (((long)lastResizeTimeTop) << 32) | (long)lastResizeTimeBottom;
-        if (Platform.supressDirtyOnResize() && System.currentTimeMillis() - lastResizeTime < 100 && (w >= width - 1 || h >= height - 1)) return;
         screenDirtyRegions.dirty(x, y, w, h);
         Refresh();
     }
@@ -359,17 +345,16 @@ public abstract class Surface {
     }
 
     /** wrapper for setSize() which makes sure to dirty the place where the scar used to be */
-    void _setSize(int width, int height) {
+    void setSize() {
         if (scarred) {
-            width = Math.max(width, scarPicture.getWidth());
-            height = Math.max(height, scarPicture.getHeight());
+            root.width = Math.max(root.width, scarPicture.getWidth());
+            root.height = Math.max(root.height, scarPicture.getHeight());
             dirty(hscar,
                   root.height - vscar - scarPicture.getHeight(),
-                  scarPicture.getWidth(), scarPicture.getHeight());
+                  scarPicture.getWidth(),
+                  scarPicture.getHeight());
         }
-        setSize(width, height);
-        this.width = width;
-        this.height = height;
+        setSize(root.width, root.height);
     }
 
     /** Indicates that the Surface is no longer needed */
@@ -422,22 +407,6 @@ public abstract class Surface {
     /** runs the prerender() and render() pipelines in the root Box to regenerate the backbuffer, then blits it to the screen */
     public synchronized void render() {
 
-        // if the window size changed as a result of a user action, we have to update the root box's size
-        if (root.width != width || root.height != height) {
-
-            // since the scar will be moving, dirty the place it used to be
-            if (scarred) dirty(hscar,
-                               root.height - vscar - scarPicture.getHeight(),
-                               scarPicture.getWidth(), scarPicture.getHeight());
-
-            // sort of ugly; we can't use set() here because it will cause an infinite mutual recursion
-            root.width = (int)width;
-            root.height = (int)height;
-
-            root.needs_reflow = true;
-            root.put("SizeChange", Boolean.TRUE);
-        }
-
         // make sure the root is properly sized
         do {
             abort = false;
@@ -451,8 +420,8 @@ public abstract class Surface {
 
         if (centerSurfaceOnRender) {
             centerSurfaceOnRender = false;
-            int x = (Platform.getScreenWidth() - width) / 2;
-            int y = (Platform.getScreenHeight() - height) / 2;
+            int x = (Platform.getScreenWidth() - root.width) / 2;
+            int y = (Platform.getScreenHeight() - root.height) / 2;
             setLocation(x, y);
             root.x = x;
             root.y = y;
@@ -468,25 +437,25 @@ public abstract class Surface {
             int h = dirt[i][3];
             if (x < 0) x = 0;
             if (y < 0) y = 0;
-            if (x+w > width) w = width - x;
-            if (y+h > height) h = height - y;
+            if (x+w > root.width) w = root.width - x;
+            if (y+h > root.height) h = root.height - y;
             if (w <= 0 || h <= 0) continue;
 
             root.render(0, 0, x, y, w, h, backbuffer);
             
             // if any area under the scar was repainted, rescar that area
             if (scarred && x < hscar + scarPicture.getWidth() &&
-                y + h > height - scarPicture.getHeight() - vscar) {
+                y + h > root.height - scarPicture.getHeight() - vscar) {
                 int _x1 = Math.max(x, hscar);
                 int _x2 = Math.min(x + w, hscar + scarPicture.getWidth());
-                int _y1 = Math.max(y, height - scarPicture.getHeight() - vscar);
-                int _y2 = Math.min(y + h, height - vscar);
+                int _y1 = Math.max(y, root.height - scarPicture.getHeight() - vscar);
+                int _y2 = Math.min(y + h, root.height - vscar);
                 
                 backbuffer.drawPicture(scarPicture, _x1, _y1, _x2, _y2,
                                        _x1 - (hscar),
-                                       _y1 - (height - scarPicture.getHeight() - vscar),
+                                       _y1 - (root.height - scarPicture.getHeight() - vscar),
                                        _x2 - (hscar),
-                                       _y2 - (height - scarPicture.getHeight() - vscar)
+                                       _y2 - (root.height - scarPicture.getHeight() - vscar)
                                        );
             }
 
@@ -522,7 +491,7 @@ public abstract class Surface {
 
         int[][] dirt = screenDirtyRegions.flush();
         if (Main.showRenders && dirt != null && dirt.length > 0 && a == -1)
-            blit(backbuffer, 0, 0, 0, 0, width, height);
+            blit(backbuffer, 0, 0, 0, 0, root.width, root.height);
 
         for(int i = 0; dirt != null && i < dirt.length; i++) {
             if (dirt[i] == null) continue;