lib/prop_inttypes.c

   1 /* Dia -- a diagram creation/manipulation program -*- c -*-
   2  * Copyright (C) 1998 Alexander Larsson
   3  *
   4  * Property system for dia objects/shapes.
   5  * Copyright (C) 2000 James Henstridge
   6  * Copyright (C) 2001 Cyrille Chepelov
   7  * Major restructuration done in August 2001 by C. Chepelov
   8  *
   9  * Property types for integral types (and arrays thereof).
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include <stdlib.h> /* strtol */
  31
  32 #undef GTK_DISABLE_DEPRECATED /* gtk_signal_connect, gtk_object_set_user_data */
  33 #include <gtk/gtk.h>
  34 #define WIDGET GtkWidget
  35 #include "properties.h"
  36 #include "propinternals.h"
  37
  38 /***************************/
  39 /* The CHAR property type. */
  40 /***************************/
  41
  42 static CharProperty *
  43 charprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
  44 {
  45   CharProperty *prop = g_new0(CharProperty,1);
  46   initialize_property(&prop->common,pdesc,reason);
  47   prop->char_data = 0;
  48   return prop;
  49 }
  50
  51 static CharProperty *
  52 charprop_copy(CharProperty *src)
  53 {
  54   CharProperty *prop =
  55     (CharProperty *)src->common.ops->new_prop(src->common.descr,
  56                                                src->common.reason);
  57   copy_init_property(&prop->common,&src->common);
  58   prop->char_data = src->char_data;
  59   return prop;
  60 }
  61
  62 static WIDGET *
  63 charprop_get_widget(CharProperty *prop, PropDialog *dialog)
  64 {
  65   GtkWidget *ret = gtk_entry_new();
  66   prophandler_connect(&prop->common,GTK_OBJECT(ret),"changed");
  67   return ret;
  68 }
  69
  70 static void
  71 charprop_reset_widget(CharProperty *prop, WIDGET *widget)
  72 {
  73   gchar ch[7];
  74   int unilen = g_unichar_to_utf8 (prop->char_data, ch);
  75   ch[unilen] = 0;
  76   gtk_entry_set_text(GTK_ENTRY(widget), ch);
  77 }
  78
  79 static void
  80 charprop_set_from_widget(CharProperty *prop, WIDGET *widget)
  81 {
  82   gchar *buf = gtk_editable_get_chars(GTK_EDITABLE(widget), 0, 1);
  83   prop->char_data = g_utf8_get_char(buf);
  84   g_free(buf);
  85 }
  86
  87 static void
  88 charprop_load(CharProperty *prop, AttributeNode attr, DataNode data)
  89 {
  90   gchar *str = data_string(data);
  91
  92   if (str && str[0]) {
  93     prop->char_data = g_utf8_get_char(str);
  94     g_free(str);
  95   } else {
  96     g_warning("Could not read character data for attribute %s",
  97               prop->common.name);
  98   }
  99 }
 100
 101 static void
 102 charprop_save(CharProperty *prop, AttributeNode attr)
 103 {
 104   gchar utf[7];
 105   gint n = g_unichar_to_utf8 (prop->char_data, utf);
 106   utf[n] = 0;
 107   data_add_string (attr, utf);
 108 }
 109
 110 static void
 111 charprop_get_from_offset(CharProperty *prop,
 112                          void *base, guint offset, guint offset2)
 113 {
 114   prop->char_data = struct_member(base,offset,gunichar);
 115 }
 116
 117 static void
 118 charprop_set_from_offset(CharProperty *prop,
 119                          void *base, guint offset, guint offset2)
 120 {
 121   struct_member(base,offset,gunichar) = prop->char_data;
 122 }
 123
 124
 125 static const PropertyOps charprop_ops = {
 126   (PropertyType_New) charprop_new,
 127   (PropertyType_Free) noopprop_free,
 128   (PropertyType_Copy) charprop_copy,
 129   (PropertyType_Load) charprop_load,
 130   (PropertyType_Save) charprop_save,
 131   (PropertyType_GetWidget) charprop_get_widget,
 132   (PropertyType_ResetWidget) charprop_reset_widget,
 133   (PropertyType_SetFromWidget) charprop_set_from_widget,
 134
 135   (PropertyType_CanMerge) noopprop_can_merge,
 136   (PropertyType_GetFromOffset) charprop_get_from_offset,
 137   (PropertyType_SetFromOffset) charprop_set_from_offset
 138 };
 139
 140 /* ************************************ */
 141
 142
 143 /***************************/
 144 /* The BOOL property type. */
 145 /***************************/
 146
 147 static void
 148 bool_toggled(GtkWidget *wid)
 149 {
 150   if (GTK_TOGGLE_BUTTON(wid)->active)
 151     gtk_label_set_text(GTK_LABEL(GTK_BIN(wid)->child), _("Yes"));
 152   else
 153     gtk_label_set_text(GTK_LABEL(GTK_BIN(wid)->child), _("No"));
 154 }
 155
 156 static Property *
 157 boolprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
 158 {
 159   BoolProperty *prop = g_new0(BoolProperty,1);
 160   initialize_property(&prop->common, pdesc, reason);
 161   prop->bool_data = FALSE;
 162   return &prop->common;
 163 }
 164
 165 static BoolProperty *
 166 boolprop_copy(BoolProperty *src)
 167 {
 168   BoolProperty *prop =
 169     (BoolProperty *)src->common.ops->new_prop(src->common.descr,
 170                                                src->common.reason);
 171   copy_init_property(&prop->common,&src->common);
 172   prop->bool_data = src->bool_data;
 173   return prop;
 174 }
 175
 176 static WIDGET *
 177 boolprop_get_widget(BoolProperty *prop, PropDialog *dialog)
 178 {
 179   GtkWidget *ret = gtk_toggle_button_new_with_label(_("No"));
 180   gtk_signal_connect(GTK_OBJECT(ret), "toggled",
 181                      GTK_SIGNAL_FUNC(bool_toggled), NULL);
 182   prophandler_connect(&prop->common,GTK_OBJECT(ret),"toggled");
 183   return ret;
 184 }
 185
 186 static void
 187 boolprop_reset_widget(BoolProperty *prop, WIDGET *widget)
 188 {
 189   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),prop->bool_data);
 190 }
 191
 192 static void
 193 boolprop_set_from_widget(BoolProperty *prop, WIDGET *widget)
 194 {
 195   prop->bool_data = GTK_TOGGLE_BUTTON(widget)->active;
 196 }
 197
 198 static void
 199 boolprop_load(BoolProperty *prop, AttributeNode attr, DataNode data)
 200 {
 201   prop->bool_data = data_boolean(data);
 202 }
 203
 204 static void
 205 boolprop_save(BoolProperty *prop, AttributeNode attr)
 206 {
 207   data_add_boolean(attr, prop->bool_data);
 208 }
 209
 210 static void
 211 boolprop_get_from_offset(BoolProperty *prop,
 212                          void *base, guint offset, guint offset2)
 213 {
 214   prop->bool_data = struct_member(base,offset,gboolean);
 215 }
 216
 217 static void
 218 boolprop_set_from_offset(BoolProperty *prop,
 219                          void *base, guint offset, guint offset2)
 220 {
 221   struct_member(base,offset,gboolean) = prop->bool_data;
 222 }
 223
 224
 225 static const PropertyOps boolprop_ops = {
 226   (PropertyType_New) boolprop_new,
 227   (PropertyType_Free) noopprop_free,
 228   (PropertyType_Copy) boolprop_copy,
 229   (PropertyType_Load) boolprop_load,
 230   (PropertyType_Save) boolprop_save,
 231   (PropertyType_GetWidget) boolprop_get_widget,
 232   (PropertyType_ResetWidget) boolprop_reset_widget,
 233   (PropertyType_SetFromWidget) boolprop_set_from_widget,
 234
 235   (PropertyType_CanMerge) noopprop_can_merge,
 236   (PropertyType_GetFromOffset) boolprop_get_from_offset,
 237   (PropertyType_SetFromOffset) boolprop_set_from_offset
 238 };
 239
 240 /***************************/
 241 /* The INT property type.  */
 242 /***************************/
 243
 244 static IntProperty *
 245 intprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
 246 {
 247   IntProperty *prop = g_new0(IntProperty,1);
 248   initialize_property(&prop->common, pdesc, reason);
 249   prop->int_data = 0;
 250   return prop;
 251 }
 252
 253 static IntProperty *
 254 intprop_copy(IntProperty *src)
 255 {
 256   IntProperty *prop =
 257     (IntProperty *)src->common.ops->new_prop(src->common.descr,
 258                                               src->common.reason);
 259   copy_init_property(&prop->common,&src->common);
 260   prop->int_data = src->int_data;
 261   return prop;
 262 }
 263
 264 static WIDGET *
 265 intprop_get_widget(IntProperty *prop, PropDialog *dialog)
 266 {
 267   GtkAdjustment *adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->int_data,
 268                                                          G_MININT, G_MAXINT,
 269                                                          1.0, 10.0, 10.0));
 270   GtkWidget *ret = gtk_spin_button_new(adj, 1.0, 0);
 271   gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(ret),TRUE);
 272   prophandler_connect(&prop->common,GTK_OBJECT(adj),"value_changed");
 273
 274   return ret;
 275 }
 276
 277 static void
 278 intprop_reset_widget(IntProperty *prop, WIDGET *widget)
 279 {
 280   GtkAdjustment *adj;
 281   if (prop->common.extra_data) {
 282     PropNumData *numdata = prop->common.extra_data;
 283     adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->int_data,
 284                                             numdata->min, numdata->max,
 285                                             numdata->step, 10.0 * numdata->step,
 286                                             10.0 * numdata->step));
 287   } else {
 288     adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->int_data,
 289                                             G_MININT, G_MAXINT,
 290                                             1.0, 10.0, 10.0));
 291   }
 292   gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(widget), adj);
 293   gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(widget), TRUE);
 294 }
 295
 296 static void
 297 intprop_set_from_widget(IntProperty *prop, WIDGET *widget)
 298 {
 299   prop->int_data = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
 300 }
 301
 302 static void
 303 intprop_load(IntProperty *prop, AttributeNode attr, DataNode data)
 304 {
 305   prop->int_data = data_int(data);
 306 }
 307
 308 static void
 309 intprop_save(IntProperty *prop, AttributeNode attr)
 310 {
 311   data_add_int(attr, prop->int_data);
 312 }
 313
 314 static void
 315 intprop_get_from_offset(IntProperty *prop,
 316                         void *base, guint offset, guint offset2)
 317 {
 318   prop->int_data = struct_member(base,offset,gint);
 319 }
 320
 321 static void
 322 intprop_set_from_offset(IntProperty *prop,
 323                         void *base, guint offset, guint offset2)
 324 {
 325   struct_member(base,offset,gint) = prop->int_data;
 326 }
 327
 328 static const PropertyOps intprop_ops = {
 329   (PropertyType_New) intprop_new,
 330   (PropertyType_Free) noopprop_free,
 331   (PropertyType_Copy) intprop_copy,
 332   (PropertyType_Load) intprop_load,
 333   (PropertyType_Save) intprop_save,
 334   (PropertyType_GetWidget) intprop_get_widget,
 335   (PropertyType_ResetWidget) intprop_reset_widget,
 336   (PropertyType_SetFromWidget) intprop_set_from_widget,
 337
 338   (PropertyType_CanMerge) noopprop_can_merge,
 339   (PropertyType_GetFromOffset) intprop_get_from_offset,
 340   (PropertyType_SetFromOffset) intprop_set_from_offset
 341 };
 342
 343 /********************************/
 344 /* The INTARRAY property type.  */
 345 /********************************/
 346
 347 static IntarrayProperty *
 348 intarrayprop_new(const PropDescription *pdesc,
 349                  PropDescToPropPredicate reason)
 350 {
 351   IntarrayProperty *prop = g_new0(IntarrayProperty,1);
 352   initialize_property(&prop->common, pdesc, reason);
 353   prop->intarray_data = g_array_new(FALSE,TRUE,sizeof(gint));
 354   return prop;
 355 }
 356
 357 static void
 358 intarrayprop_free(IntarrayProperty *prop)
 359 {
 360   g_array_free(prop->intarray_data,TRUE);
 361   g_free(prop);
 362 }
 363
 364 static IntarrayProperty *
 365 intarrayprop_copy(IntarrayProperty *src)
 366 {
 367   guint i;
 368   IntarrayProperty *prop =
 369     (IntarrayProperty *)src->common.ops->new_prop(src->common.descr,
 370                                                    src->common.reason);
 371   copy_init_property(&prop->common,&src->common);
 372   g_array_set_size(prop->intarray_data,src->intarray_data->len);
 373   for (i = 0 ; i < src->intarray_data->len; i++)
 374     g_array_index(prop->intarray_data,gint,i) =
 375       g_array_index(src->intarray_data,gint,i);
 376   return prop;
 377 }
 378
 379 static void
 380 intarrayprop_load(IntarrayProperty *prop, AttributeNode attr, DataNode data)
 381 {
 382   guint nvals = attribute_num_data(attr);
 383   guint i;
 384   g_array_set_size(prop->intarray_data,nvals);
 385   for (i=0; (i < nvals) && data; i++, data = data_next(data))
 386     g_array_index(prop->intarray_data,gint,i) = data_int(data);
 387   if (i != nvals)
 388     g_warning("attribute_num_data() and actual data count mismatch "
 389               "(shouldn't happen)");
 390 }
 391
 392 static void
 393 intarrayprop_save(IntarrayProperty *prop, AttributeNode attr)
 394 {
 395   guint i;
 396   for (i = 0; i < prop->intarray_data->len; i++)
 397     data_add_int(attr, g_array_index(prop->intarray_data,gint,i));
 398 }
 399
 400 static void
 401 intarrayprop_get_from_offset(IntarrayProperty *prop,
 402                              void *base, guint offset, guint offset2)
 403 {
 404   guint nvals = struct_member(base,offset2,guint);
 405   guint i;
 406   void *ofs_val = struct_member(base,offset,void *);
 407   g_array_set_size(prop->intarray_data,nvals);
 408   for (i = 0; i < nvals; i++)
 409     g_array_index(prop->intarray_data,gint,i) =
 410       struct_member(ofs_val,i * sizeof(gint),gint);
 411 }
 412
 413 static void
 414 intarrayprop_set_from_offset(IntarrayProperty *prop,
 415                              void *base, guint offset, guint offset2)
 416 {
 417   guint nvals = prop->intarray_data->len;
 418   gint *vals = g_memdup(&g_array_index(prop->intarray_data,gint,0),
 419                         sizeof(gint) * nvals);
 420   g_free(struct_member(base,offset,gint *));
 421   struct_member(base,offset,gint *) = vals;
 422   struct_member(base,offset2,guint) = nvals;
 423 }
 424
 425 static const PropertyOps intarrayprop_ops = {
 426   (PropertyType_New) intarrayprop_new,
 427   (PropertyType_Free) intarrayprop_free,
 428   (PropertyType_Copy) intarrayprop_copy,
 429   (PropertyType_Load) intarrayprop_load,
 430   (PropertyType_Save) intarrayprop_save,
 431   (PropertyType_GetWidget) noopprop_get_widget,
 432   (PropertyType_ResetWidget) noopprop_reset_widget,
 433   (PropertyType_SetFromWidget) noopprop_set_from_widget,
 434
 435   (PropertyType_CanMerge) noopprop_can_merge,
 436   (PropertyType_GetFromOffset) intarrayprop_get_from_offset,
 437   (PropertyType_SetFromOffset) intarrayprop_set_from_offset
 438 };
 439
 440 /***************************/
 441 /* The ENUM property type.  */
 442 /***************************/
 443
 444 static EnumProperty *
 445 enumprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
 446 {
 447   EnumProperty *prop = g_new0(EnumProperty,1);
 448   initialize_property(&prop->common, pdesc, reason);
 449   prop->enum_data = 0;
 450   return prop;
 451 }
 452
 453 static EnumProperty *
 454 enumprop_copy(EnumProperty *src)
 455 {
 456   EnumProperty *prop =
 457     (EnumProperty *)src->common.ops->new_prop(src->common.descr,
 458                                                src->common.reason);
 459   copy_init_property(&prop->common,&src->common);
 460   prop->enum_data = src->enum_data;
 461   return prop;
 462 }
 463
 464 static WIDGET *
 465 enumprop_get_widget(EnumProperty *prop, PropDialog *dialog)
 466 {
 467   GtkWidget *ret;
 468
 469   if (prop->common.extra_data) {
 470     PropEnumData *enumdata = prop->common.extra_data;
 471     GtkWidget *menu;
 472     guint i;
 473
 474     ret = gtk_option_menu_new();
 475     menu = gtk_menu_new();
 476     for (i = 0; enumdata[i].name != NULL; i++) {
 477       GtkWidget *item = gtk_menu_item_new_with_label(_(enumdata[i].name));
 478
 479       gtk_object_set_user_data(GTK_OBJECT(item),
 480                                GUINT_TO_POINTER(enumdata[i].enumv));
 481       gtk_container_add(GTK_CONTAINER(menu), item);
 482       gtk_widget_show(item);
 483       prophandler_connect(&prop->common,GTK_OBJECT(item),"activate");
 484     }
 485     gtk_option_menu_set_menu(GTK_OPTION_MENU(ret), menu);
 486   } else {
 487     ret = gtk_entry_new(); /* should use spin button/option menu */
 488   }
 489   return ret;
 490 }
 491
 492 static void
 493 enumprop_reset_widget(EnumProperty *prop, WIDGET *widget)
 494 {
 495   if (prop->common.extra_data) {
 496     PropEnumData *enumdata = prop->common.extra_data;
 497     guint i, pos = 0;
 498
 499     for (i = 0; enumdata[i].name != NULL; i++) {
 500       if (enumdata[i].enumv == prop->enum_data) {
 501         pos = i;
 502         break;
 503         }
 504     }
 505     gtk_option_menu_set_history(GTK_OPTION_MENU(widget), pos);
 506   } else {
 507     char buf[16];
 508     g_snprintf(buf, sizeof(buf), "%d", prop->enum_data);
 509     gtk_entry_set_text(GTK_ENTRY(widget), buf);
 510   }
 511 }
 512
 513 static void
 514 enumprop_set_from_widget(EnumProperty *prop, WIDGET *widget)
 515 {
 516   if (GTK_IS_OPTION_MENU(widget)) {
 517    prop->enum_data=
 518      GPOINTER_TO_UINT(gtk_object_get_user_data(
 519            GTK_OBJECT(GTK_OPTION_MENU(widget)->menu_item)));
 520   } else {
 521     prop->enum_data = strtol(gtk_entry_get_text(GTK_ENTRY(widget)),
 522                                     NULL, 0);
 523   }
 524 }
 525
 526 static void
 527 enumprop_load(EnumProperty *prop, AttributeNode attr, DataNode data)
 528 {
 529   prop->enum_data = data_enum(data);
 530 }
 531
 532 static void
 533 enumprop_save(EnumProperty *prop, AttributeNode attr)
 534 {
 535   data_add_enum(attr, prop->enum_data);
 536 }
 537
 538 static void
 539 enumprop_get_from_offset(EnumProperty *prop,
 540                          void *base, guint offset, guint offset2)
 541 {
 542   prop->enum_data = struct_member(base,offset,gint);
 543 }
 544
 545 static void
 546 enumprop_set_from_offset(EnumProperty *prop,
 547                          void *base, guint offset, guint offset2)
 548 {
 549   struct_member(base,offset,gint) = prop->enum_data;
 550 }
 551
 552 static const PropertyOps enumprop_ops = {
 553   (PropertyType_New) enumprop_new,
 554   (PropertyType_Free) noopprop_free,
 555   (PropertyType_Copy) enumprop_copy,
 556   (PropertyType_Load) enumprop_load,
 557   (PropertyType_Save) enumprop_save,
 558   (PropertyType_GetWidget) enumprop_get_widget,
 559   (PropertyType_ResetWidget) enumprop_reset_widget,
 560   (PropertyType_SetFromWidget) enumprop_set_from_widget,
 561
 562   (PropertyType_CanMerge) noopprop_can_merge,
 563   (PropertyType_GetFromOffset) enumprop_get_from_offset,
 564   (PropertyType_SetFromOffset) enumprop_set_from_offset
 565 };
 566
 567 /********************************/
 568 /* The ENUMARRAY property type.  */
 569 /********************************/
 570
 571 static EnumarrayProperty *
 572 enumarrayprop_new(const PropDescription *pdesc,
 573                   PropDescToPropPredicate reason)
 574 {
 575   EnumarrayProperty *prop = g_new0(EnumarrayProperty,1);
 576   initialize_property(&prop->common, pdesc, reason);
 577   prop->enumarray_data = g_array_new(FALSE,TRUE,sizeof(gint));
 578   return prop;
 579 }
 580
 581 static void
 582 enumarrayprop_free(EnumarrayProperty *prop)
 583 {
 584   g_array_free(prop->enumarray_data,TRUE);
 585   g_free(prop);
 586 }
 587
 588 static EnumarrayProperty *
 589 enumarrayprop_copy(EnumarrayProperty *src)
 590 {
 591   guint i;
 592   EnumarrayProperty *prop =
 593     (EnumarrayProperty *)src->common.ops->new_prop(src->common.descr,
 594                                                     src->common.reason);
 595   copy_init_property(&prop->common,&src->common);
 596   g_array_set_size(prop->enumarray_data,src->enumarray_data->len);
 597   for (i = 0 ; i < src->enumarray_data->len; i++)
 598     g_array_index(prop->enumarray_data,gint,i) =
 599       g_array_index(src->enumarray_data,gint,i);
 600   return prop;
 601 }
 602
 603 static void
 604 enumarrayprop_load(EnumarrayProperty *prop, AttributeNode attr, DataNode data)
 605 {
 606   guint nvals = attribute_num_data(attr);
 607   guint i;
 608   g_array_set_size(prop->enumarray_data,nvals);
 609
 610   for (i=0; (i < nvals) && data; i++, data = data_next(data))
 611     g_array_index(prop->enumarray_data,gint,i) = data_enum(data);
 612   if (i != nvals)
 613     g_warning("attribute_num_data() and actual data count mismatch "
 614               "(shouldn't happen)");
 615 }
 616
 617 static void
 618 enumarrayprop_save(EnumarrayProperty *prop, AttributeNode attr)
 619 {
 620   guint i;
 621   for (i = 0; i < prop->enumarray_data->len; i++)
 622     data_add_enum(attr, g_array_index(prop->enumarray_data,gint,i));
 623 }
 624
 625 static void
 626 enumarrayprop_get_from_offset(EnumarrayProperty *prop,
 627                               void *base, guint offset, guint offset2)
 628 {
 629   guint nvals = struct_member(base,offset2,guint);
 630   guint i;
 631   void *ofs_val = struct_member(base,offset,void *);
 632   g_array_set_size(prop->enumarray_data,nvals);
 633   for (i = 0; i < nvals; i++)
 634     g_array_index(prop->enumarray_data,gint,i) =
 635       struct_member(ofs_val,i * sizeof(gint),gint);
 636 }
 637
 638 static void
 639 enumarrayprop_set_from_offset(EnumarrayProperty *prop,
 640                               void *base, guint offset, guint offset2)
 641 {
 642   guint nvals = prop->enumarray_data->len;
 643   gint *vals = g_memdup(&g_array_index(prop->enumarray_data,gint,0),
 644                         sizeof(gint) * nvals);
 645   g_free(struct_member(base,offset,gint *));
 646   struct_member(base,offset,gint *) = vals;
 647   struct_member(base,offset2,guint) = nvals;
 648 }
 649
 650 static const PropertyOps enumarrayprop_ops = {
 651   (PropertyType_New) enumarrayprop_new,
 652   (PropertyType_Free) enumarrayprop_free,
 653   (PropertyType_Copy) enumarrayprop_copy,
 654   (PropertyType_Load) enumarrayprop_load,
 655   (PropertyType_Save) enumarrayprop_save,
 656   (PropertyType_GetWidget) noopprop_get_widget,
 657   (PropertyType_ResetWidget) noopprop_reset_widget,
 658   (PropertyType_SetFromWidget) noopprop_set_from_widget,
 659
 660   (PropertyType_CanMerge) noopprop_can_merge,
 661   (PropertyType_GetFromOffset) enumarrayprop_get_from_offset,
 662   (PropertyType_SetFromOffset) enumarrayprop_set_from_offset
 663 };
 664
 665 /* ************************************************************** */
 666
 667 void
 668 prop_inttypes_register(void)
 669 {
 670   prop_type_register(PROP_TYPE_CHAR,&charprop_ops);
 671   prop_type_register(PROP_TYPE_BOOL,&boolprop_ops);
 672   prop_type_register(PROP_TYPE_INT,&intprop_ops);
 673   prop_type_register(PROP_TYPE_INTARRAY,&intarrayprop_ops);
 674   prop_type_register(PROP_TYPE_ENUM,&enumprop_ops);
 675   prop_type_register(PROP_TYPE_ENUMARRAY,&enumarrayprop_ops);
 676 }