Changeset 6149 for branches/stable_5.0

Timestamp:

19/08/09 16:49:28 (3 years ago)

Author:

westram

Message:

• merged [6145], [6146], [6147] and [6148]

Location:

branches/stable_5.0

Files:

• ARBDB/ad_load.c (modified) (2 diffs)
• ARBDB/ad_prot.h (modified) (3 diffs)
• ARBDB/arbdb.c (modified) (5 diffs)
• ARBDB/arbdb.h (modified) (2 diffs)
• SL/DB_SCANNER/db_scanner.cxx (modified) (13 diffs)
• WINDOW/AW_button.cxx (modified) (15 diffs)
• WINDOW/AW_nawar.cxx (modified) (10 diffs)
• WINDOW/AW_window.cxx (modified) (1 diff)
• WINDOW/aw_root.hxx (modified) (5 diffs)
• WINDOW/aw_window.hxx (modified) (1 diff)
• WINDOW/aw_window_Xm.hxx (modified) (1 diff)

branches/stable_5.0/ARBDB/ad_load.c

@@ -1510 +1510 @@
                         }
                         else {
-                            gbd = 0;
+                            gbd   = 0;
+                            error = GB_await_error();
                         }
                     }
@@ -1594 +1595 @@
         GB_begin_transaction((GBDATA *)gbd);
     }
+
+    gb_assert(error || gbd);
     
     if (error) {

branches/stable_5.0/ARBDB/ad_prot.h

@@ -133 +133 @@
 long GB_read_int P_((GBDATA *gbd));
 int GB_read_byte P_((GBDATA *gbd));
+void *GB_read_pointer P_((GBDATA *gbd));
 double GB_read_float P_((GBDATA *gbd));
 long GB_read_count P_((GBDATA *gbd));
@@ -160 +161 @@
 GB_ERROR GB_write_byte P_((GBDATA *gbd, int i));
 GB_ERROR GB_write_int P_((GBDATA *gbd, long i));
+GB_ERROR GB_write_pointer P_((GBDATA *gbd, void *pointer));
 GB_ERROR GB_write_float P_((GBDATA *gbd, double f));
 GB_ERROR GB_write_pntr P_((GBDATA *gbd, const char *s, long bytes_size, long stored_size));
@@ -202 +204 @@
 GB_ERROR GB_set_temporary P_((GBDATA *gbd));
 GB_ERROR GB_clear_temporary P_((GBDATA *gbd));
-long GB_read_temporary P_((GBDATA *gbd));
+GB_BOOL GB_is_temporary P_((GBDATA *gbd));
+GB_BOOL GB_in_temporary_branch P_((GBDATA *gbd));
 GB_ERROR GB_push_local_transaction P_((GBDATA *gbd));
 GB_ERROR GB_pop_local_transaction P_((GBDATA *gbd));

branches/stable_5.0/ARBDB/arbdb.c

@@ -426 +426 @@
 }
 
+void *GB_read_pointer(GBDATA *gbd) {
+    GB_TEST_READ(gbd,GB_POINTER,"GB_read_pointer");
+    return gbd->info.ptr;
+}
+
 double GB_read_float(GBDATA *gbd)
 {
@@ -752 +757 @@
     if ((long)((int32_t)i) != i) {
         gb_assert(0);
+        GB_warningf("Warning: 64bit incompatibility detected\nNo data written to '%s'\n", GB_get_db_path(gbd));
         return "GB_INT out of range (signed, 32bit)";
     }
@@ -757 +763 @@
         gb_save_extern_data_in_ts(gbd);
         gbd->info.i = i;
+        gb_touch_entry(gbd,gb_changed);
+        GB_DO_CALLBACKS(gbd);
+    }
+    return 0;
+}
+
+GB_ERROR GB_write_pointer(GBDATA *gbd, void *pointer) {
+    GB_TEST_WRITE(gbd,GB_POINTER,"GB_write_pointer");
+    if (gbd->info.ptr != pointer) {
+        gb_save_extern_data_in_ts(gbd);
+        gbd->info.ptr = pointer;
         gb_touch_entry(gbd,gb_changed);
         GB_DO_CALLBACKS(gbd);
@@ -1302 +1319 @@
         return NULL;
     };
+
+    if (type == GB_POINTER) {
+        if (!GB_in_temporary_branch(father)) {
+            GB_export_error("GB_create: pointers only allowed in temporary branches");
+            return NULL;
+        }
+    }
+
     gbd = gb_make_entry((GBCONTAINER *)father, key, -1,0,type);
     gb_touch_header(GB_FATHER(gbd));
@@ -1642 +1667 @@
 }
 
-long GB_read_temporary(GBDATA *gbd) {
+GB_BOOL GB_is_temporary(GBDATA *gbd) {
     GB_TEST_TRANSACTION(gbd);
     return (long)gbd->flags.temporary;
 }
+
+GB_BOOL GB_in_temporary_branch(GBDATA *gbd) {
+    // returns true, if 'gbd' is member of a temporary subtree
+
+    if (GB_is_temporary(gbd)) return GB_TRUE;
+
+    GBDATA *gb_parent = GB_get_father(gbd);
+    if (!gb_parent) return GB_FALSE;
+
+    return GB_in_temporary_branch(gb_parent);
+}
+
 
 /********************************************************************************************

branches/stable_5.0/ARBDB/arbdb.h

@@ -125 +125 @@
     GB_INT         = 3,
     GB_FLOAT       = 4,
-    // 5 is unused
+    GB_POINTER     = 5, // not savable! only allowed in temporary entries
     GB_BITS        = 6,
     // 7 is unused
@@ -188 +188 @@
 
 union gb_data_base_type_union {
-    int32_t                  i;
-    struct GB_INTern_strings istr;
-    struct GB_INTern         in;
-    struct gb_extern_data    ex;
+    int32_t                   i;
+    void                     *ptr;
+    struct GB_INTern_strings  istr;
+    struct GB_INTern          in;
+    struct gb_extern_data     ex;
 };
 

branches/stable_5.0/SL/DB_SCANNER/db_scanner.cxx

@@ -40 +40 @@
     cbs->may_be_an_error = 0;
     GB_push_transaction(cbs->gb_main);
-    GBDATA *gbd = (GBDATA *)aw_root->awar(cbs->def_gbd)->read_int();
+    GBDATA *gbd = (GBDATA *)aw_root->awar(cbs->def_gbd)->read_pointer();
     if (    !cbs->gb_user ||
             !gbd ||
@@ -134 +134 @@
                 else    error      = GB_write_as_string(gb_new,value);
 
-                cbs->aws->get_root()->awar(cbs->def_gbd)->write_int((long)gb_new); // remap arbdb
+                cbs->aws->get_root()->awar(cbs->def_gbd)->write_pointer(gb_new); // remap arbdb
             }
         }
@@ -195 +195 @@
                         error = GB_delete(gbd);
                         if (!error) {
-                            cbs->aws->get_root()->awar(cbs->def_gbd)->write_int((long) gb_key);
+                            cbs->aws->get_root()->awar(cbs->def_gbd)->write_pointer(gb_key);
                         }
                     }
@@ -250 +250 @@
     GB_push_transaction(cbs->gb_main);
     if (cbs->may_be_an_error) {     // sorry
-        cbs->aws->get_root()->awar(cbs->def_gbd)->write_int((long)0);
-    }
-    gbd = (GBDATA *)cbs->aws->get_root()->awar(cbs->def_gbd)->read_int();
+        cbs->aws->get_root()->awar(cbs->def_gbd)->write_pointer(NULL);
+    }
+    gbd = (GBDATA *)cbs->aws->get_root()->awar(cbs->def_gbd)->read_pointer();
 
     if (cbs->gb_edit) {
@@ -301 +301 @@
     sprintf(buffer,"tmp/arbdb_scanner_%i/list",scanner_id);
     cbs->def_gbd = strdup(buffer);
-    aw_root->awar_int( cbs->def_gbd, 0, AW_ROOT_DEFAULT);
+    aw_root->awar_pointer(cbs->def_gbd, 0, AW_ROOT_DEFAULT);
 
     sprintf(buffer,"tmp/arbdb_scanner_%i/find",scanner_id);
@@ -317 +317 @@
     aws->at(box_pos_fig);
 
-    cbs->id          = aws->create_selection_list(cbs->def_gbd,0,"",20,10);
+    cbs->id          = aws->create_selection_list(cbs->def_gbd, 0, "", 20, 10);
     cbs->aws         = aws;
     cbs->awr         = aw_root;
@@ -386 +386 @@
         case GB_DB: {
             GBS_strcat(out, "<CONTAINER>:");
-            cbs->aws->insert_selection(cbs->id, GBS_mempntr(out), (long)gbd);
+            cbs->aws->insert_selection(cbs->id, GBS_mempntr(out), gbd);
             GBS_strforget(out);
 
@@ -396 +396 @@
         case GB_LINK: {
             GBS_strnprintf(out, 100, "LINK TO '%s'", GB_read_link_pntr(gbd));
-            cbs->aws->insert_selection(cbs->id, GBS_mempntr(out), (long)gbd);
+            cbs->aws->insert_selection(cbs->id, GBS_mempntr(out), gbd);
             GBS_strforget(out);
 
@@ -417 +417 @@
                 GBS_strcat(out, "<unprintable>");
             }
-            cbs->aws->insert_selection(cbs->id, GBS_mempntr(out), (long)gbd);
+            cbs->aws->insert_selection(cbs->id, GBS_mempntr(out), gbd);
             GBS_strforget(out);
             break;
@@ -492 +492 @@
                         }
                     }
-                    cbs->aws->insert_selection( cbs->id, buffer, (long)gbd );
+                    cbs->aws->insert_selection(cbs->id, buffer, gbd);
                 }
                 else { // non-existing entry
-                    p[0]=' '; p[1] = ':'; p[2] = 0;
-                    cbs->aws->insert_selection( cbs->id, buffer, (long)gb_key );
+                    p[0] = ' '; p[1] = ':'; p[2] = 0;
+                    cbs->aws->insert_selection(cbs->id, buffer, gb_key);
                 }
             }
@@ -538 +538 @@
         }
     }
-    aws->insert_default_selection( cbs->id, "", (long)0 );
+    aws->insert_default_selection( cbs->id, "", (void*)NULL);
     aws->update_selection_list( cbs->id );
     if (cbs->gb_user) {
@@ -551 +551 @@
 static void awt_scanner_changed_cb2(GBDATA *dummy, struct adawcbstruct *cbs, GB_CB_TYPE gbtype)
 {
-    cbs->aws->get_root()->awar(cbs->def_gbd)->write_int((long)0);
+    cbs->aws->get_root()->awar(cbs->def_gbd)->write_pointer(NULL);
     // unmap edit field
     awt_scanner_changed_cb(dummy,cbs,gbtype);
@@ -579 +579 @@
     }
 
-    cbs->aws->get_root()->awar(cbs->def_gbd)->write_int((long)0);
+    cbs->aws->get_root()->awar(cbs->def_gbd)->write_pointer(NULL);
     awt_scanner_changed_cb(gb_pntr,cbs,GB_CB_CHANGED);
 

branches/stable_5.0/WINDOW/AW_button.cxx

@@ -149 +149 @@
             switch ( vus->awar->variable_type ) {
                 case AW_STRING:
-                    error = vus->awar->write_string( tmp );
+                    error   = vus->awar->write_string( tmp );
                     break;
                 case AW_INT:
-                    h_int = atoi(tmp);
-                    error = vus->awar->write_int( h_int );
+                    h_int   = atoi(tmp);
+                    error   = vus->awar->write_int( h_int );
                     break;
                 case AW_FLOAT:
                     h_float = atof(tmp);
-                    error = vus->awar->write_float( h_float );
+                    error   = vus->awar->write_float( h_float );
                     break;
                 default:
-                    error = GB_export_error("Unknown AWAR type");
+                    gb_assert(0);
+                    error = GB_export_error("Unknown or incompatible AWAR type");
             }
             XtFree( tmp );
@@ -181 +182 @@
                 case AW_INT:    error = vus->awar->write_int(vus->variable_int_value );      break;
                 case AW_FLOAT:  error = vus->awar->write_float( vus->variable_float_value ); break;
-                default: GB_warning("Unknown AWAR type"); break;
+#if defined(DEVEL_RALF)
+#warning missing implementation for AW_POINTER                     
+#endif // DEVEL_RALF
+                default:
+                    gb_assert(0);
+                    GB_warning("Unknown AWAR type");
+                    break;
             }
             break;
@@ -222 +229 @@
                     error = vus->awar->write_float( list_table->float_value );
                     break;
+                case AW_POINTER:
+                    error = vus->awar->write_pointer( list_table->pointer_value );
+                    break;
                 default:
+                    gb_assert(0);
                     error = GB_export_error("Unknown AWAR type");
                     break;
@@ -232 +243 @@
             break;
         default:
+            gb_assert(0);
             GB_warning("Unknown Widget Type");
             break;
@@ -1687 +1699 @@
 
 void AW_window::insert_selection(AW_selection_list *selection_list, const char *displayed, const char *value) {
-    if ( selection_list->variable_type != AW_STRING ) {
+    if (selection_list->variable_type != AW_STRING) {
         selection_type_mismatch("string");
         return;
     }
 
-    if ( selection_list->list_table ) {
-        selection_list->last_of_list_table->next = new AW_select_table_struct( displayed, value );
+    if (selection_list->list_table) {
+        selection_list->last_of_list_table->next = new AW_select_table_struct(displayed, value);
         selection_list->last_of_list_table = selection_list->last_of_list_table->next;
         selection_list->last_of_list_table->next = NULL;
     }else {
-        selection_list->last_of_list_table = selection_list->list_table = new AW_select_table_struct( displayed, value );
-    }
-}
-
-
-void AW_window::insert_default_selection( AW_selection_list *selection_list, const char *displayed, const char *value ) {
-
-    if ( selection_list->variable_type != AW_STRING ) {
+        selection_list->last_of_list_table = selection_list->list_table = new AW_select_table_struct(displayed, value);
+    }
+}
+
+
+void AW_window::insert_default_selection(AW_selection_list *selection_list, const char *displayed, const char *value) {
+    if (selection_list->variable_type != AW_STRING) {
         selection_type_mismatch("string");
         return;
     }
-    if ( selection_list->default_select ) {
+    if (selection_list->default_select) {
         delete selection_list->default_select;
     }
-    selection_list->default_select = new AW_select_table_struct( displayed, value );
-}
-
-
-void AW_window::insert_selection( AW_selection_list *selection_list, const char *displayed, long value ) {
-
-    if ( selection_list->variable_type != AW_INT ) {
+    selection_list->default_select = new AW_select_table_struct(displayed, value);
+}
+
+#if defined(DEVEL_RALF)
+#warning parameter value must be int32_t
+#endif // DEVEL_RALF
+void AW_window::insert_selection(AW_selection_list *selection_list, const char *displayed, long value) {
+
+    if (selection_list->variable_type != AW_INT) {
         selection_type_mismatch("int");
         return;
     }
-    if ( selection_list->list_table ) {
-        selection_list->last_of_list_table->next = new AW_select_table_struct( displayed, value );
+    if (selection_list->list_table) {
+        selection_list->last_of_list_table->next = new AW_select_table_struct(displayed, value);
         selection_list->last_of_list_table = selection_list->last_of_list_table->next;
         selection_list->last_of_list_table->next = NULL;
     }else {
-        selection_list->last_of_list_table = selection_list->list_table = new AW_select_table_struct( displayed, value );
-    }
-}
-
-
-void AW_window::insert_default_selection( AW_selection_list *selection_list, const char *displayed, long value ) {
-
-    if ( selection_list->variable_type != AW_INT ) {
+        selection_list->last_of_list_table = selection_list->list_table = new AW_select_table_struct(displayed, value);
+    }
+}
+
+#if defined(DEVEL_RALF)
+#warning parameter value must be int32_t
+#endif // DEVEL_RALF
+void AW_window::insert_default_selection(AW_selection_list *selection_list, const char *displayed, long value) {
+    if (selection_list->variable_type != AW_INT) {
         selection_type_mismatch("int");
         return;
     }
-    if ( selection_list->default_select ) {
+    if (selection_list->default_select) {
         delete selection_list->default_select;
     }
-    selection_list->default_select = new AW_select_table_struct( displayed, value );
-}
-
-
-void AW_window::clear_selection_list( AW_selection_list *selection_list ) {
+    selection_list->default_select = new AW_select_table_struct(displayed, value);
+}
+
+void AW_window::insert_selection(AW_selection_list * selection_list, const char *displayed, void *pointer) {
+    if (selection_list->variable_type != AW_POINTER) {
+        selection_type_mismatch("pointer");
+        return;
+    }
+    if (selection_list->list_table) {
+        selection_list->last_of_list_table->next = new AW_select_table_struct(displayed, pointer);
+        selection_list->last_of_list_table = selection_list->last_of_list_table->next;
+        selection_list->last_of_list_table->next = NULL;
+    }else {
+        selection_list->last_of_list_table = selection_list->list_table = new AW_select_table_struct(displayed, pointer);
+    }
+}
+
+void AW_window::insert_default_selection(AW_selection_list * selection_list, const char *displayed, void *pointer) {
+    if (selection_list->variable_type != AW_POINTER) {
+        selection_type_mismatch("pointer");
+        return;
+    }
+    if (selection_list->default_select) {
+        delete selection_list->default_select;
+    }
+    selection_list->default_select = new AW_select_table_struct(displayed, pointer);
+}
+
+void AW_window::clear_selection_list(AW_selection_list *selection_list) {
     AW_select_table_struct *list_table;
     AW_select_table_struct *help;
 
 
-    for ( help = selection_list->list_table; help;  ) {
+    for (help = selection_list->list_table; help; ) {
         list_table = help;
         help = list_table->next;
         delete list_table;
     }
-    if ( selection_list->default_select ) {
+    if (selection_list->default_select) {
         delete selection_list->default_select;
     }
@@ -1814 +1852 @@
     AW_select_table_struct *list_table;
 
-    int         pos = 0;
-    char            *global_var_value = NULL;
-    long            global_var_int_value;
-    float           global_var_float_value;
+    int pos = 0;
 
     if (!selection_list->variable_name) return; // not connected to awar
@@ -1823 +1858 @@
     pos = 0;
     switch ( selection_list->variable_type ) {
-        case AW_STRING: global_var_value = root->awar( selection_list->variable_name )->read_string();
+        case AW_STRING: {
+            char *var_value = root->awar( selection_list->variable_name )->read_string();
             for ( list_table = selection_list->list_table; list_table; list_table = list_table->next ) {
-                if ( strcmp( global_var_value, list_table->char_value ) == 0 ) {
+                if ( strcmp( var_value, list_table->char_value ) == 0 ) {
                     found = true;
                     break;
@@ -1831 +1867 @@
                 pos++;
             }
+            free(var_value);
             break;
-        case AW_INT:    global_var_int_value = root->awar( selection_list->variable_name )->read_int();
+        }
+        case AW_INT: {
+            int var_value = root->awar( selection_list->variable_name )->read_int();
             for ( list_table = selection_list->list_table; list_table; list_table = list_table->next ) {
-                if ( global_var_int_value == list_table->int_value ) {
+                if ( var_value == list_table->int_value ) {
                     found = true;
                     break;
@@ -1841 +1880 @@
             }
             break;
-        case AW_FLOAT:  global_var_float_value = root->awar( selection_list->variable_name )->read_float();
+        }
+        case AW_FLOAT: {
+            float var_value = root->awar( selection_list->variable_name )->read_float();
             for ( list_table = selection_list->list_table; list_table; list_table = list_table->next ) {
-                if ( global_var_float_value == list_table->float_value ) {
+                if ( var_value == list_table->float_value ) {
                     found = true;
                     break;
@@ -1850 +1891 @@
             }
             break;
+        }
+        case AW_POINTER: {
+            void *var_value = root->awar( selection_list->variable_name )->read_pointer();
+            for ( list_table = selection_list->list_table; list_table; list_table = list_table->next ) {
+                if ( var_value == list_table->pointer_value ) {
+                    found = true;
+                    break;
+                }
+                pos++;
+            }
+            break;
+        }
         default:
+            gb_assert(0);
             GB_warning("Unknown AWAR type");
             break;
@@ -1873 +1927 @@
         }
 
-    }else{
-        AW_ERROR("Selection list '%s' has no default selection",selection_list->variable_name);
-    }
-    free(global_var_value);
+    }
+    else {
+        AW_ERROR("Selection list '%s' has no default selection", selection_list->variable_name);
+    }
 }
 
@@ -2431 +2485 @@
             char  *var_name               = oms->variable_name;
 
+#if defined(DEVEL_RALF)
+#warning missing implementation for AW_POINTER
+#endif // DEVEL_RALF
+            
             switch ( oms->variable_type ) {
                 case AW_STRING: global_var_value       = root->awar( var_name )->read_string(); break;
@@ -2444 +2502 @@
                     case AW_INT:    found_choice = (global_var_int_value   == active_choice->variable_int_value );      break;
                     case AW_FLOAT:  found_choice = (global_var_float_value == active_choice->variable_float_value );    break;
-                    default: GB_warning("Unknown AWAR type"); break;
+                    default:
+                        gb_assert(0);
+                        GB_warning("Unknown AWAR type");
+                        break;
                 }
                 if (found_choice) break;
@@ -2698 +2759 @@
             float  global_var_float_value = 0;
 
+#if defined(DEVEL_RALF)
+#warning missing implementation for AW_POINTER
+#endif // DEVEL_RALF
+            
             switch ( toggle_field_list->variable_type ) {
                 case AW_STRING: global_var_value       = root->awar( toggle_field_list->variable_name )->read_string(); break;
                 case AW_INT:    global_var_int_value   = root->awar( toggle_field_list->variable_name )->read_int();    break;
                 case AW_FLOAT:  global_var_float_value = root->awar( toggle_field_list->variable_name )->read_float();  break;
-                default: GB_warning("Unknown AWAR type"); break;
+                default:
+                    gb_assert(0);
+                    GB_warning("Unknown AWAR type");
+                    break;
             }
 
@@ -2711 +2779 @@
                     case AW_INT:    found_toggle = (global_var_int_value == active_toggle->variable_int_value);       break;
                     case AW_FLOAT:  found_toggle = (global_var_float_value == active_toggle->variable_float_value);   break;
-                    default: GB_warning("Unknown AWAR type"); break;
+                    default:
+                        gb_assert(0);
+                        GB_warning("Unknown AWAR type");
+                        break;
                 }
                 if (found_toggle) break;

branches/stable_5.0/WINDOW/AW_nawar.cxx

@@ -78 +78 @@
 }
 
-long AW_awar::read_int(){
+long AW_awar::read_int() {
     if (!gb_var) return 0;
     GB_transaction ta(gb_var);
     return (long)GB_read_int( gb_var );
 }
-double AW_awar::read_float(){
+double AW_awar::read_float() {
     if (!gb_var) return 0.0;
     GB_transaction ta(gb_var);
     return GB_read_float(gb_var);
 }
+
+void *AW_awar::read_pointer() {
+    if (!gb_var) return NULL;
+    GB_transaction ta(gb_var);
+    return GB_read_pointer(gb_var);
+}
+
 
 #if defined(DUMP_AWAR_CHANGES)
@@ -116 +123 @@
     WRITE_SKELETON(write_int, long, "%li", GB_write_int) // defines rewrite_int
     WRITE_SKELETON(write_float, double, "%f", GB_write_float) // defines rewrite_float
-    WRITE_SKELETON(write_as_string, const char *, "%s", GB_write_as_string) // defines rewrite_as_string
+    WRITE_SKELETON(write_as_string, const char*, "%s", GB_write_as_string) // defines rewrite_as_string
+    WRITE_SKELETON(write_pointer, void*, "%p", GB_write_pointer) // defines rewrite_pointer
 
 #undef WRITE_SKELETON
@@ -146 +154 @@
 // for string
 AW_awar *AW_root::awar_string( const char *var_name, const char *default_value, AW_default default_file ) {
-    AW_awar *vs;
-    vs = (AW_awar *)GBS_read_hash(hash_table_for_variables, (char *)var_name);
-    if (vs) return vs;  /* already defined */
-    default_file = aw_check_default_file(this->application_database,default_file,var_name);
-
-    vs = new AW_awar( AW_STRING, var_name, default_value, 0, default_file, this );
-    GBS_write_hash( hash_table_for_variables, (char *)var_name, (long)vs );
+    AW_awar *vs = (AW_awar *)GBS_read_hash(hash_table_for_variables, (char *)var_name);
+    if (!vs) {
+        default_file = aw_check_default_file(this->application_database,default_file,var_name);
+        vs           = new AW_awar(AW_STRING, var_name, default_value, 0, default_file, this);
+        GBS_write_hash(hash_table_for_variables, (char *)var_name, (long)vs);
+    }
     return vs;
 }
@@ -158 +165 @@
 
 // for int
-AW_awar *AW_root::awar_int( const char *var_name, long default_value, AW_default default_file ) {
-    AW_awar *vs;
-    vs = (AW_awar *)GBS_read_hash(hash_table_for_variables, (char *)var_name);
-    if (vs) return vs;  /* already defined */
-    default_file = aw_check_default_file(this->application_database,default_file,var_name);
-
-    vs = new AW_awar( AW_INT, var_name, (char *)default_value, 0, default_file, this );
-    GBS_write_hash( hash_table_for_variables, (char *)var_name, (long)vs );
+AW_awar *AW_root::awar_int(const char *var_name, long default_value, AW_default default_file) {
+    AW_awar *vs = (AW_awar *)GBS_read_hash(hash_table_for_variables, (char *)var_name);
+    if (!vs) {
+        default_file = aw_check_default_file(this->application_database,default_file,var_name);
+        vs           = new AW_awar(AW_INT, var_name, (char *)default_value, 0, default_file, this);
+        GBS_write_hash(hash_table_for_variables, (char *)var_name, (long)vs);
+    }
     return vs;
 }
@@ -171 +177 @@
 
 // for float
-AW_awar *AW_root::awar_float( const char *var_name, float default_value, AW_default default_file ) {
-    AW_awar *vs;
-    vs = (AW_awar *)GBS_read_hash(hash_table_for_variables, (char *)var_name);
-    if (vs) return vs;  /* already defined */
-    default_file = aw_check_default_file(this->application_database,default_file,var_name);
-
-    vs = new AW_awar( AW_FLOAT, var_name, "", (double)default_value, default_file, this );
-    GBS_write_hash( hash_table_for_variables, (char *)var_name, (long)vs );
+AW_awar *AW_root::awar_float(const char *var_name, float default_value, AW_default default_file) {
+    AW_awar *vs = (AW_awar *)GBS_read_hash(hash_table_for_variables, (char *)var_name);
+    if (!vs) {
+        default_file = aw_check_default_file(this->application_database,default_file,var_name);
+        vs           = new AW_awar(AW_FLOAT, var_name, "", (double)default_value, default_file, this);
+        GBS_write_hash(hash_table_for_variables, (char *)var_name, (long)vs);
+    }
     return vs;
 }
 
-AW_awar *AW_root::awar_no_error( const char *var_name){
+AW_awar *AW_root::awar_pointer(const char *var_name, void *default_value, AW_default default_file) {
+    AW_awar *vs = (AW_awar *)GBS_read_hash(hash_table_for_variables, (char *)var_name);
+    if (!vs) {
+        default_file = aw_check_default_file(this->application_database,default_file,var_name);
+        vs           = new AW_awar(AW_POINTER, var_name, (const char *)default_value, NULL, default_file, this);
+        GBS_write_hash(hash_table_for_variables, (char *)var_name, (long)vs);
+    }
+    return vs;
+}
+
+AW_awar *AW_root::awar_no_error(const char *var_name){
     AW_awar *vs = (AW_awar *)GBS_read_hash(hash_table_for_variables, (char *)var_name);
     return vs;
 }
 
-AW_awar *AW_root::awar( const char *var_name){
+AW_awar *AW_root::awar(const char *var_name){
     AW_awar *vs = (AW_awar *)GBS_read_hash(hash_table_for_variables, (char *)var_name);
     if (vs) return vs;  /* already defined */
@@ -492 +507 @@
     if (!pntr->pointer) return;
     switch(variable_type) {
-        case AW_STRING:
-            this->get((char **)pntr->pointer);break;
-        case AW_FLOAT:
-            this->get((double *)pntr->pointer);break;
-        case AW_INT:
-            this->get((long *)pntr->pointer);break;
+        case AW_STRING: this->get((char **)pntr->pointer);break;
+        case AW_FLOAT:  this->get((double *)pntr->pointer);break;
+        case AW_INT:    this->get((long *)pntr->pointer);break;
         default:
+            gb_assert(0);
             GB_warning("Unknown awar type");
+            break;
     }
 }
@@ -523 +537 @@
 
     this->awar_name = strdup(var_name);
-    this->root = rooti;
-    GBDATA *gb_def = GB_search((GBDATA *)default_file, var_name,GB_FIND);
-    if ( gb_def ) {                                                  // belege Variable mit Datenbankwert
-        AW_VARIABLE_TYPE gbtype;
-        gbtype = (AW_VARIABLE_TYPE) GB_read_type( gb_def );
-        if ( gbtype != var_type ) {
-            GB_warningf("Wrong Awar type %s\n",var_name);
-            GB_delete( gb_def );
+    this->root      = rooti;
+    GBDATA *gb_def  = GB_search((GBDATA *)default_file, var_name,GB_FIND);
+
+    GB_TYPES wanted_gbtype = (GB_TYPES)var_type;
+
+    if ( gb_def ) {                                 // belege Variable mit Datenbankwert
+        GB_TYPES gbtype = GB_read_type(gb_def);
+
+        if (gbtype != wanted_gbtype) {
+            GB_warningf("Existing awar '%s' has wrong type (%i instead of %i) - recreating\n",
+                        var_name, int(gbtype), int(wanted_gbtype));
+            GB_delete(gb_def);
             gb_def = 0;
         }
     }
-    if (!gb_def) {             // belege Variable mit Programmwert
-        gb_def = GB_search( (GBDATA *)default_file, var_name, (GB_TYPES)var_type);
-
-        switch ( var_type ) {
+
+    if (!gb_def) {                                  // belege Variable mit Programmwert
+        gb_def = GB_search( (GBDATA *)default_file, var_name, wanted_gbtype);
+
+        switch (var_type) {
             case AW_STRING:
 #if defined(DUMP_AWAR_CHANGES)
                 fprintf(stderr, "creating awar_string '%s' with default value '%s'\n", var_name, (char*)var_value);
 #endif // DUMP_AWAR_CHANGES
-                GB_write_string( gb_def, (char *)var_value );
-                break;
+                GB_write_string(gb_def, (char *)var_value);
+                break;
+                
             case AW_INT:
 #if defined(DUMP_AWAR_CHANGES)
                 fprintf(stderr, "creating awar_int '%s' with default value '%li'\n", var_name, (long)var_value);
 #endif // DUMP_AWAR_CHANGES
-                GB_write_int( gb_def, (long)var_value );
-                break;
+                GB_write_int(gb_def, (long)var_value);
+                break;
+                
             case AW_FLOAT:
 #if defined(DUMP_AWAR_CHANGES)
                 fprintf(stderr, "creating awar_float '%s' with default value '%f'\n", var_name, (double)var_double_value);
 #endif // DUMP_AWAR_CHANGES
-                GB_write_float( gb_def, (double)var_double_value );
-                break;
+                GB_write_float(gb_def, (double)var_double_value);
+                break;
+
+            case AW_POINTER: 
+#if defined(DUMP_AWAR_CHANGES)
+                fprintf(stderr, "creating awar_pointer '%s' with default value '%p'\n", var_name, (void*)var_value);
+#endif // DUMP_AWAR_CHANGES
+                GB_write_pointer(gb_def, (void*)var_value);
+                break;
+                
             default:
                 GB_warningf("AWAR '%s' cannot be created because of disallowed type",var_name);
@@ -593 +622 @@
     if (gb_default) {
         GB_no_transaction(gb_default);
+
+        GBDATA *gb_tmp = GB_search(gb_default, "tmp", GB_CREATE_CONTAINER);
+        GB_set_temporary(gb_tmp);
 #if defined(DEBUG)
         AWT_announce_db_to_browser(gb_default, GBS_global_string("Properties (%s)", default_name));
@@ -602 +634 @@
         if (!shown_name) shown_name = default_name;
 
-        GBK_terminatef(GBS_global_string("Error loading properties '%s': %s", shown_name, error));
+        GBK_terminatef("Error loading properties '%s': %s", shown_name, error);
     }
     return (AW_default) gb_default;
@@ -626 +658 @@
 AW_error *AW_root::save_default(AW_default aw_default, const char *file_name)
 {
-    GBDATA *gb_tmp;
     GBDATA *gb_main = GB_get_root((GBDATA *)aw_default);
     GB_push_transaction(gb_main);
-    gb_tmp = GB_entry(gb_main,"tmp");
-    if (gb_tmp) GB_set_temporary(gb_tmp);
     aw_update_awar_window_geometry(this);
     GB_pop_transaction(gb_main);

branches/stable_5.0/WINDOW/AW_window.cxx

@@ -250 +250 @@
     displayed = copy_string(displayedi);
     float_value = valuei;
+}
+AW_select_table_struct::AW_select_table_struct(const char *displayedi, void *pointer) {
+    memset((char *)this, 0, sizeof(AW_select_table_struct));
+    displayed = copy_string(displayedi);
+    pointer_value = pointer;
 }
 AW_select_table_struct::~AW_select_table_struct(void) {

branches/stable_5.0/WINDOW/aw_root.hxx

@@ -63 +63 @@
 
 typedef enum {
-    AW_NONE   = 0,
-    AW_BIT    = 1,
-    AW_BYTE   = 2,
-    AW_INT    = 3,
-    AW_FLOAT  = 4,
-    // 5 is unused
-    AW_BITS   = 6,
+    AW_NONE    = 0,
+    AW_BIT     = 1,
+    AW_BYTE    = 2,
+    AW_INT     = 3,
+    AW_FLOAT   = 4,
+    AW_POINTER = 5, 
+    AW_BITS    = 6,
     // 7 is unused
-    AW_BYTES  = 8,
-    AW_INTS   = 9,
-    AW_FLOATS = 10,
-    AW_STRING = 12,
+    AW_BYTES   = 8,
+    AW_INTS    = 9,
+    AW_FLOATS  = 10,
+    AW_STRING  = 12,
     // 13 is reserved (GB_STRING_SHRT)
     // 14 is unused
-    AW_DB     = 15,
-    
+    AW_DB      = 15,
+
     // keep AW_VARIABLE_TYPE consistent with GB_TYPES
     // see ../ARBDB/arbdb.h@sync_GB_TYPES_AW_VARIABLE_TYPE
@@ -219 +219 @@
     AW_awar *awar_no_error(const char *awar);
 
-    AW_awar *awar_string(const char *var_name, const char *default_value = "", AW_default default_file = AW_ROOT_DEFAULT);
-    AW_awar *awar_int   (const char *var_name, long default_value = 0,         AW_default default_file = AW_ROOT_DEFAULT);
-    AW_awar *awar_float (const char *var_name, float default_value = 0.0,      AW_default default_file = AW_ROOT_DEFAULT);
+    AW_awar *awar_string (const char *var_name, const char *default_value = "", AW_default default_file = AW_ROOT_DEFAULT);
+    AW_awar *awar_int    (const char *var_name, long default_value = 0,         AW_default default_file = AW_ROOT_DEFAULT);
+    AW_awar *awar_float  (const char *var_name, float default_value = 0.0,      AW_default default_file = AW_ROOT_DEFAULT);
+    AW_awar *awar_pointer(const char *var_name, void *default_value = NULL,     AW_default default_file = AW_ROOT_DEFAULT);
 
     AW_awar *label_is_awar(const char *label); // returns awar, if label refers to one (used by buttons, etc.)
@@ -346 +347 @@
     const char *read_char_pntr();
     char       *read_as_string();
+    long        read_int();
     double      read_float();
-    long        read_int();
+    void       *read_pointer();
 
     GB_ERROR write_string(const char *aw_string);
@@ -353 +355 @@
     GB_ERROR write_int(long aw_int);
     GB_ERROR write_float(double aw_double);
+    GB_ERROR write_pointer(void *aw_pointer);
+
     GB_ERROR write_as(char *aw_value) { return write_as_string(aw_value);};
 
@@ -360 +364 @@
     GB_ERROR rewrite_int(long aw_int);
     GB_ERROR rewrite_float(double aw_double);
+    GB_ERROR rewrite_pointer(void *aw_pointer);
+    
     GB_ERROR rewrite_as(char *aw_value) { return rewrite_as_string(aw_value);};
 

branches/stable_5.0/WINDOW/aw_window.hxx

@@ -502 +502 @@
     void insert_selection(  AW_selection_list * selection_list, const char *displayed, float value );
     void insert_default_selection(  AW_selection_list * selection_list, const char *displayed, float value );
+    // for pointers (only allowed if selection list uses a tmp-awars)
+    void insert_selection(  AW_selection_list * selection_list, const char *displayed, void *pointer );
+    void insert_default_selection(  AW_selection_list * selection_list, const char *displayed, void *pointer );
 
     void delete_selection_from_list(  AW_selection_list * selection_list, const char *displayed_string );

branches/stable_5.0/WINDOW/aw_window_Xm.hxx

@@ -158 +158 @@
 
     AW_select_table_struct( const char *displayedi, const char *value );
-    ~AW_select_table_struct( void );
     AW_select_table_struct( const char *displayedi, long value );
     AW_select_table_struct( const char *displayedi, float value );
+    AW_select_table_struct( const char *displayedi, void *pointer );
+
+    ~AW_select_table_struct( void );
 
     static char *copy_string(const char *str);
 
-    char                   *displayed;
-    char                   *char_value;
-    long                    int_value;
-    float                   float_value;
-    int                     is_selected; // internal use only
+    char *displayed;
+
+#if defined(DEVEL_RALF)
+#warning make the following variables a union
+#endif // DEVEL_RALF
+    char  *char_value;
+    long   int_value;
+    float  float_value;
+    void  *pointer_value;
+
+    int is_selected;                                // internal use only
+
     AW_select_table_struct *next;
 };