Changeset 8227 for branches

Timestamp:

18/11/11 14:24:12 (6 months ago)

Author:

westram

Message:

• extracted ED4_foldable from ED4_window
  • enables separate tests
  • added tests
    • use multiple folding lines
    • document wrong behavior (as in [8201])

Location:

branches/e4fix/EDIT4

Files:

• ED4_manager.cxx (modified) (3 diffs)
• ED4_root.cxx (modified) (5 diffs)
• ED4_window.cxx (modified) (5 diffs)
• Makefile (modified) (1 diff)
• ed4_class.hxx (modified) (3 diffs)

branches/e4fix/EDIT4/ED4_manager.cxx

@@ -998 +998 @@
 
         int x1, y1, x2, y2;
-        ED4_folding_line *flv, *flh;
         ED4_window& win = *current_ed4w();
         int old_last_window_reached = last_window_reached;
@@ -1004 +1003 @@
         last_window_reached = 0;
         x1 = area_rect.l;
-        for (flv = win.vertical_fl; ; flv = flv->next) {
+        for (const ED4_folding_line *flv = win.get_vertical_folding(); ; flv = flv->next) {
             int lastColumn = 0;
 
@@ -1023 +1022 @@
 
             y1 = area_rect.t;
-            for (flh = win.horizontal_fl; ; flh = flh->next) {
+            for (const ED4_folding_line *flh = win.get_horizontal_folding(); ; flh = flh->next) {
                 int lastRow = 0;
 

branches/e4fix/EDIT4/ED4_root.cxx

@@ -104 +104 @@
 
 
-void ED4_window::win_to_world_coords(AW_pos *xPtr, AW_pos *yPtr) {
+void ED4_foldable::win_to_world_coords(AW_pos *xPtr, AW_pos *yPtr) {
     // calculates transformation from window to world coordinates in a given window
     const AW_pos x = *xPtr;
@@ -136 +136 @@
 }
 
-void ED4_window::world_to_win_coords(AW_pos *xPtr, AW_pos *yPtr) {
+void ED4_foldable::world_to_win_coords(AW_pos *xPtr, AW_pos *yPtr) {
     // calculates transformation from world to window coordinates in a given window
     const AW_pos x = *xPtr;
@@ -167 +167 @@
     *yPtr = temp_y;
 }
+
+// --------------------------------------------------------------------------------
+
+#ifdef UNIT_TESTS
+#ifndef TEST_UNIT_H
+#include <test_unit.h>
+#endif
+
+static arb_test::match_expectation correct_win2world_calculation(ED4_foldable& foldable, int xwin_org, int ywin_org, int xwrld_expd, int ywrld_expd) {
+    using namespace arb_test;
+    match_expectation precondition(all().of(that(xwrld_expd).more_or_equal(xwin_org),
+                                            that(ywrld_expd).more_or_equal(ywin_org)));
+
+    AW_pos xwrld_calc = xwin_org;
+    AW_pos ywrld_calc = ywin_org;
+    foldable.win_to_world_coords(&xwrld_calc, &ywrld_calc);
+
+    match_expectation win_2_world_conversion(all().of(that(xwrld_calc).equals(xwrld_expd),
+                                                      that(ywrld_calc).equals(ywrld_expd)));
+
+    AW_pos xwin_back = xwrld_calc;
+    AW_pos ywin_back = ywrld_calc;
+    foldable.world_to_win_coords(&xwin_back, &ywin_back);
+    
+    match_expectation world_back2_win_conversion(all().of(that(xwin_back).equals(xwin_org),
+                                                          that(ywin_back).equals(ywin_org)));
+
+    return all().of(precondition, win_2_world_conversion, world_back2_win_conversion);
+}
+
+#define TEST_ASSERT_WIN_UNFOLDED(xwi,ywi)            TEST_EXPECT(correct_win2world_calculation(foldable, xwi, ywi, xwi, ywi))
+#define TEST_ASSERT_WIN_WORLD_FOLDING(xwi,ywi,fx,fy) TEST_EXPECT(correct_win2world_calculation(foldable, xwi, ywi, (xwi)+(fx), (ywi)+(fy)))
+
+#define TEST_ASSERT_WIN_WORLD_FOLDING__BROKEN(xwi,ywi,fx,fy)        TEST_EXPECT__BROKEN(correct_win2world_calculation(foldable, xwi, ywi, (xwi)+(fx), (ywi)+(fy)))
+#define TEST_ASSERT_WIN_WORLD_FOLDING__BROKENIF(when,xwi,ywi,fx,fy) TEST_EXPECT__BROKENIF(when, correct_win2world_calculation(foldable, xwi, ywi, (xwi)+(fx), (ywi)+(fy)))
+
+void TEST_win_2_world() {
+    ED4_foldable foldable;
+
+    ED4_folding_line *hor100 = foldable.insert_folding_line(0, 100, INFINITE, 0, NULL, ED4_P_HORIZONTAL);
+    ED4_folding_line *ver200 = foldable.insert_folding_line(200, 0, INFINITE, 0, NULL, ED4_P_VERTICAL);
+
+    ED4_folding_line *hor200 = foldable.insert_folding_line(0, 200, 300, 0, NULL, ED4_P_HORIZONTAL);
+    ED4_folding_line *ver300 = foldable.insert_folding_line(300, 100, 200, 0, NULL, ED4_P_VERTICAL);
+
+    // nothing folded yet
+    
+    TEST_ASSERT_WIN_UNFOLDED(100, 50);
+    TEST_ASSERT_WIN_UNFOLDED(250, 50);
+    TEST_ASSERT_WIN_UNFOLDED(400, 50);
+
+    TEST_ASSERT_WIN_UNFOLDED(100, 150);
+    TEST_ASSERT_WIN_UNFOLDED(250, 150);
+    TEST_ASSERT_WIN_UNFOLDED(400, 150);
+
+    TEST_ASSERT_WIN_UNFOLDED(100, 250);
+    TEST_ASSERT_WIN_UNFOLDED(250, 250);
+    TEST_ASSERT_WIN_UNFOLDED(400, 250);
+
+    TEST_ASSERT_WIN_UNFOLDED(100, 350);
+    TEST_ASSERT_WIN_UNFOLDED(250, 350);
+    TEST_ASSERT_WIN_UNFOLDED(400, 350);
+
+    for (int FACTOR = 1; FACTOR <= 10; FACTOR ++) {
+        TEST_ANNOTATE_ASSERT(GBS_global_string("FACTOR=%i", FACTOR));
+        int H1 = FACTOR* 10;
+        int H2 = FACTOR* 40;
+        int V1 = FACTOR* 20;
+        int V2 = FACTOR* 80;
+
+        hor100->dimension = H1;
+        hor200->dimension = H2;
+        ver200->dimension = V1;
+        ver300->dimension = V2;
+
+        TEST_ASSERT_WIN_UNFOLDED(100, 50); // always in unfolded range
+        TEST_ASSERT_WIN_WORLD_FOLDING(250, 50, V1, 0);
+        TEST_ASSERT_WIN_WORLD_FOLDING(400, 50, V1, 0);
+
+        TEST_ASSERT_WIN_WORLD_FOLDING__BROKENIF(FACTOR >= 5, 100, 150, 0,     H1);
+        TEST_ASSERT_WIN_WORLD_FOLDING__BROKENIF(FACTOR >= 3, 250, 150, V1,    H1);
+        TEST_ASSERT_WIN_WORLD_FOLDING(400, 150, V1+V2, H1);
+        TEST_ASSERT_WIN_WORLD_FOLDING__BROKENIF(FACTOR >= 3, 250, 250, V1,    H1+H2);
+
+        TEST_ASSERT_WIN_WORLD_FOLDING(100, 250, 0,     H1+H2);
+        TEST_ASSERT_WIN_WORLD_FOLDING__BROKENIF(FACTOR >= 6, 400, 250, V1+V2, H1);
+
+        TEST_ASSERT_WIN_WORLD_FOLDING(100, 350, 0,  H1+H2);
+        TEST_ASSERT_WIN_WORLD_FOLDING__BROKENIF(FACTOR >= 3, 250, 350, V1, H1+H2);
+        TEST_ASSERT_WIN_WORLD_FOLDING(400, 350, V1, H1);
+    }
+}
+
+#endif // UNIT_TESTS
+
+// --------------------------------------------------------------------------------
 
 short ED4_root::is_primary_selection(ED4_terminal *object)
@@ -680 +776 @@
 ED4_returncode ED4_root::get_area_rectangle(AW_screen_area *rect, AW_pos x, AW_pos y) {
     // returns win-coordinates of area (defined by folding lines) which contains position x/y
-    ED4_folding_line      *flv, *flh;
     int                    x1, x2, y1, y2;
     const AW_screen_area&  area_rect = curr_device()->get_area_size();
 
     x1 = area_rect.l;
-    for (flv=curr_ed4w()->vertical_fl; ; flv = flv->next) {
+    for (const ED4_folding_line *flv=curr_ed4w()->get_vertical_folding(); ; flv = flv->next) {
         if (flv) {
             e4_assert(flv->length==INFINITE);
@@ -698 +793 @@
 
         y1 = area_rect.t;
-        for (flh=curr_ed4w()->horizontal_fl; ; flh = flh->next) {
+        for (const ED4_folding_line *flh=curr_ed4w()->get_horizontal_folding(); ; flh = flh->next) {
             if (flh) {
                 e4_assert(flh->length==INFINITE);

branches/e4fix/EDIT4/ED4_window.cxx

@@ -17 +17 @@
 int ED4_window::no_of_windows = 0;                  // static variable has to be initialized only once
 
-void ED4_window::reset_all_for_new_config()
-{
-    horizontal_fl = NULL;
-    vertical_fl   = NULL;
+void ED4_window::reset_all_for_new_config() {
+    ED4_foldable::reset();
 
     scrolled_rect.scroll_top    = NULL;
@@ -106 +104 @@
 
 
-ED4_folding_line* ED4_window::insert_folding_line(AW_pos world_x, AW_pos world_y, AW_pos length, AW_pos dimension, ED4_base *link, ED4_properties prop) {
+ED4_folding_line* ED4_foldable::insert_folding_line(AW_pos world_x, AW_pos world_y, AW_pos length, AW_pos dimension, ED4_base *link, ED4_properties prop) {
     ED4_folding_line *fl = NULL;
 
@@ -180 +178 @@
 
 
-ED4_returncode ED4_window::delete_folding_line(ED4_folding_line */*fl*/, ED4_properties /*prop*/) {
+ED4_returncode ED4_foldable::delete_folding_line(ED4_folding_line */*fl*/, ED4_properties /*prop*/) {
+    e4_assert(0); // not implement - cause it's unused
     return ED4_R_OK;
 }
@@ -576 +575 @@
     slider_pos_horizontal = 0;
     slider_pos_vertical   = 0;
-    horizontal_fl         = 0;
-    vertical_fl           = 0;
 
     scrolled_rect.clear();
@@ -601 +598 @@
 
 
-ED4_window::~ED4_window()
-{
+ED4_window::~ED4_window() {
     delete aww;
-    delete horizontal_fl;       // be careful, don't delete links to hierarchy  in folding lines!!!
-    delete vertical_fl;
-
     no_of_windows --;
 }

branches/e4fix/EDIT4/Makefile

@@ -750 +750 @@
 ED4_root.o: $(ARBHOME)/INCLUDE/svn_revision.h
 ED4_root.o: $(ARBHOME)/INCLUDE/test_global.h
+ED4_root.o: $(ARBHOME)/INCLUDE/test_unit.h
 
 ED4_search.o: ed4_awars.hxx

branches/e4fix/EDIT4/ed4_class.hxx

@@ -467 +467 @@
 };
 
-
-class ED4_window : virtual Noncopyable {
+class ED4_foldable : virtual Noncopyable {
+    ED4_folding_line *horizontal_fl;
+    ED4_folding_line *vertical_fl;
+protected:
+    void reset() {
+        delete horizontal_fl;
+        delete vertical_fl;
+        horizontal_fl = NULL;
+        vertical_fl   = NULL;
+    }
+public:
+
+    ED4_foldable() : horizontal_fl(NULL), vertical_fl(NULL) {}
+    ~ED4_foldable() { reset(); }
+
+    const ED4_folding_line *get_horizontal_folding() { return horizontal_fl; }
+    const ED4_folding_line *get_vertical_folding() { return vertical_fl; }
+
+    void world_to_win_coords(AW_pos *x, AW_pos *y);
+    void win_to_world_coords(AW_pos *x, AW_pos *y);
+
+    ED4_folding_line *insert_folding_line(AW_pos world_x, AW_pos world_y, AW_pos length, AW_pos dimension, ED4_base *link, ED4_properties prop);
+    ED4_returncode  delete_folding_line(ED4_folding_line *fl, ED4_properties prop);
+};
+
+class ED4_window : public ED4_foldable { // derived from Noncopyable
     ED4_window(const ED4_window&); // copy-constructor not allowed
 public:
@@ -475 +499 @@
     int                     slider_pos_horizontal;
     int                     slider_pos_vertical;
-    ED4_folding_line       *horizontal_fl;
-    ED4_folding_line       *vertical_fl;
     ED4_scrolled_rectangle  scrolled_rect;
     int                     id; // unique id in window-list
@@ -507 +529 @@
     void update_window_coords();
 
-    // functions concerned with folding lines
-    ED4_folding_line    *insert_folding_line(AW_pos world_x, AW_pos world_y, AW_pos length, AW_pos dimension, ED4_base *link, ED4_properties prop);
-    ED4_returncode  delete_folding_line(ED4_folding_line *fl, ED4_properties prop);
-
-    // functions concerning coordinate transformation
-    void world_to_win_coords(AW_pos *x, AW_pos *y);
-    void win_to_world_coords(AW_pos *x, AW_pos *y);
-    
     ED4_window(AW_window *window);
     ~ED4_window();