From b4683a8f73d90fc0d4926775dfbc7268c34e6bff Mon Sep 17 00:00:00 2001
From: megacz <megacz@xwt.org>
Date: Fri, 30 Jan 2004 07:43:18 +0000
Subject: [PATCH] 2003/12/27 01:03:53

darcs-hash:20040130074318-2ba56-1223e84cf662f1a450b78c7803c7f18786957cc4.gz
---
 src/org/xwt/Box.java       |   36 ++++++++++++++++++++-------------
 src/org/xwt/Scheduler.java |   32 ++++++++++++++++++++----------
 src/org/xwt/Surface.java   |   47 ++++++++++++--------------------------------
 3 files changed, 57 insertions(+), 58 deletions(-)

diff --git a/src/org/xwt/Box.java b/src/org/xwt/Box.java
index 3e2599b..b251d3b 100644
--- a/src/org/xwt/Box.java
+++ b/src/org/xwt/Box.java
@@ -121,7 +121,7 @@ public final class Box extends JSScope implements Scheduler.Task {
     static final int ALIGN_RIGHT  = 0x00008000;
     static final int ALIGNS       = 0x0000f000;
     static final int CURSOR       = 0x00010000;  // if true, this box has a cursor in the cursor hash; FEATURE: GC issues?
-    static final int NOCLIP       = 0x00020000;
+    static final int CLIP         = 0x00020000;
     static final int STOP_UPWARD_PROPAGATION    = 0x00040000;
 
 
@@ -129,13 +129,13 @@ public final class Box extends JSScope implements Scheduler.Task {
 
     Box parent = null;
     Box redirect = this;
-    int flags = VISIBLE | PACKED | REPACK | REFLOW | RESIZE | FIXED /* ROWS */ | STOP_UPWARD_PROPAGATION;
+    int flags = VISIBLE | PACKED | REPACK | REFLOW | RESIZE | FIXED /* ROWS */ | STOP_UPWARD_PROPAGATION | CLIP;
 
     private String text = null;
     private Font font = DEFAULT_FONT; 
     private Picture texture = null;
     private short strokewidth = 1;
-    private int fillcolor = 0x00000000;
+    public int fillcolor = 0x00000000;
     private int strokecolor = 0xFF000000;
 
     private int aspect = 0;
@@ -194,7 +194,8 @@ public final class Box extends JSScope implements Scheduler.Task {
     public void dirty() { dirty(0, 0, width, height); }
     public void dirty(int x, int y, int w, int h) {
         for(Box cur = this; cur != null; cur = cur.parent) {
-            if (!cur.test(NOCLIP)) {
+            // x and y have a different meaning on the root box
+            if (cur.parent != null && cur.test(CLIP)) {
                 w = min(x + w, cur.width) - max(x, 0);
                 h = min(y + h, cur.height) - max(y, 0);
                 x = max(x, 0);
@@ -255,23 +256,23 @@ public final class Box extends JSScope implements Scheduler.Task {
     }
     
     void resize(LENGTH x, LENGTH y, LENGTH width, LENGTH height) {
-        // FEATURE reimplement, but we're destroying this
-        // FIXME: uncommenting this breaks; see http://bugs.xwt.org/show_bug.cgi?id=345
         if (x != this.x || y != this.y || width != this.width || height != this.height) {
             boolean sizechange = (this.width != width || this.height != height) && getTrap("SizeChange") != null;
             boolean poschange = (this.x != x || this.y != y) && getTrap("PosChange") != null;
             do {
+                int thisx = parent == null ? 0 : this.x;
+                int thisy = parent == null ? 0 : this.y;
                 if (texture == null && (text == null || text.equals(""))) {
                     if ((fillcolor & 0xff000000) == 0) break;
                     // FEATURE: more optimizations here
                     if (this.x == x && this.y == y) {
                         Box who = (parent == null ? this : parent);
-                        who.dirty(min(this.x+this.width,x+width), y, Math.abs(width-this.width), max(this.height, height));
-                        who.dirty(x, min(this.y+this.height,y+height), max(this.width, width), Math.abs(height-this.height));
+                        who.dirty(thisx+min(this.width,width), thisy, Math.abs(width-this.width), max(this.height, height));
+                        who.dirty(thisx, thisy+min(this.height,height), min(this.width, width), Math.abs(height-this.height));
                         break;
                     }
                 }
-                (parent == null ? this : parent).dirty(this.x, this.y, this.width, this.height);
+                (parent == null ? this : parent).dirty(thisx, thisy, this.width, this.height);
                 this.width = width; this.height = height; this.x = x; this.y = y;
                 dirty();
             } while (false);
@@ -356,7 +357,7 @@ public final class Box extends JSScope implements Scheduler.Task {
 
         // intersect the x,y,w,h rendering window with ourselves; quit if it's empty
 
-        if (!test(NOCLIP)) {
+        if (test(CLIP)) {
             cx1 = max(cx1, parent == null ? 0 : globalx);
             cy1 = max(cy1, parent == null ? 0 : globaly);
             cx2 = min(cx2, globalx + width);
@@ -441,7 +442,7 @@ public final class Box extends JSScope implements Scheduler.Task {
         case "rows": return test(FIXED) == ROWS ? N(rows) : N(0);
         case "colspan": return N(colspan);
         case "rowspan": return N(rowspan);
-        case "noclip": return B(test(NOCLIP));
+        case "clip": return B(test(CLIP));
         case "visible": return B(test(VISIBLE) && (parent == null || (parent.get("visible") == T)));
         case "packed": return B(test(PACKED));
         case "globalx": return N(localToGlobalX(0));
@@ -477,8 +478,14 @@ public final class Box extends JSScope implements Scheduler.Task {
         }
     }
 
-    void setMaxWidth(Object value) { do { CHECKSET_INT(maxwidth); MARK_RESIZE; } while(false); }
-    void setMaxHeight(Object value) { do { CHECKSET_INT(maxheight); MARK_RESIZE; } while(false); }
+    void setMaxWidth(Object value) {
+        do { CHECKSET_INT(maxwidth); MARK_RESIZE; } while(false);
+        if (parent == null && getSurface() != null) getSurface().pendingWidth = maxwidth;
+    }
+    void setMaxHeight(Object value) {
+        do { CHECKSET_INT(maxheight); MARK_RESIZE; } while(false);
+        if (parent == null && getSurface() != null) getSurface().pendingHeight = maxheight;
+    }
 
     public void put(Object name, Object value) throws JSExn {
         if (name instanceof Number) { put(toInt(name), value); return; }
@@ -501,7 +508,7 @@ public final class Box extends JSScope implements Scheduler.Task {
         case "rowspan": CHECKSET_SHORT(rowspan); MARK_REPACK_parent;
         case "rows": CHECKSET_SHORT(rows); if (rows==0){set(FIXED, COLS);if(cols==0)cols=1;} else set(FIXED, ROWS); MARK_REPACK;
         case "cols": CHECKSET_SHORT(cols); if (cols==0){set(FIXED, ROWS);if(rows==0)rows=1;} else set(FIXED, COLS); MARK_REPACK;
-        case "noclip": CHECKSET_FLAG(NOCLIP); if (parent == null) dirty(); else parent.dirty();
+        case "clip": CHECKSET_FLAG(CLIP); if (parent == null) dirty(); else parent.dirty();
         case "visible": CHECKSET_FLAG(VISIBLE); dirty(); MARK_RESIZE; dirty();
         case "packed": CHECKSET_FLAG(PACKED); MARK_REPACK_parent;
         case "aspect": CHECKSET_INT(aspect); dirty();
@@ -627,6 +634,7 @@ public final class Box extends JSScope implements Scheduler.Task {
         texture = Picture.load((Res)value, this);
     }
 
+    // FIXME: mouse move/release still needs to propagate to boxen in which the mouse was pressed and is still held down
     /**
      *  Handles events which propagate down the box tree.  If obscured
      *  is set, then we merely check for Enter/Leave.
diff --git a/src/org/xwt/Scheduler.java b/src/org/xwt/Scheduler.java
index ce59d1e..d61ad55 100644
--- a/src/org/xwt/Scheduler.java
+++ b/src/org/xwt/Scheduler.java
@@ -26,6 +26,16 @@ public class Scheduler {
     private static Task current = null;
     public static Task current() { return current; }
 
+    /** synchronizd so that we can safely call it from an event-delivery thread, in-context */
+    public static synchronized void renderAll() {
+        for(int i=0; i<Surface.allSurfaces.size(); i++) {
+            Surface s = ((Surface)Surface.allSurfaces.elementAt(i));
+            do { s.render(); } while(s.abort);
+        }
+    }
+
+    
+
     // API which must be supported by subclasses /////////////////////////////////////
 
     /**
@@ -45,18 +55,20 @@ public class Scheduler {
         while(true) {
             current = (Task)runnable.remove(true);
             try {
-                for(int i=0; i<Surface.allSurfaces.size(); i++) {
-                    Surface s = (Surface)Surface.allSurfaces.elementAt(i);
-                    if (current instanceof JSFunction) {
-                        s._mousex = Integer.MAX_VALUE;
-                        s._mousey = Integer.MAX_VALUE;
-                    } else {
-                        s._mousex = s.mousex;
-                        s._mousey = s.mousey;
+                synchronized(this) {
+                    for(int i=0; i<Surface.allSurfaces.size(); i++) {
+                        Surface s = (Surface)Surface.allSurfaces.elementAt(i);
+                        if (current instanceof JSFunction) {
+                            s._mousex = Integer.MAX_VALUE;
+                            s._mousey = Integer.MAX_VALUE;
+                        } else {
+                            s._mousex = s.mousex;
+                            s._mousey = s.mousey;
+                        }
                     }
+                    current.perform();
                 }
-                current.perform();
-                if (runnable.size() == 0 && Surface.needRender) Surface.renderAll.perform();
+                renderAll();
             } catch (JSExn e) {
                 Log.log(Scheduler.class, "a JavaScript thread spawned with xwt.thread() threw an exception:");
                 Log.log(Scheduler.class, e);
diff --git a/src/org/xwt/Surface.java b/src/org/xwt/Surface.java
index eca0dee..e28dbcd 100644
--- a/src/org/xwt/Surface.java
+++ b/src/org/xwt/Surface.java
@@ -29,7 +29,9 @@ public abstract class Surface extends PixelBuffer implements Scheduler.Task {
     public static Vec allSurfaces = new Vec();
     
     /** When set to true, render() should abort as soon as possible and restart the rendering process */
-    static volatile boolean abort = false;
+    volatile boolean abort = false;
+    volatile int pendingWidth = -1;
+    volatile int pendingHeight = -1;
 
     public static boolean alt = false;          ///< true iff the alt button is pressed down, in real time
     public static boolean control = false;      ///< true iff the control button is pressed down, in real time
@@ -158,22 +160,11 @@ public abstract class Surface extends PixelBuffer implements Scheduler.Task {
         Scheduler.add(this);
     }
 
-    private Scheduler.Task nextSizeChange = null;
-    // FEATURE: can we avoid creating objects here?
     /** subclasses should invoke this method when the user resizes the window */
     protected final void SizeChange(final int width, final int height) {
-        if (root.maxwidth == width && root.maxheight == height) return;
-        nextSizeChange = new Scheduler.Task() { public void perform() {
-            if (nextSizeChange != this) return;
-            // dirty the place where the scar used to be
-            root.dirty(0, root.maxheight - Main.scarImage.height, Main.scarImage.width, Main.scarImage.height);
-            root.setMaxWidth(JS.N(width));
-            root.setMaxHeight(JS.N(height));
-            nextSizeChange = null;
-            Refresh();
-        }};
-        Scheduler.addAtFront(nextSizeChange);
-        abort = true;
+        pendingWidth = width;
+        pendingHeight = height;
+        Refresh();
     }
 
     // FEATURE: can we avoid creating objects here?
@@ -193,19 +184,7 @@ public abstract class Surface extends PixelBuffer implements Scheduler.Task {
     protected final void Minimized(boolean b) { minimized = b; new SimpleMessage("Minimized", b ? T : F, root); }
     protected final void Maximized(boolean b) { maximized = b; new SimpleMessage("Maximized", b ? T : F, root); }
     protected final void Focused(boolean b) { new SimpleMessage("Focused", b ? T : F, root); }
-    public static void Refresh() { needRender = true; Scheduler.add(new Scheduler.Task() { public void perform() { } }); }
-
-    public static boolean needRender = false;
-    public static final Scheduler.Task renderAll = new Scheduler.Task() {
-            public void perform() {
-                for(int i=0; i<allSurfaces.size(); i++) {
-                    Surface s = ((Surface)allSurfaces.elementAt(i));
-                    do {
-                        s.render(); 
-                    } while(s.abort);
-                }
-            }
-        };
+    public void Refresh() { abort = true; }
 
     public final void setMaximized(boolean b) { if (b != maximized) _setMaximized(maximized = b); }
     public final void setMinimized(boolean b) { if (b != minimized) _setMinimized(minimized = b); }
@@ -251,14 +230,15 @@ public abstract class Surface extends PixelBuffer implements Scheduler.Task {
 
     /** runs the prerender() and render() pipelines in the root Box to regenerate the backbuffer, then blits it to the screen */
     public synchronized void render() {
-        // dirty the place where the scar used to be in case the root window size was programmatically changed
-        if (root.maxwidth != root.width || root.maxheight != root.height)
-            root.dirty(0, root.height - Main.scarImage.height, Main.scarImage.width, Main.scarImage.height);
-
         // make sure the root is properly sized
         do {
             abort = false;
             root.repack();
+            if (pendingWidth != -1) root.setMaxWidth(JS.N(pendingWidth));
+            if (pendingHeight != -1) root.setMaxHeight(JS.N(pendingHeight));
+            // dirty the place where the scar used to be in case the root window size was programmatically changed
+            if (root.maxwidth != root.width || root.maxheight != root.height)
+                root.dirty(0, root.height - Main.scarImage.height, Main.scarImage.width, Main.scarImage.height);
             root.resize(root.x, root.y, root.maxwidth, root.maxheight);
             root.resize_children();
             _setSize(root.width, root.height);
@@ -360,7 +340,6 @@ public abstract class Surface extends PixelBuffer implements Scheduler.Task {
             backbuffer.fillTrapezoid(x1, x2, y1, x3, x4, y2, color);
         }
 
-        public void render_() { render(); }
         public void render() {
             super.render();
             if (abort) return;
@@ -384,7 +363,7 @@ public abstract class Surface extends PixelBuffer implements Scheduler.Task {
         /** 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) {
             screenDirtyRegions.dirty(x, y, w, h);
-            Refresh();
+            Scheduler.renderAll();
         }
 
         public void dirty(int x, int y, int w, int h) {
-- 
1.7.10.4