Changeset 8353

Timestamp:

02/02/12 11:45:41 (4 months ago)

Author:

westram

Message:

• EDIT4 scrolling
  • EDIT4 uses two interleaved mechanisms to control scrolling. both perform similar calculations.
    • global canvas scrolling (like other ARB apps) in AW_window::calculate_scrollbars
    • local folding line calculation
  • EDIT4 is the only client which uses scrollbar indentation (affects the global slider pos calculation)
    • the scrollbar is indented by the height of top-area resp. the width of the name/group area
    • an additional offset (SLIDER_OFFSET) is added to that indentation
    • this offset was missing in calculation of lower/right folding lines (fixed)
  • other fixes
    • picture size announced by ED4_window::update_scrolled_rectangle was off by 1
• behavioral fixes:
  • scrolling down completely, then increasing window height, then scrolling up completely and decreasing window height again, leaded to negative dimension of top-folding line.
    • Afterwards there was an empty area above the first entry in the scrollable area and EDIT4 refused to scroll down completely.
    • did not disappear, regardless what action was taken.
    • introduced by [8230]. partly fixed by [8347].
  • a similar effect could be reached by scrolling down completely and then folding the last group (introduced by [8347])
  • unfolding alignment, then setting cursor far enough right (beyond folded size), then folding alignment, leaded to completely empty display.
    • did not disappear, regardless what action was taken afterwards
    • introduced by [8347]
• added debug code
  • print backtrace on negative folding line dimension
  • print mismatch if slider postions and folding line dimensions are out of sync

Location:

branches/e4fix/EDIT4

Files:

• ED4_root.cxx (modified) (1 diff)
• ED4_window.cxx (modified) (2 diffs)
• ed4_class.hxx (modified) (8 diffs)

branches/e4fix/EDIT4/ED4_root.cxx

@@ -46 +46 @@
 
 ED4_WinContext ED4_WinContext::current_context;
+
+void ED4_folding_line::warn_illegal_dimension() {
+#if defined(DEBUG)
+    if (dimension<0.0) {
+        // e4_assert(0); // crashes gdb when called from scrollbar callback - so instead only dump backtrace
+        const char *msg = GBS_global_string("illegal dimension %f\n", dimension);
+        GBK_dump_backtrace(stderr, msg);
+    }
+#endif
+}
 
 void ED4_WinContext::warn_missing_context() const {

branches/e4fix/EDIT4/ED4_window.cxx

@@ -142 +142 @@
 }
 
-ED4_returncode ED4_window::update_scrolled_rectangle() {
-    if (!scrolled_rect.exists())
-        return ED4_R_IMPOSSIBLE;
-
-    AW::Rectangle srect = scrolled_rect.get_world_rect();
-    scrolled_rect.set_rect_and_update_folding_line_positions(srect);
-
-    {
-        // update dimension and window position of folding lines at the borders of scrolled rectangle
-
-        int dx = aww->slider_pos_horizontal - slider_pos_horizontal;
-        int dy = aww->slider_pos_vertical - slider_pos_vertical;
-
-        scrolled_rect.add_to_top_left_dimension(dx, dy);
-    }
-
-    if (scrolled_rect.is_linked()) {
-        slider_pos_vertical   = aww->slider_pos_vertical;
-        slider_pos_horizontal = aww->slider_pos_horizontal;
-    }
-
-    const AW_screen_area& area_size = get_device()->get_area_size();
-    scrolled_rect.calc_bottomRight_folding_dimensions(area_size.r, area_size.b);
-
-    update_window_coords();
-
-    // update window scrollbars
-    AW_world rect = { 0, srect.height()-1, 0, srect.width()-1 };
-    set_scrollbar_indents();
-    aww->tell_scrolled_picture_size(rect);
-    aww->calculate_scrollbars();
-
-    return ED4_R_OK;
+void ED4_window::update_scrolled_rectangle() {
+    if (scrolled_rect.exists()) {
+        e4_assert(scrolled_rect.is_linked());
+
+        AW::Rectangle srect = scrolled_rect.get_world_rect();
+        scrolled_rect.set_rect_and_update_folding_line_positions(srect);
+
+        // if slider positions stored in AW_window and ED4_window differ,
+        // we correct folding line dimensions:
+        
+        {
+            // update dimension and window position of folding lines at the borders of scrolled rectangle
+            int dx = aww->slider_pos_horizontal - slider_pos_horizontal;
+            int dy = aww->slider_pos_vertical - slider_pos_vertical;
+
+            scrolled_rect.add_to_top_left_dimension(dx, dy);
+        }
+
+        const AW_screen_area& area_size = get_device()->get_area_size();
+        scrolled_rect.calc_bottomRight_folding_dimensions(area_size.r, area_size.b);
+
+        update_window_coords(); // @@@ do at end of this function? (since it uses aww-slider_pos_horizontal,
+                                // which might get modified by calculate_scrollbars below);
+
+        // update window scrollbars
+        AW_world rect = { 0, srect.height(), 0, srect.width() };
+        set_scrollbar_indents();
+        aww->tell_scrolled_picture_size(rect);
+        aww->calculate_scrollbars();
+
+        check_valid_scrollbar_values(); // test that AW_window slider positions and folding line dimensions are in sync
+    }
+
+    // store synced slider positions in ED4_window
+    slider_pos_vertical   = aww->slider_pos_vertical;
+    slider_pos_horizontal = aww->slider_pos_horizontal;
 }
 
@@ -336 +339 @@
 }
 
-ED4_returncode ED4_window::set_scrollbar_indents() {
-    if (!scrolled_rect.exists()) return ED4_R_IMPOSSIBLE;
-    
-    AW::Rectangle rect = scrolled_rect.get_window_rect();
-    aww->set_vertical_scrollbar_top_indent(rect.top() + SLIDER_OFFSET);
-    aww->set_horizontal_scrollbar_left_indent(rect.left() + SLIDER_OFFSET);
-
-    return ED4_R_OK;
+void ED4_window::set_scrollbar_indents() {
+    if (scrolled_rect.exists()) {
+        AW::Rectangle rect = scrolled_rect.get_window_rect();
+        aww->set_vertical_scrollbar_top_indent(rect.top() + SLIDER_OFFSET);
+        aww->set_horizontal_scrollbar_left_indent(rect.left() + SLIDER_OFFSET);
+    }
 }
 

branches/e4fix/EDIT4/ed4_class.hxx

@@ -319 +319 @@
     const ED4_folding_line *get_next() const { return next; }
 
-    void set_dimension(AW_pos dim) { dimension = dim; }
-    void add_to_dimension(AW_pos offset) { dimension += offset; }
+    void warn_illegal_dimension();
+
+    void set_dimension(AW_pos dim) { dimension = dim; warn_illegal_dimension(); }
+    void add_to_dimension(AW_pos offset) { dimension += offset; warn_illegal_dimension(); }
 
     void set_pos(AW_pos p) { pos = p; }
@@ -426 +428 @@
     }
 
+    AW_pos top_dim() const { return scroll_top->get_dimension(); }
+    AW_pos left_dim() const { return scroll_left->get_dimension(); }
 
     bool exists() const { return scroll_top && scroll_bottom && scroll_left && scroll_right; }
@@ -481 +485 @@
 
     void calc_bottomRight_folding_dimensions(int area_width, int area_height) {
+        area_width  -= SLIDER_OFFSET;
+        area_height -= SLIDER_OFFSET;
+
         AW_pos dim;
         if (bottom() > area_height) {   // our world doesn't fit vertically in our window
@@ -493 +500 @@
         }
 
-        // e4_assert(scroll_top->dimension >= 0); // @@@ reactivate when refresh is fixed (or better move into set_dimension)
-        // e4_assert(scroll_bottom->dimension >= 0);
         e4_assert(dim == (scroll_top->get_dimension()+scroll_bottom->get_dimension()));
-        scroll_bottom->set_pos(world.bottom()-dim);
+        scroll_bottom->set_pos(world.bottom()-dim+SLIDER_OFFSET);
 
         if (right()>area_width) {     // our world doesn't fit horizontally in our window
@@ -509 +514 @@
         }
 
-        // e4_assert(scroll_left->dimension >= 0); // @@@ reactivate when refresh is fixed (or better move into set_dimension)
-        // e4_assert(scroll_right->dimension >= 0);
         e4_assert(dim == (scroll_left->get_dimension()+scroll_right->get_dimension()));
-        scroll_right->set_pos(world.right()-dim);
+        scroll_right->set_pos(world.right()-dim+SLIDER_OFFSET);
 
         folding_dimensions_calculated = true;
@@ -538 +541 @@
         init_folding_lines();
     }
-
 };
 
@@ -705 +707 @@
 class ED4_window : public ED4_foldable, virtual ED4_WinContextFree { // derived from Noncopyable
     ED4_window(const ED4_window&); // copy-constructor not allowed
+
+    void set_scrollbar_indents();
+
 public:
     AW_window              *aww;   // Points to Window
@@ -735 +740 @@
     
     // functions concerned the scrolled area
-    ED4_returncode      update_scrolled_rectangle();
-    ED4_returncode      set_scrollbar_indents();
-    ED4_returncode      scroll_rectangle(int dx, int dy);
-    ED4_returncode      set_scrolled_rectangle(ED4_base *x_link, ED4_base *y_link, ED4_base *width_link, ED4_base *height_link);
+    void update_scrolled_rectangle();
+    ED4_returncode scroll_rectangle(int dx, int dy);
+    ED4_returncode set_scrolled_rectangle(ED4_base *x_link, ED4_base *y_link, ED4_base *width_link, ED4_base *height_link);
+
+    bool scrollbars_and_scrolledRect_inSync() const {
+        // Scrolling in EDIT4 window uses redundant data
+        // - dimension of folding lines
+        // - slider positions in AW_window and ED4_window
+        // This function checks whether they are in sync.
+        
+        bool inSync                    = 
+            (scrolled_rect.top_dim()  == aww->slider_pos_vertical) &&
+            (scrolled_rect.left_dim() == aww->slider_pos_horizontal);
+
+#if defined(DEBUG)
+        if (!inSync) {
+            fputs("scrollbars not in sync with scrolled_rect:\n", stderr);
+            fprintf(stderr, "    aww->slider_pos_vertical  =%i scrolled_rect->top_dim() =%f\n", aww->slider_pos_vertical, scrolled_rect.top_dim());
+            fprintf(stderr, "    aww->slider_pos_horizontal=%i scrolled_rect->left_dim()=%f\n", aww->slider_pos_horizontal, scrolled_rect.left_dim());
+        }
+#endif
+
+        return inSync;
+    }
+
+    void check_valid_scrollbar_values() { e4_assert(scrollbars_and_scrolledRect_inSync()); }
 
     bool shows_xpos(int x) const { return x >= coords.window_left_clip_point && x <= coords.window_right_clip_point; }