Android: adding and fixing to the graphics clipping code

Android has no classic window manager, so FLTK has to
make sure that popup windows, dialog boxes and multi
window interfaces work as expectd.



git-svn-id: file:///fltk/svn/fltk/branches/branch-1.4@12729 ea41ed52-d2ee-0310-a9c1-e6b18d33e121

3 files changed, 122 insertions, 38 deletions

diff --git a/src/drivers/Android/Fl_Android_Graphics_Driver.H b/src/drivers/Android/Fl_Android_Graphics_Driver.H
index a55e39400..6e03e26da 100644
--- a/src/drivers/Android/Fl_Android_Graphics_Driver.H
+++ b/src/drivers/Android/Fl_Android_Graphics_Driver.H
@@ -30,18 +30,61 @@
 #include <limits.h>
 
 
-struct Fl_Clip_Rect
+/**
+ * The Fl_Rect_Region is based on Fl_Rect with additional functionality for clipping.
+ */
+class Fl_Rect_Region : public Fl_Rect
 {
-  Fl_Clip_Rect() : pRect() {}
-  Fl_Clip_Rect(int x, int y, int w, int h) : pRect(x, y, w, h) {}
-  int x() { return pRect.x(); }
-  int y() { return pRect.y(); }
-  int w() { return pRect.w(); }
-  int h() { return pRect.h(); }
-  int intersect_with(Fl_Clip_Rect *r);
+public:
+  enum {
+    EMPTY = 0, SAME, LESS, MORE
+  };
+
+  /**
+   * Create an empty clipping region.
+   */
+  Fl_Rect_Region() {}
+
+  /**
+   * Create a clipping region based on position and size.
+   * @param x, y position
+   * @param w, h size
+   */
+  Fl_Rect_Region(int x, int y, int w, int h) : Fl_Rect(x, y, w, h) {}
+  int intersect_with(Fl_Rect_Region *r);
   static int min(int a, int b) { return (a<b) ? a : b; }
   static int max(int a, int b) { return (a>b) ? a : b; }
-  Fl_Rect pRect;
+};
+
+
+/**
+ * The Fl_Complex_Region represents a clipping region of any shape.
+ *
+ * This class is organized in a tree-like structure. If the region is
+ * rectangular, is_simple() returns 1 and the rectangle can be used just
+ * as in Fl_Rect_Region.
+ *
+ * If a more complex representation is needed, the first list of
+ * subregions is organizen in horizontal strips. The root region rect
+ * will contain the outline of all subregions, and the subregions
+ * will either be simple rectangles, or they will contain a second
+ * level of subregions, subdividing the horizontal region into vertical
+ * columns.
+ *
+ * When reading, the tree can be easily walked using recursion.
+ */
+class Fl_Complex_Region : public Fl_Rect_Region
+{
+public:
+  Fl_Complex_Region() : Fl_Rect_Region(), pSubregion(0L), pNext(0L) { }
+  Fl_Complex_Region(int x, int y, int w, int h) : Fl_Rect_Region(x, y, w, h), pSubregion(0L), pNext(0L)  { }
+  ~Fl_Complex_Region();
+  void set(Fl_Rect *rect);
+  char is_simple() { return pSubregion==0; }
+  char is_complex() { return pSubregion!=0; }
+protected:
+  Fl_Complex_Region *pSubregion;
+  Fl_Complex_Region *pNext;
 };
 
 
@@ -144,7 +187,7 @@ protected:
   void restore_clip();
   void clip_region(Fl_Region r);
   Fl_Region clip_region();
-  static Fl_Clip_Rect pClipRect;
+  static Fl_Complex_Region pWindowRegion;
 #if 0
   virtual Fl_Region scale_clip(float f);
   // --- implementation is in src/fl_vertex.cxx which includes src/cfg_gfx/xxx_rect.cxx
diff --git a/src/drivers/Android/Fl_Android_Graphics_Driver.cxx b/src/drivers/Android/Fl_Android_Graphics_Driver.cxx
index 1df52462a..2a0b62cc8 100644
--- a/src/drivers/Android/Fl_Android_Graphics_Driver.cxx
+++ b/src/drivers/Android/Fl_Android_Graphics_Driver.cxx
@@ -55,10 +55,32 @@ static uint16_t make565(Fl_Color crgba)
 
 void Fl_Android_Graphics_Driver::rectf_unscaled(float x, float y, float w, float h) {
   Fl_Android_Application::log_w("rectf %g %g %g %g", x, y, w, h);
-  Fl_Clip_Rect r(x, y, w, h);
-  if (r.intersect_with(&pClipRect)) {
+  Fl_Rect_Region r(x, y, w, h);
+  if (r.intersect_with(&pWindowRegion)) {
     rectf_unclipped(r.x(), r.y(), r.w(), r.h());
   }
+
+  /*
+   * rectf(x, y, w, h) {
+   *   rectf(complex_window_region, drawing_rect(x, y, w, h))
+   * }
+   *
+   * rectf( complexRgn, drawRgn) {
+   *   // B: start of iterator
+   *     if (intersect(rect_of_complexRgn, drawRgn) {
+   *       if (complexRgn->is_complex() {
+   *         rectf(complexRgn->subregion, drawRect);
+   *       } else {
+   *         rawRect = intersection(rect_of_complexRgn, drawRgn);
+   *         rawDrawRect(rawRect);
+   *       }
+   *     }
+   *     // A: recursion
+   *     if (complexRgn->next)
+   *       rectf(complexRgn->next, drawRgn);
+   *   // B: end of iterator
+   * }
+   */
 }
 
 void Fl_Android_Graphics_Driver::rectf_unclipped(float x, float y, float w, float h) {
diff --git a/src/drivers/Android/Fl_Android_Graphics_Driver_region.cxx b/src/drivers/Android/Fl_Android_Graphics_Driver_region.cxx
index 107a6e708..27e105d89 100644
--- a/src/drivers/Android/Fl_Android_Graphics_Driver_region.cxx
+++ b/src/drivers/Android/Fl_Android_Graphics_Driver_region.cxx
@@ -23,37 +23,55 @@
 #include <FL/platform.H>
 
 
-Fl_Clip_Rect Fl_Android_Graphics_Driver::pClipRect;
+Fl_Complex_Region Fl_Android_Graphics_Driver::pWindowRegion;
+
 
 
 // return 0 for empty, 1 for same, 2 if intersecting
-int Fl_Clip_Rect::intersect_with(Fl_Clip_Rect *a)
+int Fl_Rect_Region::intersect_with(Fl_Rect_Region *a)
 {
-  if (pRect.is_empty()) {
-    return 0;
+  if (is_empty()) {
+    return EMPTY;
   }
-  if (a->pRect.is_empty()) {
-    pRect.clear();
-    return 0;
+  if (a->is_empty()) {
+    clear();
+    return EMPTY;
   }
-  int x = max(pRect.x(), a->pRect.x());
-  int y = max(pRect.y(), a->pRect.y());
-  int r = min(pRect.r(), a->pRect.r());
-  int b = min(pRect.b(), a->pRect.b());
-  int w = r-x;
-  int h = b-y;
-  if (pRect.equals(x, y, w, h)) {
-    return 1;
+  int lx = max(x(), a->x());
+  int ly = max(y(), a->y());
+  int lr = min(r(), a->r());
+  int lb = min(b(), a->b());
+  int lw = lr-lx;
+  int lh = lb-ly;
+  if (equals(lx, ly, lw, lh)) {
+    return SAME;
   }
-  pRect.set(x, y, w, h);
-  if ( (pRect.w()<=0) || (pRect.h()<=0) ) {
-    pRect.clear();
-    return 0;
+  set(lx, ly, lw, lh);
+  if ( (w()<=0) || (h()<=0) ) {
+    clear();
+    return EMPTY;
   }
-  return 2;
+  return LESS;
+}
+
+
+
+Fl_Complex_Region::~Fl_Complex_Region()
+{
+  delete pSubregion; // recursively delete all subregions
+  delete pNext; // recursively delete all following regions
 }
 
 
+void Fl_Complex_Region::set(Fl_Rect *rect)
+{
+  delete pSubregion;
+  pSubregion = 0L;
+  delete pNext;
+  pNext = 0L;
+  Fl_Rect_Region::set(rect);
+}
+
 
 void Fl_Android_Graphics_Driver::clip_region(Fl_Region r)
 {
@@ -73,27 +91,28 @@ void Fl_Android_Graphics_Driver::restore_clip()
 {
   fl_clip_state_number++;
   Fl_Window *win = Fl_Window::current();
-  Fl_Clip_Rect a(0, 0, win->w(), win->h());
+  Fl_Rect_Region a(0, 0, win->w(), win->h());
 
   Fl_Region b = rstack[rstackptr];
   if (b) {
     // FIXME: scaling!
     a.intersect_with(b);
   }
-  pClipRect = a;
+  pWindowRegion.set(b);
+  // FIXME: intersect with complex window region
 }
 
 void Fl_Android_Graphics_Driver::push_clip(int x, int y, int w, int h)
 {
   Fl_Region r;
   if (w > 0 && h > 0) {
-    r = new Fl_Clip_Rect(x,y,w,h);
+    r = new Fl_Rect_Region(x,y,w,h);
     Fl_Region current = rstack[rstackptr];
     if (current) {
       r->intersect_with(current);
     }
   } else { // make empty clip region:
-    r = new Fl_Clip_Rect();
+    r = new Fl_Rect_Region();
   }
   if (rstackptr < region_stack_max) rstack[++rstackptr] = r;
   else Fl::warning("Fl_Android_Graphics_Driver::push_clip: clip stack overflow!\n");
@@ -136,7 +155,7 @@ int Fl_Android_Graphics_Driver::clip_box(int x, int y, int w, int h, int& X, int
     return 0;
   }
 
-  Fl_Clip_Rect a(x, y, w, h);
+  Fl_Rect_Region a(x, y, w, h);
   int ret = a.intersect_with(r); // return 0 for empty, 1 for same, 2 if intersecting
   X = a.x();
   Y = a.y();
@@ -161,7 +180,7 @@ int Fl_Android_Graphics_Driver::not_clipped(int x, int y, int w, int h) {
   Fl_Region r = rstack[rstackptr];
   if (!r) return 1;
 
-  Fl_Clip_Rect a(x, y, w, h); // return 0 for empty, 1 for same, 2 if intersecting
+  Fl_Rect_Region a(x, y, w, h); // return 0 for empty, 1 for same, 2 if intersecting
   return a.intersect_with(r);
 }