Changeset 8275

Timestamp:

03/12/11 12:28:00 (6 months ago)

Author:

westram

Message:

• define window-contexts by instanciating context-objects
  • ED4_LocalWinContext (used where calls are triggered via a window)
  • ED4_MostRecentWinContext (uses "last used window"; used when window is not known)
  • iterate over all windows and define context foreach, e.g. in
    • announce_deletion (buggy, not called from kill-mode)
    • ED4_edit_direction_changed
    • ED4_with_whole_block (restore cursor; buggy)
    • resize_requested_by_parent
• Note: the design of EDIT4 does not fit well with multiple edit-windows (which is only a hack in my view)
  • this patch only helps to detect wrong/missing contexts, but definitely doesnt fix the broken design

Location:

branches/e4fix

Files:

• EDIT4/ED4_ProteinViewer.cxx (modified) (1 diff)
• EDIT4/ED4_base.cxx (modified) (3 diffs)
• EDIT4/ED4_block.cxx (modified) (3 diffs)
• EDIT4/ED4_cursor.cxx (modified) (14 diffs)
• EDIT4/ED4_dots.cxx (modified) (2 diffs)
• EDIT4/ED4_edit_string.cxx (modified) (1 diff)
• EDIT4/ED4_main.cxx (modified) (4 diffs)
• EDIT4/ED4_manager.cxx (modified) (1 diff)
• EDIT4/ED4_nds.cxx (modified) (1 diff)
• EDIT4/ED4_no_class.cxx (modified) (17 diffs)
• EDIT4/ED4_root.cxx (modified) (19 diffs)
• EDIT4/ED4_search.cxx (modified) (3 diffs)
• EDIT4/ED4_window.cxx (modified) (6 diffs)
• EDIT4/EDB_root_bact.cxx (modified) (2 diffs)
• EDIT4/Makefile (modified) (1 diff)
• EDIT4/ed4_class.hxx (modified) (12 diffs)
• WINDOW/AW_status.cxx (modified) (1 diff)
• WINDOW/aw_status.hxx (modified) (1 diff)

branches/e4fix/EDIT4/ED4_ProteinViewer.cxx

@@ -399 +399 @@
     }
     // Refresh all windows
-     ED4_refresh_window(0, 0, 0);
-     ED4_ROOT->refresh_all_windows(0);
+    ED4_ROOT->refresh_all_windows(0);
 }
 

branches/e4fix/EDIT4/ED4_base.cxx

@@ -110 +110 @@
 #endif // DEBUG
     }
-    ED4_ROOT->main_manager->Show();
+
+    ED4_ROOT->refresh_all_windows(0);
 }
 
@@ -326 +327 @@
 // -----------------
 
-bool ED4_base::is_visible(AW_pos x, AW_pos y, ED4_direction direction) {
-    // indicates whether x, y are in the visible scrolling area
-    // x, y are calculated by calc_world_coords
+bool ED4_base::is_visible(ED4_window *in_ed4w, AW_pos x, AW_pos y, ED4_direction direction) {
+    // return true if position (world coordinates) is visible in_ed4w
+    // (tests only into direction)
     bool        visible = true;
-    ED4_coords& coords  = current_ed4w()->coords;
+    ED4_coords& coords  = in_ed4w->coords;
 
     switch (direction)
@@ -377 +378 @@
 }
 
-bool ED4_base::is_visible(AW_pos x1, AW_pos y1, AW_pos x2, AW_pos y2, ED4_direction IF_ASSERTION_USED(direction))
-// optimized case of function above (to avoid the need to call it 4 times)
-{
+bool ED4_base::is_visible(ED4_window *in_ed4w, AW_pos x1, AW_pos y1, AW_pos x2, AW_pos y2, ED4_direction IF_ASSERTION_USED(direction)) {
+    // return true if rectangle x1/y1/x2/y2 overlaps with clipped screen
     e4_assert(direction == ED4_D_ALL_DIRECTION);
     e4_assert(x1 <= x2);
     e4_assert(y1 <= y2);
 
-    ED4_coords& coords  = current_ed4w()->coords;
+    ED4_coords& coords  = in_ed4w->coords;
 
     bool visible = (ranges_overlap(x1, x2, coords.window_left_clip_point, coords.window_right_clip_point) &&

branches/e4fix/EDIT4/ED4_block.cxx

@@ -13 +13 @@
 #include <climits>
 #include <cctype>
+#include <map>
+
+using namespace std;
 
 // --------------------------------------------------------------------------------
@@ -163 +166 @@
 }
 
-
-
 void ED4_with_whole_block(ED4_blockoperation block_operation, int repeat) {
-    GB_ERROR    error    = GB_begin_transaction(GLOBAL_gb_main);
-    ED4_cursor *cursor   = &current_cursor();
-    int         base_pos = (cursor && cursor->owner_of_cursor != 0) ? cursor->get_base_position() : -1;
+    GB_ERROR error = GB_begin_transaction(GLOBAL_gb_main);
+
+    typedef map<ED4_window*, int> CursorPositions;
+    CursorPositions at_base;
+
+    for (ED4_window *win = ED4_ROOT->first_window; win; win = win->next) {
+        ED4_cursor& cursor = win->cursor;
+        if (cursor.owner_of_cursor) at_base[win] = cursor.get_base_position();
+    }
+
 
     switch (blocktype) {
@@ -200 +208 @@
     GB_end_transaction_show_error(GLOBAL_gb_main, error, aw_message);
 
-    if (!error && base_pos != -1) {
-        cursor->jump_base_pos(current_aww(), base_pos, ED4_JUMP_KEEP_VISIBLE); // restore cursor at same base
+    if (!error) {
+        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
+            
+#if defined(DEBUG)
+            ED4_cursor& cursor = win->cursor;
+            if (cursor.owner_of_cursor) {
+                int bp_now = cursor.get_base_position();
+                e4_assert(bp_now == ab->second);
+            }
+#endif
+        }
     }
 }

branches/e4fix/EDIT4/ED4_cursor.cxx

@@ -299 +299 @@
     }
     x = del_mark;
-    window()->world_to_win_coords(&x, &y);
+
+    ED4_window *win = window();
+    win->world_to_win_coords(&x, &y);
 
     // refresh own terminal + terminal above + terminal below
@@ -344 +346 @@
     // clear rectangle where cursor is displayed
 
-    AW_device *dev = current_device();
+    AW_device *dev = win->get_device();
     dev->push_clip_scale();
 
@@ -393 +395 @@
 }
 
-ED4_window *ED4_cursor::window() const
-{
+ED4_window *ED4_cursor::window() const {
     ED4_window *win;
-
     for (win=ED4_ROOT->first_window; win; win=win->next) {
         if (&win->cursor==this) {
@@ -467 +467 @@
     ED4_species_name_terminal *name_term = ED4_find_species_name_terminal(name);
     if (name_term) {
+        ED4_MostRecentWinContext context; // use the last used window for selection
+
         // lookup current name term
         ED4_species_name_terminal *cursor_name_term = 0;
@@ -522 +524 @@
         }
     }
-    ignore_selected_SAI_changes_cb = false;
     ED4_update_global_cursor_awars_allowed = true;
 }
@@ -537 +538 @@
 #endif
             select_named_sequence_terminal(name);
-            free(name);
-        }
+        }
+        free(name);
     }
     else {
@@ -545 +546 @@
 #endif
     }
-    ignore_selected_species_changes_cb = false;
     ED4_update_global_cursor_awars_allowed = true;
 }
 
-void ED4_jump_to_current_species(AW_window * /* aw */, AW_CL)
-{
+void ED4_jump_to_current_species(AW_window *aww, AW_CL) {
+    ED4_LocalWinContext uses(aww);
     char *name = GBT_read_string(GLOBAL_gb_main, AWAR_SPECIES_NAME);
     if (name && name[0]) {
@@ -676 +676 @@
 }
 
-void ED4_get_and_jump_to_actual(AW_window *, AW_CL)
-{
+void ED4_get_and_jump_to_actual(AW_window *aww, AW_CL) { // @@@ fix name
+    ED4_LocalWinContext uses(aww);
     char *name = GBT_read_string(GLOBAL_gb_main, AWAR_SPECIES_NAME);
     if (name && name[0]) {
@@ -996 +996 @@
     }
 
+    ED4_LocalWinContext uses(aww);
     ED4_coords *coords = &current_ed4w()->coords;
 
@@ -1235 +1236 @@
 
     switch (owner_of_cursor->get_area_level(0)) {
-        case ED4_A_TOP_AREA:
-            visible =
-                owner_of_cursor->is_visible(x1, 0, ED4_D_HORIZONTAL) ||
-                owner_of_cursor->is_visible(x2, 0, ED4_D_HORIZONTAL);
+        case ED4_A_TOP_AREA: {
+            ED4_window *win = window();
+            visible = 
+                owner_of_cursor->is_visible(win, x1, 0, ED4_D_HORIZONTAL) ||
+                owner_of_cursor->is_visible(win, x2, 0, ED4_D_HORIZONTAL);
             break;
+        }
         case ED4_A_MIDDLE_AREA:
-            visible = owner_of_cursor->is_visible(x1, y1, x2, y2, ED4_D_ALL_DIRECTION);
+            visible = owner_of_cursor->is_visible(window(), x1, y1, x2, y2, ED4_D_ALL_DIRECTION);
             break;
         default:
@@ -1251 +1254 @@
 
 void ED4_terminal::scroll_into_view(AW_window *aww) { // scroll y-position only
+    ED4_LocalWinContext uses(aww);
+
     AW_pos termw_x, termw_y;
     calc_world_coords(&termw_x, &termw_y);
@@ -1590 +1595 @@
 CursorPos *CursorPos::head = 0;
 
-void ED4_store_curpos(AW_window *aww, AW_CL /* cd1 */, AW_CL /* cd2 */)
-{
-    GB_transaction dummy(GLOBAL_gb_main);
-    ED4_ROOT->use_window(aww);
-    ED4_cursor *cursor = &current_cursor();
+void ED4_store_curpos(AW_window *aww, AW_CL /* cd1 */, AW_CL /* cd2 */) {
+    GB_transaction       dummy(GLOBAL_gb_main);
+    ED4_LocalWinContext  uses(aww);
+    ED4_cursor          *cursor = &current_cursor();
+    
     if (!cursor->owner_of_cursor) {
         aw_message("First you have to place the cursor.");
-        return;
-    }
-
-    new CursorPos(cursor->owner_of_cursor->to_terminal(), cursor->get_sequence_pos());
-}
-
-void ED4_restore_curpos(AW_window *aww, AW_CL /* cd1 */, AW_CL /* cd2 */)
-{
-    GB_transaction dummy(GLOBAL_gb_main);
-    ED4_ROOT->use_window(aww);
-    ED4_cursor *cursor = &current_cursor();
+    }
+    else {
+        new CursorPos(cursor->owner_of_cursor->to_terminal(), cursor->get_sequence_pos());
+    }
+}
+
+void ED4_restore_curpos(AW_window *aww, AW_CL /* cd1 */, AW_CL /* cd2 */) {
+    GB_transaction       dummy(GLOBAL_gb_main);
+    ED4_LocalWinContext  uses(aww);
+    ED4_cursor          *cursor = &current_cursor();
 
     CursorPos *pos = CursorPos::get_head();
@@ -1628 +1632 @@
    -------------------------------------------------------------------------------- */
 
-void ED4_helix_jump_opposite(AW_window *aww, AW_CL /* cd1 */, AW_CL /* cd2 */)
-{
-    GB_transaction  dummy(GLOBAL_gb_main);
-    ED4_ROOT->use_window(aww);
-    ED4_cursor     *cursor = &current_cursor();
+void ED4_helix_jump_opposite(AW_window *aww, AW_CL /* cd1 */, AW_CL /* cd2 */) {
+    GB_transaction       dummy(GLOBAL_gb_main);
+    ED4_LocalWinContext  uses(aww);
+    ED4_cursor          *cursor = &current_cursor();
 
     if (!cursor->owner_of_cursor) {
@@ -1652 +1655 @@
 }
 
-void ED4_change_cursor(AW_window * /* aww */, AW_CL /* cd1 */, AW_CL /* cd2 */) {
-    ED4_cursor *cursor = &current_cursor();
-    ED4_CursorType typ = cursor->getType();
+void ED4_change_cursor(AW_window *aww, AW_CL /* cd1 */, AW_CL /* cd2 */) {
+    ED4_LocalWinContext uses(aww);
+    ED4_cursor     *cursor = &current_cursor();
+    ED4_CursorType  typ    = cursor->getType();
 
     cursor->changeType((ED4_CursorType)((typ+1)%ED4_CURSOR_TYPES));

branches/e4fix/EDIT4/ED4_dots.cxx

@@ -99 +99 @@
 
 static void dot_missing_bases(AW_window *aww) {
-    ED4_window *ed4w     = current_ed4w();
-    ED4_cursor *cursor   = &ed4w->cursor;
+    ED4_MostRecentWinContext context;
+
+    ED4_cursor *cursor   = &current_cursor();
     ED4_base   *selected = cursor->owner_of_cursor;
 
@@ -233 +234 @@
     static AW_window_simple *aws     = 0;
 
-    ED4_ROOT->use_window(editor_window);
+    ED4_LocalWinContext uses(editor_window);
 
     if (!aws) {

branches/e4fix/EDIT4/ED4_edit_string.cxx

@@ -772 +772 @@
                         }
                         case 'L': {  // CTRL-L = Refresh
-                            ED4_refresh_window(0, 0, 0);
+                            ED4_refresh_window(current_aww());
                             cursor_jump = ED4_JUMP_CENTERED;
                             break;

branches/e4fix/EDIT4/ED4_main.cxx

@@ -321 +321 @@
 }
 
+void ED4_with_all_edit_windows(void (*cb)(ED4_window *)) {
+    for (ED4_window *win = ED4_ROOT->first_window; win; win = win->next) {
+        ED4_LocalWinContext uses(win);
+        cb(win);
+    }
+}
+
+static void redraw_cursor(ED4_window *win) { win->cursor.redraw(); }
 static void ED4_edit_direction_changed(AW_root * /* awr */) {
-    current_cursor().redraw();
+    ED4_with_all_edit_windows(redraw_cursor);
 }
 
@@ -554 +562 @@
 
     ED4_ROOT->st_ml = STAT_create_ST_ML(GLOBAL_gb_main);
-    ED4_ROOT->sequence_colors = new AWT_seq_colors(AW_ROOT_DEFAULT, ED4_G_SEQUENCES, ED4_refresh_window, 0, 0);
+    ED4_ROOT->sequence_colors = new AWT_seq_colors(AW_ROOT_DEFAULT, ED4_G_SEQUENCES, (AW_CB)ED4_refresh_window, 0, 0);
 
     ED4_ROOT->edk = new ed_key;
@@ -589 +597 @@
     {
         int found_config = 0;
+        ED4_LocalWinContext uses(ED4_ROOT->first_window);
 
         if (config_name)
@@ -648 +657 @@
     AWT_install_postcb_cb(ED4_postcbcb);
     AWT_install_cb_guards();
+    e4_assert(ED4_WinContext::dont_have_global_context()); // context shall be local
     ED4_ROOT->aw_root->main_loop(); // enter main-loop
 

branches/e4fix/EDIT4/ED4_manager.cxx

@@ -905 +905 @@
 }
 
+static void update_scrolled_rectangles(ED4_window *win) { win->update_scrolled_rectangle(); }
 ED4_returncode ED4_main_manager::resize_requested_by_parent() {
     if (update_info.resize) {
         ED4_manager::resize_requested_by_parent();
-        current_ed4w()->update_scrolled_rectangle();
+        ED4_with_all_edit_windows(update_scrolled_rectangles);
     }
     return ED4_R_OK;

branches/e4fix/EDIT4/ED4_nds.cxx

@@ -59 +59 @@
             aw_message_if(error);
         }
-        ED4_gc_is_modified(current_aww(), 0, 0);
+        ED4_gc_is_modified_cb(current_aww(), 0, 0);
     }
 }

branches/e4fix/EDIT4/ED4_no_class.cxx

@@ -128 +128 @@
     static bool dummy = 0;
 
-    ED4_ROOT->use_window(aww);
+    ED4_LocalWinContext uses(aww);
 
     GB_push_transaction(GLOBAL_gb_main);
@@ -148 +148 @@
 
 void ED4_resize_cb(AW_window *aww, AW_CL /*cd1*/, AW_CL /*cd2*/) {
-    ED4_ROOT->use_window(aww);
+    ED4_LocalWinContext uses(aww);
 
     GB_push_transaction(GLOBAL_gb_main);
@@ -367 +367 @@
     static int repeatCount;
 
-    ED4_ROOT->use_window(aww);
+    ED4_LocalWinContext uses(aww);
 
     aww->get_event(&event);
@@ -487 +487 @@
 
 void ED4_vertical_change_cb(AW_window *aww, AW_CL /*cd1*/, AW_CL /*cd2*/) {
-    ED4_ROOT->use_window(aww);
+    ED4_LocalWinContext uses(aww);
 
     GB_push_transaction(GLOBAL_gb_main);
@@ -514 +514 @@
 
 void ED4_horizontal_change_cb(AW_window *aww, AW_CL /*cd1*/, AW_CL /*cd2*/) {
-    ED4_ROOT->use_window(aww);
+    ED4_LocalWinContext uses(aww);
 
     GB_push_transaction(GLOBAL_gb_main);
@@ -541 +541 @@
 
 void ED4_scrollbar_change_cb(AW_window *aww, AW_CL /*cd1*/, AW_CL /*cd2*/) {
-    ED4_ROOT->use_window(aww);
+    ED4_LocalWinContext uses(aww);
 
     GB_push_transaction(GLOBAL_gb_main);
@@ -583 +583 @@
     AW_event event;
 
-    ED4_ROOT->use_window(aww);
+    ED4_LocalWinContext uses(aww);
 
     aww->get_event(&event);
@@ -663 +663 @@
 
 void ED4_jump_to_cursor_position(AW_window *aww, AW_CL cl_awar_name, AW_CL cl_pos_type) {
-    const char   *awar_name = (const char *)cl_awar_name;
-    PositionType  posType   = (PositionType)cl_pos_type;
-    ED4_ROOT->use_window(aww);
-
-    ED4_cursor *cursor = &current_cursor();
-    GB_ERROR    error  = 0;
+    const char          *awar_name = (const char *)cl_awar_name;
+    PositionType         posType   = (PositionType)cl_pos_type;
+    ED4_LocalWinContext  uses(aww);
+    ED4_cursor          *cursor    = &current_cursor();
+    GB_ERROR             error     = 0;
 
     long pos = aww->get_root()->awar(awar_name)->read_int();
@@ -796 +795 @@
 }
 
-void ED4_gc_is_modified(AW_window *aww, AW_CL cd1, AW_CL cd2)                       // callback if gc is modified
-{
-    ED4_ROOT->use_window(aww);
+void ED4_gc_is_modified_cb(AW_window *aww, AW_CL cd1, AW_CL cd2) {
+    ED4_LocalWinContext uses(aww);
 
     ED4_resize_cb(aww, cd1, cd2);
@@ -831 +829 @@
 
 void ED4_quit_editor(AW_window *aww, AW_CL /* cd1 */, AW_CL /* cd2 */) {
-    ED4_ROOT->use_window(aww);
+    ED4_LocalWinContext uses(aww);
 
     if (ED4_ROOT->first_window == current_ed4w()) { // quit button has been pressed in first window
@@ -839 +837 @@
     current_aww()->hide();
     current_ed4w()->is_hidden = true;
-}
-
-void ED4_load_data(AW_window *aww, AW_CL /*cd1*/, AW_CL /*cd2*/) {
-    ED4_ROOT->use_window(aww);
-}
-
-void ED4_save_data(AW_window *aww, AW_CL /*cd1*/, AW_CL /*cd2*/) {
-    ED4_ROOT->use_window(aww);
 }
 
@@ -862 +852 @@
 }
 
-void ED4_refresh_window(AW_window *aww, AW_CL cd_called_from_menu, AW_CL /* cd2 */)
-{
-    GB_transaction dummy(GLOBAL_gb_main);
-
-    if (int(cd_called_from_menu)) {
-        ED4_ROOT->use_window(aww);
-    }
+void ED4_refresh_window(AW_window *aww) {
+    GB_transaction      dummy(GLOBAL_gb_main); // @@@ move down ?
+    ED4_LocalWinContext uses(aww); // @@@ move down ?
 
     ED4_main_manager *mainman = ED4_ROOT->main_manager;
@@ -881 +867 @@
 }
 
-void ED4_set_reference_species(AW_window *aww, AW_CL disable, AW_CL cd2) {
+void ED4_set_reference_species(AW_window *aww, AW_CL disable, AW_CL ) {
+    ED4_LocalWinContext uses(aww);
     GB_transaction dummy(GLOBAL_gb_main);
 
@@ -922 +909 @@
     }
 
-    ED4_refresh_window(aww, 0, cd2);
+    ED4_refresh_window(aww);
 }
 
@@ -964 +951 @@
 }
 
-void ED4_toggle_detailed_column_stats(AW_window *aww, AW_CL, AW_CL)
-{
+void ED4_toggle_detailed_column_stats(AW_window *aww, AW_CL, AW_CL) {
     while (!ED4_columnStat_terminal::threshold_is_set()) {
         ED4_set_col_stat_threshold(aww, 0, 0);
     }
 
+    ED4_LocalWinContext uses(aww);
     ED4_cursor *cursor = &current_cursor();
     if (!cursor->owner_of_cursor) {
@@ -1160 +1147 @@
     GB_push_transaction(GLOBAL_gb_main);
 
-    ED4_ROOT->use_window(use_as_main_window);
+    ED4_LocalWinContext uses(use_as_main_window);
 
     if (!use_field) {
@@ -1405 +1392 @@
 }
 
-void ED4_new_editor_window(AW_window *aww, AW_CL /* cd1 */, AW_CL /* cd2 */)
-{
-    ED4_ROOT->use_window(aww);
+void ED4_new_editor_window(AW_window *aww, AW_CL /* cd1 */, AW_CL /* cd2 */) {
+    ED4_LocalWinContext uses(aww);
 
     AW_device  *device;
     ED4_window *new_window = 0;
 
-    if (ED4_ROOT->generate_window(&device, &new_window) == ED4_R_BREAK)  // don't open more than five windows
-        return;
-
-    ED4_ROOT->use_window(new_window);
-
-    new_window->set_scrolled_rectangle(ED4_ROOT->scroll_links.link_for_hor_slider,
-                                       ED4_ROOT->scroll_links.link_for_ver_slider,
-                                       ED4_ROOT->scroll_links.link_for_hor_slider,
-                                       ED4_ROOT->scroll_links.link_for_ver_slider);
-
-    new_window->aww->show();
-    new_window->update_scrolled_rectangle();
-
-    ED4_ROOT->use_window(aww);
+    if (ED4_ROOT->generate_window(&device, &new_window) != ED4_R_BREAK) {
+        ED4_LocalWinContext now_uses(new_window);
+
+        new_window->set_scrolled_rectangle(ED4_ROOT->scroll_links.link_for_hor_slider,
+                                           ED4_ROOT->scroll_links.link_for_ver_slider,
+                                           ED4_ROOT->scroll_links.link_for_hor_slider,
+                                           ED4_ROOT->scroll_links.link_for_ver_slider);
+
+        new_window->aww->show();
+        new_window->update_scrolled_rectangle();
+    }
 }
 

branches/e4fix/EDIT4/ED4_root.cxx

@@ -36 +36 @@
 #include <aw_root.hxx>
 #include <aw_advice.hxx>
+#include "../WINDOW/aw_status.hxx" // @@@ hack - obsolete when EDIT4 status works like elsewhere
 #include <arb_version.h>
 #include <arb_file.h>
@@ -43 +44 @@
 
 AW_window *AWTC_create_island_hopping_window(AW_root *root, AW_CL);
+
+ED4_WinContext ED4_WinContext::current_context;
 
 ED4_returncode ED4_root::refresh_window_simple(int redraw)
@@ -73 +76 @@
 }
 
-ED4_returncode ED4_root::refresh_all_windows(int redraw)
-{
-    ED4_window *old_window = curr_ed4w();
-
+ED4_returncode ED4_root::refresh_all_windows(int redraw) {
     last_window_reached = 0;
 
@@ -93 +93 @@
     while (window) {
         if (!window->next) last_window_reached = 1;
-        use_window(window);
+        ED4_LocalWinContext uses(window);
         refresh_window_simple(redraw);
         window = window->next;
     }
-
-    use_window(old_window);
 
     return (ED4_R_OK);
@@ -335 +333 @@
 }
 
+void ED4_window::announce_deletion(ED4_base *object) {
+    if (cursor.owner_of_cursor == object) { // about to delete owner_of_cursor
+        cursor.HideCursor();
+        e4_assert(!cursor.owner_of_cursor);
+    }
+}
 void ED4_root::announce_deletion(ED4_base *object) {
     // remove any links which might point to the object
-
-    ED4_cursor& cursor = curr_ed4w()->cursor;
-    if (cursor.owner_of_cursor == object) { // about to delete owner_of_cursor
-        cursor.HideCursor();
-        e4_assert(cursor.owner_of_cursor != object);
+    // @@@ not triggered by kill_object()
+    for (ED4_window *win = first_window; win; win = win->next) {
+        ED4_LocalWinContext uses(win);
+        win->announce_deletion(object);
     }
 }
@@ -527 +530 @@
     font_group.unregisterAll();
     for (int f=ED4_G_FIRST_FONT; f<=ED4_G_LAST_FONT; f++) {
-        font_group.registerFont(curr_device(), f);
+        ED4_MostRecentWinContext context;
+        font_group.registerFont(current_device(), f);
     }
 }
@@ -743 +747 @@
         new_window->aww->show();
         new_window->update_scrolled_rectangle();
-        ED4_refresh_window(new_window->aww, 0, 0);
+        ED4_refresh_window(new_window->aww);
         new_window = new_window->next;
     }
@@ -757 +761 @@
     // returns win-coordinates of area (defined by folding lines) which contains position x/y
     int                    x1, x2, y1, y2;
-    const AW_screen_area&  area_rect = curr_device()->get_area_size();
+    const AW_screen_area&  area_rect = current_device()->get_area_size();
 
     x1 = area_rect.l;
-    for (const ED4_folding_line *flv=curr_ed4w()->get_vertical_folding(); ; flv = flv->get_next()) {
+    for (const ED4_folding_line *flv=current_ed4w()->get_vertical_folding(); ; flv = flv->get_next()) {
         if (flv) {
             x2 = int(flv->get_pos()); // @@@ use AW_INT ? 
@@ -772 +776 @@
 
         y1 = area_rect.t;
-        for (const ED4_folding_line *flh=curr_ed4w()->get_horizontal_folding(); ; flh = flh->get_next()) {
+        for (const ED4_folding_line *flh=current_ed4w()->get_horizontal_folding(); ; flh = flh->get_next()) {
             if (flh) {
                 y2 = int(flh->get_pos()); // @@@ use AW_INT ? 
@@ -807 +811 @@
 
 
-void ED4_reload_helix_cb(AW_window *aww, AW_CL cd1, AW_CL cd2) {
+void ED4_reload_helix_cb(AW_window *aww) {
     const char *err = ED4_ROOT->helix->init(GLOBAL_gb_main);
     if (err) aw_message(err);
-    ED4_refresh_window(aww, cd1, cd2);
-}
-
-
-void ED4_reload_ecoli_cb(AW_window *aww, AW_CL cd1, AW_CL cd2)
-{
+    ED4_refresh_window(aww);
+}
+
+
+void ED4_reload_ecoli_cb(AW_window *aww) {
     const char *err = ED4_ROOT->ecoli_ref->init(GLOBAL_gb_main);
     if (err) aw_message(err);
-    ED4_refresh_window(aww, cd1, cd2);
+    ED4_refresh_window(aww);
 }
 
@@ -1070 +1073 @@
 }
 
-void ED4_undo_redo(AW_window*, AW_CL undo_type)
-{
+void ED4_undo_redo(AW_window *aww, AW_CL undo_type) {
+    ED4_LocalWinContext uses(aww);
     GB_ERROR error = GB_undo(GLOBAL_gb_main, (GB_UNDO_TYPE)undo_type);
 
@@ -1090 +1093 @@
 }
 
-void aw_clear_message_cb(AW_window *aww);
-
-void ED4_clear_errors(AW_window*, AW_CL)
-{
-    aw_clear_message_cb(current_aww());
+void ED4_clear_errors(AW_window *aww, AW_CL) {
+    aw_clear_message_cb(aww);
 }
 
@@ -1158 +1158 @@
 }
 
-void ED4_set_protection(AW_window * /* aww */, AW_CL cd1, AW_CL /* cd2 */) {
+void ED4_set_protection(AW_window *aww, AW_CL cd1, AW_CL /* cd2 */) {
+    ED4_LocalWinContext uses(aww);
     ED4_cursor *cursor = &current_cursor();
     GB_ERROR    error  = 0;
@@ -1272 +1273 @@
     }
 
-    ED4_refresh_window(aww, 1, 0);
-}
-
-void ED4_menu_perform_block_operation(AW_window*, AW_CL type, AW_CL) {
+    ED4_refresh_window(aww);
+}
+
+void ED4_menu_perform_block_operation(AW_window */*aww*/, AW_CL type, AW_CL) {
     ED4_perform_block_operation(ED4_blockoperation_type(type));
 }
@@ -1386 +1387 @@
     }
 
+    ED4_LocalWinContext uses(*new_window);
+    
     // each window has its own gc-manager
     aw_gc_manager = AW_manage_GC(awmm,              // window
@@ -1467 +1470 @@
 
     awmm->create_menu("Edit", "E", AWM_ALL);
-    awmm->insert_menu_topic("refresh",     "Refresh [Ctrl-L]",           "f",  0, AWM_ALL, ED4_refresh_window,                   1, 0);
+    awmm->insert_menu_topic("refresh",     "Refresh [Ctrl-L]",           "f", 0, AWM_ALL, (AW_CB)ED4_refresh_window,            0, 0);
     awmm->insert_menu_topic("load_actual", "Load current species [GET]", "G", 0, AWM_ALL, ED4_get_and_jump_to_actual_from_menu, 0, 0);
     awmm->insert_menu_topic("load_marked", "Load marked species",        "m", 0, AWM_ALL, ED4_get_marked_from_menu,             0, 0);
     SEP________________________SEP;
-    awmm->insert_menu_topic("refresh_ecoli",       "Reload Ecoli sequence",        "E", "ecoliref.hlp", AWM_ALL, ED4_reload_ecoli_cb,     0, 0);
-    awmm->insert_menu_topic("refresh_helix",       "Reload Helix",                 "H", "helix.hlp",    AWM_ALL, ED4_reload_helix_cb,     0, 0);
-    awmm->insert_menu_topic("helix_jump_opposite", "Jump helix opposite [Ctrl-J]", "J", 0,              AWM_ALL, ED4_helix_jump_opposite, 0, 0);
+    awmm->insert_menu_topic("refresh_ecoli",       "Reload Ecoli sequence",        "E", "ecoliref.hlp", AWM_ALL, (AW_CB)ED4_reload_ecoli_cb, 0, 0);
+    awmm->insert_menu_topic("refresh_helix",       "Reload Helix",                 "H", "helix.hlp",    AWM_ALL, (AW_CB)ED4_reload_helix_cb, 0, 0);
+    awmm->insert_menu_topic("helix_jump_opposite", "Jump helix opposite [Ctrl-J]", "J", 0,              AWM_ALL, ED4_helix_jump_opposite,    0, 0);
     SEP________________________SEP;
 
@@ -1721 +1724 @@
 
     awmm->at("pos");
-    awmm->callback((AW_CB)ED4_jump_to_cursor_position, (AW_CL) curr_ed4w()->awar_path_for_cursor, AW_CL(ED4_POS_SEQUENCE));
-    awmm->create_input_field(curr_ed4w()->awar_path_for_cursor, 7);
+    awmm->callback((AW_CB)ED4_jump_to_cursor_position, (AW_CL) current_ed4w()->awar_path_for_cursor, AW_CL(ED4_POS_SEQUENCE));
+    awmm->create_input_field(current_ed4w()->awar_path_for_cursor, 7);
 
     awmm->at("ecoli");
-    awmm->callback((AW_CB)ED4_jump_to_cursor_position, (AW_CL) curr_ed4w()->awar_path_for_Ecoli, AW_CL(ED4_POS_ECOLI));
-    awmm->create_input_field(curr_ed4w()->awar_path_for_Ecoli, 6);
+    awmm->callback((AW_CB)ED4_jump_to_cursor_position, (AW_CL) current_ed4w()->awar_path_for_Ecoli, AW_CL(ED4_POS_ECOLI));
+    awmm->create_input_field(current_ed4w()->awar_path_for_Ecoli, 6);
 
     awmm->at("base");
-    awmm->callback((AW_CB)ED4_jump_to_cursor_position, (AW_CL) curr_ed4w()->awar_path_for_basePos, AW_CL(ED4_POS_BASE));
-    awmm->create_input_field(curr_ed4w()->awar_path_for_basePos, 6);
+    awmm->callback((AW_CB)ED4_jump_to_cursor_position, (AW_CL) current_ed4w()->awar_path_for_basePos, AW_CL(ED4_POS_BASE));
+    awmm->create_input_field(current_ed4w()->awar_path_for_basePos, 6);
 
     awmm->at("iupac");
-    awmm->callback((AW_CB)ED4_set_iupac, (AW_CL) curr_ed4w()->awar_path_for_IUPAC, AW_CL(0));
-    awmm->create_input_field(curr_ed4w()->awar_path_for_IUPAC, 4);
+    awmm->callback((AW_CB)ED4_set_iupac, (AW_CL) current_ed4w()->awar_path_for_IUPAC, AW_CL(0));
+    awmm->create_input_field(current_ed4w()->awar_path_for_IUPAC, 4);
 
     awmm->at("helixnr");
-    awmm->callback((AW_CB)ED4_set_helixnr, (AW_CL) curr_ed4w()->awar_path_for_helixNr, AW_CL(0));
-    awmm->create_input_field(curr_ed4w()->awar_path_for_helixNr, 5);
+    awmm->callback((AW_CB)ED4_set_helixnr, (AW_CL) current_ed4w()->awar_path_for_helixNr, AW_CL(0));
+    awmm->create_input_field(current_ed4w()->awar_path_for_helixNr, 5);
 
     // ---------------------------
@@ -1908 +1911 @@
     // Buttons at left window border
 
-    awmm->create_mode("edit/arrow.bitmap", "normal.hlp", AWM_ALL, (AW_CB)modes_cb, (AW_CL)0, (AW_CL)0);
-    awmm->create_mode("edit/kill.bitmap",  "kill.hlp",   AWM_ALL, (AW_CB)modes_cb, (AW_CL)1, (AW_CL)0);
-    awmm->create_mode("edit/mark.bitmap",  "mark.hlp",   AWM_ALL, (AW_CB)modes_cb, (AW_CL)2, (AW_CL)0);
+    awmm->create_mode("edit/arrow.bitmap", "normal.hlp", AWM_ALL, (AW_CB)modes_cb, (AW_CL)ED4_SM_MOVE, (AW_CL)0);
+    awmm->create_mode("edit/kill.bitmap",  "kill.hlp",   AWM_ALL, (AW_CB)modes_cb, (AW_CL)ED4_SM_KILL, (AW_CL)0);
+    awmm->create_mode("edit/mark.bitmap",  "mark.hlp",   AWM_ALL, (AW_CB)modes_cb, (AW_CL)ED4_SM_MARK, (AW_CL)0);
 
     FastAligner_create_variables(awmm->get_root(), props_db);
@@ -1924 +1927 @@
     generate_window(&device, &new_window);
 
+    ED4_LocalWinContext uses(new_window);
+    
     ED4_calc_terminal_extentions();
 

branches/e4fix/EDIT4/ED4_search.cxx

@@ -727 +727 @@
 
     if (settings[type]->get_autoJump() && (action & DO_AUTO_JUMP)) { // auto jump
+        ED4_MostRecentWinContext context;
         ED4_cursor *cursor = &current_cursor();
-        bool jumped = false;
+        bool        jumped = false;
 
         if (cursor->owner_of_cursor && cursor->owner_of_cursor->is_sequence_terminal()) {
@@ -772 +773 @@
         bool old_update                        = ED4_update_global_cursor_awars_allowed;
         ED4_update_global_cursor_awars_allowed = false;
-        ED4_refresh_window(current_aww(), 0, 0);
+        ED4_ROOT->refresh_all_windows(0);
         ED4_update_global_cursor_awars_allowed = old_update;
     }
@@ -1341 +1342 @@
 }
 
-void ED4_search(AW_window * /* aww */, AW_CL searchDescriptor)
-{
-    int direction;
+void ED4_search(AW_window *aww , AW_CL searchDescriptor) {
+    ED4_MostRecentWinContext context;
+    int direction; // @@@ fix locals
     ED4_SearchPositionType pattern;
     int searchOnlyForShownPatterns;

branches/e4fix/EDIT4/ED4_window.cxx

@@ -106 +106 @@
 
 ED4_window *ED4_window::get_matching_ed4w(AW_window *aw) {
+    e4_assert(aw);
+    
     ED4_window *window = ED4_ROOT->first_window;
-    while (window && window->aww != aw) window = window->next;
+    while (window && window->aww != aw) {
+        window = window->next;
+    }
+    
+    e4_assert(window); // aw is not an edit-window
     return window;
 }
@@ -336 +342 @@
 
 
-void ED4_window::delete_window(ED4_window *window)  // delete from window list
-{
+void ED4_window::delete_window(ED4_window *window) {
+    // delete from window list
     ED4_window *temp, *temp2;
 
@@ -343 +349 @@
         temp = ED4_ROOT->first_window;                  // delete temp afterwards
         ED4_ROOT->first_window = ED4_ROOT->first_window->next;
-
-        if (no_of_windows > 1) {
-            ED4_ROOT->use_first_window();
-        }
     }
     else {
@@ -357 +359 @@
 
         temp2->next = temp->next;
-
-        ED4_ROOT->use_window(temp2);
     }
 
@@ -370 +370 @@
 
 
-ED4_window *ED4_window::insert_window(AW_window *new_aww)
-{
+ED4_window *ED4_window::insert_window(AW_window *new_aww) {
     ED4_window *last, *temp;
 
@@ -399 +398 @@
     new_aww->set_vertical_change_callback  (ED4_vertical_change_cb,   0, 0);
 
-    ED4_ROOT->use_window(temp);
     ED4_ROOT->temp_gc = ED4_G_STANDARD;
 

branches/e4fix/EDIT4/EDB_root_bact.cxx

@@ -168 +168 @@
     char       namebuffer[NAME_BUFFERSIZE];
 
-    device = ED4_ROOT->first_window->aww->get_device(AW_MIDDLE_AREA);
+    device = ED4_ROOT->first_window->get_device();
 
     if (alignment_flag == ED4_A_DEFAULT) {
@@ -577 +577 @@
     sequence_manager->children->append_member(sequence_info_terminal);
 
-    device = ED4_ROOT->first_window->aww->get_device(AW_MIDDLE_AREA);
+    device = ED4_ROOT->first_window->get_device();
     pixel_length = device->get_string_size(ED4_G_SEQUENCES, CONSENSUS,   0);
 

branches/e4fix/EDIT4/Makefile

@@ -689 +689 @@
 ED4_ProteinViewer.o: $(ARBHOME)/INCLUDE/Translate.hxx
 
+ED4_root.o: ../WINDOW/aw_status.hxx
 ED4_root.o: ed4_awars.hxx
 ED4_root.o: ed4_block.hxx

branches/e4fix/EDIT4/ed4_class.hxx

@@ -689 +689 @@
     ED4_window *get_matching_ed4w(AW_window *aww);
 
+    void announce_deletion(ED4_base *object);
+
     // functions concerned the scrolled area
     ED4_returncode      update_scrolled_rectangle();
@@ -696 +698 @@
 
     void update_window_coords();
+
+    AW_device *get_device() const { return aww->get_device(AW_MIDDLE_AREA); }
 
     ED4_window(AW_window *window);
@@ -1028 +1032 @@
 
     ED4_returncode clear_whole_background();       // clear AW_MIDDLE_AREA
-    bool is_visible(AW_pos x, AW_pos y, ED4_direction direction);
-    bool is_visible(AW_pos x1, AW_pos y1, AW_pos x2, AW_pos y2, ED4_direction direction);
+    bool is_visible(ED4_window *in_ed4w, AW_pos x, AW_pos y, ED4_direction direction);
+    bool is_visible(ED4_window *in_ed4w, AW_pos x1, AW_pos y1, AW_pos x2, AW_pos y2, ED4_direction direction);
 
     // functions concerned with links in the hierarchy
@@ -1381 +1385 @@
         e4_assert(ew);
         ed4w   = ew;
-        device = ed4w->aww->get_device(AW_MIDDLE_AREA);
-    }
-
-public:
+        device = ed4w->get_device();
+    }
+
+protected:
     ED4_WinContext() : ed4w(0), device(0) {}
-
+    static ED4_WinContext current_context;
+
+public:
     inline ED4_WinContext(AW_window *aww_);
     ED4_WinContext(ED4_window *ed4w_) { init(ed4w_); }
@@ -1392 +1398 @@
     AW_device *get_device() const { e4_assert(have_context()); return device; }
     ED4_window *get_ed4w() const { e4_assert(have_context()); return ed4w; }
-};
+
+    static const ED4_WinContext& get_current_context() { return current_context; }
+    static bool dont_have_global_context() { return !current_context.have_context(); }
+};
+
+
+inline AW_device *current_device() { return ED4_WinContext::get_current_context().get_device(); }
+inline ED4_window *current_ed4w() { return ED4_WinContext::get_current_context().get_ed4w(); }
+inline AW_window *current_aww() { return current_ed4w()->aww; }
+inline ED4_cursor& current_cursor() { return current_ed4w()->cursor; }
 
 class ED4_root : virtual Noncopyable {
@@ -1399 +1414 @@
     ED4_returncode refresh_window_simple(int redraw);
 
-    ED4_WinContext  context;
-    ED4_window     *most_recently_used_window;
+    ED4_window *most_recently_used_window;
 
 public:
@@ -1441 +1455 @@
     AW_font_group            font_group;
 
-    void use_window(AW_window *aww) { context = ED4_WinContext(aww); }
-    void use_window(ED4_window *ed4w) { context = ED4_WinContext(ed4w); }
-    void use_first_window() { use_window(first_window); }
-
-    AW_device *curr_device() const { return context.get_device(); }
-    ED4_window *curr_ed4w() const { return context.get_ed4w(); }
-    AW_window *curr_aww() const { return context.get_ed4w()->aww; }
-
     void announce_useraction_in(AW_window *aww);
     ED4_window *get_most_recently_used_window() const { return most_recently_used_window; }
@@ -1485 +1491 @@
 };
 
-inline AW_window *current_aww() { return ED4_ROOT->curr_aww(); }
-inline AW_device *current_device() { return ED4_ROOT->curr_device(); }
-inline ED4_window *current_ed4w() { return ED4_ROOT->curr_ed4w(); }
-inline ED4_cursor& current_cursor() { return current_ed4w()->cursor; }
-
-ED4_WinContext::ED4_WinContext(AW_window *aww_) {
-    init(ED4_ROOT->first_window->get_matching_ed4w(aww_));
-}
+ED4_WinContext::ED4_WinContext(AW_window *aww_) { init(ED4_ROOT->first_window->get_matching_ed4w(aww_)); }
+
+class ED4_LocalWinContext : private ED4_WinContext {
+public:
+    ED4_LocalWinContext(AW_window *aww) : ED4_WinContext(current_context) { current_context = ED4_WinContext(aww); }
+    ED4_LocalWinContext(ED4_window *ew) : ED4_WinContext(current_context) { current_context = ED4_WinContext(ew); }
+    ~ED4_LocalWinContext() { current_context = *this; }
+};
+
+class ED4_MostRecentWinContext : virtual Noncopyable { 
+    ED4_LocalWinContext *most_recent;
+public:
+    ED4_MostRecentWinContext() : most_recent(0) {
+        if (ED4_WinContext::dont_have_global_context()) {
+            most_recent = new ED4_LocalWinContext(ED4_ROOT->get_most_recently_used_window());
+        }
+    }
+    ~ED4_MostRecentWinContext() {
+        delete most_recent;
+    }
+};
+
 
 // ------------------------
@@ -2076 +2096 @@
 extern      ST_ML *st_ml;
 
+void ED4_with_all_edit_windows(void (*cb)(ED4_window *));
+
 void ED4_expose_cb(AW_window *aww, AW_CL cd1, AW_CL cd2);
 void ED4_expose_all_windows();
@@ -2086 +2108 @@
 void ED4_remote_event(AW_event *faked_event);
 
-void        ED4_gc_is_modified      (AW_window *aww, AW_CL cd1, AW_CL cd2);
-void        ED4_quit            (AW_window *aww, AW_CL cd1, AW_CL cd2);
+void        ED4_gc_is_modified_cb(AW_window *aww, AW_CL cd1, AW_CL cd2);
+void        ED4_quit(AW_window *aww, AW_CL cd1, AW_CL cd2);
 
 void        ED4_motion_cb           (AW_window *aww, AW_CL cd1, AW_CL cd2);
@@ -2120 +2142 @@
 
 void        ED4_quit_editor         (AW_window *aww, AW_CL cd1, AW_CL cd2);                 // Be Careful: Is this the last window?
-void        ED4_load_data           (AW_window *aww, AW_CL cd1, AW_CL cd2);
-void        ED4_save_data           (AW_window *aww, AW_CL cd1, AW_CL cd2);
-void        ED4_refresh_window      (AW_window *aww, AW_CL cd1, AW_CL cd2);
+void        ED4_refresh_window      (AW_window *aww);
 
 void        ED4_store_curpos        (AW_window *aww, AW_CL cd1, AW_CL cd2);
@@ -2185 +2205 @@
 
 
+

branches/e4fix/WINDOW/AW_status.cxx

@@ -746 +746 @@
 }
 
-void aw_clear_message_cb(AW_window *aww)
-{
-    int i;
+void aw_clear_message_cb(AW_window *aww) {
     AW_root *awr = aww->get_root();
-    for (i = 0; i< AW_MESSAGE_LINES; i++) freenull(aw_stg.lines[i]);
+    for (int i = 0; i< AW_MESSAGE_LINES; i++) freenull(aw_stg.lines[i]);
     awr->awar(AWAR_ERROR_MESSAGES)->write_string("");
 }

branches/e4fix/WINDOW/aw_status.hxx

@@ -25 +25 @@
 void aw_closestatus();                 // hide status
 
+// special for EDIT4 (obsolete - nobody listens to EDIT4-errors)
+void aw_clear_message_cb(AW_window *aww);
+
 #else
 #error aw_status.hxx included twice