← Back to branch summary

~ubuntu-branches/ubuntu/edgy/gtk2-engines/edgy

« back to all changes in this revision

Viewing changes to engines/redmond/src/redmond_gtk2_misc.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2006-07-25 11:08:46 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20060725110846-uwksdyyifgaxnaep
Tags: 1:2.7.6-0ubuntu1
* New upstream release.
* debian/rules:
  - enable --enable-animation.
* Resynchronized with Debian, no Ubuntu changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
engines/redmond/src/redmond_gtk2_misc.c
23
23
#include "redmond_gtk2_drawing.h"
24
24
#include "redmond_gtk2_misc.h"
25
25
 
26
 
static char radio_base_bits[] = {
27
 
  0x00,0x00,0x00,0x00,0xf0,0x01,0xf8,0x03,0xfc,0x07,0xfc,0x07,0xfc,0x07,0xfc,
28
 
  0x07,0xfc,0x07,0xf8,0x03,0xf0,0x01,0x00,0x00,0x00,0x00,0x00,0x00};
29
 
static char radio_black_bits[] = {
30
 
  0x00,0x00,0xf0,0x01,0x0c,0x02,0x04,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,
31
 
  0x00,0x02,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0d,0x08};
32
 
static char radio_dark_bits[] = {
33
 
  0xf0,0x00,0x0c,0x02,0x02,0x00,0x02,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,
34
 
  0x00,0x00,0x00,0x02,0x00,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
35
 
static char radio_light_bits[] = {
36
 
  0x00,0x00,0x00,0x04,0x00,0x08,0x00,0x08,0x00,0x10,0x00,0x10,0x00,0x10,0x00,
37
 
  0x10,0x00,0x10,0x00,0x08,0x00,0x08,0x08,0x06,0xf0,0x01,0x00,0x00};
38
 
static char radio_mid_bits[] = {
39
 
  0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x04,0x00,0x08,0x00,0x08,0x00,0x08,0x00,
40
 
  0x08,0x00,0x08,0x00,0x04,0x00,0x06,0xf0,0x01,0x00,0x00,0x00,0x00};
41
 
static char radio_text_bits[] = {
42
 
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0x00,0xf0,0x01,0xf0,0x01,0xf0,
43
 
  0x01,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
44
 
 
45
 
static struct
46
 
{
47
 
  char *bits;
48
 
  GdkBitmap *bmap;
49
 
} parts[] =
50
 
{
51
 
  {
52
 
  radio_base_bits, NULL},
53
 
  {
54
 
  radio_black_bits, NULL},
55
 
  {
56
 
  radio_dark_bits, NULL},
57
 
  {
58
 
  radio_light_bits, NULL},
59
 
  {
60
 
  radio_mid_bits, NULL},
61
 
  {
62
 
  radio_text_bits, NULL}
63
 
};
64
 
 
65
 
 
66
 
/* Widget Type Lookups/Macros
67
 
   
68
 
   Based on/modified from functions in
69
 
   Smooth-Engine.
70
 
*/ 
71
 
gboolean
72
 
redmond_object_is_a (GtkWidget * widget, gchar * type_name)
73
 
{
74
 
  gboolean result = FALSE;
75
 
 
76
 
  if ((widget))
77
 
    {
78
 
      GType tmp = g_type_from_name (type_name);
79
 
      if (tmp)
80
 
        result = g_type_check_instance_is_a ((GTypeInstance *) widget, tmp);
81
 
    }
82
 
 
83
 
  return result;
84
 
}
85
 
 
86
 
gboolean
87
 
redmond_is_combo_box_entry (GtkWidget * widget)
88
 
{
89
 
  gboolean result = FALSE;
90
 
 
91
 
  if ((widget) && (widget->parent))
92
 
    {
93
 
      if (IS_COMBO_BOX_ENTRY (widget->parent))
94
 
        result = TRUE;
95
 
      else
96
 
        result = redmond_is_combo_box_entry (widget->parent);
97
 
    }
98
 
  return result;
99
 
}
100
 
 
101
 
static gboolean
102
 
combo_box_is_using_list (GtkWidget * widget)
103
 
{
104
 
  gboolean result = FALSE;
105
 
 
106
 
  if ((widget) && (IS_COMBO_BOX (widget->parent)))
107
 
    {
108
 
      gboolean *tmp = NULL;
109
 
 
110
 
      gtk_widget_style_get (widget, "appears-as-list", &result, NULL);
111
 
 
112
 
      if (tmp)
113
 
        result = *tmp;
114
 
    }
115
 
 
116
 
  return result;
117
 
}
118
 
 
119
 
gboolean
120
 
redmond_is_combo_box (GtkWidget * widget, gboolean as_list)
121
 
{
122
 
  gboolean result = FALSE;
123
 
 
124
 
  if ((widget) && (widget->parent))
125
 
    {
126
 
      if (IS_COMBO_BOX (widget->parent))
127
 
        {
128
 
          if (as_list)
129
 
            result = (combo_box_is_using_list(widget));
130
 
          else
131
 
            result = (!combo_box_is_using_list(widget));
132
 
        }
133
 
      else
134
 
        result = redmond_is_combo_box (widget->parent, as_list);
135
 
    }
136
 
  return result;
137
 
}
138
 
 
139
 
gboolean
140
 
redmond_is_combo (GtkWidget * widget)
141
 
{
142
 
  gboolean result = FALSE;
143
 
 
144
 
  if ((widget) && (widget->parent))
145
 
    {
146
 
      if (IS_COMBO (widget->parent))
147
 
        result = TRUE;
148
 
      else
149
 
        result = redmond_is_combo (widget->parent);
150
 
    }
151
 
  return result;
152
 
}
153
 
 
154
 
gboolean
155
 
redmond_is_in_combo_box (GtkWidget * widget)
156
 
{
157
 
  return ((redmond_is_combo (widget) || redmond_is_combo_box (widget, TRUE) || redmond_is_combo_box_entry (widget)));
158
 
}
159
 
 
160
 
gboolean
161
 
redmond_is_toolbar_item (GtkWidget * widget)
162
 
{
163
 
  gboolean result = FALSE;
164
 
 
165
 
  if ((widget) && (widget->parent)) {
166
 
    if ((IS_BONOBO_TOOLBAR (widget->parent))
167
 
        || (IS_BONOBO_DOCK_ITEM (widget->parent))
168
 
        || (IS_EGG_TOOLBAR (widget->parent))
169
 
        || (IS_TOOLBAR (widget->parent))
170
 
        || (IS_HANDLE_BOX (widget->parent)))
171
 
      result = TRUE;
172
 
    else
173
 
      result = redmond_is_toolbar_item (widget->parent);
174
 
  }
175
 
  return result;
176
 
}
177
 
 
178
 
gboolean
179
 
redmond_is_panel_widget_item (GtkWidget * widget)
180
 
{
181
 
  gboolean result = FALSE;
182
 
 
183
 
  if ((widget) && (widget->parent))
184
 
    {
185
 
      if (IS_PANEL_WIDGET (widget->parent))
186
 
        result = TRUE;
187
 
      else
188
 
        result = redmond_is_panel_widget_item (widget->parent);
189
 
    }
190
 
  return result;
191
 
}
192
 
 
193
 
gboolean 
194
 
redmond_is_bonobo_dock_item (GtkWidget * widget)
195
 
{
196
 
  gboolean result = FALSE;
197
 
 
198
 
  if ((widget))
199
 
    {
200
 
      if (IS_BONOBO_DOCK_ITEM(widget) || IS_BONOBO_DOCK_ITEM (widget->parent))
201
 
        result = TRUE;
202
 
      else if (IS_BOX(widget) || IS_BOX(widget->parent))
203
 
        {
204
 
          GtkContainer *box = IS_BOX(widget)?GTK_CONTAINER(widget):GTK_CONTAINER(widget->parent);
205
 
          GList *children = NULL, *child = NULL;
206
 
 
207
 
          children = gtk_container_get_children(box);
208
 
              
209
 
          for (child = g_list_first(children); child; child = g_list_next(child))
210
 
            {
211
 
              if (IS_BONOBO_DOCK_ITEM_GRIP(child->data))
212
 
                {
213
 
                  result = TRUE;
214
 
                  child = NULL;
215
 
                }
216
 
            }               
217
 
         
218
 
          if (children)   
219
 
            g_list_free(children);
220
 
        }
221
 
    }
222
 
  return result;
223
 
}
224
 
 
225
 
/***********************************************/
226
 
/* Widget Sizing                               */
227
 
/***********************************************/
228
 
 
229
 
/***********************************************
230
 
 * redmond_sanitize_parameters -
231
 
 *  
232
 
 *   Ensure Size and Values are valid
233
 
 *
234
 
 *   Taken from Smooth based on Metal
235
 
 ***********************************************/
236
 
gboolean
237
 
redmond_sanitize_parameters(GtkStyle * style,
238
 
                    GdkWindow * window,
239
 
                    gint * width,
240
 
                    gint * height)
241
 
{
242
 
  if (!style) return FALSE;
243
 
  if (!window) return FALSE;
244
 
 
245
 
  if ((width) && (height)) {
246
 
    if ((*width == -1) && (*height == -1))
247
 
      gdk_drawable_get_size (window, width, height);
248
 
    else if (*width == -1)
249
 
      gdk_drawable_get_size(window, width, NULL);
250
 
    else if (*height == -1)
251
 
      gdk_drawable_get_size (window, NULL, height);  
252
 
  }
253
 
  return TRUE;  
254
 
}
255
 
 
256
 
/***********************************************
257
 
 * redmond_option_menu_get_props -
258
 
 *  
259
 
 *   Find Option Menu Size and Spacing
260
 
 *
261
 
 *   Taken from Smooth
262
 
 ***********************************************/ 
263
 
static GtkRequisition default_option_indicator_size = { 9, 5 }; 
264
 
static GtkBorder default_option_indicator_spacing = { 7, 5, 2, 2 }; 
265
 
 
266
 
void
267
 
redmond_option_menu_get_props (GtkWidget * widget,
268
 
                       GtkRequisition * indicator_size,
269
 
                       GtkBorder * indicator_spacing)
270
 
{
271
 
  GtkRequisition *tmp_size = NULL;
272
 
  GtkBorder *tmp_spacing = NULL;
273
 
 
274
 
  if ((widget) && IS_OPTION_MENU(widget))
275
 
    gtk_widget_style_get (widget,
276
 
                          "indicator_size", &tmp_size,
277
 
                          "indicator_spacing", &tmp_spacing, NULL);
278
 
 
279
 
  if (tmp_size)
280
 
    {
281
 
      *indicator_size = *tmp_size;
282
 
      g_free (tmp_size);
283
 
    }
284
 
  else
285
 
    *indicator_size = default_option_indicator_size;
286
 
 
287
 
  if (tmp_spacing)
288
 
    {
289
 
      *indicator_spacing = *tmp_spacing;
290
 
      g_free (tmp_spacing);
291
 
    }
292
 
  else
293
 
    *indicator_spacing = default_option_indicator_spacing;
294
 
}
295
 
 
296
 
/***********************************************/
297
 
/* Colour Shade Routines                       */
298
 
/***********************************************/
299
 
 
300
 
/***********************************************
301
 
 * color_get_rgb_from_hsb -
302
 
 *  
303
 
 *   Get HSB values from RGB values.
304
 
 *
305
 
 *   Taken from Smooth but originated in GTK+
306
 
 ***********************************************/
307
 
static void
308
 
color_get_hsb_from_rgb (gdouble red, 
309
 
                        gdouble green, 
310
 
                        gdouble blue,   
311
 
                        gdouble *hue, 
312
 
                        gdouble *saturation,
313
 
                        gdouble *brightness) 
314
 
{
315
 
  gdouble min, max, delta;
316
 
    
317
 
  if (red > green)
318
 
    {
319
 
      max = MAX(red, blue);
320
 
      min = MIN(green, blue);      
321
 
    }
322
 
  else
323
 
    {
324
 
      max = MAX(green, blue);
325
 
      min = MIN(red, blue);      
326
 
    }
327
 
  
328
 
  *brightness = (max + min) / 2;
329
 
        
330
 
  if (max == min)
331
 
    {
332
 
      *hue = 0;
333
 
      *saturation = 0;
334
 
    }   
335
 
  else
336
 
    {
337
 
      if (*brightness <= 0.5)
338
 
        *saturation = (max - min) / (max + min);
339
 
      else
340
 
        *saturation = (max - min) / (2 - max - min);
341
 
       
342
 
      delta = max -min;
343
 
 
344
 
      if (red == max)
345
 
        *hue = (green - blue) / delta;
346
 
      else if (green == max)
347
 
        *hue = 2 + (blue - red) / delta;
348
 
      else if (blue == max)
349
 
        *hue = 4 + (red - green) / delta;
350
 
 
351
 
      *hue *= 60;
352
 
      if (*hue < 0.0)
353
 
        *hue += 360;
354
 
    }
355
 
}
356
 
 
357
 
/***********************************************
358
 
 * color_get_rgb_from_hsb -
359
 
 *  
360
 
 *   Get RGB values from HSB values.
361
 
 *
362
 
 *   Taken from Smooth but originated in GTK+
363
 
 ***********************************************/
364
 
#define MODULA(number, divisor) (((gint)number % divisor) + (number - (gint)number))
365
 
static void
366
 
color_get_rgb_from_hsb (gdouble hue, 
367
 
                        gdouble saturation,
368
 
                        gdouble brightness, 
369
 
                        gdouble *red, 
370
 
                        gdouble *green, 
371
 
                        gdouble *blue)
372
 
{
373
 
  gint i;
374
 
  gdouble hue_shift[3], color_shift[3];
375
 
  gdouble m1, m2, m3;
376
 
          
377
 
  if (brightness <= 0.5)
378
 
    m2 = brightness * (1 + saturation);
379
 
  else
380
 
    m2 = brightness + saturation - brightness * saturation;
381
 
 
382
 
  m1 = 2 * brightness - m2;
383
 
 
384
 
  hue_shift[0] = hue + 120;
385
 
  hue_shift[1] = hue;
386
 
  hue_shift[2] = hue - 120;
387
 
 
388
 
  color_shift[0] = color_shift[1] = color_shift[2] = brightness;        
389
 
 
390
 
  i = (saturation == 0)?3:0;
391
 
 
392
 
  for (; i < 3; i++)
393
 
    {
394
 
      m3 = hue_shift[i];
395
 
 
396
 
      if (m3 > 360)
397
 
        m3 = MODULA(m3, 360);
398
 
      else if (m3 < 0)
399
 
        m3 = 360 - MODULA(ABS(m3), 360);
400
 
 
401
 
      if (m3 < 60)
402
 
        color_shift[i] = m1 + (m2 - m1) * m3 / 60;
403
 
      else if (m3 < 180)
404
 
        color_shift[i] = m2;
405
 
      else if (m3 < 240)
406
 
        color_shift[i] = m1 + (m2 - m1) * (240 - m3) / 60;
407
 
      else
408
 
        color_shift[i] = m1;
409
 
    }   
410
 
 
411
 
  *red = color_shift[0];
412
 
  *green = color_shift[1];
413
 
  *blue = color_shift[2];       
414
 
}
415
 
 
416
 
/***********************************************
417
 
 * redmond_composite_color_shade -
418
 
 *  
419
 
 *   Calculate a composite color shade ratio.
420
 
 *
421
 
 *   Taken from Smooth but originated in GTK+
422
 
 ***********************************************/
423
 
void
424
 
redmond_composite_color_shade(GdkColor *original, 
425
 
                      gdouble shade_ratio,
426
 
                      GdkColor *composite)
427
 
{
428
 
  gdouble red=0;
429
 
  gdouble green=0;
430
 
  gdouble blue=0;
431
 
 
432
 
  gdouble hue = 0;
433
 
  gdouble saturation = 0;
434
 
  gdouble brightness = 0;
435
 
 
436
 
  red = (gdouble) original->red / 65535.0;
437
 
  green = (gdouble) original->green / 65535.0;
438
 
  blue = (gdouble) original->blue / 65535.0;
439
 
 
440
 
  color_get_hsb_from_rgb (red, green, blue, &hue, &saturation, &brightness);
441
 
 
442
 
  brightness = MIN(brightness*shade_ratio, 1.0);
443
 
  brightness = MAX(brightness, 0.0);
444
 
  
445
 
  saturation = MIN(saturation*shade_ratio, 1.0);
446
 
  saturation = MAX(saturation, 0.0);
447
 
  
448
 
  color_get_rgb_from_hsb (hue, saturation, brightness, &red, &green, &blue);
449
 
 
450
 
  composite->red = red * 65535.0;
451
 
  composite->green = green * 65535.0;
452
 
  composite->blue = blue * 65535.0;
453
 
}
454
 
 
455
 
/***********************************************/
456
 
/* Base Drawing Routines                       */
457
 
/***********************************************/
458
 
 
459
 
/***********************************************
460
 
 * redmond_draw_part -
461
 
 *  
462
 
 *   draw a bits generated pixmap part with a
463
 
 *   specific gc.
464
 
 ***********************************************/
465
 
void
466
 
redmond_draw_part (GdkDrawable * drawable,
467
 
           GdkGC * gc, 
468
 
           GdkRectangle * area, 
469
 
           gint x, 
470
 
           gint y, 
471
 
           Part part)
472
 
{
473
 
  if (area)
474
 
    gdk_gc_set_clip_rectangle (gc, area);
475
 
 
476
 
  if (!parts[part].bmap)
477
 
    parts[part].bmap = gdk_bitmap_create_from_data (drawable,
478
 
                                                    parts[part].bits,
479
 
                                                    PART_SIZE, PART_SIZE);
480
 
 
481
 
  gdk_gc_set_ts_origin (gc, x, y);
482
 
  gdk_gc_set_stipple (gc, parts[part].bmap);
483
 
  gdk_gc_set_fill (gc, GDK_STIPPLED);
484
 
 
485
 
  gdk_draw_rectangle (drawable, gc, TRUE, x, y, PART_SIZE, PART_SIZE);
486
 
 
487
 
  gdk_gc_set_fill (gc, GDK_SOLID);
488
 
 
489
 
  if (area)
490
 
    gdk_gc_set_clip_rectangle (gc, NULL);
491
 
}
492
 
 
493
 
/***********************************************
494
 
 * do_redmond_draw_fill -
495
 
 *  
496
 
 *   A simple routine to fill with the bg_gc
497
 
 ***********************************************/
498
 
void
499
 
do_redmond_draw_default_fill (GtkStyle *style, 
500
 
                              GdkWindow *window, 
501
 
                              GtkStateType state_type, 
502
 
                              GdkRectangle *area, 
503
 
                              gint x, 
504
 
                              gint y, 
505
 
                              gint width, 
506
 
                              gint height)
507
 
{
508
 
      if (area)
509
 
        gdk_gc_set_clip_rectangle(style->bg_gc[state_type], area);
510
 
        
511
 
      gdk_draw_rectangle (window, style->bg_gc[state_type], TRUE,
512
 
                          x, y,width, height);
513
 
 
514
 
      if (area)
515
 
        gdk_gc_set_clip_rectangle(style->bg_gc[state_type], NULL);
516
 
}
517
 
 
518
 
/***********************************************
519
 
 * do_redmond_draw_cross_hatch_fill -
520
 
 *  
521
 
 *   A simple routine to draw a thin cross-hatch 
522
 
 *   background fill. This is use for Scrollbar
523
 
 *   Trough's and greyed Checkbox's
524
 
 *    
525
 
 *   It originated in Smooth-Engine.
526
 
 ***********************************************/
527
 
void
528
 
do_redmond_draw_cross_hatch_fill (GtkStyle * style,
529
 
                                  GdkWindow * window,
530
 
                                  GtkStateType state,
531
 
                                  GdkRectangle * area,
532
 
                                  Part part,
533
 
                                  gint x,
534
 
                                  gint y, 
535
 
                                  gint width, 
536
 
                                  gint height)
537
 
{
538
 
  GdkGCValues gc_values;
539
 
  GdkGC *gc;
540
 
  GdkPixmap *pixmap;
541
 
 
542
 
  pixmap = gdk_pixmap_new (window, 2, 2, -1);
543
 
 
544
 
  gdk_draw_point (pixmap, style->bg_gc[state], 0, 0);
545
 
  gdk_draw_point (pixmap, style->bg_gc[state], 1, 1);
546
 
  gdk_draw_point (pixmap, style->light_gc[state], 1, 0);
547
 
  gdk_draw_point (pixmap, style->light_gc[state], 0, 1);
548
 
 
549
 
  gc_values.fill = GDK_TILED;
550
 
  gc_values.tile = pixmap;
551
 
  gc_values.ts_x_origin = x;
552
 
  gc_values.ts_y_origin = y;
553
 
  gc = gdk_gc_new_with_values (window, &gc_values,
554
 
                               GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN |
555
 
                               GDK_GC_FILL | GDK_GC_TILE);
556
 
 
557
 
  if (part != RADIO_NONE)
558
 
  {
559
 
    if (!parts[part].bmap)
560
 
      parts[part].bmap = gdk_bitmap_create_from_data (window,
561
 
                                                      parts[part].bits,
562
 
                                                      PART_SIZE, PART_SIZE);
563
 
    gdk_gc_set_clip_origin (gc, x, y);  
564
 
    gdk_gc_set_clip_mask(gc, parts[part].bmap);
565
 
  }
566
 
  else if (area)
567
 
    gdk_gc_set_clip_rectangle (gc, area);
568
 
 
569
 
  gdk_draw_rectangle (window, gc, TRUE, x, y, width, height);
570
 
 
571
 
  g_object_unref (gc);
572
 
  g_object_unref (pixmap);
573
 
}
574
 
 
575
 
/***********************************************
576
 
 * do_redmond_draw_shadow -
577
 
 *  
578
 
 *   A simple routine to draw thin border
579
 
 *   with a topleft and bottomright gc.
580
 
 *   Used to cut down the length of all the 
581
 
 *   functions.
582
 
 *    
583
 
 *   It originated in Smooth-Engine.
584
 
 ***********************************************/
585
 
void
586
 
do_redmond_draw_shadow (GdkWindow * window,
587
 
                GdkGC * tl_gc,
588
 
                GdkGC * br_gc,
589
 
                gint x,
590
 
                gint y, 
591
 
                gint width, 
592
 
                gint height, 
593
 
                gboolean topleft_overlap)
594
 
{
595
 
  if (topleft_overlap)
596
 
    {
597
 
      gdk_draw_line (window, br_gc, x, y + height - 1, x + width - 1,
598
 
                     y + height - 1);
599
 
      gdk_draw_line (window, br_gc, x + width - 1, y, x + width - 1,
600
 
                     y + height - 1);
601
 
    }
602
 
 
603
 
  gdk_draw_line (window, tl_gc, x, y, x, y + height - 1);
604
 
  gdk_draw_line (window, tl_gc, x, y, x + width - 1, y);
605
 
 
606
 
  if (!topleft_overlap)
607
 
    {
608
 
      gdk_draw_line (window, br_gc, x, y + height - 1, x + width - 1,
609
 
                     y + height - 1);
610
 
      gdk_draw_line (window, br_gc, x + width - 1, y, x + width - 1,
611
 
                     y + height - 1);
612
 
    }
613
 
}
614
 
 
 
26
void
 
27
do_redmond_draw_pattern_fill (cairo_t * cr,
 
28
                                  CairoPattern *pattern,
 
29
                                  gint x,
 
30
                                  gint y, 
 
31
                                  gint width, 
 
32
                                  gint height)
 
33
{
 
34
        cairo_matrix_t original_matrix, current_matrix;
 
35
 
 
36
        cairo_pattern_get_matrix(pattern->handle, &original_matrix);
 
37
        current_matrix = original_matrix;
 
38
 
 
39
        if (pattern->scale != REDMOND_DIRECTION_NONE)
 
40
        {
 
41
                gdouble scale_x = 1.0;
 
42
                gdouble scale_y = 1.0;
 
43
 
 
44
                if ((pattern->scale == REDMOND_DIRECTION_VERTICAL) || (pattern->scale == REDMOND_DIRECTION_BOTH))
 
45
                {
 
46
                        scale_x = 1.0/width;
 
47
                }
 
48
 
 
49
                if ((pattern->scale == REDMOND_DIRECTION_HORIZONTAL) || (pattern->scale == REDMOND_DIRECTION_BOTH))
 
50
                {
 
51
                        scale_y = 1.0/height;
 
52
                }
 
53
 
 
54
                cairo_matrix_scale(&current_matrix, scale_x, scale_y);
 
55
        }
 
56
 
 
57
        if (pattern->translate != REDMOND_DIRECTION_NONE)
 
58
        {
 
59
                gdouble translate_x = 0;
 
60
                gdouble translate_y = 0;
 
61
 
 
62
                if ((pattern->translate == REDMOND_DIRECTION_VERTICAL) || (pattern->translate == REDMOND_DIRECTION_BOTH))
 
63
                {
 
64
                        translate_x = -x;
 
65
                }
 
66
 
 
67
                if ((pattern->translate == REDMOND_DIRECTION_HORIZONTAL) || (pattern->translate == REDMOND_DIRECTION_BOTH))
 
68
                {
 
69
                        translate_y = -y;
 
70
                }
 
71
 
 
72
                cairo_matrix_translate(&current_matrix, translate_x, translate_y);
 
73
        }
 
74
 
 
75
        cairo_pattern_set_matrix(pattern->handle, &current_matrix);
 
76
 
 
77
        cairo_save(cr);
 
78
 
 
79
        cairo_set_source(cr, pattern->handle);
 
80
 
 
81
        cairo_rectangle(cr, x, y, width, height);
 
82
 
 
83
        cairo_fill (cr);
 
84
 
 
85
        cairo_restore(cr);
 
86
 
 
87
        cairo_pattern_set_matrix(pattern->handle, &original_matrix);
 
88
}
 
89
 
 
90
void
 
91
do_redmond_draw_masked_fill (cairo_t * cr,
 
92
                                  CairoPattern *mask,
 
93
                                  CairoColor * background,
 
94
                                  CairoColor * foreground,
 
95
                                  gint x,
 
96
                                  gint y, 
 
97
                                  gint width, 
 
98
                                  gint height)
 
99
{
 
100
        ge_cairo_set_color(cr, background);
 
101
        cairo_rectangle (cr, x, y, width, height);
 
102
        cairo_fill(cr);
 
103
 
 
104
        ge_cairo_set_color(cr, foreground);
 
105
        cairo_rectangle (cr, x, y, width, height);
 
106
        cairo_mask (cr, mask->handle);
 
107
}
 
108
  
615
109
/***********************************************
616
110
 * do_redmond_draw_check -
617
111
 *  
618
112
 *   A simple routine to draw a redmond style
619
 
 *   check mark using the passed GC.
 
113
 *   check mark using the passed Color.
620
114
 *  
621
115
 *   It originated in Smooth-Engine.
622
116
 ***********************************************/
623
117
void
624
 
do_redmond_draw_check (GdkWindow * window,
625
 
               GdkGC * gc,
626
 
               gint x, 
627
 
               gint y, 
628
 
               gint width, 
629
 
               gint height)
630
 
{
631
 
  x += 1;
632
 
  y += 1;
633
 
  width -= 2;
634
 
  height -= 2;
635
 
 
636
 
  /* short diagonal */
637
 
  gdk_draw_line (window, gc, x + 0, y + height - 5, x + 0, y + height - 3);     /* Left Line */
638
 
  gdk_draw_line (window, gc, x + 1, y + height - 4, x + 1, y + height - 2);     /* Right Line */
639
 
 
640
 
  /* Long Diagonal */
641
 
  gdk_draw_line (window, gc, x + 2, y + height - 3, x + width - 1, y + 0);      /* Top Line */
642
 
  gdk_draw_line (window, gc, x + 2, y + height - 2, x + width - 1, y + 1);      /* Center Line */
643
 
  gdk_draw_line (window, gc, x + 2, y + height - 1, x + width - 1, y + 2);      /* Bottom Line */
 
118
do_redmond_draw_check (cairo_t *canvas,
 
119
                       CairoColor * color,
 
120
                       gint x, 
 
121
                       gint y, 
 
122
                       gint width, 
 
123
                       gint height)
 
124
{ 
 
125
  gint odd = 0;
 
126
  gdouble left, top;
 
127
  gint scale, factor;
 
128
 
 
129
  scale = MIN(width, height);
 
130
 
 
131
  factor = 10;
 
132
 
 
133
  if (odd = (scale % 2))
 
134
  {
 
135
    factor -= 1;
 
136
  }
 
137
 
 
138
  if (scale <= (factor + 2))
 
139
    scale = factor;
 
140
 
 
141
  left = x + floor((width - scale) / 2) + 0.5;
 
142
  top = y + floor((height - scale) / 2) + 0.5;
 
143
 
 
144
  cairo_save(canvas);
 
145
 
 
146
  ge_cairo_set_color(canvas, color);    
 
147
  cairo_set_line_width(canvas, 0.5);
 
148
/*
 
149
 
 
150
EVEN - 
 
151
 
 
152
    0   1   2   3   4   5   6   7   8   9
 
153
  +---+---+---+---+---+---+---+---+---+---+
 
154
0 |   |   |   |   |   |   |   |   |   |   |
 
155
  +---+---+---+---+---+---+---+---+---+---+
 
156
1 |   |   |   |   |   |   |   |   | x |   |
 
157
  +---+---+---+---+---+---+---+---+---+---+
 
158
2 |   |   |   |   |   |   |   | x | x |   |
 
159
  +---+---+---+---+---+---+---+---+---+---+
 
160
3 |   |   |   |   |   |   | x | x | x |   |
 
161
  +---+---+---+---+---+---+---+---+---+---+
 
162
4 |   | x |   |   |   | x | x | x |   |   |
 
163
  +---+---+---+---+---+---+---+---+---+---+
 
164
5 |   | x | x |   | x | x | x |   |   |   |
 
165
  +---+---+---+---+---+---+---+---+---+---+
 
166
6 |   | x | x | x | x | x |   |   |   |   |
 
167
  +---+---+---+---+---+---+---+---+---+---+
 
168
7 |   |   | x | x | x |   |   |   |   |   |
 
169
  +---+---+---+---+---+---+---+---+---+---+
 
170
8 |   |   |   | x |   |   |   |   |   |   |
 
171
  +---+---+---+---+---+---+---+---+---+---+
 
172
9 |   |   |   |   |   |   |   |   |   |   |
 
173
  +---+---+---+---+---+---+---+---+---+---+
 
174
 
 
175
ODD -
 
176
 
 
177
    0   1   2   3   4   5   6   7   8
 
178
  +---+---+---+---+---+---+---+---+---+
 
179
0 |   |   |   |   |   |   |   |   |   |
 
180
  +---+---+---+---+---+---+---+---+---+
 
181
1 |   |   |   |   |   |   |   | x |   |
 
182
  +---+---+---+---+---+---+---+---+---+
 
183
2 |   |   |   |   |   |   | x | x |   |
 
184
  +---+---+---+---+---+---+---+---+---+
 
185
3 |   | x |   |   |   | x | x | x |   |
 
186
  +---+---+---+---+---+---+---+---+---+
 
187
4 |   | x | x |   | x | x | x |   |   |
 
188
  +---+---+---+---+---+---+---+---+---+
 
189
5 |   | x | x | x | x | x |   |   |   |
 
190
  +---+---+---+---+---+---+---+---+---+
 
191
6 |   |   | x | x | x |   |   |   |   |
 
192
  +---+---+---+---+---+---+---+---+---+
 
193
7 |   |   |   | x |   |   |   |   |   |
 
194
  +---+---+---+---+---+---+---+---+---+
 
195
8 |   |   |   |   |   |   |   |   |   |
 
196
  +---+---+---+---+---+---+---+---+---+
 
197
 
 
198
*/
 
199
 
 
200
  cairo_move_to(canvas, left + floor((1*scale)/factor), top + floor(((4-odd)*scale)/factor)); //(1,4-odd)
 
201
  cairo_line_to(canvas, left + floor((1*scale)/factor), top + floor(((6-odd)*scale)/factor)); //(1,6-odd)
 
202
  cairo_line_to(canvas, left + floor((3*scale)/factor), top + floor(((8-odd)*scale)/factor)); //(3,8-odd)
 
203
  cairo_line_to(canvas, left + floor(((8-odd)*scale)/factor), top + floor((3*scale)/factor)); //(8-odd,3)
 
204
  cairo_line_to(canvas, left + floor(((8-odd)*scale)/factor), top + floor((1*scale)/factor)); //(8-odd,1)
 
205
  cairo_line_to(canvas, left + floor((3*scale)/factor), top + floor(((6-odd)*scale)/factor)); //(3,6-odd)
 
206
  cairo_line_to(canvas, left + floor((1*scale)/factor), top + floor(((4-odd)*scale)/factor)); //(1,4-odd)
 
207
 
 
208
  cairo_fill(canvas);
 
209
 
 
210
  cairo_move_to(canvas, left + floor((1*scale)/factor), top + floor(((4-odd)*scale)/factor)); //(1,4-odd)
 
211
  cairo_line_to(canvas, left + floor((1*scale)/factor), top + floor(((6-odd)*scale)/factor)); //(1,6-odd)
 
212
  cairo_line_to(canvas, left + floor((3*scale)/factor), top + floor(((8-odd)*scale)/factor)); //(3,8-odd)
 
213
  cairo_line_to(canvas, left + floor(((8-odd)*scale)/factor), top + floor((3*scale)/factor)); //(8-odd,3)
 
214
  cairo_line_to(canvas, left + floor(((8-odd)*scale)/factor), top + floor((1*scale)/factor)); //(8-odd,1)
 
215
  cairo_line_to(canvas, left + floor((3*scale)/factor), top + floor(((6-odd)*scale)/factor)); //(3,6-odd)
 
216
  cairo_line_to(canvas, left + floor((1*scale)/factor), top + floor(((4-odd)*scale)/factor)); //(1,4-odd)
 
217
 
 
218
  cairo_stroke(canvas);
 
219
 
 
220
  cairo_restore(canvas);
644
221
}
645
222
 
646
223
/***********************************************
654
231
 *   both which  were based on ThinIce's.
655
232
 ***********************************************/
656
233
void
657
 
do_redmond_draw_arrow (GdkWindow * window,
658
 
               GdkGC * gc,
 
234
do_redmond_draw_arrow (cairo_t *canvas,
 
235
               CairoColor * color,
659
236
               GtkArrowType arrow_type,
 
237
               gboolean fill,
660
238
               gint x, 
661
239
               gint y, 
662
240
               gint width, 
663
241
               gint height)
664
242
{
665
 
  gint i;
666
 
 
667
 
  gint steps, extra;
668
 
  gint start, increment;
669
 
  gint aw = width, ah = height;
670
 
        
671
 
  if ((arrow_type == GTK_ARROW_UP) || (arrow_type == GTK_ARROW_DOWN))
672
 
    {
673
 
      gdouble tmp=((aw+1)/2) - ((height%2)?1:0);
 
243
        gint steps, extra;
 
244
        gint start, increment;
 
245
        gint aw = width, ah = height;
 
246
        GdkPoint points[3];
 
247
 
 
248
        switch (arrow_type)
 
249
        {
 
250
                case GTK_ARROW_UP:
 
251
                case GTK_ARROW_DOWN:
 
252
                {
 
253
                        gdouble tmp=((aw+1)/2) - ((height%2)?1:0);
674
254
       
675
 
      if (tmp > ah) 
676
 
        {
677
 
          aw = 2*ah - 1 - ((height%2)?1:0);
678
 
          ah = (aw+1)/2;
679
 
        } 
680
 
      else 
681
 
        {
682
 
          ah = (gint) tmp;
683
 
          aw = 2*ah - 1;
684
 
        }  
685
 
 
686
 
      if ((aw < 5) || (ah < 3)) 
687
 
        {
688
 
          aw = 5;
689
 
          ah = 3;
690
 
        }
691
 
 
692
 
      x += (width - aw) / 2 ;
693
 
      y += (height - ah) / 2;
694
 
      width = aw;
695
 
      height = ah;
 
255
                        if (tmp > ah) 
 
256
                        {
 
257
                                aw = 2*ah - 1 - ((height%2)?1:0);
 
258
                                ah = (aw+1)/2;
 
259
                        } 
 
260
                        else 
 
261
                        {
 
262
                                ah = (gint) tmp;
 
263
                                aw = 2*ah - 1;
 
264
                        }  
 
265
 
 
266
                        if ((aw < 5) || (ah < 3)) 
 
267
                        {
 
268
                                aw = 5;
 
269
                                ah = 3;
 
270
                        }
 
271
 
 
272
                        x += (width - aw) / 2 ;
 
273
                        y += (height - ah) / 2;
 
274
                        width = aw;
 
275
                        height = ah;
696
276
                
697
 
      width += width % 2 - 1;
698
 
 
699
 
      steps = 1 + width / 2;
700
 
      extra = height - steps;
701
 
 
702
 
      if (arrow_type == GTK_ARROW_DOWN)
703
 
        {
704
 
          start = y;
705
 
          increment = 1;
706
 
        }
707
 
      else
708
 
        {
709
 
          start = y + height - 1;
710
 
          increment = -1;
711
 
        }
712
 
 
713
 
      for (i = extra; i < height; i++)
714
 
        gdk_draw_line(window, gc, 
715
 
                      x + (i - extra), start + i * increment, 
716
 
                      x + width - (i - extra) - 1,  start + i * increment);
717
 
    }
718
 
  else
719
 
    {
720
 
      gdouble tmp=((ah+1)/2) - ((width%2)?1:0);
721
 
 
722
 
      if (tmp > aw) 
723
 
        {
724
 
          ah = 2*aw - 1 - ((width%2)?1:0);
725
 
          aw = (ah+1)/2;
726
 
        } 
727
 
      else 
728
 
        {
729
 
          aw = (gint) tmp;
730
 
          ah = 2*aw - 1;
731
 
        }  
732
 
 
733
 
      if ((ah < 5) || (aw < 3)) 
734
 
        {
735
 
          ah = 5;
736
 
          aw = 3;
737
 
        }
738
 
 
739
 
      x += (width - aw) / 2 ;
740
 
      y += (height - ah) / 2;
741
 
      width = aw;
742
 
      height = ah;
743
 
 
744
 
      height += height % 2 - 1;
745
 
 
746
 
      steps = 1 + height / 2;
747
 
      extra = width - steps;
748
 
 
749
 
      if (arrow_type == GTK_ARROW_RIGHT)
750
 
        {
751
 
          start = x;
752
 
          increment = 1;
753
 
        }
754
 
      else
755
 
        {
756
 
          start = x + width - 1;
757
 
          increment = -1;
758
 
        }
759
 
 
760
 
      for (i = extra; i < width; i++)
761
 
        gdk_draw_line(window, gc, 
762
 
                      start + i * increment, y + (i - extra), 
763
 
                      start + i * increment, y + height - (i - extra) - 1);
764
 
    }
765
 
}
766
 
 
767
 
/***********************************************/
768
 
/* MenuShell/MenuBar Item Prelight Workaround  */
769
 
/***********************************************/
770
 
 
 
277
                        width += width % 2 - 1;
 
278
 
 
279
                        points[0].x = x;
 
280
                        points[1].x = x + width - 1;
 
281
                        points[2].x = x + ((height - 1) - (height - (1 + width / 2)));
 
282
 
 
283
                        points[0].y = points[1].y = y;
 
284
                        points[2].y = y + height - 1;
 
285
 
 
286
                        if (arrow_type == GTK_ARROW_UP)
 
287
                        {
 
288
                                gint flip = points[1].y;
 
289
 
 
290
                                points[0].y = points[1].y = points[2].y;
 
291
                                points[2].y = flip;
 
292
                        }
 
293
                }
 
294
                break;
 
295
 
 
296
                case GTK_ARROW_LEFT:
 
297
                case GTK_ARROW_RIGHT:
 
298
                {
 
299
                        gdouble tmp=((ah+1)/2) - ((width%2)?1:0);
 
300
 
 
301
                        if (tmp > aw) 
 
302
                        {
 
303
                                ah = 2*aw - 1 - ((width%2)?1:0);
 
304
                                aw = (ah+1)/2;
 
305
                        } 
 
306
                        else 
 
307
                        {
 
308
                                aw = (gint) tmp;
 
309
                                ah = 2*aw - 1;
 
310
                        }  
 
311
 
 
312
                        if ((ah < 5) || (aw < 3)) 
 
313
                        {
 
314
                                ah = 5;
 
315
                                aw = 3;
 
316
                        }
 
317
 
 
318
                        x += (width - aw) / 2 ;
 
319
                        y += (height - ah) / 2;
 
320
                        width = aw;
 
321
                        height = ah;
 
322
 
 
323
                        height += height % 2 - 1;
 
324
 
 
325
                        points[0].y = y;
 
326
                        points[1].y = y + height - 1;
 
327
                        points[2].y = y + ((width - 1) - (width - (1 + height / 2)));
 
328
 
 
329
                        points[0].x = points[1].x = x;
 
330
                        points[2].x = x + width - 1;
 
331
 
 
332
                        if (arrow_type == GTK_ARROW_LEFT)
 
333
                        {
 
334
                                gint flip = points[0].x;
 
335
 
 
336
                                points[0].x = points[1].x = points[2].x;
 
337
                                points[2].x = flip;
 
338
                        }
 
339
                }
 
340
                break;
 
341
 
 
342
                default:
 
343
                {
 
344
                        return;
 
345
                }
 
346
        }
 
347
 
 
348
        cairo_save(canvas);
 
349
 
 
350
        ge_cairo_set_color(canvas, color);      
 
351
        cairo_set_line_width (canvas, 0.5);
 
352
 
 
353
        cairo_move_to(canvas, points[0].x + 0.5, points[0].y + 0.5);
 
354
        cairo_line_to(canvas, points[1].x + 0.5, points[1].y + 0.5);
 
355
        cairo_line_to(canvas, points[2].x + 0.5, points[2].y + 0.5);
 
356
        cairo_line_to(canvas, points[0].x + 0.5, points[0].y + 0.5);
 
357
 
 
358
        if (fill)
 
359
        {
 
360
                cairo_stroke_preserve(canvas);
 
361
 
 
362
                cairo_fill(canvas);
 
363
        }
 
364
        else
 
365
        {
 
366
                cairo_stroke(canvas);
 
367
        }
 
368
 
 
369
        cairo_restore(canvas);
 
370
}
 
371
 
 
372
void
 
373
do_redmond_draw_simple_circle (cairo_t *canvas,
 
374
                                        CairoColor * tl,
 
375
                                        CairoColor * br,
 
376
                                        gint center_x, 
 
377
                                        gint center_y, 
 
378
                                        gint radius)
 
379
{ 
 
380
      cairo_save(canvas);
 
381
 
 
382
      cairo_move_to(canvas, center_x + (radius + 2), center_y + (radius + 2));
 
383
      cairo_line_to(canvas, center_x + (radius + 2)*sin(M_PI/4.0), center_y - (radius + 2)*cos(M_PI/4.0));
 
384
      cairo_line_to(canvas, center_x - (radius + 2)*sin(M_PI/4.0), center_y + (radius + 2)*cos(M_PI/4.0));
 
385
      cairo_line_to(canvas, center_x + (radius + 2), center_y + (radius + 2));
 
386
 
 
387
      cairo_clip (canvas);
 
388
 
 
389
      ge_cairo_set_color(canvas, br);
 
390
      cairo_arc(canvas, center_x, center_y, radius, 0,  2*M_PI);
 
391
      cairo_fill(canvas);
 
392
 
 
393
      cairo_restore(canvas);
 
394
 
 
395
      cairo_save(canvas);
 
396
 
 
397
      cairo_move_to(canvas, center_x - (radius + 2), center_y - (radius + 2));
 
398
      cairo_line_to(canvas, center_x + (radius + 2)*sin(M_PI/4.0), center_y - (radius + 2)*cos(M_PI/4.0));
 
399
      cairo_line_to(canvas, center_x - (radius + 2)*sin(M_PI/4.0), center_y + (radius + 2)*cos(M_PI/4.0));
 
400
      cairo_line_to(canvas, center_x - (radius + 2), center_y - (radius + 2));
 
401
 
 
402
      cairo_clip (canvas);
 
403
 
 
404
      ge_cairo_set_color(canvas, tl); 
 
405
      cairo_arc(canvas, center_x, center_y, radius, 0, 2*M_PI);
 
406
      cairo_fill(canvas);
 
407
 
 
408
      cairo_restore(canvas);
 
409
}
 
410
 
771
411
/***********************************************
772
412
 * do_redmond_draw_line -
773
413
 *  
775
415
 *   spacer line.
776
416
 ***********************************************/
777
417
void
778
 
do_redmond_draw_line(GdkWindow * window,
779
 
             GdkGC * dark_gc,
780
 
             GdkGC * light_gc,
 
418
do_redmond_draw_line(cairo_t *cr,
 
419
             CairoColor * dark,
 
420
             CairoColor * light,
781
421
             GdkRectangle * area,
782
422
             gint start,
783
423
             gint end,
784
424
             gint base,
785
425
             gboolean horizontal)
786
426
{  
787
 
  if (area)
788
 
    {
789
 
      gdk_gc_set_clip_rectangle (dark_gc, area);
790
 
      gdk_gc_set_clip_rectangle (light_gc, area);
791
 
    }
792
 
 
 
427
  cairo_set_line_width (cr, 1);
 
428
 
793
429
  if (horizontal) 
794
430
    {
795
 
      gdk_draw_line (window, dark_gc, start + 1, base + 0, end - 2, base + 0);
796
 
      gdk_draw_line (window, light_gc, start + 1, base + 1, end - 2, base + 1);
 
431
      ge_cairo_set_color(cr, dark);     
 
432
      cairo_move_to(cr, start + 1.5, base + 0.5);
 
433
      cairo_line_to(cr, end - 1.5, base + 0.5);
 
434
      cairo_stroke(cr);
 
435
 
 
436
      ge_cairo_set_color(cr, light);    
 
437
      cairo_move_to(cr, start + 1.5, base + 1.5);
 
438
      cairo_line_to(cr, end - 1.5, base + 1.5);
 
439
      cairo_stroke(cr);
797
440
    } 
798
441
  else 
799
442
    {
800
 
      gdk_draw_line (window, dark_gc, base + 0, start + 1, base + 0, end - 2);
801
 
      gdk_draw_line (window, light_gc, base + 1, start + 1, base + 1, end - 2);
802
 
    }
803
 
   
804
 
  if (area)
805
 
    {
806
 
      gdk_gc_set_clip_rectangle (dark_gc, NULL);
807
 
      gdk_gc_set_clip_rectangle (light_gc, NULL);
 
443
      ge_cairo_set_color(cr, dark);     
 
444
      cairo_move_to(cr, base + 0.5, start + 1.5);
 
445
      cairo_line_to(cr, base + 0.5, end - 1.5);
 
446
      cairo_stroke(cr);
 
447
 
 
448
      ge_cairo_set_color(cr, light);    
 
449
      cairo_move_to(cr, base + 1.5, start + 1.5);
 
450
      cairo_line_to(cr, base + 1.5, end - 1.5);
 
451
      cairo_stroke(cr);
808
452
    }
809
453
}
810
454
 
 
455
/***********************************************/
 
456
/* MenuShell/MenuBar Item Prelight Workaround  */
 
457
/***********************************************/
 
458
 
811
459
/***********************************************
812
 
 * gtk_menu_shell_style_set -
 
460
 * redmond_gtk2_engine_hack_menu_shell_style_set -
813
461
 *  
814
462
 *   Style set signal to ensure menushell signals
815
463
 *   get cleaned up if the theme changes
816
464
 ***********************************************/
817
465
static gboolean 
818
 
gtk_menu_shell_style_set(GtkWidget *widget,
 
466
redmond_gtk2_engine_hack_menu_shell_style_set(GtkWidget *widget,
819
467
                         GtkStyle *previous_style,
820
468
                         gpointer user_data)
821
469
{
822
 
  gtk_menu_shell_cleanup_signals(widget);
 
470
  redmond_gtk2_engine_hack_menu_shell_cleanup_signals(widget);
823
471
  
824
472
  return FALSE;
825
473
}
826
474
 
827
475
/***********************************************
828
 
 * gtk_menu_shell_destroy -
 
476
 * redmond_gtk2_engine_hack_menu_shell_destroy -
829
477
 *  
830
478
 *   Destroy signal to ensure menushell signals
831
479
 *   get cleaned if it is destroyed
832
480
 ***********************************************/
833
481
static gboolean    
834
 
gtk_menu_shell_destroy(GtkWidget *widget,
 
482
redmond_gtk2_engine_hack_menu_shell_destroy(GtkWidget *widget,
835
483
                       GdkEvent *event,
836
484
                       gpointer user_data)
837
485
{
838
 
  gtk_menu_shell_cleanup_signals(widget);
 
486
  redmond_gtk2_engine_hack_menu_shell_cleanup_signals(widget);
839
487
  
840
488
  return FALSE;
841
489
}
842
490
 
843
491
/***********************************************
844
 
 * gtk_menu_shell_motion -
 
492
 * redmond_gtk2_engine_hack_menu_shell_motion -
845
493
 *  
846
494
 *   Motion signal to ensure menushell items
847
495
 *   prelight state changes on mouse move.
848
496
 ***********************************************/
849
497
static gboolean 
850
 
gtk_menu_shell_motion(GtkWidget *widget, 
 
498
redmond_gtk2_engine_hack_menu_shell_motion(GtkWidget *widget, 
851
499
                      GdkEventMotion *event, 
852
500
                      gpointer user_data)
853
501
{
893
541
}
894
542
 
895
543
/***********************************************
896
 
 * gtk_menu_shell_leave -
 
544
 * redmond_gtk2_engine_hack_menu_shell_leave -
897
545
 *  
898
546
 *   Leave signal to ensure menushell items
899
547
 *   normal state on mouse leave.
900
548
 ***********************************************/
901
549
static gboolean 
902
 
gtk_menu_shell_leave(GtkWidget *widget, 
 
550
redmond_gtk2_engine_hack_menu_shell_leave(GtkWidget *widget, 
903
551
                      GdkEventCrossing *event,
904
552
                      gpointer user_data)
905
553
{
936
584
}
937
585
 
938
586
/***********************************************
939
 
 * gtk_menu_shell_setup_signals -
 
587
 * redmond_gtk2_engine_menu_shell_setup_signals -
940
588
 *  
941
589
 *   Setup Menu Shell with signals to ensure
942
590
 *   prelight works on items
943
591
 ***********************************************/
944
592
void
945
 
gtk_menu_shell_setup_signals(GtkWidget *widget)
 
593
redmond_gtk2_engine_hack_menu_shell_setup_signals(GtkWidget *widget)
946
594
{
947
595
  if (IS_MENU_BAR(widget))
948
596
    {
951
599
      if (!g_object_get_data(G_OBJECT(widget), "REDMOND_MENU_SHELL_HACK_SET"))
952
600
      {
953
601
        id = g_signal_connect(G_OBJECT(widget), "motion-notify-event",
954
 
                                             (GtkSignalFunc)gtk_menu_shell_motion,
 
602
                                             (GtkSignalFunc)redmond_gtk2_engine_hack_menu_shell_motion,
955
603
                                             NULL);
956
604
                                  
957
605
        g_object_set_data(G_OBJECT(widget), "REDMOND_MENU_SHELL_MOTION_ID", (gpointer)id);
958
606
        
959
607
        id = g_signal_connect(G_OBJECT(widget), "leave-notify-event",
960
 
                                             (GtkSignalFunc)gtk_menu_shell_leave,
 
608
                                             (GtkSignalFunc)redmond_gtk2_engine_hack_menu_shell_leave,
961
609
                                             NULL);
962
610
        g_object_set_data(G_OBJECT(widget), "REDMOND_MENU_SHELL_LEAVE_ID", (gpointer)id);
963
611
                                             
964
612
        id = g_signal_connect(G_OBJECT(widget), "destroy-event",
965
 
                                             (GtkSignalFunc)gtk_menu_shell_destroy,
 
613
                                             (GtkSignalFunc)redmond_gtk2_engine_hack_menu_shell_destroy,
966
614
                                             NULL);
967
615
        g_object_set_data(G_OBJECT(widget), "REDMOND_MENU_SHELL_DESTROY_ID", (gpointer)id);
968
616
 
969
617
        g_object_set_data(G_OBJECT(widget), "REDMOND_MENU_SHELL_HACK_SET", (gpointer)1);
970
618
        
971
619
        id = g_signal_connect(G_OBJECT(widget), "style-set",
972
 
                                             (GtkSignalFunc)gtk_menu_shell_style_set,
 
620
                                             (GtkSignalFunc)redmond_gtk2_engine_hack_menu_shell_style_set,
973
621
                                             NULL);
974
622
        g_object_set_data(G_OBJECT(widget), "REDMOND_MENU_SHELL_STYLE_SET_ID", (gpointer)id);
975
623
      }
977
625
}
978
626
 
979
627
/***********************************************
980
 
 * gtk_menu_shell_cleanuo_signals -
 
628
 * redmond_gtk2_engine_hack_menu_shell_cleanuo_signals -
981
629
 *  
982
630
 *   Cleanup/remove Menu Shell signals
983
631
 ***********************************************/
984
632
void
985
 
gtk_menu_shell_cleanup_signals(GtkWidget *widget)
 
633
redmond_gtk2_engine_hack_menu_shell_cleanup_signals(GtkWidget *widget)
986
634
{
987
635
  if (IS_MENU_BAR(widget))
988
636
    {