Changeset 8293 for branches

Timestamp:

10/12/11 12:24:52 (6 months ago)

Author:

westram

Message:

• each cursor remembers the window where its located
  • removed now unneeded parameters from several member functions

Location:

branches/e4fix/EDIT4

Files:

• ED4_block.cxx (modified) (1 diff)
• ED4_cursor.cxx (modified) (23 diffs)
• ED4_no_class.cxx (modified) (14 diffs)
• ED4_terminal.cxx (modified) (1 diff)
• ED4_window.cxx (modified) (1 diff)
• ed4_class.hxx (modified) (5 diffs)

branches/e4fix/EDIT4/ED4_block.cxx

@@ -211 +211 @@
         for (CursorPositions::iterator ab = at_base.begin(); ab != at_base.end(); ++ab) {
             ED4_window *win = ab->first;
-            win->cursor.jump_base_pos(win->aww, ab->second, ED4_JUMP_KEEP_VISIBLE); // restore cursor at same base
+            win->cursor.jump_base_pos(ab->second, ED4_JUMP_KEEP_VISIBLE); // restore cursor at same base
             
 #if defined(DEBUG)

branches/e4fix/EDIT4/ED4_cursor.cxx

@@ -300 +300 @@
     x = del_mark;
 
-    ED4_window *win = window();
     win->world_to_win_coords(&x, &y);
 
@@ -363 +362 @@
 
 #define EXPAND_SIZE 0
-    if (current_device()->reduceClipBorders(ymin-EXPAND_SIZE, ymax+1+EXPAND_SIZE, xmin-EXPAND_SIZE, xmax+1+EXPAND_SIZE)) {
+    if (window()->get_device()->reduceClipBorders(ymin-EXPAND_SIZE, ymax+1+EXPAND_SIZE, xmin-EXPAND_SIZE, xmax+1+EXPAND_SIZE)) {
         // refresh terminal
         int old_allowed_to_draw = allowed_to_draw;
@@ -376 +375 @@
 
 
-ED4_cursor::ED4_cursor()
-{
+ED4_cursor::ED4_cursor(ED4_window *win_) : win(win_) {
     init();
     allowed_to_draw = 1;
@@ -384 +382 @@
     ctype = (ED4_CursorType)(ED4_ROOT->aw_root->awar(ED4_AWAR_CURSOR_TYPE)->read_int()%ED4_CURSOR_TYPES);
 }
-void ED4_cursor::init() // used by ED4_terminal-d-tor
-{
+void ED4_cursor::init() {
+    // used by ED4_terminal-d-tor
     owner_of_cursor   = NULL;
     cursor_abs_x      = 0;
     screen_position   = 0;
 }
-ED4_cursor::~ED4_cursor()
-{
+ED4_cursor::~ED4_cursor() {
     delete cursor_shape;
 }
 
-ED4_window *ED4_cursor::window() const {
-    ED4_window *win;
-    for (win=ED4_ROOT->first_window; win; win=win->next) {
-        if (&win->cursor==this) {
-            break;
-        }
-    }
-    e4_assert(win);
-    return win;
-}
-
-int ED4_cursor::get_sequence_pos() const
-{
+int ED4_cursor::get_sequence_pos() const {
     ED4_remap *remap = ED4_ROOT->root_group_man->remap();
     size_t max_scrpos = remap->get_max_screen_pos();
@@ -437 +422 @@
         if (terminal) {
             if (seq_pos == -1) seq_pos = cursor->get_sequence_pos();
-            cursor->set_to_terminal(current_aww(), terminal, seq_pos, jump_type);
+            cursor->set_to_terminal(terminal, seq_pos, jump_type);
             return true;
         }
@@ -825 +810 @@
 void ED4_cursor::updateAwars()
 {
-    AW_root     *aw_root = ED4_ROOT->aw_root;
-    ED4_window  *win = current_ed4w();
-    int         seq_pos = get_sequence_pos();
+    AW_root *aw_root = ED4_ROOT->aw_root;
+    int      seq_pos = get_sequence_pos();
 
     if (ED4_update_global_cursor_awars_allowed) {
@@ -947 +931 @@
     return cursor_abs_x - coords->window_left_clip_point;
 }
-void ED4_cursor::set_screen_relative_pos(AW_window *aww, int scroll_to_relpos) {
+void ED4_cursor::set_screen_relative_pos(int scroll_to_relpos) {
     int curr_rel_pos  = get_screen_relative_pos();
     int scroll_amount = curr_rel_pos-scroll_to_relpos;
@@ -955 +939 @@
 
     if (scroll_amount != 0) {
+        AW_window *aww = window()->aww;
         aww->set_horizontal_scrollbar_position(aww->slider_pos_horizontal + scroll_amount);
 #if defined(TRACE_JUMPS)
@@ -964 +949 @@
 
 
-void ED4_cursor::jump_screen_pos(AW_window *aww, int screen_pos, ED4_CursorJumpType jump_type) {
+void ED4_cursor::jump_screen_pos(int screen_pos, ED4_CursorJumpType jump_type) {
     if (!owner_of_cursor) {
         aw_message("First you have to place the cursor");
@@ -984 +969 @@
 
     ED4_terminal *term = owner_of_cursor->to_terminal();
-    term->scroll_into_view(aww); // correct y-position of terminal
+    ED4_window   *ed4w = window();
+
+    term->scroll_into_view(ed4w); // correct y-position of terminal
 
     int cursor_diff = screen_pos-screen_position;
@@ -991 +978 @@
     }
 
-    int terminal_pixel_length = aww->get_device(AW_MIDDLE_AREA)->get_string_size(ED4_G_SEQUENCES, 0, owner_of_cursor->to_text_terminal()->get_length());
+    int terminal_pixel_length = ed4w->get_device()->get_string_size(ED4_G_SEQUENCES, 0, owner_of_cursor->to_text_terminal()->get_length());
     int length_of_char        = ED4_ROOT->font_group.get_width(ED4_G_SEQUENCES);
     int abs_x_new             = cursor_abs_x+cursor_diff*length_of_char; // position in terminal
@@ -999 +986 @@
     }
 
-    ED4_LocalWinContext uses(aww);
-    ED4_coords *coords = &current_ed4w()->coords;
+    ED4_coords *coords = &ed4w->coords;
 
     int screen_width  = coords->window_right_clip_point-coords->window_left_clip_point;
@@ -1046 +1032 @@
         scroll_amount = (scroll_amount/length_of_char)*length_of_char; // align to char-size
         if (scroll_amount != 0) {
+            AW_window *aww  = ed4w->aww;
             aww->set_horizontal_scrollbar_position(aww->slider_pos_horizontal + scroll_amount);
 #if defined(TRACE_JUMPS)
@@ -1065 +1052 @@
 }
 
-void ED4_cursor::jump_sequence_pos(AW_window *aww, int seq_pos, ED4_CursorJumpType jump_type) {
+void ED4_cursor::jump_sequence_pos(int seq_pos, ED4_CursorJumpType jump_type) {
     int screen_pos = ED4_ROOT->root_group_man->remap()->sequence_to_screen_clipped(seq_pos);
-    jump_screen_pos(aww, screen_pos, jump_type);
-}
-
-void ED4_cursor::jump_base_pos(AW_window *aww, int base_pos, ED4_CursorJumpType jump_type) {
+    jump_screen_pos(screen_pos, jump_type);
+}
+
+void ED4_cursor::jump_base_pos(int base_pos, ED4_CursorJumpType jump_type) {
     int seq_pos = base2sequence_position(base_pos);
-    jump_sequence_pos(aww, seq_pos, jump_type);
+    jump_sequence_pos(seq_pos, jump_type);
 }
 
@@ -1123 +1110 @@
 
         if (result == ED4_R_OK) {
-            AW_pos     x_dummy, y_world;
-            AW_window *aww      = current_aww();
-
+            AW_pos x_dummy, y_world;
+            
             owner_of_cursor->calc_world_coords(&x_dummy, &y_world);
 
@@ -1171 +1157 @@
 
             if (target_terminal) {
-                set_to_terminal(aww, target_terminal->to_terminal(), seq_pos, ED4_JUMP_KEEP_VISIBLE);
+                set_to_terminal(target_terminal->to_terminal(), seq_pos, ED4_JUMP_KEEP_VISIBLE);
             }
         }
@@ -1240 +1226 @@
     switch (owner_of_cursor->get_area_level(0)) {
         case ED4_A_TOP_AREA: {
-            ED4_window *win = window();
             visible = 
                 owner_of_cursor->is_visible(win, x1, 0, ED4_D_HORIZONTAL) ||
@@ -1256 +1241 @@
 }
 
-void ED4_terminal::scroll_into_view(AW_window *aww) { // scroll y-position only
-    ED4_LocalWinContext uses(aww);
+void ED4_terminal::scroll_into_view(ED4_window *ed4w) { // scroll y-position only
+    ED4_LocalWinContext uses(ed4w);
 
     AW_pos termw_x, termw_y;
@@ -1300 +1285 @@
 
     if (scroll) {
+        AW_window *aww = ed4w->aww;
+
         int pic_ysize         = int(aww->get_scrolled_picture_height());
         int slider_pos_yrange = pic_ysize - win_ysize;
@@ -1311 +1298 @@
 }
 
-void ED4_cursor::set_to_terminal(AW_window *aww, ED4_terminal *terminal, int seq_pos, ED4_CursorJumpType jump_type)
-{
+void ED4_cursor::set_to_terminal(ED4_terminal *terminal, int seq_pos, ED4_CursorJumpType jump_type) {
     if (seq_pos == -1) seq_pos = get_sequence_pos();
 
     if (owner_of_cursor == terminal) {
-        jump_sequence_pos(aww, seq_pos, jump_type);
+        jump_sequence_pos(seq_pos, jump_type);
     }
     else {
         if (owner_of_cursor) {
             if (get_sequence_pos() != seq_pos) {
-                jump_sequence_pos(aww, seq_pos, jump_type); // position to wanted column -- scrolls horizontally
+                jump_sequence_pos(seq_pos, jump_type); // position to wanted column -- scrolls horizontally
             }
         }
@@ -1329 +1315 @@
 
         if (!is_partly_visible()) {
-#if defined(DEBUG) && 0
-            printf("Cursor not visible in set_to_terminal (was drawn outside screen)\n");
-#endif // DEBUG
-            jump_sequence_pos(aww, seq_pos, jump_type);
+            jump_sequence_pos(seq_pos, jump_type);
         }
     }
@@ -1354 +1337 @@
     }
 
-    target_terminal->scroll_into_view(current_aww());
+    target_terminal->scroll_into_view(current_ed4w());
 
     AW_pos termw_x, termw_y;
@@ -1651 +1634 @@
     if (pairType != HELIX_NONE) {
         int pairing_pos = helix->opposite_position(seq_pos);
-        cursor->jump_sequence_pos(aww, pairing_pos, ED4_JUMP_KEEP_POSITION);
+        cursor->jump_sequence_pos(pairing_pos, ED4_JUMP_KEEP_POSITION);
     }
     else {

branches/e4fix/EDIT4/ED4_no_class.cxx

@@ -219 +219 @@
 
                 if (move_cursor) {
-                    current_cursor().jump_sequence_pos(current_aww(), new_work_info.out_seq_position, ED4_JUMP_KEEP_VISIBLE);
+                    current_cursor().jump_sequence_pos(new_work_info.out_seq_position, ED4_JUMP_KEEP_VISIBLE);
                     move_cursor = 0;
                 }
@@ -228 +228 @@
 }
 
-static void executeKeystroke(AW_window *aww, AW_event *event, int repeatCount) {
+static void executeKeystroke(AW_event *event, int repeatCount) {
     e4_assert(repeatCount>0);
 
@@ -307 +307 @@
                     error = edit_string->edit(work_info);
 
-                    cursor->jump_sequence_pos(aww, work_info->out_seq_position, ED4_JUMP_KEEP_VISIBLE);
+                    cursor->jump_sequence_pos(work_info->out_seq_position, ED4_JUMP_KEEP_VISIBLE);
 
                     work_info->string = 0;
@@ -329 +329 @@
                     // ED4_ROOT->main_manager->Show(); // original version
 
-                    cursor->jump_sequence_pos(aww, work_info->out_seq_position, work_info->cursor_jump);
+                    cursor->jump_sequence_pos(work_info->out_seq_position, work_info->cursor_jump);
                 }
 
@@ -358 +358 @@
 
 void ED4_remote_event(AW_event *faked_event) { // keystrokes forwarded from SECEDIT
-    executeKeystroke(current_aww(), faked_event, 1);
+    executeKeystroke(faked_event, 1);
 }
 
@@ -388 +388 @@
                 }
                 else { // other key => execute now
-                    executeKeystroke(aww, &lastEvent, repeatCount);
+                    executeKeystroke(&lastEvent, repeatCount);
                     lastEvent = event;
                     repeatCount = 1;
@@ -398 +398 @@
                 // sth goes wrong with OSX -> always execute keystroke
                 // Xfree 4.3 has problems as well, so repeat counting is disabled completely
-                executeKeystroke(aww, &lastEvent, repeatCount);
+                executeKeystroke(&lastEvent, repeatCount);
                 repeatCount                       = 0;
 #else
@@ -404 +404 @@
 
                 if (nextEventType!=KEY_RELEASED) { // no key waiting => execute now
-                    executeKeystroke(aww, &lastEvent, repeatCount);
+                    executeKeystroke(&lastEvent, repeatCount);
                     repeatCount = 0;
                 }
@@ -415 +415 @@
 
             if (nextEventType!=KEY_PRESSED && repeatCount) { // no key follows => execute keystrokes (if any)
-                executeKeystroke(aww, &lastEvent, repeatCount);
+                executeKeystroke(&lastEvent, repeatCount);
                 repeatCount = 0;
             }
@@ -657 +657 @@
     if (pos != -1) {
         ED4_cursor *cursor = &current_cursor();
-        cursor->jump_sequence_pos(current_aww(), pos, ED4_JUMP_CENTERED);
+        cursor->jump_sequence_pos(pos, ED4_JUMP_CENTERED);
         awar->write_int(-1);
     }
@@ -734 +734 @@
     }
     else {
-        cursor->jump_sequence_pos(aww, pos, ED4_JUMP_CENTERED);
+        cursor->jump_sequence_pos(pos, ED4_JUMP_CENTERED);
     }
 }
@@ -754 +754 @@
             }
             else {
-                cursor->jump_sequence_pos(aww, pos, ED4_JUMP_CENTERED);
+                cursor->jump_sequence_pos(pos, ED4_JUMP_CENTERED);
             }
         }
@@ -1422 +1422 @@
 
 void ED4_compression_changed_cb(AW_root *awr) {
-    ED4_remap_mode mode = (ED4_remap_mode)awr->awar(ED4_AWAR_COMPRESS_SEQUENCE_TYPE)->read_int();
-    int percent = awr->awar(ED4_AWAR_COMPRESS_SEQUENCE_PERCENT)->read_int();
-    GB_transaction transaction_var(GLOBAL_gb_main);
+    ED4_remap_mode mode    = (ED4_remap_mode)awr->awar(ED4_AWAR_COMPRESS_SEQUENCE_TYPE)->read_int();
+    int            percent = awr->awar(ED4_AWAR_COMPRESS_SEQUENCE_PERCENT)->read_int();
+    GB_transaction ta(GLOBAL_gb_main);
 
     if (ED4_ROOT->root_group_man) {
@@ -1440 +1440 @@
         device->set_clipall();     // draw nothing
 
-        ED4_expose_recalculations();
-
-        cursor.jump_sequence_pos(aww, seq_pos, ED4_JUMP_KEEP_POSITION);
-        cursor.set_screen_relative_pos(aww, rel_pos);
+        ED4_expose_recalculations(); // @@@ do not perform for all windows
+
+        cursor.jump_sequence_pos(seq_pos, ED4_JUMP_KEEP_POSITION);
+        cursor.set_screen_relative_pos(rel_pos);
 
         ED4_expose_cb(aww, 0, 0); // does pop_clip_scale + refresh

branches/e4fix/EDIT4/ED4_terminal.cxx

@@ -762 +762 @@
 
 
-ED4_terminal::~ED4_terminal()
-{
-    if (selection_info) {
-        delete selection_info;
-    }
+ED4_terminal::~ED4_terminal() {
+    delete selection_info;
     ED4_cursor& cursor = current_cursor();
     if (this == cursor.owner_of_cursor) {

branches/e4fix/EDIT4/ED4_window.cxx

@@ -403 +403 @@
 }
 
-ED4_window::ED4_window(AW_window *window) {
-    aww                   = window;
-    next                  = 0;
-    slider_pos_horizontal = 0;
-    slider_pos_vertical   = 0;
-
-    id        = ++no_of_windows;
+ED4_window::ED4_window(AW_window *window)
+    : aww(window),
+      next(NULL),
+      slider_pos_horizontal(0),
+      slider_pos_vertical(0),
+      id(++no_of_windows),
+      is_hidden(false),
+      cursor(this)
+{
     coords.clear();
-    is_hidden = false;
 
     sprintf(awar_path_for_cursor, AWAR_EDIT_SEQ_POSITION, id);

branches/e4fix/EDIT4/ed4_class.hxx

@@ -605 +605 @@
 
 class ED4_cursor : virtual Noncopyable {
-    ED4_index                  cursor_abs_x; // absolute (to terminal) x-position of cursor (absolute world coordinate of edit window)
+    ED4_window                *win;
+    ED4_index                  cursor_abs_x;    // absolute (to terminal) x-position of cursor (absolute world coordinate of edit window)
     int                        screen_position; // number of displayed characters leading the cursor
-    mutable ED4_base_position  base_position; // # of bases left of cursor
+    mutable ED4_base_position  base_position;   // # of bases left of cursor
     ED4_CursorType             ctype;
     ED4_CursorShape           *cursor_shape;
@@ -649 +650 @@
     void invalidate_base_position() { base_position.invalidate(); }
 
-    void jump_screen_pos(AW_window *aww, int screen_pos, ED4_CursorJumpType jump_type);
-    void jump_sequence_pos(AW_window *aww, int sequence_pos, ED4_CursorJumpType jump_type);
-    void jump_base_pos(AW_window *aww, int base_pos, ED4_CursorJumpType jump_type);
+    void jump_screen_pos(int screen_pos, ED4_CursorJumpType jump_type);
+    void jump_sequence_pos(int sequence_pos, ED4_CursorJumpType jump_type);
+    void jump_base_pos(int base_pos, ED4_CursorJumpType jump_type);
 
     int get_screen_relative_pos();
-    void set_screen_relative_pos(AW_window *aww, int scroll_to_relpos);
-
-    void set_to_terminal(AW_window *aww, ED4_terminal *terminal, int seq_pos, ED4_CursorJumpType jump_type);
+    void set_screen_relative_pos(int scroll_to_relpos);
+
+    void set_to_terminal(ED4_terminal *terminal, int seq_pos, ED4_CursorJumpType jump_type);
 
     void announce_deletion(ED4_base *object) {
@@ -665 +666 @@
     void init();
 
-    ED4_window *window() const;
-
-    ED4_cursor();
+    ED4_window *window() const { return win; }
+
+    ED4_cursor(ED4_window *win);
     ~ED4_cursor();
 };
@@ -674 +675 @@
     ED4_window(const ED4_window&); // copy-constructor not allowed
 public:
-    AW_window              *aww; // Points to Window
+    AW_window              *aww;   // Points to Window
     ED4_window             *next;
     int                     slider_pos_horizontal;
     int                     slider_pos_vertical;
     ED4_scrolled_rectangle  scrolled_rect;
-    int                     id; // unique id in window-list
+    int                     id;    // unique id in window-list
     ED4_coords              coords;
-    static int              no_of_windows;
+
+    static int no_of_windows;
 
     char awar_path_for_cursor[50];                  // position in current sequence, range = [1;len]
@@ -1352 +1354 @@
     GB_ERROR write_sequence(const char *seq, int seq_len);
 
-    void scroll_into_view(AW_window *aww);
+    void scroll_into_view(ED4_window *ed4w);
     inline bool setCursorTo(ED4_cursor *cursor, int seq_pos, bool unfoldGroups, ED4_CursorJumpType jump_type);