gnome/gdesktop-icon.c

   1 /* Desktop icon widget for the Midnight Commander
   2  *
   3  * Copyright (C) 1998 The Free Software Foundation
   4  *
   5  * Author: Federico Mena <federico@nuclecu.unam.mx>
   6  */
   7
   8 #include <config.h>
   9 #include <gnome.h>
  10 #include <sys/stat.h>
  11 #include <X11/Xlib.h>
  12 #include <X11/Xutil.h>
  13 #include <gdk/gdkx.h>
  14 #include "gdesktop.h"
  15 #include "gdesktop-icon.h"
  16 #include "dir.h"
  17
  18
  19 /* Spacing between icon and text */
  20 #define SPACING 2
  21
  22
  23 /* The 50% gray stipple for selected icons */
  24 #define gray50_width 2
  25 #define gray50_height 2
  26 static char gray50_bits[] = {
  27   0x02, 0x01, };
  28
  29
  30 static void desktop_icon_class_init (DesktopIconClass *class);
  31 static void desktop_icon_init       (DesktopIcon      *dicon);
  32 static void desktop_icon_realize    (GtkWidget        *widget);
  33
  34
  35 static GtkWindowClass *parent_class;
  36
  37
  38 /**
  39  * desktop_icon_get_type
  40  *
  41  * Returns the Gtk type assigned to the DesktopIcon class.
  42  */
  43 GtkType
  44 desktop_icon_get_type (void)
  45 {
  46         static GtkType desktop_icon_type = 0;
  47
  48         if (!desktop_icon_type) {
  49                 GtkTypeInfo desktop_icon_info = {
  50                         "DesktopIcon",
  51                         sizeof (DesktopIcon),
  52                         sizeof (DesktopIconClass),
  53                         (GtkClassInitFunc) desktop_icon_class_init,
  54                         (GtkObjectInitFunc) desktop_icon_init,
  55                         NULL, /* reserved_1 */
  56                         NULL, /* reserved_2 */
  57                         (GtkClassInitFunc) NULL
  58                 };
  59
  60                 desktop_icon_type = gtk_type_unique (gtk_window_get_type (), &desktop_icon_info);
  61         }
  62
  63         return desktop_icon_type;
  64 }
  65
  66 static void
  67 desktop_icon_class_init (DesktopIconClass *class)
  68 {
  69         GtkObjectClass *object_class;
  70         GtkWidgetClass *widget_class;
  71
  72         object_class = (GtkObjectClass *) class;
  73         widget_class = (GtkWidgetClass *) class;
  74
  75         parent_class = gtk_type_class (gtk_window_get_type ());
  76
  77         widget_class->realize = desktop_icon_realize;
  78 }
  79
  80 /* Callback used when the size of the icon text item changes */
  81 static void
  82 size_changed (GnomeIconTextItem *text, gpointer data)
  83 {
  84         DesktopIcon *dicon;
  85
  86         dicon = DESKTOP_ICON (data);
  87
  88         desktop_icon_reshape (dicon);
  89 }
  90
  91 /* Callback used when the desktop icon's canvas is size_allocated.  We reset the canvas scrolling
  92  * region here, instead of doing it when the window shape changes, to avoid flicker.
  93  */
  94 static void
  95 canvas_size_allocated (GtkWidget *widget, GtkAllocation *allocation, gpointer data)
  96 {
  97         gnome_canvas_set_scroll_region (GNOME_CANVAS (widget),
  98                                         0, 0,
  99                                         allocation->width, allocation->height);
 100 }
 101
 102 static void
 103 desktop_icon_init (DesktopIcon *dicon)
 104 {
 105         GdkBitmap *stipple;
 106
 107         /* Set the window policy */
 108
 109         gtk_window_set_policy (GTK_WINDOW (dicon), TRUE, TRUE, TRUE);
 110
 111         /* Create the canvas */
 112
 113         dicon->canvas = gnome_canvas_new ();
 114         gtk_signal_connect (GTK_OBJECT (dicon->canvas), "size_allocate",
 115                             (GtkSignalFunc) canvas_size_allocated,
 116                             NULL);
 117
 118         gtk_container_add (GTK_CONTAINER (dicon), dicon->canvas);
 119         gtk_widget_show (dicon->canvas);
 120
 121         /* Create the icon and the text items */
 122
 123         dicon->icon = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS (dicon->canvas)),
 124                                              gnome_canvas_image_get_type (),
 125                                              "anchor", GTK_ANCHOR_NW,
 126                                              NULL);
 127
 128         dicon->text = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS (dicon->canvas)),
 129                                              gnome_icon_text_item_get_type (),
 130                                              NULL);
 131
 132         stipple = gdk_bitmap_create_from_data (NULL, gray50_bits, gray50_width, gray50_height);
 133         dicon->stipple = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS (dicon->canvas)),
 134                                                 gnome_canvas_rect_get_type (),
 135                                                 "fill_stipple", stipple,
 136                                                 NULL);
 137         gnome_canvas_item_hide (dicon->stipple);
 138         gdk_bitmap_unref (stipple);
 139
 140         dicon->w_changed_id = gtk_signal_connect (GTK_OBJECT (dicon->text), "width_changed",
 141                                                   (GtkSignalFunc) size_changed,
 142                                                   dicon);
 143         dicon->h_changed_id = gtk_signal_connect (GTK_OBJECT (dicon->text), "height_changed",
 144                                                   (GtkSignalFunc) size_changed,
 145                                                   dicon);
 146 }
 147
 148 static void
 149 desktop_icon_realize (GtkWidget *widget)
 150 {
 151         DesktopIcon *dicon;
 152
 153         g_return_if_fail (widget != NULL);
 154         g_return_if_fail (IS_DESKTOP_ICON (widget));
 155
 156         dicon = DESKTOP_ICON (widget);
 157
 158         if (GTK_WIDGET_CLASS (parent_class)->realize)
 159                 (* GTK_WIDGET_CLASS (parent_class)->realize) (widget);
 160
 161         /* Set the window decorations to none and hints to the appropriate combination */
 162
 163         gdk_window_set_decorations (widget->window, 0);
 164         gdk_window_set_functions (widget->window, 0);
 165
 166         /* Set the proper GNOME hints */
 167
 168         gnome_win_hints_init ();
 169
 170         if (gnome_win_hints_wm_exists ()) {
 171                 gnome_win_hints_set_layer (widget, WIN_LAYER_DESKTOP);
 172                 gnome_win_hints_set_state (widget,
 173                                            WIN_STATE_FIXED_POSITION
 174                                            | WIN_STATE_ARRANGE_IGNORE
 175                                            | WIN_STATE_STICKY);
 176                 gnome_win_hints_set_hints (widget,
 177                                            WIN_HINTS_SKIP_FOCUS
 178                                            | WIN_HINTS_SKIP_WINLIST
 179                                            | WIN_HINTS_SKIP_TASKBAR);
 180         }
 181
 182         /* Set the stipple color now that we have a style */
 183
 184         gnome_canvas_item_set (dicon->stipple,
 185                                "fill_color_gdk", &widget->style->bg[GTK_STATE_SELECTED],
 186                                NULL);
 187 }
 188
 189 /* Sets the icon from the specified image.  Does not re-create the window shape for the desktop
 190  * icon.
 191  */
 192 static void
 193 set_icon (DesktopIcon *dicon, GdkImlibImage *im)
 194 {
 195         gnome_canvas_item_set (dicon->icon,
 196                                "image", im,
 197                                "width", (double) im->rgb_width,
 198                                "height", (double) im->rgb_height,
 199                                NULL);
 200 }
 201
 202 /* Sets the text in the desktop icon, but does not re-create its window shape.  */
 203 static void
 204 set_text (DesktopIcon *dicon, char *text)
 205 {
 206         int text_height;
 207         double x1, y1, x2, y2;
 208
 209         gnome_canvas_item_get_bounds (dicon->text, &x1, &y1, &x2, &y2);
 210         text_height = y2 = y1;
 211
 212         gtk_signal_handler_block (GTK_OBJECT (dicon->text), dicon->w_changed_id);
 213         gtk_signal_handler_block (GTK_OBJECT (dicon->text), dicon->h_changed_id);
 214
 215         gnome_icon_text_item_configure (GNOME_ICON_TEXT_ITEM (dicon->text),
 216                                         0, dicon->height - text_height,
 217                                         DESKTOP_SNAP_X,
 218                                         DESKTOP_ICON_FONT,
 219                                         text,
 220                                         TRUE,
 221                                         FALSE);
 222
 223         gtk_signal_handler_unblock (GTK_OBJECT (dicon->text), dicon->w_changed_id);
 224         gtk_signal_handler_unblock (GTK_OBJECT (dicon->text), dicon->h_changed_id);
 225 }
 226
 227 /**
 228  * desktop_icon_new
 229  * @image:      Imlib image with the icon.
 230  * @text:       Text to use for the icon.
 231  *
 232  * Creates a new desktop icon widget with the specified icon image and text.  The icon has to be
 233  * positioned at the desired place.
 234  *
 235  * Returns the newly-created desktop icon widget.
 236  */
 237 GtkWidget *
 238 desktop_icon_new (GdkImlibImage *image, char *text)
 239 {
 240         DesktopIcon *dicon;
 241
 242         g_return_val_if_fail (image != NULL, NULL);
 243         g_return_val_if_fail (text != NULL, NULL);
 244
 245         dicon = gtk_type_new (desktop_icon_get_type ());
 246
 247         set_icon (dicon, image);
 248         set_text (dicon, text);
 249         desktop_icon_reshape (dicon);
 250
 251         return GTK_WIDGET (dicon);
 252 }
 253
 254 /**
 255  * desktop_icon_set_icon
 256  * @dicon:      The desktop icon to set the icon for
 257  * @image:      Imlib image with the icon.
 258  *
 259  * Sets a new icon for an existing desktop icon.
 260  */
 261 void
 262 desktop_icon_set_icon (DesktopIcon *dicon, GdkImlibImage *image)
 263 {
 264         g_return_if_fail (dicon != NULL);
 265         g_return_if_fail (IS_DESKTOP_ICON (dicon));
 266         g_return_if_fail (image != NULL);
 267
 268         set_icon (dicon, image);
 269         desktop_icon_reshape (dicon);
 270 }
 271
 272 /**
 273  * desktop_icon_set_text
 274  * @dicon:      The desktop icon to set the text for
 275  * @text:       The new text to use for the icon's title
 276  *
 277  * Sets a new title for an existing desktop icon.
 278  */
 279 void
 280 desktop_icon_set_text (DesktopIcon *dicon, char *text)
 281 {
 282         g_return_if_fail (dicon != NULL);
 283         g_return_if_fail (IS_DESKTOP_ICON (dicon));
 284         g_return_if_fail (text != NULL);
 285
 286         set_text (dicon, text);
 287         desktop_icon_reshape (dicon);
 288 }
 289
 290 /* Computes and sets a new window shape for the desktop icon */
 291 static void
 292 create_window_shape (DesktopIcon *dicon, int icon_width, int icon_height, int text_width, int text_height)
 293 {
 294         GdkImlibImage *im;
 295         GdkBitmap *mask;
 296         GdkBitmap *im_mask;
 297         GdkGC *mgc;
 298         GdkColor c;
 299         GnomeIconTextItem *i;
 300
 301         /* Create the initial mask and clear it */
 302
 303         mask = gdk_pixmap_new (GTK_WIDGET (dicon)->window, dicon->width, dicon->height, 1);
 304
 305         mgc = gdk_gc_new (mask);
 306         c.pixel = 0;
 307         gdk_gc_set_foreground (mgc, &c);
 308         gdk_draw_rectangle (mask, mgc, TRUE, 0, 0, dicon->width, dicon->height);
 309
 310         c.pixel = 1;
 311         gdk_gc_set_foreground (mgc, &c);
 312
 313         /* Paint the mask of the image */
 314
 315         im = GNOME_CANVAS_IMAGE (dicon->icon)->im;
 316         gdk_imlib_render (im, icon_width, icon_height);
 317         im_mask = gdk_imlib_move_mask (im);
 318
 319         if (im_mask && desktop_use_shaped_icons) {
 320                 gdk_draw_pixmap (mask,
 321                                  mgc,
 322                                  im_mask,
 323                                  0, 0,
 324                                  dicon->icon_x, dicon->icon_y,
 325                                  icon_width, icon_height);
 326                 gdk_imlib_free_bitmap (im_mask);
 327         } else
 328                 gdk_draw_rectangle (mask, mgc, TRUE,
 329                                     dicon->icon_x, dicon->icon_y,
 330                                     icon_width, icon_height);
 331
 332         /* Fill the area for the text */
 333
 334         i = GNOME_ICON_TEXT_ITEM (dicon->text);
 335         if (desktop_use_shaped_text && !i->editing && !i->selected)
 336                 gnome_icon_paint_text (i->ti,
 337                                        mask, mgc,
 338                                        dicon->text_x + 2,
 339                                        dicon->text_y + 2,
 340                                        GTK_JUSTIFY_CENTER);
 341         else
 342                 gdk_draw_rectangle (mask, mgc, TRUE,
 343                                     dicon->text_x,
 344                                     dicon->text_y,
 345                                     text_width, text_height);
 346
 347         if (!GTK_WIDGET_REALIZED (dicon))
 348                 gtk_widget_realize (GTK_WIDGET (dicon));
 349
 350         gtk_widget_shape_combine_mask (GTK_WIDGET (dicon), mask, 0, 0);
 351         gdk_bitmap_unref (mask);
 352         gdk_gc_unref (mgc);
 353 }
 354
 355 /**
 356  * desktop_icon_reshape
 357  * @dicon:      The desktop icon whose shape will be recalculated
 358  *
 359  * Recomputes the window shape for the specified desktop icon.  This needs to be called only when
 360  * the global desktop_use_shaped_icons flag changes.
 361  */
 362 void
 363 desktop_icon_reshape (DesktopIcon *dicon)
 364 {
 365         GtkArg args[2];
 366         int icon_width, icon_height;
 367         int text_width, text_height;
 368         int total_height;
 369         double x1, y1, x2, y2;
 370
 371         g_return_if_fail (dicon != NULL);
 372         g_return_if_fail (IS_DESKTOP_ICON (dicon));
 373
 374         /* Get size of icon image */
 375
 376         args[0].name = "width";
 377         args[1].name = "height";
 378         gtk_object_getv (GTK_OBJECT (dicon->icon), 2, args);
 379         icon_width = GTK_VALUE_DOUBLE (args[0]);
 380         icon_height = GTK_VALUE_DOUBLE (args[1]);
 381
 382         /* Get size of icon text */
 383
 384         gnome_canvas_item_get_bounds (dicon->text, &x1, &y1, &x2, &y2);
 385
 386         text_width = x2 - x1;
 387         text_height = y2 - y1;
 388
 389         total_height = icon_height + SPACING + text_height;
 390
 391         /* Calculate new size of widget */
 392
 393         dicon->width = MAX (icon_width, DESKTOP_SNAP_X);
 394         dicon->height = MAX (total_height, DESKTOP_SNAP_Y);
 395
 396         /* Set new position of children */
 397
 398         gnome_canvas_item_set (dicon->icon,
 399                                "x", (dicon->width - icon_width) / 2.0,
 400                                "y", (dicon->height - total_height) / 2.0,
 401                                NULL);
 402         gnome_canvas_item_set (dicon->stipple,
 403                                "x1", 0.0,
 404                                "y1", 0.0,
 405                                "x2", (double) dicon->width,
 406                                "y2", (double) dicon->height - text_height - SPACING,
 407                                NULL);
 408
 409         if (dicon->width <= DESKTOP_SNAP_X)
 410                 gnome_icon_text_item_setxy (GNOME_ICON_TEXT_ITEM (dicon->text),
 411                                             0,
 412                                             dicon->height - text_height);
 413         else
 414                 gnome_icon_text_item_setxy (GNOME_ICON_TEXT_ITEM (dicon->text),
 415                                             (dicon->width - DESKTOP_SNAP_X) / 2,
 416                                             dicon->height - text_height);
 417
 418         gtk_widget_set_usize (GTK_WIDGET (dicon), dicon->width, dicon->height);
 419
 420         dicon->icon_x = (int) ((dicon->width - icon_width) / 2.0 + 0.5);
 421         dicon->icon_y = (int) ((dicon->height - total_height) / 2.0 + 0.5);
 422         dicon->icon_w = icon_width;
 423         dicon->icon_h = icon_height;
 424
 425         gnome_canvas_item_get_bounds (dicon->text, &x1, &y1, &x2, &y2);
 426
 427         dicon->text_x = x1;
 428         dicon->text_y = y1;
 429         dicon->text_w = text_width;
 430         dicon->text_h = text_height;
 431
 432         /* Create and set the window shape */
 433
 434         create_window_shape (dicon, icon_width, icon_height, text_width, text_height);
 435
 436 }
 437
 438 /**
 439  * desktop_icon_select
 440  * @dicon:      The desktop icon which will be selected/unselected
 441  * @sel:        TRUE if icon should be selected, FALSE if it should be unselected
 442  *
 443  * Selects or unselects the icon.  This means setting the selection flag of the icon text item as
 444  * appropriate, and displaying the icon image as selected or not.
 445  */
 446 void
 447 desktop_icon_select (DesktopIcon *dicon, int sel)
 448 {
 449         g_return_if_fail (dicon != NULL);
 450         g_return_if_fail (IS_DESKTOP_ICON (dicon));
 451
 452         gnome_icon_text_item_select (GNOME_ICON_TEXT_ITEM (dicon->text), sel);
 453
 454         if (desktop_use_shaped_text)
 455                 desktop_icon_reshape (dicon);
 456
 457         if (sel)
 458                 gnome_canvas_item_show (dicon->stipple);
 459         else
 460                 gnome_canvas_item_hide (dicon->stipple);
 461 }