lib/prop_geomtypes.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 "geometric" types (real, points, rectangles, etc.)
  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 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <string.h>
  30
  31 #include <gtk/gtk.h>
  32 #define WIDGET GtkWidget
  33 #include "widgets.h"
  34 #include "properties.h"
  35 #include "propinternals.h"
  36 #include "geometry.h"
  37 #include "connpoint_line.h"
  38 #include "prop_geomtypes.h"
  39
  40 static void fontsizeprop_reset_widget(FontsizeProperty *prop, WIDGET *widget);
  41
  42 /****************************/
  43 /* The REAL property type.  */
  44 /****************************/
  45
  46 static RealProperty *
  47 realprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
  48 {
  49   RealProperty *prop = g_new0(RealProperty,1);
  50   initialize_property(&prop->common, pdesc, reason);
  51   prop->real_data = 0.0;
  52   return prop;
  53 }
  54
  55 static RealProperty *
  56 realprop_copy(RealProperty *src)
  57 {
  58   RealProperty *prop =
  59     (RealProperty *)src->common.ops->new_prop(src->common.descr,
  60                                                src->common.reason);
  61   copy_init_property(&prop->common,&src->common);
  62   prop->real_data = src->real_data;
  63   return prop;
  64 }
  65
  66 static WIDGET *
  67 realprop_get_widget(RealProperty *prop, PropDialog *dialog)
  68 {
  69   GtkAdjustment *adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->real_data,
  70                                                          G_MINFLOAT,
  71                                                          G_MAXFLOAT,
  72                                                          0.1, 1.0, 1.0));
  73   GtkWidget *ret = gtk_spin_button_new(adj, 1.0, 2);
  74   gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(ret),TRUE);
  75   prophandler_connect(&prop->common,GTK_OBJECT(adj),"value_changed");
  76
  77   return ret;
  78 }
  79
  80 static void
  81 realprop_reset_widget(RealProperty *prop, WIDGET *widget)
  82 {
  83   GtkAdjustment *adj;
  84   if (prop->common.extra_data) {
  85     PropNumData *numdata = prop->common.extra_data;
  86     adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->real_data,
  87                                             numdata->min, numdata->max,
  88                                             numdata->step,
  89                                             10.0 * numdata->step,
  90                                             10.0 * numdata->step));
  91   } else {
  92     adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->real_data,
  93                                             G_MINFLOAT, G_MAXFLOAT,
  94                                             0.1, 1.0, 1.0));
  95   }
  96   gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(widget), adj);
  97 }
  98
  99 static void
 100 realprop_set_from_widget(RealProperty *prop, WIDGET *widget)
 101 {
 102   prop->real_data = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
 103 }
 104
 105 static void
 106 realprop_load(RealProperty *prop, AttributeNode attr, DataNode data)
 107 {
 108   prop->real_data = data_real(data);
 109 }
 110
 111 static void
 112 realprop_save(RealProperty *prop, AttributeNode attr)
 113 {
 114   data_add_real(attr, prop->real_data);
 115 }
 116
 117 static void
 118 realprop_get_from_offset(RealProperty *prop,
 119                          void *base, guint offset, guint offset2)
 120 {
 121   prop->real_data = struct_member(base,offset,real);
 122 }
 123
 124 static void
 125 realprop_set_from_offset(RealProperty *prop,
 126                          void *base, guint offset, guint offset2)
 127 {
 128   struct_member(base,offset,real) = prop->real_data;
 129 }
 130
 131 static int
 132 realprop_get_data_size(RealProperty *prop)
 133 {
 134   return sizeof (prop->real_data);
 135 }
 136
 137 static const PropertyOps realprop_ops = {
 138   (PropertyType_New) realprop_new,
 139   (PropertyType_Free) noopprop_free,
 140   (PropertyType_Copy) realprop_copy,
 141   (PropertyType_Load) realprop_load,
 142   (PropertyType_Save) realprop_save,
 143   (PropertyType_GetWidget) realprop_get_widget,
 144   (PropertyType_ResetWidget) realprop_reset_widget,
 145   (PropertyType_SetFromWidget) realprop_set_from_widget,
 146
 147   (PropertyType_CanMerge) noopprop_can_merge,
 148   (PropertyType_GetFromOffset) realprop_get_from_offset,
 149   (PropertyType_SetFromOffset) realprop_set_from_offset,
 150   (PropertyType_GetDataSize) realprop_get_data_size
 151 };
 152
 153 /****************************/
 154 /* The LENGTH property type.  */
 155 /****************************/
 156
 157 static LengthProperty *
 158 lengthprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
 159 {
 160   LengthProperty *prop = g_new0(LengthProperty,1);
 161   initialize_property(&prop->common, pdesc, reason);
 162   prop->length_data = 0.0;
 163   return prop;
 164 }
 165
 166 static LengthProperty *
 167 lengthprop_copy(LengthProperty *src)
 168 {
 169   LengthProperty *prop =
 170     (LengthProperty *)src->common.ops->new_prop(src->common.descr,
 171                                                src->common.reason);
 172   copy_init_property(&prop->common,&src->common);
 173   prop->length_data = src->length_data;
 174   return prop;
 175 }
 176
 177 static WIDGET *
 178 lengthprop_get_widget(LengthProperty *prop, PropDialog *dialog)
 179 {
 180   GtkAdjustment *adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->length_data,
 181                                                          G_MINFLOAT,
 182                                                          G_MAXFLOAT,
 183                                                          0.1, 1.0, 1.0));
 184   GtkWidget *ret = dia_unit_spinner_new(adj, 2, DIA_UNIT_MILLIMETER);
 185   /*  gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(ret),TRUE);*/
 186   prophandler_connect(&prop->common,GTK_OBJECT(adj),"value_changed");
 187
 188   return ret;
 189 }
 190
 191 static void
 192 lengthprop_reset_widget(LengthProperty *prop, WIDGET *widget)
 193 {
 194   /*
 195   GtkAdjustment *adj;
 196   if (prop->common.extra_data) {
 197     PropNumData *numdata = prop->common.extra_data;
 198     adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->length_data,
 199                                             numdata->min, numdata->max,
 200                                             numdata->step,
 201                                             10.0 * numdata->step,
 202                                             10.0 * numdata->step));
 203   } else {
 204     adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->length_data,
 205                                             G_MINFLOAT, G_MAXFLOAT,
 206                                             0.1, 1.0, 1.0));
 207   }
 208   dia_unit_spinner_set_adjustment(GTK_SPIN_BUTTON(widget), adj);
 209   */
 210   dia_unit_spinner_set_value(DIA_UNIT_SPINNER(widget), prop->length_data);
 211 }
 212
 213 static void
 214 lengthprop_set_from_widget(LengthProperty *prop, WIDGET *widget)
 215 {
 216   prop->length_data = dia_unit_spinner_get_value((DiaUnitSpinner *)
 217                                                  GTK_SPIN_BUTTON(widget));
 218 }
 219
 220 static void
 221 lengthprop_load(LengthProperty *prop, AttributeNode attr, DataNode data)
 222 {
 223   prop->length_data = data_real(data);
 224 }
 225
 226 static void
 227 lengthprop_save(LengthProperty *prop, AttributeNode attr)
 228 {
 229   data_add_real(attr, prop->length_data);
 230 }
 231
 232 static void
 233 lengthprop_get_from_offset(LengthProperty *prop,
 234                          void *base, guint offset, guint offset2)
 235 {
 236   prop->length_data = struct_member(base,offset,real);
 237 }
 238
 239 static void
 240 lengthprop_set_from_offset(LengthProperty *prop,
 241                          void *base, guint offset, guint offset2)
 242 {
 243   struct_member(base,offset,real) = prop->length_data;
 244 }
 245
 246 static int
 247 lengthprop_get_data_size(LengthProperty *prop)
 248 {
 249   return sizeof (prop->length_data);
 250 }
 251
 252 static const PropertyOps lengthprop_ops = {
 253   (PropertyType_New) lengthprop_new,
 254   (PropertyType_Free) noopprop_free,
 255   (PropertyType_Copy) lengthprop_copy,
 256   (PropertyType_Load) lengthprop_load,
 257   (PropertyType_Save) lengthprop_save,
 258   (PropertyType_GetWidget) lengthprop_get_widget,
 259   (PropertyType_ResetWidget) lengthprop_reset_widget,
 260   (PropertyType_SetFromWidget) lengthprop_set_from_widget,
 261
 262   (PropertyType_CanMerge) noopprop_can_merge,
 263   (PropertyType_GetFromOffset) lengthprop_get_from_offset,
 264   (PropertyType_SetFromOffset) lengthprop_set_from_offset,
 265   (PropertyType_GetDataSize) lengthprop_get_data_size
 266 };
 267
 268 /****************************/
 269 /* The FONTSIZE property type.  */
 270 /****************************/
 271
 272 static FontsizeProperty *
 273 fontsizeprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
 274 {
 275   FontsizeProperty *prop = g_new0(FontsizeProperty,1);
 276   initialize_property(&prop->common, pdesc, reason);
 277   prop->fontsize_data = 0.0;
 278   return prop;
 279 }
 280
 281 static FontsizeProperty *
 282 fontsizeprop_copy(FontsizeProperty *src)
 283 {
 284   FontsizeProperty *prop =
 285     (FontsizeProperty *)src->common.ops->new_prop(src->common.descr,
 286                                                src->common.reason);
 287   copy_init_property(&prop->common,&src->common);
 288   prop->fontsize_data = src->fontsize_data;
 289   return prop;
 290 }
 291
 292 static WIDGET *
 293 fontsizeprop_get_widget(FontsizeProperty *prop, PropDialog *dialog)
 294 {
 295   GtkAdjustment *adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->fontsize_data,
 296                                                          G_MINFLOAT,
 297                                                          G_MAXFLOAT,
 298                                                          0.1, 1.0, 1.0));
 299   GtkWidget *ret = dia_unit_spinner_new(adj, 2, DIA_UNIT_POINT);
 300   /*  gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(ret),TRUE);*/
 301   prophandler_connect(&prop->common,GTK_OBJECT(adj),"value_changed");
 302   fontsizeprop_reset_widget(prop, ret);
 303   return ret;
 304 }
 305
 306 static void
 307 fontsizeprop_reset_widget(FontsizeProperty *prop, WIDGET *widget)
 308 {
 309   /*
 310   GtkAdjustment *adj;
 311   if (prop->common.extra_data) {
 312     PropNumData *numdata = prop->common.extra_data;
 313     adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->fontsize_data,
 314                                             numdata->min, numdata->max,
 315                                             numdata->step,
 316                                             10.0 * numdata->step,
 317                                             10.0 * numdata->step));
 318   } else {
 319     adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->fontsize_data,
 320                                             G_MINFLOAT, G_MAXFLOAT,
 321                                             0.1, 1.0, 1.0));
 322   }
 323   gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(widget), adj);
 324   */
 325   printf("Resetting\n");
 326   dia_unit_spinner_set_value(DIA_UNIT_SPINNER(widget), prop->fontsize_data);
 327 }
 328
 329 static void
 330 fontsizeprop_set_from_widget(FontsizeProperty *prop, WIDGET *widget)
 331 {
 332   printf("Setting\n");
 333   prop->fontsize_data = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(widget));
 334 }
 335
 336 static void
 337 fontsizeprop_load(FontsizeProperty *prop, AttributeNode attr, DataNode data)
 338 {
 339   prop->fontsize_data = data_real(data);
 340 }
 341
 342 static void
 343 fontsizeprop_save(FontsizeProperty *prop, AttributeNode attr)
 344 {
 345   data_add_real(attr, prop->fontsize_data);
 346 }
 347
 348 static void
 349 fontsizeprop_get_from_offset(FontsizeProperty *prop,
 350                          void *base, guint offset, guint offset2)
 351 {
 352   prop->fontsize_data = struct_member(base,offset,real);
 353 }
 354
 355 static void
 356 fontsizeprop_set_from_offset(FontsizeProperty *prop,
 357                          void *base, guint offset, guint offset2)
 358 {
 359   struct_member(base,offset,real) = prop->fontsize_data;
 360 }
 361
 362 static int
 363 fontsizeprop_get_data_size(FontsizeProperty *prop)
 364 {
 365   return sizeof (prop->fontsize_data);
 366 }
 367
 368 static const PropertyOps fontsizeprop_ops = {
 369   (PropertyType_New) fontsizeprop_new,
 370   (PropertyType_Free) noopprop_free,
 371   (PropertyType_Copy) fontsizeprop_copy,
 372   (PropertyType_Load) fontsizeprop_load,
 373   (PropertyType_Save) fontsizeprop_save,
 374   (PropertyType_GetWidget) fontsizeprop_get_widget,
 375   (PropertyType_ResetWidget) fontsizeprop_reset_widget,
 376   (PropertyType_SetFromWidget) fontsizeprop_set_from_widget,
 377
 378   (PropertyType_CanMerge) noopprop_can_merge,
 379   (PropertyType_GetFromOffset) fontsizeprop_get_from_offset,
 380   (PropertyType_SetFromOffset) fontsizeprop_set_from_offset,
 381   (PropertyType_GetDataSize) fontsizeprop_get_data_size
 382 };
 383
 384 /*****************************/
 385 /* The POINT property type.  */
 386 /*****************************/
 387
 388 static PointProperty *
 389 pointprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
 390 {
 391   PointProperty *prop = g_new0(PointProperty,1);
 392   initialize_property(&prop->common, pdesc, reason);
 393   prop->point_data.x = 0.0;
 394   prop->point_data.y = 0.0;
 395   return prop;
 396 }
 397
 398 static PointProperty *
 399 pointprop_copy(PointProperty *src)
 400 {
 401   PointProperty *prop =
 402     (PointProperty *)src->common.ops->new_prop(src->common.descr,
 403                                                 src->common.reason);
 404   copy_init_property(&prop->common,&src->common);
 405   prop->point_data = src->point_data;
 406   return prop;
 407 }
 408
 409 static void
 410 pointprop_load(PointProperty *prop, AttributeNode attr, DataNode data)
 411 {
 412   data_point(data,&prop->point_data);
 413 }
 414
 415 static void
 416 pointprop_save(PointProperty *prop, AttributeNode attr)
 417 {
 418   data_add_point(attr, &prop->point_data);
 419 }
 420
 421 static void
 422 pointprop_get_from_offset(PointProperty *prop,
 423                           void *base, guint offset, guint offset2)
 424 {
 425   prop->point_data = struct_member(base,offset,Point);
 426 }
 427
 428 static void
 429 pointprop_set_from_offset(PointProperty *prop,
 430                           void *base, guint offset, guint offset2)
 431 {
 432   struct_member(base,offset,Point) = prop->point_data;
 433 }
 434
 435 static const PropertyOps pointprop_ops = {
 436   (PropertyType_New) pointprop_new,
 437   (PropertyType_Free) noopprop_free,
 438   (PropertyType_Copy) pointprop_copy,
 439   (PropertyType_Load) pointprop_load,
 440   (PropertyType_Save) pointprop_save,
 441   (PropertyType_GetWidget) invalidprop_get_widget,
 442   (PropertyType_ResetWidget) invalidprop_reset_widget,
 443   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 444
 445   (PropertyType_CanMerge) noopprop_can_merge,
 446   (PropertyType_GetFromOffset) pointprop_get_from_offset,
 447   (PropertyType_SetFromOffset) pointprop_set_from_offset
 448 };
 449
 450 /********************************/
 451 /* The POINTARRAY property type.  */
 452 /********************************/
 453
 454 static PointarrayProperty *
 455 pointarrayprop_new(const PropDescription *pdesc,
 456                    PropDescToPropPredicate reason)
 457 {
 458   PointarrayProperty *prop = g_new0(PointarrayProperty,1);
 459   initialize_property(&prop->common,pdesc,reason);
 460   prop->pointarray_data = g_array_new(FALSE,TRUE,sizeof(Point));
 461   return prop;
 462 }
 463
 464 static void
 465 pointarrayprop_free(PointarrayProperty *prop)
 466 {
 467   g_array_free(prop->pointarray_data,TRUE);
 468   g_free(prop);
 469 }
 470
 471 static PointarrayProperty *
 472 pointarrayprop_copy(PointarrayProperty *src)
 473 {
 474   guint i;
 475   PointarrayProperty *prop =
 476     (PointarrayProperty *)src->common.ops->new_prop(src->common.descr,
 477                                                      src->common.reason);
 478   copy_init_property(&prop->common,&src->common);
 479   g_array_set_size(prop->pointarray_data,src->pointarray_data->len);
 480   for (i = 0 ; i < src->pointarray_data->len; i++)
 481     g_array_index(prop->pointarray_data,Point,i) =
 482       g_array_index(src->pointarray_data,Point,i);
 483   return prop;
 484 }
 485
 486 static void
 487 pointarrayprop_load(PointarrayProperty *prop, AttributeNode attr, DataNode data)
 488 {
 489   guint nvals = attribute_num_data(attr);
 490   guint i;
 491   g_array_set_size(prop->pointarray_data,nvals);
 492   for (i=0; (i < nvals) && data; i++, data = data_next(data))
 493     data_point(data,&g_array_index(prop->pointarray_data,Point,i));
 494   if (i != nvals)
 495     g_warning("attribute_num_data() and actual data count mismatch "
 496               "(shouldn't happen)");
 497 }
 498
 499 static void
 500 pointarrayprop_save(PointarrayProperty *prop, AttributeNode attr)
 501 {
 502   guint i;
 503   for (i = 0; i < prop->pointarray_data->len; i++)
 504     data_add_point(attr, &g_array_index(prop->pointarray_data,Point,i));
 505 }
 506
 507 static void
 508 pointarrayprop_get_from_offset(PointarrayProperty *prop,
 509                                void *base, guint offset, guint offset2)
 510 {
 511   guint nvals = struct_member(base,offset2,guint);
 512   guint i;
 513   void *ofs_val = struct_member(base,offset,void *);
 514   g_array_set_size(prop->pointarray_data,nvals);
 515   for (i = 0; i < nvals; i++)
 516     g_array_index(prop->pointarray_data,Point,i) =
 517       struct_member(ofs_val,i * sizeof(Point),Point);
 518 }
 519
 520 static void
 521 pointarrayprop_set_from_offset(PointarrayProperty *prop,
 522                                void *base, guint offset, guint offset2)
 523 {
 524   guint nvals = prop->pointarray_data->len;
 525   Point *vals = g_memdup(&g_array_index(prop->pointarray_data,Point,0),
 526                          sizeof(Point) * nvals);
 527   g_free(struct_member(base,offset,Point *));
 528   struct_member(base,offset,Point *) = vals;
 529   struct_member(base,offset2,guint) = nvals;
 530 }
 531
 532 static const PropertyOps pointarrayprop_ops = {
 533   (PropertyType_New) pointarrayprop_new,
 534   (PropertyType_Free) pointarrayprop_free,
 535   (PropertyType_Copy) pointarrayprop_copy,
 536   (PropertyType_Load) pointarrayprop_load,
 537   (PropertyType_Save) pointarrayprop_save,
 538   (PropertyType_GetWidget) invalidprop_get_widget,
 539   (PropertyType_ResetWidget) invalidprop_reset_widget,
 540   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 541
 542   (PropertyType_CanMerge) noopprop_can_merge,
 543   (PropertyType_GetFromOffset) pointarrayprop_get_from_offset,
 544   (PropertyType_SetFromOffset) pointarrayprop_set_from_offset
 545 };
 546
 547
 548 /********************************/
 549 /* The BEZPOINT property type.  */
 550 /********************************/
 551
 552 static BezPointProperty *
 553 bezpointprop_new(const PropDescription *pdesc,
 554                  PropDescToPropPredicate reason)
 555 {
 556   BezPointProperty *prop = g_new0(BezPointProperty,1);
 557   initialize_property(&prop->common,pdesc,reason);
 558   memset(&prop->bezpoint_data,0,sizeof(prop->bezpoint_data));
 559   return prop;
 560 }
 561
 562 static BezPointProperty *
 563 bezpointprop_copy(BezPointProperty *src)
 564 {
 565   BezPointProperty *prop =
 566     (BezPointProperty *)src->common.ops->new_prop(src->common.descr,
 567                                                    src->common.reason);
 568   copy_init_property(&prop->common,&src->common);
 569   prop->bezpoint_data = src->bezpoint_data;
 570   return prop;
 571 }
 572
 573 static void
 574 bezpointprop_load(BezPointProperty *prop, AttributeNode attr, DataNode data)
 575 {
 576 #if 0
 577   data_bezpoint(data,&prop->bezpoint_data);
 578 #else
 579   g_error("BezPoint_load() not implemented. Missing data_bezpoint().");
 580 #endif
 581 }
 582
 583 static void
 584 bezpointprop_save(BezPointProperty *prop, AttributeNode attr)
 585 {
 586 #if 0
 587   data_add_bezpoint(attr, &prop->bezpoint_data);
 588 #else
 589   g_error("BezPoint_save() not implemented. Missing data_bezpoint().");
 590 #endif
 591 }
 592
 593 static void
 594 bezpointprop_get_from_offset(BezPointProperty *prop,
 595                              void *base, guint offset, guint offset2)
 596 {
 597   prop->bezpoint_data = struct_member(base,offset,BezPoint);
 598 }
 599
 600 static void
 601 bezpointprop_set_from_offset(BezPointProperty *prop,
 602                              void *base, guint offset, guint offset2)
 603 {
 604   struct_member(base,offset,BezPoint) = prop->bezpoint_data;
 605 }
 606
 607 static const PropertyOps bezpointprop_ops = {
 608   (PropertyType_New) bezpointprop_new,
 609   (PropertyType_Free) noopprop_free,
 610   (PropertyType_Copy) bezpointprop_copy,
 611   (PropertyType_Load) bezpointprop_load,
 612   (PropertyType_Save) bezpointprop_save,
 613   (PropertyType_GetWidget) invalidprop_get_widget,
 614   (PropertyType_ResetWidget) invalidprop_reset_widget,
 615   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 616
 617   (PropertyType_CanMerge) noopprop_can_merge,
 618   (PropertyType_GetFromOffset) bezpointprop_get_from_offset,
 619   (PropertyType_SetFromOffset) bezpointprop_set_from_offset
 620 };
 621
 622 /*************************************/
 623 /* The BEZPOINTARRAY property type.  */
 624 /*************************************/
 625
 626 static BezPointarrayProperty *
 627 bezpointarrayprop_new(const PropDescription *pdesc,
 628                       PropDescToPropPredicate reason)
 629 {
 630   BezPointarrayProperty *prop = g_new0(BezPointarrayProperty,1);
 631   initialize_property(&prop->common,pdesc,reason);
 632   prop->bezpointarray_data = g_array_new(FALSE,TRUE,sizeof(BezPoint));
 633   return prop;
 634 }
 635
 636 static void
 637 bezpointarrayprop_free(BezPointarrayProperty *prop)
 638 {
 639   g_array_free(prop->bezpointarray_data,TRUE);
 640   g_free(prop);
 641 }
 642
 643 static BezPointarrayProperty *
 644 bezpointarrayprop_copy(BezPointarrayProperty *src)
 645 {
 646   guint i;
 647   BezPointarrayProperty *prop =
 648     (BezPointarrayProperty *)src->common.ops->new_prop(src->common.descr,
 649                                                         src->common.reason);
 650   copy_init_property(&prop->common,&src->common);
 651   g_array_set_size(prop->bezpointarray_data,src->bezpointarray_data->len);
 652   for (i = 0 ; i < src->bezpointarray_data->len; i++)
 653     g_array_index(prop->bezpointarray_data,BezPoint,i) =
 654       g_array_index(src->bezpointarray_data,BezPoint,i);
 655   return prop;
 656 }
 657
 658 static void
 659 bezpointarrayprop_load(BezPointarrayProperty *prop,
 660                        AttributeNode attr, DataNode data)
 661 {
 662 #if 0
 663   guint nvals = attribute_num_data(attr);
 664   guint i;
 665
 666   g_array_set_size(prop->bezpointarray_data,nvals);
 667
 668   for (i=0; (i < nvals) && data; i++, data = data_next(data))
 669     data_bezpoint(data,&g_array_index(prop->bezpointarray_data,BezPoint,i));
 670   if (i != nvals)
 671     g_warning("attribute_num_data() and actual data count mismatch "
 672               "(shouldn't happen)");
 673 #else
 674   g_error("BezPointArray_load() not implemented. Missing data_bezpoint().");
 675 #endif
 676 }
 677
 678 static void
 679 bezpointarrayprop_save(BezPointarrayProperty *prop, AttributeNode attr)
 680 {
 681 #if 0
 682   guint i;
 683   for (i = 0; i < prop->bezpointarray_data->len; i++)
 684     data_add_bezpoint(attr,
 685                       &g_array_index(prop->bezpointarray_data,BezPoint,i));
 686 #else
 687   g_error("BezPointArray_load() not implemented. Missing data_bezpoint().");
 688 #endif
 689 }
 690
 691 static void
 692 bezpointarrayprop_get_from_offset(BezPointarrayProperty *prop,
 693                                   void *base, guint offset, guint offset2)
 694 {
 695   guint nvals = struct_member(base,offset2,guint);
 696   guint i;
 697   void *ofs_val = struct_member(base,offset,void *);
 698   g_array_set_size(prop->bezpointarray_data,nvals);
 699   for (i = 0; i < nvals; i++)
 700     g_array_index(prop->bezpointarray_data,BezPoint,i) =
 701       struct_member(ofs_val,i * sizeof(BezPoint),BezPoint);
 702 }
 703
 704 static void
 705 bezpointarrayprop_set_from_offset(BezPointarrayProperty *prop,
 706                                   void *base, guint offset, guint offset2)
 707 {
 708   guint nvals = prop->bezpointarray_data->len;
 709   BezPoint *vals = g_memdup(&g_array_index(prop->bezpointarray_data,
 710                                            BezPoint,0),
 711                             sizeof(BezPoint) * nvals);
 712   g_free(struct_member(base,offset,gint *));
 713   struct_member(base,offset,BezPoint *) = vals;
 714   struct_member(base,offset2,guint) = nvals;
 715 }
 716
 717 static const PropertyOps bezpointarrayprop_ops = {
 718   (PropertyType_New) bezpointarrayprop_new,
 719   (PropertyType_Free) bezpointarrayprop_free,
 720   (PropertyType_Copy) bezpointarrayprop_copy,
 721   (PropertyType_Load) bezpointarrayprop_load,
 722   (PropertyType_Save) bezpointarrayprop_save,
 723   (PropertyType_GetWidget) invalidprop_get_widget,
 724   (PropertyType_ResetWidget) invalidprop_reset_widget,
 725   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 726
 727   (PropertyType_CanMerge) noopprop_can_merge,
 728   (PropertyType_GetFromOffset) bezpointarrayprop_get_from_offset,
 729   (PropertyType_SetFromOffset) bezpointarrayprop_set_from_offset
 730 };
 731
 732 /*****************************/
 733 /* The RECT property type.  */
 734 /*****************************/
 735
 736 static RectProperty *
 737 rectprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
 738 {
 739   RectProperty *prop = g_new0(RectProperty,1);
 740   initialize_property(&prop->common,pdesc,reason);
 741   memset(&prop->rect_data,0,sizeof(prop->rect_data));
 742   return prop;
 743 }
 744
 745 static RectProperty *
 746 rectprop_copy(RectProperty *src)
 747 {
 748   RectProperty *prop =
 749     (RectProperty *)src->common.ops->new_prop(src->common.descr,
 750                                                src->common.reason);
 751   copy_init_property(&prop->common,&src->common);
 752   prop->rect_data = src->rect_data;
 753   return prop;
 754 }
 755
 756 static void
 757 rectprop_load(RectProperty *prop, AttributeNode attr, DataNode data)
 758 {
 759   data_rectangle(data,&prop->rect_data);
 760 }
 761
 762 static void
 763 rectprop_save(RectProperty *prop, AttributeNode attr)
 764 {
 765   data_add_rectangle(attr, &prop->rect_data);
 766 }
 767
 768 static void
 769 rectprop_get_from_offset(RectProperty *prop,
 770                          void *base, guint offset, guint offset2)
 771 {
 772   prop->rect_data = struct_member(base,offset,Rectangle);
 773 }
 774
 775 static void
 776 rectprop_set_from_offset(RectProperty *prop,
 777                          void *base, guint offset, guint offset2)
 778 {
 779   struct_member(base,offset,Rectangle) = prop->rect_data;
 780 }
 781
 782 static const PropertyOps rectprop_ops = {
 783   (PropertyType_New) rectprop_new,
 784   (PropertyType_Free) noopprop_free,
 785   (PropertyType_Copy) rectprop_copy,
 786   (PropertyType_Load) rectprop_load,
 787   (PropertyType_Save) rectprop_save,
 788   (PropertyType_GetWidget) invalidprop_get_widget,
 789   (PropertyType_ResetWidget) invalidprop_reset_widget,
 790   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 791
 792   (PropertyType_CanMerge) noopprop_can_merge,
 793   (PropertyType_GetFromOffset) rectprop_get_from_offset,
 794   (PropertyType_SetFromOffset) rectprop_set_from_offset
 795 };
 796
 797 /*********************************/
 798 /* The ENDPOINTS property type.  */
 799 /*********************************/
 800
 801 static EndpointsProperty *
 802 endpointsprop_new(const PropDescription *pdesc,
 803                   PropDescToPropPredicate reason)
 804 {
 805   EndpointsProperty *prop = g_new0(EndpointsProperty,1);
 806   initialize_property(&prop->common,pdesc,reason);
 807   memset(&prop->endpoints_data,0,sizeof(prop->endpoints_data));
 808   return prop;
 809 }
 810
 811 static EndpointsProperty *
 812 endpointsprop_copy(EndpointsProperty *src)
 813 {
 814   EndpointsProperty *prop =
 815     (EndpointsProperty *)src->common.ops->new_prop(src->common.descr,
 816                                                     src->common.reason);
 817   copy_init_property(&prop->common,&src->common);
 818   memcpy(&prop->endpoints_data,
 819          &src->endpoints_data,
 820          sizeof(prop->endpoints_data));
 821   return prop;
 822 }
 823
 824 static void
 825 endpointsprop_load(EndpointsProperty *prop, AttributeNode attr, DataNode data)
 826 {
 827   data_point(data,&prop->endpoints_data[0]);
 828   data = data_next(data);
 829   data_point(data,&prop->endpoints_data[1]);
 830 }
 831
 832 static void
 833 endpointsprop_save(EndpointsProperty *prop, AttributeNode attr)
 834 {
 835   data_add_point(attr, &prop->endpoints_data[0]);
 836   data_add_point(attr, &prop->endpoints_data[1]);
 837 }
 838
 839 static void
 840 endpointsprop_get_from_offset(EndpointsProperty *prop,
 841                               void *base, guint offset, guint offset2)
 842 {
 843   memcpy(&prop->endpoints_data,
 844          &struct_member(base,offset,Point),
 845          sizeof(prop->endpoints_data));
 846 }
 847
 848 static void
 849 endpointsprop_set_from_offset(EndpointsProperty *prop,
 850                               void *base, guint offset, guint offset2)
 851 {
 852   memcpy(&struct_member(base,offset,Point),
 853          &prop->endpoints_data,
 854          sizeof(prop->endpoints_data));
 855 }
 856
 857 static const PropertyOps endpointsprop_ops = {
 858   (PropertyType_New) endpointsprop_new,
 859   (PropertyType_Free) noopprop_free,
 860   (PropertyType_Copy) endpointsprop_copy,
 861   (PropertyType_Load) endpointsprop_load,
 862   (PropertyType_Save) endpointsprop_save,
 863   (PropertyType_GetWidget) invalidprop_get_widget,
 864   (PropertyType_ResetWidget) invalidprop_reset_widget,
 865   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 866
 867   (PropertyType_CanMerge) noopprop_can_merge,
 868   (PropertyType_GetFromOffset) endpointsprop_get_from_offset,
 869   (PropertyType_SetFromOffset) endpointsprop_set_from_offset
 870 };
 871
 872 /***************************/
 873 /* The CONNPOINT_LINE property type.  */
 874 /***************************/
 875
 876 static Connpoint_LineProperty *
 877 connpoint_lineprop_new(const PropDescription *pdesc,
 878                        PropDescToPropPredicate reason)
 879 {
 880   Connpoint_LineProperty *prop = g_new0(Connpoint_LineProperty,1);
 881   initialize_property(&prop->common,pdesc,reason);
 882   prop->connpoint_line_data = 0;
 883   return prop;
 884 }
 885
 886 static Connpoint_LineProperty *
 887 connpoint_lineprop_copy(Connpoint_LineProperty *src)
 888 {
 889   Connpoint_LineProperty *prop =
 890     (Connpoint_LineProperty *)src->common.ops->new_prop(src->common.descr,
 891                                                          src->common.reason);
 892   copy_init_property(&prop->common,&src->common);
 893   prop->connpoint_line_data = src->connpoint_line_data;
 894   return prop;
 895 }
 896
 897 static void
 898 connpoint_lineprop_load(Connpoint_LineProperty *prop, AttributeNode attr, DataNode data)
 899 {
 900   prop->connpoint_line_data = data_int(data);
 901 }
 902
 903 static void
 904 connpoint_lineprop_save(Connpoint_LineProperty *prop, AttributeNode attr)
 905 {
 906   data_add_int(attr, prop->connpoint_line_data);
 907 }
 908
 909 static void
 910 connpoint_lineprop_get_from_offset(Connpoint_LineProperty *prop,
 911                                    void *base, guint offset, guint offset2)
 912 {
 913   prop->connpoint_line_data =
 914     struct_member(base,offset,ConnPointLine *)->num_connections;
 915 }
 916
 917 static void
 918 connpoint_lineprop_set_from_offset(Connpoint_LineProperty *prop,
 919                                    void *base, guint offset, guint offset2)
 920 {
 921   connpointline_adjust_count(struct_member(base,offset,ConnPointLine *),
 922                              prop->connpoint_line_data,
 923                              &struct_member(base,offset,ConnPointLine *)->end);
 924 }
 925
 926 static const PropertyOps connpoint_lineprop_ops = {
 927   (PropertyType_New) connpoint_lineprop_new,
 928   (PropertyType_Free) noopprop_free,
 929   (PropertyType_Copy) connpoint_lineprop_copy,
 930   (PropertyType_Load) connpoint_lineprop_load,
 931   (PropertyType_Save) connpoint_lineprop_save,
 932   (PropertyType_GetWidget) invalidprop_get_widget,
 933   (PropertyType_ResetWidget) invalidprop_reset_widget,
 934   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 935
 936   (PropertyType_CanMerge) noopprop_can_merge,
 937   (PropertyType_GetFromOffset) connpoint_lineprop_get_from_offset,
 938   (PropertyType_SetFromOffset) connpoint_lineprop_set_from_offset
 939 };
 940
 941
 942 /* ************************************************************** */
 943
 944 void
 945 prop_geomtypes_register(void)
 946 {
 947   prop_type_register(PROP_TYPE_REAL,&realprop_ops);
 948   prop_type_register(PROP_TYPE_LENGTH,&lengthprop_ops);
 949   prop_type_register(PROP_TYPE_FONTSIZE,&fontsizeprop_ops);
 950   prop_type_register(PROP_TYPE_POINT,&pointprop_ops);
 951   prop_type_register(PROP_TYPE_POINTARRAY,&pointarrayprop_ops);
 952   prop_type_register(PROP_TYPE_BEZPOINTARRAY,&bezpointarrayprop_ops);
 953   prop_type_register(PROP_TYPE_RECT,&rectprop_ops);
 954   prop_type_register(PROP_TYPE_ENDPOINTS,&endpointsprop_ops);
 955   prop_type_register(PROP_TYPE_CONNPOINT_LINE,&connpoint_lineprop_ops);
 956 }