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
  39 /****************************/
  40 /* The REAL property type.  */
  41 /****************************/
  42
  43 static RealProperty *
  44 realprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
  45 {
  46   RealProperty *prop = g_new0(RealProperty,1);
  47   initialize_property(&prop->common, pdesc, reason);
  48   prop->real_data = 0.0;
  49   return prop;
  50 }
  51
  52 static RealProperty *
  53 realprop_copy(RealProperty *src)
  54 {
  55   RealProperty *prop =
  56     (RealProperty *)src->common.ops->new_prop(src->common.descr,
  57                                                src->common.reason);
  58   copy_init_property(&prop->common,&src->common);
  59   prop->real_data = src->real_data;
  60   return prop;
  61 }
  62
  63 static WIDGET *
  64 realprop_get_widget(RealProperty *prop, PropDialog *dialog)
  65 {
  66   GtkAdjustment *adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->real_data,
  67                                                          G_MINFLOAT,
  68                                                          G_MAXFLOAT,
  69                                                          0.1, 1.0, 1.0));
  70   GtkWidget *ret = gtk_spin_button_new(adj, 1.0, 2);
  71   gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(ret),TRUE);
  72   prophandler_connect(&prop->common,GTK_OBJECT(adj),"value_changed");
  73
  74   return ret;
  75 }
  76
  77 static void
  78 realprop_reset_widget(RealProperty *prop, WIDGET *widget)
  79 {
  80   GtkAdjustment *adj;
  81   if (prop->common.extra_data) {
  82     PropNumData *numdata = prop->common.extra_data;
  83     adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->real_data,
  84                                             numdata->min, numdata->max,
  85                                             numdata->step,
  86                                             10.0 * numdata->step,
  87                                             10.0 * numdata->step));
  88   } else {
  89     adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->real_data,
  90                                             G_MINFLOAT, G_MAXFLOAT,
  91                                             0.1, 1.0, 1.0));
  92   }
  93   gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(widget), adj);
  94 }
  95
  96 static void
  97 realprop_set_from_widget(RealProperty *prop, WIDGET *widget)
  98 {
  99   prop->real_data = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
 100 }
 101
 102 static void
 103 realprop_load(RealProperty *prop, AttributeNode attr, DataNode data)
 104 {
 105   prop->real_data = data_real(data);
 106 }
 107
 108 static void
 109 realprop_save(RealProperty *prop, AttributeNode attr)
 110 {
 111   data_add_real(attr, prop->real_data);
 112 }
 113
 114 static void
 115 realprop_get_from_offset(RealProperty *prop,
 116                          void *base, guint offset, guint offset2)
 117 {
 118   prop->real_data = struct_member(base,offset,real);
 119 }
 120
 121 static void
 122 realprop_set_from_offset(RealProperty *prop,
 123                          void *base, guint offset, guint offset2)
 124 {
 125   struct_member(base,offset,real) = prop->real_data;
 126 }
 127
 128 static int
 129 realprop_get_data_size(RealProperty *prop)
 130 {
 131   return sizeof (prop->real_data);
 132 }
 133
 134 static const PropertyOps realprop_ops = {
 135   (PropertyType_New) realprop_new,
 136   (PropertyType_Free) noopprop_free,
 137   (PropertyType_Copy) realprop_copy,
 138   (PropertyType_Load) realprop_load,
 139   (PropertyType_Save) realprop_save,
 140   (PropertyType_GetWidget) realprop_get_widget,
 141   (PropertyType_ResetWidget) realprop_reset_widget,
 142   (PropertyType_SetFromWidget) realprop_set_from_widget,
 143
 144   (PropertyType_CanMerge) noopprop_can_merge,
 145   (PropertyType_GetFromOffset) realprop_get_from_offset,
 146   (PropertyType_SetFromOffset) realprop_set_from_offset,
 147   (PropertyType_GetDataSize) realprop_get_data_size
 148 };
 149
 150 /*****************************/
 151 /* The POINT property type.  */
 152 /*****************************/
 153
 154 static PointProperty *
 155 pointprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
 156 {
 157   PointProperty *prop = g_new0(PointProperty,1);
 158   initialize_property(&prop->common, pdesc, reason);
 159   prop->point_data.x = 0.0;
 160   prop->point_data.y = 0.0;
 161   return prop;
 162 }
 163
 164 static PointProperty *
 165 pointprop_copy(PointProperty *src)
 166 {
 167   PointProperty *prop =
 168     (PointProperty *)src->common.ops->new_prop(src->common.descr,
 169                                                 src->common.reason);
 170   copy_init_property(&prop->common,&src->common);
 171   prop->point_data = src->point_data;
 172   return prop;
 173 }
 174
 175 static void
 176 pointprop_load(PointProperty *prop, AttributeNode attr, DataNode data)
 177 {
 178   data_point(data,&prop->point_data);
 179 }
 180
 181 static void
 182 pointprop_save(PointProperty *prop, AttributeNode attr)
 183 {
 184   data_add_point(attr, &prop->point_data);
 185 }
 186
 187 static void
 188 pointprop_get_from_offset(PointProperty *prop,
 189                           void *base, guint offset, guint offset2)
 190 {
 191   prop->point_data = struct_member(base,offset,Point);
 192 }
 193
 194 static void
 195 pointprop_set_from_offset(PointProperty *prop,
 196                           void *base, guint offset, guint offset2)
 197 {
 198   struct_member(base,offset,Point) = prop->point_data;
 199 }
 200
 201 static const PropertyOps pointprop_ops = {
 202   (PropertyType_New) pointprop_new,
 203   (PropertyType_Free) noopprop_free,
 204   (PropertyType_Copy) pointprop_copy,
 205   (PropertyType_Load) pointprop_load,
 206   (PropertyType_Save) pointprop_save,
 207   (PropertyType_GetWidget) invalidprop_get_widget,
 208   (PropertyType_ResetWidget) invalidprop_reset_widget,
 209   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 210
 211   (PropertyType_CanMerge) noopprop_can_merge,
 212   (PropertyType_GetFromOffset) pointprop_get_from_offset,
 213   (PropertyType_SetFromOffset) pointprop_set_from_offset
 214 };
 215
 216 /********************************/
 217 /* The POINTARRAY property type.  */
 218 /********************************/
 219
 220 static PointarrayProperty *
 221 pointarrayprop_new(const PropDescription *pdesc,
 222                    PropDescToPropPredicate reason)
 223 {
 224   PointarrayProperty *prop = g_new0(PointarrayProperty,1);
 225   initialize_property(&prop->common,pdesc,reason);
 226   prop->pointarray_data = g_array_new(FALSE,TRUE,sizeof(Point));
 227   return prop;
 228 }
 229
 230 static void
 231 pointarrayprop_free(PointarrayProperty *prop)
 232 {
 233   g_array_free(prop->pointarray_data,TRUE);
 234   g_free(prop);
 235 }
 236
 237 static PointarrayProperty *
 238 pointarrayprop_copy(PointarrayProperty *src)
 239 {
 240   guint i;
 241   PointarrayProperty *prop =
 242     (PointarrayProperty *)src->common.ops->new_prop(src->common.descr,
 243                                                      src->common.reason);
 244   copy_init_property(&prop->common,&src->common);
 245   g_array_set_size(prop->pointarray_data,src->pointarray_data->len);
 246   for (i = 0 ; i < src->pointarray_data->len; i++)
 247     g_array_index(prop->pointarray_data,Point,i) =
 248       g_array_index(src->pointarray_data,Point,i);
 249   return prop;
 250 }
 251
 252 static void
 253 pointarrayprop_load(PointarrayProperty *prop, AttributeNode attr, DataNode data)
 254 {
 255   guint nvals = attribute_num_data(attr);
 256   guint i;
 257   g_array_set_size(prop->pointarray_data,nvals);
 258   for (i=0; (i < nvals) && data; i++, data = data_next(data))
 259     data_point(data,&g_array_index(prop->pointarray_data,Point,i));
 260   if (i != nvals)
 261     g_warning("attribute_num_data() and actual data count mismatch "
 262               "(shouldn't happen)");
 263 }
 264
 265 static void
 266 pointarrayprop_save(PointarrayProperty *prop, AttributeNode attr)
 267 {
 268   guint i;
 269   for (i = 0; i < prop->pointarray_data->len; i++)
 270     data_add_point(attr, &g_array_index(prop->pointarray_data,Point,i));
 271 }
 272
 273 static void
 274 pointarrayprop_get_from_offset(PointarrayProperty *prop,
 275                                void *base, guint offset, guint offset2)
 276 {
 277   guint nvals = struct_member(base,offset2,guint);
 278   guint i;
 279   void *ofs_val = struct_member(base,offset,void *);
 280   g_array_set_size(prop->pointarray_data,nvals);
 281   for (i = 0; i < nvals; i++)
 282     g_array_index(prop->pointarray_data,Point,i) =
 283       struct_member(ofs_val,i * sizeof(Point),Point);
 284 }
 285
 286 static void
 287 pointarrayprop_set_from_offset(PointarrayProperty *prop,
 288                                void *base, guint offset, guint offset2)
 289 {
 290   guint nvals = prop->pointarray_data->len;
 291   Point *vals = g_memdup(&g_array_index(prop->pointarray_data,Point,0),
 292                          sizeof(Point) * nvals);
 293   g_free(struct_member(base,offset,Point *));
 294   struct_member(base,offset,Point *) = vals;
 295   struct_member(base,offset2,guint) = nvals;
 296 }
 297
 298 static const PropertyOps pointarrayprop_ops = {
 299   (PropertyType_New) pointarrayprop_new,
 300   (PropertyType_Free) pointarrayprop_free,
 301   (PropertyType_Copy) pointarrayprop_copy,
 302   (PropertyType_Load) pointarrayprop_load,
 303   (PropertyType_Save) pointarrayprop_save,
 304   (PropertyType_GetWidget) invalidprop_get_widget,
 305   (PropertyType_ResetWidget) invalidprop_reset_widget,
 306   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 307
 308   (PropertyType_CanMerge) noopprop_can_merge,
 309   (PropertyType_GetFromOffset) pointarrayprop_get_from_offset,
 310   (PropertyType_SetFromOffset) pointarrayprop_set_from_offset
 311 };
 312
 313
 314 /********************************/
 315 /* The BEZPOINT property type.  */
 316 /********************************/
 317
 318 static BezPointProperty *
 319 bezpointprop_new(const PropDescription *pdesc,
 320                  PropDescToPropPredicate reason)
 321 {
 322   BezPointProperty *prop = g_new0(BezPointProperty,1);
 323   initialize_property(&prop->common,pdesc,reason);
 324   memset(&prop->bezpoint_data,0,sizeof(prop->bezpoint_data));
 325   return prop;
 326 }
 327
 328 static BezPointProperty *
 329 bezpointprop_copy(BezPointProperty *src)
 330 {
 331   BezPointProperty *prop =
 332     (BezPointProperty *)src->common.ops->new_prop(src->common.descr,
 333                                                    src->common.reason);
 334   copy_init_property(&prop->common,&src->common);
 335   prop->bezpoint_data = src->bezpoint_data;
 336   return prop;
 337 }
 338
 339 static void
 340 bezpointprop_load(BezPointProperty *prop, AttributeNode attr, DataNode data)
 341 {
 342 #if 0
 343   data_bezpoint(data,&prop->bezpoint_data);
 344 #else
 345   g_error("BezPoint_load() not implemented. Missing data_bezpoint().");
 346 #endif
 347 }
 348
 349 static void
 350 bezpointprop_save(BezPointProperty *prop, AttributeNode attr)
 351 {
 352 #if 0
 353   data_add_bezpoint(attr, &prop->bezpoint_data);
 354 #else
 355   g_error("BezPoint_save() not implemented. Missing data_bezpoint().");
 356 #endif
 357 }
 358
 359 static void
 360 bezpointprop_get_from_offset(BezPointProperty *prop,
 361                              void *base, guint offset, guint offset2)
 362 {
 363   prop->bezpoint_data = struct_member(base,offset,BezPoint);
 364 }
 365
 366 static void
 367 bezpointprop_set_from_offset(BezPointProperty *prop,
 368                              void *base, guint offset, guint offset2)
 369 {
 370   struct_member(base,offset,BezPoint) = prop->bezpoint_data;
 371 }
 372
 373 static const PropertyOps bezpointprop_ops = {
 374   (PropertyType_New) bezpointprop_new,
 375   (PropertyType_Free) noopprop_free,
 376   (PropertyType_Copy) bezpointprop_copy,
 377   (PropertyType_Load) bezpointprop_load,
 378   (PropertyType_Save) bezpointprop_save,
 379   (PropertyType_GetWidget) invalidprop_get_widget,
 380   (PropertyType_ResetWidget) invalidprop_reset_widget,
 381   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 382
 383   (PropertyType_CanMerge) noopprop_can_merge,
 384   (PropertyType_GetFromOffset) bezpointprop_get_from_offset,
 385   (PropertyType_SetFromOffset) bezpointprop_set_from_offset
 386 };
 387
 388 /*************************************/
 389 /* The BEZPOINTARRAY property type.  */
 390 /*************************************/
 391
 392 static BezPointarrayProperty *
 393 bezpointarrayprop_new(const PropDescription *pdesc,
 394                       PropDescToPropPredicate reason)
 395 {
 396   BezPointarrayProperty *prop = g_new0(BezPointarrayProperty,1);
 397   initialize_property(&prop->common,pdesc,reason);
 398   prop->bezpointarray_data = g_array_new(FALSE,TRUE,sizeof(BezPoint));
 399   return prop;
 400 }
 401
 402 static void
 403 bezpointarrayprop_free(BezPointarrayProperty *prop)
 404 {
 405   g_array_free(prop->bezpointarray_data,TRUE);
 406   g_free(prop);
 407 }
 408
 409 static BezPointarrayProperty *
 410 bezpointarrayprop_copy(BezPointarrayProperty *src)
 411 {
 412   guint i;
 413   BezPointarrayProperty *prop =
 414     (BezPointarrayProperty *)src->common.ops->new_prop(src->common.descr,
 415                                                         src->common.reason);
 416   copy_init_property(&prop->common,&src->common);
 417   g_array_set_size(prop->bezpointarray_data,src->bezpointarray_data->len);
 418   for (i = 0 ; i < src->bezpointarray_data->len; i++)
 419     g_array_index(prop->bezpointarray_data,BezPoint,i) =
 420       g_array_index(src->bezpointarray_data,BezPoint,i);
 421   return prop;
 422 }
 423
 424 static void
 425 bezpointarrayprop_load(BezPointarrayProperty *prop,
 426                        AttributeNode attr, DataNode data)
 427 {
 428 #if 0
 429   guint nvals = attribute_num_data(attr);
 430   guint i;
 431
 432   g_array_set_size(prop->bezpointarray_data,nvals);
 433
 434   for (i=0; (i < nvals) && data; i++, data = data_next(data))
 435     data_bezpoint(data,&g_array_index(prop->bezpointarray_data,BezPoint,i));
 436   if (i != nvals)
 437     g_warning("attribute_num_data() and actual data count mismatch "
 438               "(shouldn't happen)");
 439 #else
 440   g_error("BezPointArray_load() not implemented. Missing data_bezpoint().");
 441 #endif
 442 }
 443
 444 static void
 445 bezpointarrayprop_save(BezPointarrayProperty *prop, AttributeNode attr)
 446 {
 447 #if 0
 448   guint i;
 449   for (i = 0; i < prop->bezpointarray_data->len; i++)
 450     data_add_bezpoint(attr,
 451                       &g_array_index(prop->bezpointarray_data,BezPoint,i));
 452 #else
 453   g_error("BezPointArray_load() not implemented. Missing data_bezpoint().");
 454 #endif
 455 }
 456
 457 static void
 458 bezpointarrayprop_get_from_offset(BezPointarrayProperty *prop,
 459                                   void *base, guint offset, guint offset2)
 460 {
 461   guint nvals = struct_member(base,offset2,guint);
 462   guint i;
 463   void *ofs_val = struct_member(base,offset,void *);
 464   g_array_set_size(prop->bezpointarray_data,nvals);
 465   for (i = 0; i < nvals; i++)
 466     g_array_index(prop->bezpointarray_data,BezPoint,i) =
 467       struct_member(ofs_val,i * sizeof(BezPoint),BezPoint);
 468 }
 469
 470 static void
 471 bezpointarrayprop_set_from_offset(BezPointarrayProperty *prop,
 472                                   void *base, guint offset, guint offset2)
 473 {
 474   guint nvals = prop->bezpointarray_data->len;
 475   BezPoint *vals = g_memdup(&g_array_index(prop->bezpointarray_data,
 476                                            BezPoint,0),
 477                             sizeof(BezPoint) * nvals);
 478   g_free(struct_member(base,offset,gint *));
 479   struct_member(base,offset,BezPoint *) = vals;
 480   struct_member(base,offset2,guint) = nvals;
 481 }
 482
 483 static const PropertyOps bezpointarrayprop_ops = {
 484   (PropertyType_New) bezpointarrayprop_new,
 485   (PropertyType_Free) bezpointarrayprop_free,
 486   (PropertyType_Copy) bezpointarrayprop_copy,
 487   (PropertyType_Load) bezpointarrayprop_load,
 488   (PropertyType_Save) bezpointarrayprop_save,
 489   (PropertyType_GetWidget) invalidprop_get_widget,
 490   (PropertyType_ResetWidget) invalidprop_reset_widget,
 491   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 492
 493   (PropertyType_CanMerge) noopprop_can_merge,
 494   (PropertyType_GetFromOffset) bezpointarrayprop_get_from_offset,
 495   (PropertyType_SetFromOffset) bezpointarrayprop_set_from_offset
 496 };
 497
 498 /*****************************/
 499 /* The RECT property type.  */
 500 /*****************************/
 501
 502 static RectProperty *
 503 rectprop_new(const PropDescription *pdesc, PropDescToPropPredicate reason)
 504 {
 505   RectProperty *prop = g_new0(RectProperty,1);
 506   initialize_property(&prop->common,pdesc,reason);
 507   memset(&prop->rect_data,0,sizeof(prop->rect_data));
 508   return prop;
 509 }
 510
 511 static RectProperty *
 512 rectprop_copy(RectProperty *src)
 513 {
 514   RectProperty *prop =
 515     (RectProperty *)src->common.ops->new_prop(src->common.descr,
 516                                                src->common.reason);
 517   copy_init_property(&prop->common,&src->common);
 518   prop->rect_data = src->rect_data;
 519   return prop;
 520 }
 521
 522 static void
 523 rectprop_load(RectProperty *prop, AttributeNode attr, DataNode data)
 524 {
 525   data_rectangle(data,&prop->rect_data);
 526 }
 527
 528 static void
 529 rectprop_save(RectProperty *prop, AttributeNode attr)
 530 {
 531   data_add_rectangle(attr, &prop->rect_data);
 532 }
 533
 534 static void
 535 rectprop_get_from_offset(RectProperty *prop,
 536                          void *base, guint offset, guint offset2)
 537 {
 538   prop->rect_data = struct_member(base,offset,Rectangle);
 539 }
 540
 541 static void
 542 rectprop_set_from_offset(RectProperty *prop,
 543                          void *base, guint offset, guint offset2)
 544 {
 545   struct_member(base,offset,Rectangle) = prop->rect_data;
 546 }
 547
 548 static const PropertyOps rectprop_ops = {
 549   (PropertyType_New) rectprop_new,
 550   (PropertyType_Free) noopprop_free,
 551   (PropertyType_Copy) rectprop_copy,
 552   (PropertyType_Load) rectprop_load,
 553   (PropertyType_Save) rectprop_save,
 554   (PropertyType_GetWidget) invalidprop_get_widget,
 555   (PropertyType_ResetWidget) invalidprop_reset_widget,
 556   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 557
 558   (PropertyType_CanMerge) noopprop_can_merge,
 559   (PropertyType_GetFromOffset) rectprop_get_from_offset,
 560   (PropertyType_SetFromOffset) rectprop_set_from_offset
 561 };
 562
 563 /*********************************/
 564 /* The ENDPOINTS property type.  */
 565 /*********************************/
 566
 567 static EndpointsProperty *
 568 endpointsprop_new(const PropDescription *pdesc,
 569                   PropDescToPropPredicate reason)
 570 {
 571   EndpointsProperty *prop = g_new0(EndpointsProperty,1);
 572   initialize_property(&prop->common,pdesc,reason);
 573   memset(&prop->endpoints_data,0,sizeof(prop->endpoints_data));
 574   return prop;
 575 }
 576
 577 static EndpointsProperty *
 578 endpointsprop_copy(EndpointsProperty *src)
 579 {
 580   EndpointsProperty *prop =
 581     (EndpointsProperty *)src->common.ops->new_prop(src->common.descr,
 582                                                     src->common.reason);
 583   copy_init_property(&prop->common,&src->common);
 584   memcpy(&prop->endpoints_data,
 585          &src->endpoints_data,
 586          sizeof(prop->endpoints_data));
 587   return prop;
 588 }
 589
 590 static void
 591 endpointsprop_load(EndpointsProperty *prop, AttributeNode attr, DataNode data)
 592 {
 593   data_point(data,&prop->endpoints_data[0]);
 594   data = data_next(data);
 595   data_point(data,&prop->endpoints_data[1]);
 596 }
 597
 598 static void
 599 endpointsprop_save(EndpointsProperty *prop, AttributeNode attr)
 600 {
 601   data_add_point(attr, &prop->endpoints_data[0]);
 602   data_add_point(attr, &prop->endpoints_data[1]);
 603 }
 604
 605 static void
 606 endpointsprop_get_from_offset(EndpointsProperty *prop,
 607                               void *base, guint offset, guint offset2)
 608 {
 609   memcpy(&prop->endpoints_data,
 610          &struct_member(base,offset,Point),
 611          sizeof(prop->endpoints_data));
 612 }
 613
 614 static void
 615 endpointsprop_set_from_offset(EndpointsProperty *prop,
 616                               void *base, guint offset, guint offset2)
 617 {
 618   memcpy(&struct_member(base,offset,Point),
 619          &prop->endpoints_data,
 620          sizeof(prop->endpoints_data));
 621 }
 622
 623 static const PropertyOps endpointsprop_ops = {
 624   (PropertyType_New) endpointsprop_new,
 625   (PropertyType_Free) noopprop_free,
 626   (PropertyType_Copy) endpointsprop_copy,
 627   (PropertyType_Load) endpointsprop_load,
 628   (PropertyType_Save) endpointsprop_save,
 629   (PropertyType_GetWidget) invalidprop_get_widget,
 630   (PropertyType_ResetWidget) invalidprop_reset_widget,
 631   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 632
 633   (PropertyType_CanMerge) noopprop_can_merge,
 634   (PropertyType_GetFromOffset) endpointsprop_get_from_offset,
 635   (PropertyType_SetFromOffset) endpointsprop_set_from_offset
 636 };
 637
 638 /***************************/
 639 /* The CONNPOINT_LINE property type.  */
 640 /***************************/
 641
 642 static Connpoint_LineProperty *
 643 connpoint_lineprop_new(const PropDescription *pdesc,
 644                        PropDescToPropPredicate reason)
 645 {
 646   Connpoint_LineProperty *prop = g_new0(Connpoint_LineProperty,1);
 647   initialize_property(&prop->common,pdesc,reason);
 648   prop->connpoint_line_data = 0;
 649   return prop;
 650 }
 651
 652 static Connpoint_LineProperty *
 653 connpoint_lineprop_copy(Connpoint_LineProperty *src)
 654 {
 655   Connpoint_LineProperty *prop =
 656     (Connpoint_LineProperty *)src->common.ops->new_prop(src->common.descr,
 657                                                          src->common.reason);
 658   copy_init_property(&prop->common,&src->common);
 659   prop->connpoint_line_data = src->connpoint_line_data;
 660   return prop;
 661 }
 662
 663 static void
 664 connpoint_lineprop_load(Connpoint_LineProperty *prop, AttributeNode attr, DataNode data)
 665 {
 666   prop->connpoint_line_data = data_int(data);
 667 }
 668
 669 static void
 670 connpoint_lineprop_save(Connpoint_LineProperty *prop, AttributeNode attr)
 671 {
 672   data_add_int(attr, prop->connpoint_line_data);
 673 }
 674
 675 static void
 676 connpoint_lineprop_get_from_offset(Connpoint_LineProperty *prop,
 677                                    void *base, guint offset, guint offset2)
 678 {
 679   prop->connpoint_line_data =
 680     struct_member(base,offset,ConnPointLine *)->num_connections;
 681 }
 682
 683 static void
 684 connpoint_lineprop_set_from_offset(Connpoint_LineProperty *prop,
 685                                    void *base, guint offset, guint offset2)
 686 {
 687   connpointline_adjust_count(struct_member(base,offset,ConnPointLine *),
 688                              prop->connpoint_line_data,
 689                              &struct_member(base,offset,ConnPointLine *)->end);
 690 }
 691
 692 static const PropertyOps connpoint_lineprop_ops = {
 693   (PropertyType_New) connpoint_lineprop_new,
 694   (PropertyType_Free) noopprop_free,
 695   (PropertyType_Copy) connpoint_lineprop_copy,
 696   (PropertyType_Load) connpoint_lineprop_load,
 697   (PropertyType_Save) connpoint_lineprop_save,
 698   (PropertyType_GetWidget) invalidprop_get_widget,
 699   (PropertyType_ResetWidget) invalidprop_reset_widget,
 700   (PropertyType_SetFromWidget) invalidprop_set_from_widget,
 701
 702   (PropertyType_CanMerge) noopprop_can_merge,
 703   (PropertyType_GetFromOffset) connpoint_lineprop_get_from_offset,
 704   (PropertyType_SetFromOffset) connpoint_lineprop_set_from_offset
 705 };
 706
 707
 708 /* ************************************************************** */
 709
 710 void
 711 prop_geomtypes_register(void)
 712 {
 713   prop_type_register(PROP_TYPE_REAL,&realprop_ops);
 714   prop_type_register(PROP_TYPE_POINT,&pointprop_ops);
 715   prop_type_register(PROP_TYPE_POINTARRAY,&pointarrayprop_ops);
 716   prop_type_register(PROP_TYPE_BEZPOINTARRAY,&bezpointarrayprop_ops);
 717   prop_type_register(PROP_TYPE_RECT,&rectprop_ops);
 718   prop_type_register(PROP_TYPE_ENDPOINTS,&endpointsprop_ops);
 719   prop_type_register(PROP_TYPE_CONNPOINT_LINE,&connpoint_lineprop_ops);
 720 }