git.sur5r.net Git - glabels/blob - glabels1/src/highlight.c

   1 /*
   2  *  (GLABELS) Label and Business Card Creation program for GNOME
   3  *
   4  *  highlight.c:  GLabels Resizable Highlight module
   5  *
   6  *  Copyright (C) 2001-2002  Jim Evins <evins@snaught.com>.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21  */
  22
  23 #include <config.h>
  24
  25 #include "highlight.h"
  26 #include "item.h"
  27
  28 #include "math.h"
  29
  30 #include "debug.h"
  31
  32 #define MIN_ITEM_SIZE 1.0
  33
  34 /*===========================================*/
  35 /* Private data types                        */
  36 /*===========================================*/
  37
  38 /*===========================================*/
  39 /* Private globals                           */
  40 /*===========================================*/
  41
  42 /*===========================================*/
  43 /* Local function prototypes                 */
  44 /*===========================================*/
  45
  46 static void highlight_resizable_box (GnomeCanvasItem * item,
  47                                      glHighlightStyle style);
  48 static void highlight_resizable_line (GnomeCanvasItem * item);
  49 static void highlight_simple (GnomeCanvasItem * item);
  50
  51 static int tl_resize_event_handler (GnomeCanvasItem * handle_item,
  52                                     GdkEvent * event, gpointer data);
  53 static int tr_resize_event_handler (GnomeCanvasItem * handle_item,
  54                                     GdkEvent * event, gpointer data);
  55 static int bl_resize_event_handler (GnomeCanvasItem * handle_item,
  56                                     GdkEvent * event, gpointer data);
  57 static int br_resize_event_handler (GnomeCanvasItem * handle_item,
  58                                     GdkEvent * event, gpointer data);
  59
  60 static int sl_resize_event_handler (GnomeCanvasItem * handle_item,
  61                                     GdkEvent * event, gpointer data);
  62 static int sr_resize_event_handler (GnomeCanvasItem * handle_item,
  63                                     GdkEvent * event, gpointer data);
  64 static int st_resize_event_handler (GnomeCanvasItem * handle_item,
  65                                     GdkEvent * event, gpointer data);
  66 static int sb_resize_event_handler (GnomeCanvasItem * handle_item,
  67                                     GdkEvent * event, gpointer data);
  68
  69 static int p1_resize_event_handler (GnomeCanvasItem * handle_item,
  70                                     GdkEvent * event, gpointer data);
  71 static int p2_resize_event_handler (GnomeCanvasItem * handle_item,
  72                                     GdkEvent * event, gpointer data);
  73
  74 static int passthrough_event_handler (GnomeCanvasItem * handle_item,
  75                                       GdkEvent * event, gpointer data);
  76 \f
  77 /*****************************************************************************/
  78 /* Create/Update & Display a resizable highlight for given item.             */
  79 /*****************************************************************************/
  80 void
  81 gl_highlight (GnomeCanvasItem * item,
  82               glHighlightStyle style)
  83 {
  84         g_return_if_fail (GNOME_IS_CANVAS_ITEM (item));
  85
  86         switch (style) {
  87
  88         case GL_HIGHLIGHT_BOX_RESIZABLE:
  89         case GL_HIGHLIGHT_ELLIPSE_RESIZABLE:
  90                 highlight_resizable_box (item, style);
  91                 break;
  92
  93         case GL_HIGHLIGHT_LINE_RESIZABLE:
  94                 highlight_resizable_line (item);
  95                 break;
  96
  97         case GL_HIGHLIGHT_SIMPLE:
  98                 highlight_simple (item);
  99                 break;
 100
 101         default:
 102                 WARN ("Invalid resizable highlight style");
 103
 104         }
 105 }
 106
 107 /*---------------------------------------------------------------------------*/
 108 /* PRIVATE.  Create/Update & Display a resizable box highlight.              */
 109 /*---------------------------------------------------------------------------*/
 110 static void
 111 highlight_resizable_box (GnomeCanvasItem * item,
 112                          glHighlightStyle style)
 113 {
 114         GnomeCanvasItem *highlight;
 115         gdouble x, y, w, h;
 116         GnomeCanvasItem *outline;       /* Outline around item */
 117         GnomeCanvasItem *tl, *tr, *bl, *br;     /* Handles at four corners */
 118         GnomeCanvasItem *sl, *sr, *st, *sb;     /* Handles at each side */
 119
 120         g_return_if_fail (GNOME_IS_CANVAS_ITEM (item));
 121
 122         highlight = gtk_object_get_data (GTK_OBJECT (item), "highlight");
 123
 124         gl_item_get_position_size (item, &x, &y, &w, &h);
 125
 126         if (highlight == NULL) {
 127
 128                 highlight =
 129                     gnome_canvas_item_new (gnome_canvas_root
 130                                            (GNOME_CANVAS (item->canvas)),
 131                                            gnome_canvas_group_get_type (), "x",
 132                                            x, "y", y, NULL);
 133
 134                 switch (style) {
 135                 case GL_HIGHLIGHT_BOX_RESIZABLE:
 136                         outline =
 137                             gnome_canvas_item_new (GNOME_CANVAS_GROUP
 138                                                    (highlight),
 139                                                    gnome_canvas_rect_get_type
 140                                                    (),
 141                                                    "x1", -0.5,
 142                                                    "y1", -0.5,
 143                                                    "x2", w + 0.5,
 144                                                    "y2", h + 0.5,
 145                                                    "width_pixels", 2,
 146                                                    "outline_color_rgba",
 147                                                    GNOME_CANVAS_COLOR_A (0, 0,
 148                                                                          255,
 149                                                                          255),
 150                                                    NULL);
 151                         break;
 152                 case GL_HIGHLIGHT_ELLIPSE_RESIZABLE:
 153                         outline =
 154                             gnome_canvas_item_new (GNOME_CANVAS_GROUP
 155                                                    (highlight),
 156                                                    gnome_canvas_ellipse_get_type
 157                                                    (),
 158                                                    "x1", -0.5,
 159                                                    "y1", -0.5,
 160                                                    "x2", w + 0.5,
 161                                                    "y2", h + 0.5,
 162                                                    "width_pixels", 2,
 163                                                    "outline_color_rgba",
 164                                                    GNOME_CANVAS_COLOR_A (0, 0,
 165                                                                          255,
 166                                                                          255),
 167                                                    NULL);
 168                         break;
 169                 default:
 170                         outline = NULL;
 171                         WARN ("Invalid resizable highlight style");
 172                 }
 173
 174                 tl = gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 175                                             gnome_canvas_rect_get_type (),
 176                                             "x1", -1.0,
 177                                             "y1", -1.0,
 178                                             "x2", +1.0,
 179                                             "y2", +1.0,
 180                                             "fill_color_rgba",
 181                                             GNOME_CANVAS_COLOR_A (0, 0, 255,
 182                                                                   255),
 183                                             "outline_color_rgba",
 184                                             GNOME_CANVAS_COLOR_A (255, 255, 255,
 185                                                                   255), NULL);
 186
 187                 tr = gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 188                                             gnome_canvas_rect_get_type (),
 189                                             "x1", w - 1.0,
 190                                             "y1", -1.0,
 191                                             "x2", w + 1.0,
 192                                             "y2", +1.0,
 193                                             "fill_color_rgba",
 194                                             GNOME_CANVAS_COLOR_A (0, 0, 255,
 195                                                                   255),
 196                                             "outline_color_rgba",
 197                                             GNOME_CANVAS_COLOR_A (255, 255, 255,
 198                                                                   255), NULL);
 199
 200                 bl = gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 201                                             gnome_canvas_rect_get_type (),
 202                                             "x1", -1.0,
 203                                             "y1", h - 1.0,
 204                                             "x2", +1.0,
 205                                             "y2", h + 1.0,
 206                                             "fill_color_rgba",
 207                                             GNOME_CANVAS_COLOR_A (0, 0, 255,
 208                                                                   255),
 209                                             "outline_color_rgba",
 210                                             GNOME_CANVAS_COLOR_A (255, 255, 255,
 211                                                                   255), NULL);
 212
 213                 br = gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 214                                             gnome_canvas_rect_get_type (),
 215                                             "x1", w - 1.0,
 216                                             "y1", h - 1.0,
 217                                             "x2", w + 1.0,
 218                                             "y2", h + 1.0,
 219                                             "fill_color_rgba",
 220                                             GNOME_CANVAS_COLOR_A (0, 0, 255,
 221                                                                   255),
 222                                             "outline_color_rgba",
 223                                             GNOME_CANVAS_COLOR_A (255, 255, 255,
 224                                                                   255), NULL);
 225
 226                 sl = gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 227                                             gnome_canvas_rect_get_type (),
 228                                             "x1", -1.0,
 229                                             "y1", h / 2.0 - 1.0,
 230                                             "x2", +1.0,
 231                                             "y2", h / 2.0 + 1.0,
 232                                             "fill_color_rgba",
 233                                             GNOME_CANVAS_COLOR_A (0, 0, 255,
 234                                                                   255),
 235                                             "outline_color_rgba",
 236                                             GNOME_CANVAS_COLOR_A (255, 255, 255,
 237                                                                   255), NULL);
 238
 239                 sr = gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 240                                             gnome_canvas_rect_get_type (),
 241                                             "x1", w - 1.0,
 242                                             "y1", h / 2.0 - 1.0,
 243                                             "x2", w + 1.0,
 244                                             "y2", h / 2.0 + 1.0,
 245                                             "fill_color_rgba",
 246                                             GNOME_CANVAS_COLOR_A (0, 0, 255,
 247                                                                   255),
 248                                             "outline_color_rgba",
 249                                             GNOME_CANVAS_COLOR_A (255, 255, 255,
 250                                                                   255), NULL);
 251
 252                 st = gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 253                                             gnome_canvas_rect_get_type (),
 254                                             "x1", w / 2.0 - 1.0,
 255                                             "y1", -1.0,
 256                                             "x2", w / 2.0 + 1.0,
 257                                             "y2", +1.0,
 258                                             "fill_color_rgba",
 259                                             GNOME_CANVAS_COLOR_A (0, 0, 255,
 260                                                                   255),
 261                                             "outline_color_rgba",
 262                                             GNOME_CANVAS_COLOR_A (255, 255, 255,
 263                                                                   255), NULL);
 264
 265                 sb = gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 266                                             gnome_canvas_rect_get_type (),
 267                                             "x1", w / 2.0 - 1.0,
 268                                             "y1", h - 1.0,
 269                                             "x2", w / 2.0 + 1.0,
 270                                             "y2", h + 1.0,
 271                                             "fill_color_rgba",
 272                                             GNOME_CANVAS_COLOR_A (0, 0, 255,
 273                                                                   255),
 274                                             "outline_color_rgba",
 275                                             GNOME_CANVAS_COLOR_A (255, 255, 255,
 276                                                                   255), NULL);
 277
 278                 gtk_object_set_data (GTK_OBJECT (item), "highlight", highlight);
 279
 280                 gtk_object_set_data (GTK_OBJECT (highlight), "outline",
 281                                      outline);
 282
 283                 gtk_object_set_data (GTK_OBJECT (highlight), "tl", tl);
 284                 gtk_object_set_data (GTK_OBJECT (highlight), "tr", tr);
 285                 gtk_object_set_data (GTK_OBJECT (highlight), "bl", bl);
 286                 gtk_object_set_data (GTK_OBJECT (highlight), "br", br);
 287                 gtk_object_set_data (GTK_OBJECT (highlight), "sl", sl);
 288                 gtk_object_set_data (GTK_OBJECT (highlight), "sr", sr);
 289                 gtk_object_set_data (GTK_OBJECT (highlight), "st", st);
 290                 gtk_object_set_data (GTK_OBJECT (highlight), "sb", sb);
 291
 292                 gtk_signal_connect (GTK_OBJECT (tl), "event",
 293                                     GTK_SIGNAL_FUNC (tl_resize_event_handler),
 294                                     item);
 295                 gtk_signal_connect (GTK_OBJECT (tr), "event",
 296                                     GTK_SIGNAL_FUNC (tr_resize_event_handler),
 297                                     item);
 298                 gtk_signal_connect (GTK_OBJECT (bl), "event",
 299                                     GTK_SIGNAL_FUNC (bl_resize_event_handler),
 300                                     item);
 301                 gtk_signal_connect (GTK_OBJECT (br), "event",
 302                                     GTK_SIGNAL_FUNC (br_resize_event_handler),
 303                                     item);
 304                 gtk_signal_connect (GTK_OBJECT (sl), "event",
 305                                     GTK_SIGNAL_FUNC (sl_resize_event_handler),
 306                                     item);
 307                 gtk_signal_connect (GTK_OBJECT (sr), "event",
 308                                     GTK_SIGNAL_FUNC (sr_resize_event_handler),
 309                                     item);
 310                 gtk_signal_connect (GTK_OBJECT (st), "event",
 311                                     GTK_SIGNAL_FUNC (st_resize_event_handler),
 312                                     item);
 313                 gtk_signal_connect (GTK_OBJECT (sb), "event",
 314                                     GTK_SIGNAL_FUNC (sb_resize_event_handler),
 315                                     item);
 316
 317                 gtk_signal_connect (GTK_OBJECT (outline), "event",
 318                                     GTK_SIGNAL_FUNC (passthrough_event_handler),
 319                                     item);
 320
 321         } else {
 322
 323                 gnome_canvas_item_set (highlight, "x", x, "y", y, NULL);
 324
 325                 outline =
 326                     gtk_object_get_data (GTK_OBJECT (highlight), "outline");
 327
 328                 tl = gtk_object_get_data (GTK_OBJECT (highlight), "tl");
 329                 tr = gtk_object_get_data (GTK_OBJECT (highlight), "tr");
 330                 bl = gtk_object_get_data (GTK_OBJECT (highlight), "bl");
 331                 br = gtk_object_get_data (GTK_OBJECT (highlight), "br");
 332                 sl = gtk_object_get_data (GTK_OBJECT (highlight), "sl");
 333                 sr = gtk_object_get_data (GTK_OBJECT (highlight), "sr");
 334                 st = gtk_object_get_data (GTK_OBJECT (highlight), "st");
 335                 sb = gtk_object_get_data (GTK_OBJECT (highlight), "sb");
 336
 337                 gnome_canvas_item_set (outline,
 338                                        "x1", -0.5,
 339                                        "y1", -0.5,
 340                                        "x2", w + 0.5, "y2", h + 0.5, NULL);
 341
 342                 gnome_canvas_item_set (tl,
 343                                        "x1", -1.0,
 344                                        "y1", -1.0,
 345                                        "x2", +1.0, "y2", +1.0, NULL);
 346
 347                 gnome_canvas_item_set (tr,
 348                                        "x1", w - 1.0,
 349                                        "y1", -1.0,
 350                                        "x2", w + 1.0, "y2", +1.0, NULL);
 351
 352                 gnome_canvas_item_set (bl,
 353                                        "x1", -1.0,
 354                                        "y1", h - 1.0,
 355                                        "x2", +1.0, "y2", h + 1.0, NULL);
 356
 357                 gnome_canvas_item_set (br,
 358                                        "x1", w - 1.0,
 359                                        "y1", h - 1.0,
 360                                        "x2", w + 1.0, "y2", h + 1.0, NULL);
 361
 362                 gnome_canvas_item_set (sl,
 363                                        "x1", -1.0,
 364                                        "y1", h / 2.0 - 1.0,
 365                                        "x2", +1.0, "y2", h / 2.0 + 1.0, NULL);
 366
 367                 gnome_canvas_item_set (sr,
 368                                        "x1", w - 1.0,
 369                                        "y1", h / 2.0 - 1.0,
 370                                        "x2", w + 1.0,
 371                                        "y2", h / 2.0 + 1.0, NULL);
 372
 373                 gnome_canvas_item_set (st,
 374                                        "x1", w / 2.0 - 1.0,
 375                                        "y1", -1.0,
 376                                        "x2", w / 2.0 + 1.0, "y2", +1.0, NULL);
 377
 378                 gnome_canvas_item_set (sb,
 379                                        "x1", w / 2.0 - 1.0,
 380                                        "y1", h - 1.0,
 381                                        "x2", w / 2.0 + 1.0,
 382                                        "y2", h + 1.0, NULL);
 383
 384                 gnome_canvas_item_show (highlight);
 385
 386         }
 387
 388         gnome_canvas_item_raise_to_top (highlight);
 389
 390 }
 391
 392 /*---------------------------------------------------------------------------*/
 393 /* PRIVATE.  Create/Update & Display a resizable line highlight.             */
 394 /*---------------------------------------------------------------------------*/
 395 static void
 396 highlight_resizable_line (GnomeCanvasItem * item)
 397 {
 398         GnomeCanvasItem *highlight;
 399         gdouble x, y, dx, dy;
 400         GnomeCanvasPoints *points;
 401         GnomeCanvasItem *outline;       /* Outline around item */
 402         GnomeCanvasItem *p1, *p2;       /* Handles at endpoints */
 403
 404         g_return_if_fail (GNOME_IS_CANVAS_ITEM (item));
 405
 406         highlight = gtk_object_get_data (GTK_OBJECT (item), "highlight");
 407
 408         gl_item_get_position_size (item, &x, &y, &dx, &dy);
 409
 410         points = gnome_canvas_points_new (2);
 411
 412         if (highlight == NULL) {
 413
 414                 highlight =
 415                     gnome_canvas_item_new (gnome_canvas_root
 416                                            (GNOME_CANVAS (item->canvas)),
 417                                            gnome_canvas_group_get_type (), "x",
 418                                            x, "y", y, NULL);
 419
 420                 points->coords[0] = 0.0;
 421                 points->coords[1] = 0.0;
 422                 points->coords[2] = dx;
 423                 points->coords[3] = dy;
 424                 outline =
 425                     gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 426                                            gnome_canvas_line_get_type (),
 427                                            "points", points,
 428                                            "width_pixels", 3,
 429                                            "fill_color_rgba",
 430                                            GNOME_CANVAS_COLOR_A (0, 0, 255,
 431                                                                  255), NULL);
 432
 433                 p1 = gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 434                                             gnome_canvas_rect_get_type (),
 435                                             "x1", -1.0,
 436                                             "y1", -1.0,
 437                                             "x2", +1.0,
 438                                             "y2", +1.0,
 439                                             "fill_color_rgba",
 440                                             GNOME_CANVAS_COLOR_A (0, 0, 255,
 441                                                                   255),
 442                                             "outline_color_rgba",
 443                                             GNOME_CANVAS_COLOR_A (255, 255, 255,
 444                                                                   255), NULL);
 445
 446                 p2 = gnome_canvas_item_new (GNOME_CANVAS_GROUP (highlight),
 447                                             gnome_canvas_rect_get_type (),
 448                                             "x1", dx - 1.0,
 449                                             "y1", dy - 1.0,
 450                                             "x2", dx + 1.0,
 451                                             "y2", dy + 1.0,
 452                                             "fill_color_rgba",
 453                                             GNOME_CANVAS_COLOR_A (0, 0, 255,
 454                                                                   255),
 455                                             "outline_color_rgba",
 456                                             GNOME_CANVAS_COLOR_A (255, 255, 255,
 457                                                                   255), NULL);
 458
 459                 gtk_object_set_data (GTK_OBJECT (item), "highlight", highlight);
 460
 461                 gtk_object_set_data (GTK_OBJECT (highlight), "outline",
 462                                      outline);
 463
 464                 gtk_object_set_data (GTK_OBJECT (highlight), "p1", p1);
 465                 gtk_object_set_data (GTK_OBJECT (highlight), "p2", p2);
 466
 467                 gtk_signal_connect (GTK_OBJECT (outline), "event",
 468                                     GTK_SIGNAL_FUNC (passthrough_event_handler),
 469                                     item);
 470
 471                 gtk_signal_connect (GTK_OBJECT (p1), "event",
 472                                     GTK_SIGNAL_FUNC (p1_resize_event_handler),
 473                                     item);
 474                 gtk_signal_connect (GTK_OBJECT (p2), "event",
 475                                     GTK_SIGNAL_FUNC (p2_resize_event_handler),
 476                                     item);
 477
 478         } else {
 479
 480                 gnome_canvas_item_set (highlight, "x", x, "y", y, NULL);
 481
 482                 outline =
 483                     gtk_object_get_data (GTK_OBJECT (highlight), "outline");
 484
 485                 p1 = gtk_object_get_data (GTK_OBJECT (highlight), "p1");
 486                 p2 = gtk_object_get_data (GTK_OBJECT (highlight), "p2");
 487
 488                 points->coords[0] = 0.0;
 489                 points->coords[1] = 0.0;
 490                 points->coords[2] = dx;
 491                 points->coords[3] = dy;
 492                 gnome_canvas_item_set (outline, "points", points, NULL);
 493
 494                 gnome_canvas_item_set (p1,
 495                                        "x1", -1.0,
 496                                        "y1", -1.0,
 497                                        "x2", +1.0, "y2", +1.0, NULL);
 498
 499                 gnome_canvas_item_set (p2,
 500                                        "x1", dx - 1.0,
 501                                        "y1", dy - 1.0,
 502                                        "x2", dx + 1.0, "y2", dy + 1.0, NULL);
 503
 504                 gnome_canvas_item_show (highlight);
 505
 506         }
 507
 508         gnome_canvas_points_free (points);
 509
 510         gnome_canvas_item_raise_to_top (highlight);
 511
 512 }
 513
 514 /*---------------------------------------------------------------------------*/
 515 /* PRIVATE.  Create/Update & Display a simple box highlight.                 */
 516 /*---------------------------------------------------------------------------*/
 517 static void
 518 highlight_simple (GnomeCanvasItem * item)
 519 {
 520         GnomeCanvasItem *highlight;
 521         gdouble x1, y1, x2, y2;
 522
 523         g_return_if_fail (GNOME_IS_CANVAS_ITEM (item));
 524
 525         highlight = gtk_object_get_data (GTK_OBJECT (item), "highlight");
 526
 527         gl_item_get_bounds (item, &x1, &y1, &x2, &y2);
 528
 529         if (highlight == NULL) {
 530
 531                 highlight =
 532                     gnome_canvas_item_new (gnome_canvas_root
 533                                            (GNOME_CANVAS (item->canvas)),
 534                                            gnome_canvas_rect_get_type (), "x1",
 535                                            x1 - 0.5, "y1", y1 - 0.5, "x2",
 536                                            x2 + 0.5, "y2", y2 + 0.5,
 537                                            "width_pixels", 2,
 538                                            "outline_color_rgba",
 539                                            GNOME_CANVAS_COLOR_A (0, 0, 255,
 540                                                                  255), NULL);
 541
 542                 gtk_object_set_data (GTK_OBJECT (item), "highlight", highlight);
 543
 544                 gtk_signal_connect (GTK_OBJECT (highlight), "event",
 545                                     GTK_SIGNAL_FUNC (passthrough_event_handler),
 546                                     item);
 547
 548         } else {
 549
 550                 gnome_canvas_item_set (highlight,
 551                                        "x1", x1 - 0.5,
 552                                        "y1", y1 - 0.5,
 553                                        "x2", x2 + 0.5,
 554                                        "y2", y2 + 0.5,
 555                                        "width_pixels", 2,
 556                                        "outline_color_rgba",
 557                                        GNOME_CANVAS_COLOR_A (0, 0, 255, 255),
 558                                        NULL);
 559
 560                 gnome_canvas_item_show (highlight);
 561
 562         }
 563
 564         gnome_canvas_item_raise_to_top (highlight);
 565
 566 }
 567
 568 /*---------------------------------------------------------------------------*/
 569 /* PRIVATE.  "Top-left" Resize event handler.                    */
 570 /*---------------------------------------------------------------------------*/
 571 static int
 572 tl_resize_event_handler (GnomeCanvasItem * handle_item,
 573                          GdkEvent * event,
 574                          gpointer data)
 575 {
 576         gdouble x, y, w, h;
 577         static gdouble x2, y2;
 578         static gboolean dragging = FALSE;
 579         static GnomeCanvasItem *item;
 580         static glDisplay *display;
 581         GdkCursor *cursor;
 582
 583         item = GNOME_CANVAS_ITEM (data);
 584         gl_item_get_position_size (item, &x, &y, &w, &h);
 585         display = gl_item_get_display (item);
 586
 587         switch (event->type) {
 588
 589         case GDK_BUTTON_PRESS:
 590                 switch (event->button.button) {
 591                 case 1:
 592                         dragging = TRUE;
 593                         gnome_canvas_item_grab (handle_item,
 594                                                 GDK_POINTER_MOTION_MASK |
 595                                                 GDK_BUTTON_RELEASE_MASK |
 596                                                 GDK_BUTTON_PRESS_MASK,
 597                                                 NULL, event->button.time);
 598                         /* Anchor to bottom-right corner */
 599                         x2 = x + w;
 600                         y2 = y + h;
 601                         return TRUE;
 602
 603                 default:
 604                         return FALSE;
 605                 }
 606
 607         case GDK_BUTTON_RELEASE:
 608                 switch (event->button.button) {
 609                 case 1:
 610                         dragging = FALSE;
 611                         gnome_canvas_item_ungrab (handle_item,
 612                                                   event->button.time);
 613                         x = MIN (event->button.x, x2 - MIN_ITEM_SIZE);
 614                         y = MIN (event->button.y, y2 - MIN_ITEM_SIZE);
 615                         w = MAX (x2 - event->button.x, MIN_ITEM_SIZE);
 616                         h = MAX (y2 - event->button.y, MIN_ITEM_SIZE);
 617                         gl_item_set_position_size (item, x, y, w, h);
 618                         gl_display_select_item (display, item);
 619                         return TRUE;
 620
 621                 default:
 622                         return FALSE;
 623                 }
 624
 625         case GDK_MOTION_NOTIFY:
 626                 if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
 627                         x = MIN (event->button.x, x2 - MIN_ITEM_SIZE);
 628                         y = MIN (event->button.y, y2 - MIN_ITEM_SIZE);
 629                         w = MAX (x2 - event->button.x, MIN_ITEM_SIZE);
 630                         h = MAX (y2 - event->button.y, MIN_ITEM_SIZE);
 631                         gl_item_set_position_size (item, x, y, w, h);
 632                         gl_display_select_item (display, item);
 633                         return TRUE;
 634                 } else {
 635                         return FALSE;
 636                 }
 637
 638         case GDK_ENTER_NOTIFY:
 639                 cursor = gdk_cursor_new (GDK_CROSSHAIR);
 640                 gdk_window_set_cursor (display->canvas->window, cursor);
 641                 gdk_cursor_destroy (cursor);
 642                 return TRUE;
 643
 644         case GDK_LEAVE_NOTIFY:
 645                 cursor = gdk_cursor_new (GDK_LEFT_PTR);
 646                 gdk_window_set_cursor (display->canvas->window, cursor);
 647                 gdk_cursor_destroy (cursor);
 648                 return TRUE;
 649
 650         default:
 651                 return FALSE;
 652         }
 653
 654 }
 655
 656 /*---------------------------------------------------------------------------*/
 657 /* PRIVATE.  "Top-right" Resize event handler.                               */
 658 /*---------------------------------------------------------------------------*/
 659 static int
 660 tr_resize_event_handler (GnomeCanvasItem * handle_item,
 661                          GdkEvent * event,
 662                          gpointer data)
 663 {
 664         gdouble x, y, w, h;
 665         static gdouble x1, y2;
 666         static gboolean dragging = FALSE;
 667         static GnomeCanvasItem *item;
 668         static glDisplay *display;
 669         GdkCursor *cursor;
 670
 671         item = GNOME_CANVAS_ITEM (data);
 672         gl_item_get_position_size (item, &x, &y, &w, &h);
 673         display = gl_item_get_display (item);
 674
 675         switch (event->type) {
 676
 677         case GDK_BUTTON_PRESS:
 678                 switch (event->button.button) {
 679                 case 1:
 680                         dragging = TRUE;
 681                         gnome_canvas_item_grab (handle_item,
 682                                                 GDK_POINTER_MOTION_MASK |
 683                                                 GDK_BUTTON_RELEASE_MASK |
 684                                                 GDK_BUTTON_PRESS_MASK,
 685                                                 NULL, event->button.time);
 686                         /* Anchor to bottom-left corner */
 687                         x1 = x;
 688                         y2 = y + h;
 689                         return TRUE;
 690
 691                 default:
 692                         return FALSE;
 693                 }
 694
 695         case GDK_BUTTON_RELEASE:
 696                 switch (event->button.button) {
 697                 case 1:
 698                         dragging = FALSE;
 699                         gnome_canvas_item_ungrab (handle_item,
 700                                                   event->button.time);
 701                         x = x1;
 702                         y = MIN (event->button.y, y2 - MIN_ITEM_SIZE);
 703                         w = MAX (event->button.x - x1, MIN_ITEM_SIZE);
 704                         h = MAX (y2 - event->button.y, MIN_ITEM_SIZE);
 705                         gl_item_set_position_size (item, x, y, w, h);
 706                         gl_display_select_item (display, item);
 707                         return TRUE;
 708
 709                 default:
 710                         return FALSE;
 711                 }
 712
 713         case GDK_MOTION_NOTIFY:
 714                 if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
 715                         x = x1;
 716                         y = MIN (event->button.y, y2 - MIN_ITEM_SIZE);
 717                         w = MAX (event->button.x - x1, MIN_ITEM_SIZE);
 718                         h = MAX (y2 - event->button.y, MIN_ITEM_SIZE);
 719                         gl_item_set_position_size (item, x, y, w, h);
 720                         gl_display_select_item (display, item);
 721                         return TRUE;
 722                 } else {
 723                         return FALSE;
 724                 }
 725
 726         case GDK_ENTER_NOTIFY:
 727                 cursor = gdk_cursor_new (GDK_CROSSHAIR);
 728                 gdk_window_set_cursor (display->canvas->window, cursor);
 729                 gdk_cursor_destroy (cursor);
 730                 return TRUE;
 731
 732         case GDK_LEAVE_NOTIFY:
 733                 cursor = gdk_cursor_new (GDK_LEFT_PTR);
 734                 gdk_window_set_cursor (display->canvas->window, cursor);
 735                 gdk_cursor_destroy (cursor);
 736                 return TRUE;
 737
 738         default:
 739                 return FALSE;
 740         }
 741
 742 }
 743
 744 /*---------------------------------------------------------------------------*/
 745 /* PRIVATE.  "Bottom-left" Resize event handler.                             */
 746 /*---------------------------------------------------------------------------*/
 747 static int
 748 bl_resize_event_handler (GnomeCanvasItem * handle_item,
 749                          GdkEvent * event,
 750                          gpointer data)
 751 {
 752         gdouble x, y, w, h;
 753         static gdouble x2, y1;
 754         static gboolean dragging = FALSE;
 755         static GnomeCanvasItem *item;
 756         static glDisplay *display;
 757         GdkCursor *cursor;
 758
 759         item = GNOME_CANVAS_ITEM (data);
 760         gl_item_get_position_size (item, &x, &y, &w, &h);
 761         display = gl_item_get_display (item);
 762
 763         switch (event->type) {
 764
 765         case GDK_BUTTON_PRESS:
 766                 switch (event->button.button) {
 767                 case 1:
 768                         dragging = TRUE;
 769                         gnome_canvas_item_grab (handle_item,
 770                                                 GDK_POINTER_MOTION_MASK |
 771                                                 GDK_BUTTON_RELEASE_MASK |
 772                                                 GDK_BUTTON_PRESS_MASK,
 773                                                 NULL, event->button.time);
 774                         /* Anchor to top-right corner */
 775                         x2 = x + w;
 776                         y1 = y;
 777                         return TRUE;
 778
 779                 default:
 780                         return FALSE;
 781                 }
 782
 783         case GDK_BUTTON_RELEASE:
 784                 switch (event->button.button) {
 785                 case 1:
 786                         dragging = FALSE;
 787                         gnome_canvas_item_ungrab (handle_item,
 788                                                   event->button.time);
 789                         x = MIN (event->button.x, x2 - MIN_ITEM_SIZE);
 790                         y = y1;
 791                         w = MAX (x2 - event->button.x, MIN_ITEM_SIZE);
 792                         h = MAX (event->button.y - y1, MIN_ITEM_SIZE);
 793                         gl_item_set_position_size (item, x, y, w, h);
 794                         gl_display_select_item (display, item);
 795                         return TRUE;
 796
 797                 default:
 798                         return FALSE;
 799                 }
 800
 801         case GDK_MOTION_NOTIFY:
 802                 if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
 803                         x = MIN (event->button.x, x2 - MIN_ITEM_SIZE);
 804                         y = y1;
 805                         w = MAX (x2 - event->button.x, MIN_ITEM_SIZE);
 806                         h = MAX (event->button.y - y1, MIN_ITEM_SIZE);
 807                         gl_item_set_position_size (item, x, y, w, h);
 808                         gl_display_select_item (display, item);
 809                         return TRUE;
 810                 } else {
 811                         return FALSE;
 812                 }
 813
 814         case GDK_ENTER_NOTIFY:
 815                 cursor = gdk_cursor_new (GDK_CROSSHAIR);
 816                 gdk_window_set_cursor (display->canvas->window, cursor);
 817                 gdk_cursor_destroy (cursor);
 818                 return TRUE;
 819
 820         case GDK_LEAVE_NOTIFY:
 821                 cursor = gdk_cursor_new (GDK_LEFT_PTR);
 822                 gdk_window_set_cursor (display->canvas->window, cursor);
 823                 gdk_cursor_destroy (cursor);
 824                 return TRUE;
 825
 826         default:
 827                 return FALSE;
 828         }
 829
 830 }
 831
 832 /*---------------------------------------------------------------------------*/
 833 /* PRIVATE.  "Bottom-right" Resize event handler.                            */
 834 /*---------------------------------------------------------------------------*/
 835 static int
 836 br_resize_event_handler (GnomeCanvasItem * handle_item,
 837                          GdkEvent * event,
 838                          gpointer data)
 839 {
 840         gdouble x, y, w, h;
 841         static gdouble x1, y1;
 842         static gboolean dragging = FALSE;
 843         static GnomeCanvasItem *item;
 844         static glDisplay *display;
 845         GdkCursor *cursor;
 846
 847         item = GNOME_CANVAS_ITEM (data);
 848         gl_item_get_position_size (item, &x, &y, &w, &h);
 849         display = gl_item_get_display (item);
 850
 851         switch (event->type) {
 852
 853         case GDK_BUTTON_PRESS:
 854                 switch (event->button.button) {
 855                 case 1:
 856                         dragging = TRUE;
 857                         gnome_canvas_item_grab (handle_item,
 858                                                 GDK_POINTER_MOTION_MASK |
 859                                                 GDK_BUTTON_RELEASE_MASK |
 860                                                 GDK_BUTTON_PRESS_MASK,
 861                                                 NULL, event->button.time);
 862                         /* Anchor to top-left corner */
 863                         x1 = x;
 864                         y1 = y;
 865                         return TRUE;
 866
 867                 default:
 868                         return FALSE;
 869                 }
 870
 871         case GDK_BUTTON_RELEASE:
 872                 switch (event->button.button) {
 873                 case 1:
 874                         dragging = FALSE;
 875                         gnome_canvas_item_ungrab (handle_item,
 876                                                   event->button.time);
 877                         x = x1;
 878                         y = y1;
 879                         w = MAX (event->button.x - x1, MIN_ITEM_SIZE);
 880                         h = MAX (event->button.y - y1, MIN_ITEM_SIZE);
 881                         gl_item_set_position_size (item, x, y, w, h);
 882                         gl_display_select_item (display, item);
 883                         return TRUE;
 884
 885                 default:
 886                         return FALSE;
 887                 }
 888
 889         case GDK_MOTION_NOTIFY:
 890                 if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
 891                         x = x1;
 892                         y = y1;
 893                         w = MAX (event->button.x - x1, MIN_ITEM_SIZE);
 894                         h = MAX (event->button.y - y1, MIN_ITEM_SIZE);
 895                         gl_item_set_position_size (item, x, y, w, h);
 896                         gl_display_select_item (display, item);
 897                         return TRUE;
 898                 } else {
 899                         return FALSE;
 900                 }
 901
 902         case GDK_ENTER_NOTIFY:
 903                 cursor = gdk_cursor_new (GDK_CROSSHAIR);
 904                 gdk_window_set_cursor (display->canvas->window, cursor);
 905                 gdk_cursor_destroy (cursor);
 906                 return TRUE;
 907
 908         case GDK_LEAVE_NOTIFY:
 909                 cursor = gdk_cursor_new (GDK_LEFT_PTR);
 910                 gdk_window_set_cursor (display->canvas->window, cursor);
 911                 gdk_cursor_destroy (cursor);
 912                 return TRUE;
 913
 914         default:
 915                 return FALSE;
 916         }
 917
 918 }
 919
 920 /*---------------------------------------------------------------------------*/
 921 /* PRIVATE.  "Left-side" Resize event handler.                               */
 922 /*---------------------------------------------------------------------------*/
 923 static int
 924 sl_resize_event_handler (GnomeCanvasItem * handle_item,
 925                          GdkEvent * event,
 926                          gpointer data)
 927 {
 928         gdouble x, y, w, h;
 929         static gdouble x2;
 930         static gboolean dragging = FALSE;
 931         static GnomeCanvasItem *item;
 932         static glDisplay *display;
 933         GdkCursor *cursor;
 934
 935         item = GNOME_CANVAS_ITEM (data);
 936         gl_item_get_position_size (item, &x, &y, &w, &h);
 937         display = gl_item_get_display (item);
 938
 939         switch (event->type) {
 940
 941         case GDK_BUTTON_PRESS:
 942                 switch (event->button.button) {
 943                 case 1:
 944                         dragging = TRUE;
 945                         gnome_canvas_item_grab (handle_item,
 946                                                 GDK_POINTER_MOTION_MASK |
 947                                                 GDK_BUTTON_RELEASE_MASK |
 948                                                 GDK_BUTTON_PRESS_MASK,
 949                                                 NULL, event->button.time);
 950                         /* Anchor to right side */
 951                         x2 = x + w;
 952                         return TRUE;
 953
 954                 default:
 955                         return FALSE;
 956                 }
 957
 958         case GDK_BUTTON_RELEASE:
 959                 switch (event->button.button) {
 960                 case 1:
 961                         dragging = FALSE;
 962                         gnome_canvas_item_ungrab (handle_item,
 963                                                   event->button.time);
 964                         x = MIN (event->button.x, x2 - MIN_ITEM_SIZE);
 965                         w = MAX (x2 - event->button.x, MIN_ITEM_SIZE);
 966                         gl_item_set_position_size (item, x, y, w, h);
 967                         gl_display_select_item (display, item);
 968                         return TRUE;
 969
 970                 default:
 971                         return FALSE;
 972                 }
 973
 974         case GDK_MOTION_NOTIFY:
 975                 if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
 976                         x = MIN (event->button.x, x2 - MIN_ITEM_SIZE);
 977                         w = MAX (x2 - event->button.x, MIN_ITEM_SIZE);
 978                         gl_item_set_position_size (item, x, y, w, h);
 979                         gl_display_select_item (display, item);
 980                         return TRUE;
 981                 } else {
 982                         return FALSE;
 983                 }
 984
 985         case GDK_ENTER_NOTIFY:
 986                 cursor = gdk_cursor_new (GDK_CROSSHAIR);
 987                 gdk_window_set_cursor (display->canvas->window, cursor);
 988                 gdk_cursor_destroy (cursor);
 989                 return TRUE;
 990
 991         case GDK_LEAVE_NOTIFY:
 992                 cursor = gdk_cursor_new (GDK_LEFT_PTR);
 993                 gdk_window_set_cursor (display->canvas->window, cursor);
 994                 gdk_cursor_destroy (cursor);
 995                 return TRUE;
 996
 997         default:
 998                 return FALSE;
 999         }
1000
1001 }
1002
1003 /*---------------------------------------------------------------------------*/
1004 /* PRIVATE.  "Right-side" Resize event handler.                              */
1005 /*---------------------------------------------------------------------------*/
1006 static int
1007 sr_resize_event_handler (GnomeCanvasItem * handle_item,
1008                          GdkEvent * event,
1009                          gpointer data)
1010 {
1011         gdouble x, y, w, h;
1012         static gdouble x1;
1013         static gboolean dragging = FALSE;
1014         static GnomeCanvasItem *item;
1015         static glDisplay *display;
1016         GdkCursor *cursor;
1017
1018         item = GNOME_CANVAS_ITEM (data);
1019         gl_item_get_position_size (item, &x, &y, &w, &h);
1020         display = gl_item_get_display (item);
1021
1022         switch (event->type) {
1023
1024         case GDK_BUTTON_PRESS:
1025                 switch (event->button.button) {
1026                 case 1:
1027                         dragging = TRUE;
1028                         gnome_canvas_item_grab (handle_item,
1029                                                 GDK_POINTER_MOTION_MASK |
1030                                                 GDK_BUTTON_RELEASE_MASK |
1031                                                 GDK_BUTTON_PRESS_MASK,
1032                                                 NULL, event->button.time);
1033                         /* Anchor to left side */
1034                         x1 = x;
1035                         return TRUE;
1036
1037                 default:
1038                         return FALSE;
1039                 }
1040
1041         case GDK_BUTTON_RELEASE:
1042                 switch (event->button.button) {
1043                 case 1:
1044                         dragging = FALSE;
1045                         gnome_canvas_item_ungrab (handle_item,
1046                                                   event->button.time);
1047                         x = x1;
1048                         w = MAX (event->button.x - x1, MIN_ITEM_SIZE);
1049                         gl_item_set_position_size (item, x, y, w, h);
1050                         gl_display_select_item (display, item);
1051                         return TRUE;
1052
1053                 default:
1054                         return FALSE;
1055                 }
1056
1057         case GDK_MOTION_NOTIFY:
1058                 if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
1059                         x = x1;
1060                         w = MAX (event->button.x - x1, MIN_ITEM_SIZE);
1061                         gl_item_set_position_size (item, x, y, w, h);
1062                         gl_display_select_item (display, item);
1063                         return TRUE;
1064                 } else {
1065                         return FALSE;
1066                 }
1067
1068         case GDK_ENTER_NOTIFY:
1069                 cursor = gdk_cursor_new (GDK_CROSSHAIR);
1070                 gdk_window_set_cursor (display->canvas->window, cursor);
1071                 gdk_cursor_destroy (cursor);
1072                 return TRUE;
1073
1074         case GDK_LEAVE_NOTIFY:
1075                 cursor = gdk_cursor_new (GDK_LEFT_PTR);
1076                 gdk_window_set_cursor (display->canvas->window, cursor);
1077                 gdk_cursor_destroy (cursor);
1078                 return TRUE;
1079
1080         default:
1081                 return FALSE;
1082         }
1083
1084 }
1085
1086 /*---------------------------------------------------------------------------*/
1087 /* PRIVATE.  "Top-side" Resize event handler.                                */
1088 /*---------------------------------------------------------------------------*/
1089 static int
1090 st_resize_event_handler (GnomeCanvasItem * handle_item,
1091                          GdkEvent * event,
1092                          gpointer data)
1093 {
1094         gdouble x, y, w, h;
1095         static gdouble y2;
1096         static gboolean dragging = FALSE;
1097         static GnomeCanvasItem *item;
1098         static glDisplay *display;
1099         GdkCursor *cursor;
1100
1101         item = GNOME_CANVAS_ITEM (data);
1102         gl_item_get_position_size (item, &x, &y, &w, &h);
1103         display = gl_item_get_display (item);
1104
1105         switch (event->type) {
1106
1107         case GDK_BUTTON_PRESS:
1108                 switch (event->button.button) {
1109                 case 1:
1110                         dragging = TRUE;
1111                         gnome_canvas_item_grab (handle_item,
1112                                                 GDK_POINTER_MOTION_MASK |
1113                                                 GDK_BUTTON_RELEASE_MASK |
1114                                                 GDK_BUTTON_PRESS_MASK,
1115                                                 NULL, event->button.time);
1116                         /* Anchor to bottom-right corner */
1117                         y2 = y + h;
1118                         return TRUE;
1119
1120                 default:
1121                         return FALSE;
1122                 }
1123
1124         case GDK_BUTTON_RELEASE:
1125                 switch (event->button.button) {
1126                 case 1:
1127                         dragging = FALSE;
1128                         gnome_canvas_item_ungrab (handle_item,
1129                                                   event->button.time);
1130                         y = MIN (event->button.y, y2 - MIN_ITEM_SIZE);
1131                         h = MAX (y2 - event->button.y, MIN_ITEM_SIZE);
1132                         gl_item_set_position_size (item, x, y, w, h);
1133                         gl_display_select_item (display, item);
1134                         return TRUE;
1135
1136                 default:
1137                         return FALSE;
1138                 }
1139
1140         case GDK_MOTION_NOTIFY:
1141                 if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
1142                         y = MIN (event->button.y, y2 - MIN_ITEM_SIZE);
1143                         h = MAX (y2 - event->button.y, MIN_ITEM_SIZE);
1144                         gl_item_set_position_size (item, x, y, w, h);
1145                         gl_display_select_item (display, item);
1146                         return TRUE;
1147                 } else {
1148                         return FALSE;
1149                 }
1150
1151         case GDK_ENTER_NOTIFY:
1152                 cursor = gdk_cursor_new (GDK_CROSSHAIR);
1153                 gdk_window_set_cursor (display->canvas->window, cursor);
1154                 gdk_cursor_destroy (cursor);
1155                 return TRUE;
1156
1157         case GDK_LEAVE_NOTIFY:
1158                 cursor = gdk_cursor_new (GDK_LEFT_PTR);
1159                 gdk_window_set_cursor (display->canvas->window, cursor);
1160                 gdk_cursor_destroy (cursor);
1161                 return TRUE;
1162
1163         default:
1164                 return FALSE;
1165         }
1166
1167 }
1168
1169 /*---------------------------------------------------------------------------*/
1170 /* PRIVATE.  "Bottom-side" Resize event handler.                             */
1171 /*---------------------------------------------------------------------------*/
1172 static int
1173 sb_resize_event_handler (GnomeCanvasItem * handle_item,
1174                          GdkEvent * event,
1175                          gpointer data)
1176 {
1177         gdouble x, y, w, h;
1178         static gdouble y1;
1179         static gboolean dragging = FALSE;
1180         static GnomeCanvasItem *item;
1181         static glDisplay *display;
1182         GdkCursor *cursor;
1183
1184         item = GNOME_CANVAS_ITEM (data);
1185         gl_item_get_position_size (item, &x, &y, &w, &h);
1186         display = gl_item_get_display (item);
1187
1188         switch (event->type) {
1189
1190         case GDK_BUTTON_PRESS:
1191                 switch (event->button.button) {
1192                 case 1:
1193                         dragging = TRUE;
1194                         gnome_canvas_item_grab (handle_item,
1195                                                 GDK_POINTER_MOTION_MASK |
1196                                                 GDK_BUTTON_RELEASE_MASK |
1197                                                 GDK_BUTTON_PRESS_MASK,
1198                                                 NULL, event->button.time);
1199                         /* Anchor to top side */
1200                         y1 = y;
1201                         return TRUE;
1202
1203                 default:
1204                         return FALSE;
1205                 }
1206
1207         case GDK_BUTTON_RELEASE:
1208                 switch (event->button.button) {
1209                 case 1:
1210                         dragging = FALSE;
1211                         gnome_canvas_item_ungrab (handle_item,
1212                                                   event->button.time);
1213                         y = y1;
1214                         h = MAX (event->button.y - y1, MIN_ITEM_SIZE);
1215                         gl_item_set_position_size (item, x, y, w, h);
1216                         gl_display_select_item (display, item);
1217                         return TRUE;
1218
1219                 default:
1220                         return FALSE;
1221                 }
1222
1223         case GDK_MOTION_NOTIFY:
1224                 if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
1225                         y = y1;
1226                         h = MAX (event->button.y - y1, MIN_ITEM_SIZE);
1227                         gl_item_set_position_size (item, x, y, w, h);
1228                         gl_display_select_item (display, item);
1229                         return TRUE;
1230                 } else {
1231                         return FALSE;
1232                 }
1233
1234         case GDK_ENTER_NOTIFY:
1235                 cursor = gdk_cursor_new (GDK_CROSSHAIR);
1236                 gdk_window_set_cursor (display->canvas->window, cursor);
1237                 gdk_cursor_destroy (cursor);
1238                 return TRUE;
1239
1240         case GDK_LEAVE_NOTIFY:
1241                 cursor = gdk_cursor_new (GDK_LEFT_PTR);
1242                 gdk_window_set_cursor (display->canvas->window, cursor);
1243                 gdk_cursor_destroy (cursor);
1244                 return TRUE;
1245
1246         default:
1247                 return FALSE;
1248         }
1249
1250 }
1251
1252 /*---------------------------------------------------------------------------*/
1253 /* PRIVATE.  Resize "P1" event handler.                                      */
1254 /*---------------------------------------------------------------------------*/
1255 static int
1256 p1_resize_event_handler (GnomeCanvasItem * handle_item,
1257                          GdkEvent * event,
1258                          gpointer data)
1259 {
1260         gdouble x, y, dx, dy;
1261         static gdouble x0, y0;
1262         static gboolean dragging = FALSE;
1263         static GnomeCanvasItem *item;
1264         static glDisplay *display;
1265         GdkCursor *cursor;
1266
1267         item = GNOME_CANVAS_ITEM (data);
1268         gl_item_get_position_size (item, &x, &y, &dx, &dy);
1269         display = gl_item_get_display (item);
1270
1271         switch (event->type) {
1272
1273         case GDK_BUTTON_PRESS:
1274                 switch (event->button.button) {
1275                 case 1:
1276                         dragging = TRUE;
1277                         gnome_canvas_item_grab (handle_item,
1278                                                 GDK_POINTER_MOTION_MASK |
1279                                                 GDK_BUTTON_RELEASE_MASK |
1280                                                 GDK_BUTTON_PRESS_MASK,
1281                                                 NULL, event->button.time);
1282                         /* Anchor to P2 */
1283                         x0 = x + dx;
1284                         y0 = y + dy;
1285                         return TRUE;
1286
1287                 default:
1288                         return FALSE;
1289                 }
1290
1291         case GDK_BUTTON_RELEASE:
1292                 switch (event->button.button) {
1293                 case 1:
1294                         dragging = FALSE;
1295                         gnome_canvas_item_ungrab (handle_item,
1296                                                   event->button.time);
1297                         x = x0;
1298                         y = y0;
1299                         dx = (event->button.x - x0);
1300                         dy = (event->button.y - y0);
1301                         gl_item_set_position_size (item, x, y, dx, dy);
1302                         gl_display_select_item (display, item);
1303                         return TRUE;
1304
1305                 default:
1306                         return FALSE;
1307                 }
1308
1309         case GDK_MOTION_NOTIFY:
1310                 if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
1311                         x = x0;
1312                         y = y0;
1313                         dx = (event->button.x - x0);
1314                         dy = (event->button.y - y0);
1315                         gl_item_set_position_size (item, x, y, dx, dy);
1316                         gl_display_select_item (display, item);
1317                         return TRUE;
1318                 } else {
1319                         return FALSE;
1320                 }
1321
1322         case GDK_ENTER_NOTIFY:
1323                 cursor = gdk_cursor_new (GDK_CROSSHAIR);
1324                 gdk_window_set_cursor (display->canvas->window, cursor);
1325                 gdk_cursor_destroy (cursor);
1326                 return TRUE;
1327
1328         case GDK_LEAVE_NOTIFY:
1329                 cursor = gdk_cursor_new (GDK_LEFT_PTR);
1330                 gdk_window_set_cursor (display->canvas->window, cursor);
1331                 gdk_cursor_destroy (cursor);
1332                 return TRUE;
1333
1334         default:
1335                 return FALSE;
1336         }
1337
1338 }
1339
1340 /*---------------------------------------------------------------------------*/
1341 /* PRIVATE.  Resize "P2" event handler.                                      */
1342 /*---------------------------------------------------------------------------*/
1343 static int
1344 p2_resize_event_handler (GnomeCanvasItem * handle_item,
1345                          GdkEvent * event,
1346                          gpointer data)
1347 {
1348         gdouble x, y, dx, dy;
1349         static gdouble x0, y0;
1350         static gboolean dragging = FALSE;
1351         static GnomeCanvasItem *item;
1352         static glDisplay *display;
1353         GdkCursor *cursor;
1354
1355         item = GNOME_CANVAS_ITEM (data);
1356         gl_item_get_position_size (item, &x, &y, &dx, &dy);
1357         display = gl_item_get_display (item);
1358
1359         switch (event->type) {
1360
1361         case GDK_BUTTON_PRESS:
1362                 switch (event->button.button) {
1363                 case 1:
1364                         dragging = TRUE;
1365                         gnome_canvas_item_grab (handle_item,
1366                                                 GDK_POINTER_MOTION_MASK |
1367                                                 GDK_BUTTON_RELEASE_MASK |
1368                                                 GDK_BUTTON_PRESS_MASK,
1369                                                 NULL, event->button.time);
1370                         /* Anchor to P1 */
1371                         x0 = x;
1372                         y0 = y;
1373                         return TRUE;
1374
1375                 default:
1376                         return FALSE;
1377                 }
1378
1379         case GDK_BUTTON_RELEASE:
1380                 switch (event->button.button) {
1381                 case 1:
1382                         dragging = FALSE;
1383                         gnome_canvas_item_ungrab (handle_item,
1384                                                   event->button.time);
1385                         x = x0;
1386                         y = y0;
1387                         dx = (event->button.x - x0);
1388                         dy = (event->button.y - y0);
1389                         gl_item_set_position_size (item, x, y, dx, dy);
1390                         gl_display_select_item (display, item);
1391                         return TRUE;
1392
1393                 default:
1394                         return FALSE;
1395                 }
1396
1397         case GDK_MOTION_NOTIFY:
1398                 if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
1399                         x = x0;
1400                         y = y0;
1401                         dx = (event->button.x - x0);
1402                         dy = (event->button.y - y0);
1403                         gl_item_set_position_size (item, x, y, dx, dy);
1404                         gl_display_select_item (display, item);
1405                         return TRUE;
1406                 } else {
1407                         return FALSE;
1408                 }
1409
1410         case GDK_ENTER_NOTIFY:
1411                 cursor = gdk_cursor_new (GDK_CROSSHAIR);
1412                 gdk_window_set_cursor (display->canvas->window, cursor);
1413                 gdk_cursor_destroy (cursor);
1414                 return TRUE;
1415
1416         case GDK_LEAVE_NOTIFY:
1417                 cursor = gdk_cursor_new (GDK_LEFT_PTR);
1418                 gdk_window_set_cursor (display->canvas->window, cursor);
1419                 gdk_cursor_destroy (cursor);
1420                 return TRUE;
1421
1422         default:
1423                 return FALSE;
1424         }
1425
1426 }
1427
1428 /*---------------------------------------------------------------------------*/
1429 /* PRIVATE.  Passthrough event handler.                                      */
1430 /*---------------------------------------------------------------------------*/
1431 static int
1432 passthrough_event_handler (GnomeCanvasItem * handle_item,
1433                            GdkEvent * event,
1434                            gpointer data)
1435 {
1436         static GnomeCanvasItem *item;
1437         static glDisplay *display;
1438
1439         item = GNOME_CANVAS_ITEM (data);
1440         display = gl_item_get_display (item);
1441         return gl_display_item_event_handler (item, event, display);
1442
1443 }