Pileus Git - ~andy/gtk/blob - gtk/gtkstyle.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 #include <math.h>
  20 #include "gtkgc.h"
  21 #include "gtkrc.h"
  22 #include "gtkstyle.h"
  23 #include "gtkthemes.h"
  24 #include "gtkwidget.h"
  25 #include "gtkthemes.h"
  26 #include "gtkprivate.h"
  27 #include "gdk/gdkprivate.h"
  28
  29
  30 #define LIGHTNESS_MULT  1.3
  31 #define DARKNESS_MULT   0.7
  32
  33 static void         gtk_style_init         (GtkStyle    *style,
  34                                             GdkColormap *colormap,
  35                                             gint         depth);
  36 static void         gtk_style_destroy      (GtkStyle    *style);
  37
  38 static void gtk_default_draw_hline   (GtkStyle      *style,
  39                                       GdkWindow     *window,
  40                                       GtkStateType   state_type,
  41                                       GdkRectangle  *area,
  42                                       GtkWidget     *widget,
  43                                       gchar         *detail,
  44                                       gint           x1,
  45                                       gint           x2,
  46                                       gint           y);
  47 static void gtk_default_draw_vline   (GtkStyle      *style,
  48                                       GdkWindow     *window,
  49                                       GtkStateType   state_type,
  50                                       GdkRectangle  *area,
  51                                       GtkWidget     *widget,
  52                                       gchar         *detail,
  53                                       gint           y1,
  54                                       gint           y2,
  55                                       gint           x);
  56 static void gtk_default_draw_shadow  (GtkStyle      *style,
  57                                       GdkWindow     *window,
  58                                       GtkStateType   state_type,
  59                                       GtkShadowType  shadow_type,
  60                                       GdkRectangle  *area,
  61                                       GtkWidget     *widget,
  62                                       gchar         *detail,
  63                                       gint           x,
  64                                       gint           y,
  65                                       gint           width,
  66                                       gint           height);
  67 static void gtk_default_draw_shadow  (GtkStyle      *style,
  68                                       GdkWindow     *window,
  69                                       GtkStateType   state_type,
  70                                       GtkShadowType  shadow_type,
  71                                       GdkRectangle  *area,
  72                                       GtkWidget     *widget,
  73                                       gchar         *detail,
  74                                       gint           x,
  75                                       gint           y,
  76                                       gint           width,
  77                                       gint           height);
  78 static void gtk_default_draw_polygon (GtkStyle      *style,
  79                                       GdkWindow     *window,
  80                                       GtkStateType   state_type,
  81                                       GtkShadowType  shadow_type,
  82                                       GdkRectangle  *area,
  83                                       GtkWidget     *widget,
  84                                       gchar         *detail,
  85                                       GdkPoint      *points,
  86                                       gint           npoints,
  87                                       gboolean       fill);
  88 static void gtk_default_draw_arrow   (GtkStyle      *style,
  89                                       GdkWindow     *window,
  90                                       GtkStateType   state_type,
  91                                       GtkShadowType  shadow_type,
  92                                       GdkRectangle  *area,
  93                                       GtkWidget     *widget,
  94                                       gchar         *detail,
  95                                       GtkArrowType   arrow_type,
  96                                       gboolean       fill,
  97                                       gint           x,
  98                                       gint           y,
  99                                       gint           width,
 100                                       gint           height);
 101 static void gtk_default_draw_diamond (GtkStyle      *style,
 102                                       GdkWindow     *window,
 103                                       GtkStateType   state_type,
 104                                       GtkShadowType  shadow_type,
 105                                       GdkRectangle  *area,
 106                                       GtkWidget     *widget,
 107                                       gchar         *detail,
 108                                       gint           x,
 109                                       gint           y,
 110                                       gint           width,
 111                                       gint           height);
 112 static void gtk_default_draw_oval    (GtkStyle      *style,
 113                                       GdkWindow     *window,
 114                                       GtkStateType   state_type,
 115                                       GtkShadowType  shadow_type,
 116                                       GdkRectangle  *area,
 117                                       GtkWidget     *widget,
 118                                       gchar         *detail,
 119                                       gint           x,
 120                                       gint           y,
 121                                       gint           width,
 122                                       gint           height);
 123 static void gtk_default_draw_string  (GtkStyle      *style,
 124                                       GdkWindow     *window,
 125                                       GtkStateType   state_type,
 126                                       GdkRectangle  *area,
 127                                       GtkWidget     *widget,
 128                                       gchar         *detail,
 129                                       gint           x,
 130                                       gint           y,
 131                                       const gchar   *string);
 132 static void gtk_default_draw_box     (GtkStyle      *style,
 133                                       GdkWindow     *window,
 134                                       GtkStateType   state_type,
 135                                       GtkShadowType  shadow_type,
 136                                       GdkRectangle  *area,
 137                                       GtkWidget     *widget,
 138                                       gchar         *detail,
 139                                       gint           x,
 140                                       gint           y,
 141                                       gint           width,
 142                                       gint           height);
 143 static void gtk_default_draw_flat_box (GtkStyle      *style,
 144                                        GdkWindow     *window,
 145                                        GtkStateType   state_type,
 146                                        GtkShadowType  shadow_type,
 147                                        GdkRectangle  *area,
 148                                        GtkWidget     *widget,
 149                                        gchar         *detail,
 150                                        gint           x,
 151                                        gint           y,
 152                                        gint           width,
 153                                        gint           height);
 154 static void gtk_default_draw_check   (GtkStyle      *style,
 155                                       GdkWindow     *window,
 156                                       GtkStateType   state_type,
 157                                       GtkShadowType  shadow_type,
 158                                       GdkRectangle  *area,
 159                                       GtkWidget     *widget,
 160                                       gchar         *detail,
 161                                       gint           x,
 162                                       gint           y,
 163                                       gint           width,
 164                                       gint           height);
 165 static void gtk_default_draw_option  (GtkStyle      *style,
 166                                       GdkWindow     *window,
 167                                       GtkStateType   state_type,
 168                                       GtkShadowType  shadow_type,
 169                                       GdkRectangle  *area,
 170                                       GtkWidget     *widget,
 171                                       gchar         *detail,
 172                                       gint           x,
 173                                       gint           y,
 174                                       gint           width,
 175                                       gint           height);
 176 static void gtk_default_draw_cross   (GtkStyle      *style,
 177                                       GdkWindow     *window,
 178                                       GtkStateType   state_type,
 179                                       GtkShadowType  shadow_type,
 180                                       GdkRectangle  *area,
 181                                       GtkWidget     *widget,
 182                                       gchar         *detail,
 183                                       gint           x,
 184                                       gint           y,
 185                                       gint           width,
 186                                       gint           height);
 187 static void gtk_default_draw_ramp    (GtkStyle      *style,
 188                                       GdkWindow     *window,
 189                                       GtkStateType   state_type,
 190                                       GtkShadowType  shadow_type,
 191                                       GdkRectangle  *area,
 192                                       GtkWidget     *widget,
 193                                       gchar         *detail,
 194                                       GtkArrowType   arrow_type,
 195                                       gint           x,
 196                                       gint           y,
 197                                       gint           width,
 198                                       gint           height);
 199 static void gtk_default_draw_tab     (GtkStyle      *style,
 200                                       GdkWindow     *window,
 201                                       GtkStateType   state_type,
 202                                       GtkShadowType  shadow_type,
 203                                       GdkRectangle  *area,
 204                                       GtkWidget     *widget,
 205                                       gchar         *detail,
 206                                       gint           x,
 207                                       gint           y,
 208                                       gint           width,
 209                                       gint           height);
 210 static void gtk_default_draw_shadow_gap (GtkStyle       *style,
 211                                          GdkWindow      *window,
 212                                          GtkStateType    state_type,
 213                                          GtkShadowType   shadow_type,
 214                                          GdkRectangle   *area,
 215                                          GtkWidget      *widget,
 216                                          gchar          *detail,
 217                                          gint            x,
 218                                          gint            y,
 219                                          gint            width,
 220                                          gint            height,
 221                                          GtkPositionType gap_side,
 222                                          gint            gap_x,
 223                                          gint            gap_width);
 224 static void gtk_default_draw_box_gap (GtkStyle       *style,
 225                                       GdkWindow      *window,
 226                                       GtkStateType    state_type,
 227                                       GtkShadowType   shadow_type,
 228                                       GdkRectangle   *area,
 229                                       GtkWidget      *widget,
 230                                       gchar          *detail,
 231                                       gint            x,
 232                                       gint            y,
 233                                       gint            width,
 234                                       gint            height,
 235                                       GtkPositionType gap_side,
 236                                       gint            gap_x,
 237                                       gint            gap_width);
 238 static void gtk_default_draw_extension (GtkStyle       *style,
 239                                         GdkWindow      *window,
 240                                         GtkStateType    state_type,
 241                                         GtkShadowType   shadow_type,
 242                                         GdkRectangle   *area,
 243                                         GtkWidget      *widget,
 244                                         gchar          *detail,
 245                                         gint            x,
 246                                         gint            y,
 247                                         gint            width,
 248                                         gint            height,
 249                                         GtkPositionType gap_side);
 250 static void gtk_default_draw_focus   (GtkStyle      *style,
 251                                       GdkWindow     *window,
 252                                       GdkRectangle  *area,
 253                                       GtkWidget     *widget,
 254                                       gchar         *detail,
 255                                       gint           x,
 256                                       gint           y,
 257                                       gint           width,
 258                                       gint           height);
 259 static void gtk_default_draw_slider  (GtkStyle      *style,
 260                                       GdkWindow     *window,
 261                                       GtkStateType   state_type,
 262                                       GtkShadowType  shadow_type,
 263                                       GdkRectangle  *area,
 264                                       GtkWidget     *widget,
 265                                       gchar         *detail,
 266                                       gint           x,
 267                                       gint           y,
 268                                       gint           width,
 269                                       gint           height,
 270                                       GtkOrientation orientation);
 271 static void gtk_default_draw_handle  (GtkStyle      *style,
 272                                       GdkWindow     *window,
 273                                       GtkStateType   state_type,
 274                                       GtkShadowType  shadow_type,
 275                                       GdkRectangle  *area,
 276                                       GtkWidget     *widget,
 277                                       gchar         *detail,
 278                                       gint           x,
 279                                       gint           y,
 280                                       gint           width,
 281                                       gint           height,
 282                                       GtkOrientation orientation);
 283
 284
 285 static void gtk_style_shade (GdkColor *a, GdkColor *b, gdouble k);
 286 static void rgb_to_hls (gdouble *r, gdouble *g, gdouble *b);
 287 static void hls_to_rgb (gdouble *h, gdouble *l, gdouble *s);
 288
 289 static void gtk_reset_window_and_children(GtkWidget *widget,
 290                                           GdkWindow *window);
 291
 292
 293 GtkStyleClass default_class =
 294 {
 295    2,
 296    2,
 297    gtk_default_draw_hline,
 298    gtk_default_draw_vline,
 299    gtk_default_draw_shadow,
 300    gtk_default_draw_polygon,
 301    gtk_default_draw_arrow,
 302    gtk_default_draw_diamond,
 303    gtk_default_draw_oval,
 304    gtk_default_draw_string,
 305    gtk_default_draw_box,
 306    gtk_default_draw_flat_box,
 307    gtk_default_draw_check,
 308    gtk_default_draw_option,
 309    gtk_default_draw_cross,
 310    gtk_default_draw_ramp,
 311    gtk_default_draw_tab,
 312    gtk_default_draw_shadow_gap,
 313    gtk_default_draw_box_gap,
 314    gtk_default_draw_extension,
 315    gtk_default_draw_focus,
 316    gtk_default_draw_slider,
 317    gtk_default_draw_handle
 318 };
 319 GdkFont *default_font = NULL;
 320
 321 static GdkColor gtk_default_normal_fg =      { 0,      0,      0,      0 };
 322 static GdkColor gtk_default_active_fg =      { 0,      0,      0,      0 };
 323 static GdkColor gtk_default_prelight_fg =    { 0,      0,      0,      0 };
 324 static GdkColor gtk_default_selected_fg =    { 0, 0xffff, 0xffff, 0xffff };
 325 static GdkColor gtk_default_insensitive_fg = { 0, 0x7530, 0x7530, 0x7530 };
 326
 327 static GdkColor gtk_default_normal_bg =      { 0, 0xd6d6, 0xd6d6, 0xd6d6 };
 328 static GdkColor gtk_default_active_bg =      { 0, 0xc350, 0xc350, 0xc350 };
 329 static GdkColor gtk_default_prelight_bg =    { 0, 0xea60, 0xea60, 0xea60 };
 330 static GdkColor gtk_default_selected_bg =    { 0,      0,      0, 0x9c40 };
 331 static GdkColor gtk_default_insensitive_bg = { 0, 0xd6d6, 0xd6d6, 0xd6d6 };
 332
 333 static void
 334 gtk_reset_window_and_children(GtkWidget *widget, GdkWindow *window)
 335 {
 336   GdkWindowPrivate *private;
 337   guint i, num;
 338   GList *list;
 339   gpointer data;
 340
 341   g_return_if_fail (window != NULL);
 342
 343   private = (GdkWindowPrivate *)window;
 344
 345   if (private->destroyed)
 346     return;
 347   gdk_window_get_user_data(window, &data);
 348   if ((data) && (data != widget))
 349     return;
 350   gdk_window_shape_combine_mask(window, NULL, 0, 0);
 351   if (private->children)
 352     {
 353       num = g_list_length(private->children);
 354       for(i = 0; i < num; i++)
 355         {
 356           list = g_list_nth(private->children, i);
 357           gtk_reset_window_and_children(widget, (GdkWindow *)list->data);
 358         }
 359     }
 360 }
 361
 362 void
 363 gtk_reset_widget_shapes(GtkWidget *widget)
 364 {
 365   g_return_if_fail (widget != NULL);
 366
 367   if (!GTK_WIDGET_HAS_SHAPE_MASK(GTK_OBJECT(widget)))
 368     gtk_reset_window_and_children(widget, widget->window);
 369 }
 370
 371 GtkStyle*
 372 gtk_style_copy (GtkStyle     *style)
 373 {
 374   GtkStyle *new_style;
 375   guint i;
 376
 377   g_return_val_if_fail (style != NULL, NULL);
 378
 379   new_style = gtk_style_new ();
 380
 381   for (i = 0; i < 5; i++)
 382     {
 383       new_style->fg[i] = style->fg[i];
 384       new_style->bg[i] = style->bg[i];
 385       new_style->text[i] = style->text[i];
 386       new_style->base[i] = style->base[i];
 387
 388       new_style->bg_pixmap[i] = style->bg_pixmap[i];
 389     }
 390
 391   new_style->font = style->font;
 392   gdk_font_ref (new_style->font);
 393
 394   return new_style;
 395 }
 396
 397 static GtkStyle*
 398 gtk_style_duplicate (GtkStyle     *style)
 399 {
 400   GtkStyle *new_style;
 401
 402   g_return_val_if_fail (style != NULL, NULL);
 403
 404   new_style = gtk_style_copy (style);
 405
 406   style->styles = g_slist_append (style->styles, new_style);
 407   new_style->styles = style->styles;
 408
 409   if (style->rc_style)
 410     {
 411       new_style->rc_style = style->rc_style;
 412       gtk_rc_style_ref (style->rc_style);
 413     }
 414
 415   if (style->engine)
 416     {
 417       new_style->engine = style->engine;
 418       new_style->engine->duplicate_style (new_style, style);
 419     }
 420
 421   return new_style;
 422 }
 423
 424 GtkStyle*
 425 gtk_style_new (void)
 426 {
 427   GtkStyle *style;
 428   gint i;
 429
 430   style = g_new0 (GtkStyle, 1);
 431
 432   if (!default_font)
 433     default_font =
 434       gdk_font_load ("-adobe-helvetica-medium-r-normal--*-120-*-*-*-*-*-*");
 435
 436   style->font = default_font;
 437   gdk_font_ref (style->font);
 438
 439   style->ref_count = 1;
 440   style->attach_count = 0;
 441   style->colormap = NULL;
 442   style->depth = -1;
 443   style->klass = &default_class;
 444
 445   style->black.red = 0;
 446   style->black.green = 0;
 447   style->black.blue = 0;
 448
 449   style->white.red = 65535;
 450   style->white.green = 65535;
 451   style->white.blue = 65535;
 452
 453   style->black_gc = NULL;
 454   style->white_gc = NULL;
 455
 456   style->fg[GTK_STATE_NORMAL] = gtk_default_normal_fg;
 457   style->fg[GTK_STATE_ACTIVE] = gtk_default_active_fg;
 458   style->fg[GTK_STATE_PRELIGHT] = gtk_default_prelight_fg;
 459   style->fg[GTK_STATE_SELECTED] = gtk_default_selected_fg;
 460   style->fg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_fg;
 461
 462   style->bg[GTK_STATE_NORMAL] = gtk_default_normal_bg;
 463   style->bg[GTK_STATE_ACTIVE] = gtk_default_active_bg;
 464   style->bg[GTK_STATE_PRELIGHT] = gtk_default_prelight_bg;
 465   style->bg[GTK_STATE_SELECTED] = gtk_default_selected_bg;
 466   style->bg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
 467
 468   for (i = 0; i < 4; i++)
 469     {
 470       style->text[i] = style->fg[i];
 471       style->base[i] = style->white;
 472     }
 473
 474   style->base[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
 475   style->text[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
 476
 477   for (i = 0; i < 5; i++)
 478     style->bg_pixmap[i] = NULL;
 479
 480   style->engine = NULL;
 481   style->engine_data = NULL;
 482
 483   style->rc_style = NULL;
 484
 485   for (i = 0; i < 5; i++)
 486     {
 487       style->fg_gc[i] = NULL;
 488       style->bg_gc[i] = NULL;
 489       style->light_gc[i] = NULL;
 490       style->dark_gc[i] = NULL;
 491       style->mid_gc[i] = NULL;
 492       style->text_gc[i] = NULL;
 493       style->base_gc[i] = NULL;
 494     }
 495
 496   return style;
 497 }
 498
 499 GtkStyle *
 500 gtk_style_attach (GtkStyle  *style,
 501                   GdkWindow *window)
 502 {
 503   GSList *styles;
 504   GtkStyle *new_style = NULL;
 505   GdkColormap *colormap;
 506   gint depth;
 507
 508   g_return_val_if_fail (style != NULL, NULL);
 509   g_return_val_if_fail (window != NULL, NULL);
 510
 511   colormap = gdk_window_get_colormap (window);
 512   depth = gdk_window_get_visual (window)->depth;
 513
 514   if (!style->styles)
 515     style->styles = g_slist_append (NULL, style);
 516
 517   styles = style->styles;
 518   while (styles)
 519     {
 520       new_style = styles->data;
 521
 522       if (new_style->attach_count == 0)
 523         {
 524           gtk_style_init (new_style, colormap, depth);
 525           break;
 526         }
 527       else if ((new_style->colormap == colormap) &&
 528                (new_style->depth == depth))
 529         break;
 530
 531       new_style = NULL;
 532       styles = styles->next;
 533     }
 534
 535   if (!new_style)
 536     {
 537       new_style = gtk_style_duplicate (style);
 538       gtk_style_init (new_style, colormap, depth);
 539     }
 540
 541   if (new_style->attach_count == 0)
 542     gtk_style_ref (new_style);
 543
 544
 545
 546   new_style->attach_count++;
 547
 548   return new_style;
 549 }
 550
 551 void
 552 gtk_style_detach (GtkStyle *style)
 553 {
 554   gint i;
 555
 556   g_return_if_fail (style != NULL);
 557
 558   style->attach_count -= 1;
 559   if (style->attach_count == 0)
 560     {
 561       if (style->engine)
 562         style->engine->unrealize_style (style);
 563
 564       gtk_gc_release (style->black_gc);
 565       gtk_gc_release (style->white_gc);
 566
 567       for (i = 0; i < 5; i++)
 568         {
 569           gtk_gc_release (style->fg_gc[i]);
 570           gtk_gc_release (style->bg_gc[i]);
 571           gtk_gc_release (style->light_gc[i]);
 572           gtk_gc_release (style->dark_gc[i]);
 573           gtk_gc_release (style->mid_gc[i]);
 574           gtk_gc_release (style->text_gc[i]);
 575           gtk_gc_release (style->base_gc[i]);
 576         }
 577
 578       gtk_style_unref (style);
 579     }
 580 }
 581
 582 GtkStyle*
 583 gtk_style_ref (GtkStyle *style)
 584 {
 585   g_return_val_if_fail (style != NULL, NULL);
 586
 587   style->ref_count += 1;
 588   return style;
 589 }
 590
 591 void
 592 gtk_style_unref (GtkStyle *style)
 593 {
 594   g_return_if_fail (style != NULL);
 595
 596   style->ref_count -= 1;
 597   if (style->ref_count == 0)
 598     gtk_style_destroy (style);
 599 }
 600
 601 static void
 602 gtk_style_init (GtkStyle *style,
 603                 GdkColormap *colormap,
 604                 gint         depth)
 605 {
 606   GdkGCValues gc_values;
 607   GdkGCValuesMask gc_values_mask;
 608   gint i;
 609
 610   g_return_if_fail (style != NULL);
 611
 612   style->colormap = colormap;
 613   style->depth = depth;
 614
 615   for (i = 0; i < 5; i++)
 616     {
 617       gtk_style_shade (&style->bg[i], &style->light[i], LIGHTNESS_MULT);
 618       gtk_style_shade (&style->bg[i], &style->dark[i], DARKNESS_MULT);
 619
 620       style->mid[i].red = (style->light[i].red + style->dark[i].red) / 2;
 621       style->mid[i].green = (style->light[i].green + style->dark[i].green) / 2;
 622       style->mid[i].blue = (style->light[i].blue + style->dark[i].blue) / 2;
 623     }
 624
 625   gdk_color_black (colormap, &style->black);
 626   gdk_color_white (colormap, &style->white);
 627
 628   gc_values_mask = GDK_GC_FOREGROUND | GDK_GC_FONT;
 629   if (style->font->type == GDK_FONT_FONT)
 630     {
 631       gc_values.font = style->font;
 632     }
 633   else if (style->font->type == GDK_FONT_FONTSET)
 634     {
 635       gc_values.font = default_font;
 636     }
 637
 638   gc_values.foreground = style->black;
 639   style->black_gc = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
 640
 641   gc_values.foreground = style->white;
 642   style->white_gc = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
 643
 644   for (i = 0; i < 5; i++)
 645     {
 646       if (style->rc_style && style->rc_style->bg_pixmap_name[i])
 647         style->bg_pixmap[i] = gtk_rc_load_image (style->colormap,
 648                                                  &style->bg[i],
 649                                                  style->rc_style->bg_pixmap_name[i]);
 650
 651       if (!gdk_color_alloc (colormap, &style->fg[i]))
 652         g_warning ("unable to allocate color: ( %d %d %d )",
 653                    style->fg[i].red, style->fg[i].green, style->fg[i].blue);
 654       if (!gdk_color_alloc (colormap, &style->bg[i]))
 655         g_warning ("unable to allocate color: ( %d %d %d )",
 656                    style->bg[i].red, style->bg[i].green, style->bg[i].blue);
 657       if (!gdk_color_alloc (colormap, &style->light[i]))
 658         g_warning ("unable to allocate color: ( %d %d %d )",
 659                    style->light[i].red, style->light[i].green, style->light[i].blue);
 660       if (!gdk_color_alloc (colormap, &style->dark[i]))
 661         g_warning ("unable to allocate color: ( %d %d %d )",
 662                    style->dark[i].red, style->dark[i].green, style->dark[i].blue);
 663       if (!gdk_color_alloc (colormap, &style->mid[i]))
 664         g_warning ("unable to allocate color: ( %d %d %d )",
 665                    style->mid[i].red, style->mid[i].green, style->mid[i].blue);
 666       if (!gdk_color_alloc (colormap, &style->text[i]))
 667         g_warning ("unable to allocate color: ( %d %d %d )",
 668                    style->text[i].red, style->text[i].green, style->text[i].blue);
 669       if (!gdk_color_alloc (colormap, &style->base[i]))
 670         g_warning ("unable to allocate color: ( %d %d %d )",
 671                    style->base[i].red, style->base[i].green, style->base[i].blue);
 672
 673       gc_values.foreground = style->fg[i];
 674       style->fg_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
 675
 676       gc_values.foreground = style->bg[i];
 677       style->bg_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
 678
 679       gc_values.foreground = style->light[i];
 680       style->light_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
 681
 682       gc_values.foreground = style->dark[i];
 683       style->dark_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
 684
 685       gc_values.foreground = style->mid[i];
 686       style->mid_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
 687
 688       gc_values.foreground = style->text[i];
 689       style->text_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
 690
 691       gc_values.foreground = style->base[i];
 692       style->base_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
 693     }
 694   if (style->engine)
 695     style->engine->realize_style (style);
 696 }
 697
 698 static void
 699 gtk_style_destroy (GtkStyle *style)
 700 {
 701   g_return_if_fail (style->attach_count == 0);
 702
 703   if (style->styles)
 704     {
 705       if (style->styles->data != style)
 706         g_slist_remove (style->styles, style);
 707       else
 708         {
 709           GSList *tmp_list = style->styles->next;
 710           while (tmp_list)
 711             {
 712               ((GtkStyle *)tmp_list->data)->styles = style->styles->next;
 713               tmp_list = tmp_list->next;
 714             }
 715           g_slist_free_1 (style->styles);
 716         }
 717     }
 718
 719   if (style->engine)
 720     {
 721       style->engine->destroy_style (style);
 722       gtk_theme_engine_unref (style->engine);
 723     }
 724
 725   gdk_font_unref (style->font);
 726   if (style->rc_style)
 727     gtk_rc_style_unref (style->rc_style);
 728
 729   g_free (style);
 730 }
 731
 732 void
 733 gtk_style_set_background (GtkStyle     *style,
 734                           GdkWindow    *window,
 735                           GtkStateType  state_type)
 736 {
 737   GdkPixmap *pixmap;
 738   gint parent_relative;
 739
 740    if (style->engine && style->engine->set_background)
 741      {
 742         (*style->engine->set_background) (style, window, state_type);
 743         return;
 744      }
 745
 746    g_return_if_fail (style != NULL);
 747    g_return_if_fail (window != NULL);
 748
 749   if (style->bg_pixmap[state_type])
 750     {
 751       if (style->bg_pixmap[state_type] == (GdkPixmap*) GDK_PARENT_RELATIVE)
 752         {
 753           pixmap = NULL;
 754           parent_relative = TRUE;
 755         }
 756       else
 757         {
 758           pixmap = style->bg_pixmap[state_type];
 759           parent_relative = FALSE;
 760         }
 761
 762       gdk_window_set_back_pixmap (window, pixmap, parent_relative);
 763     }
 764   else
 765     gdk_window_set_background (window, &style->bg[state_type]);
 766 }
 767
 768
 769 void
 770 gtk_draw_hline (GtkStyle     *style,
 771                 GdkWindow    *window,
 772                 GtkStateType  state_type,
 773                 gint          x1,
 774                 gint          x2,
 775                 gint          y)
 776 {
 777   g_return_if_fail (style != NULL);
 778   g_return_if_fail (style->klass != NULL);
 779   g_return_if_fail (style->klass->draw_hline != NULL);
 780
 781   (*style->klass->draw_hline) (style, window, state_type, NULL, NULL, NULL, x1, x2, y);
 782 }
 783
 784
 785 void
 786 gtk_draw_vline (GtkStyle     *style,
 787                 GdkWindow    *window,
 788                 GtkStateType  state_type,
 789                 gint          y1,
 790                 gint          y2,
 791                 gint          x)
 792 {
 793   g_return_if_fail (style != NULL);
 794   g_return_if_fail (style->klass != NULL);
 795   g_return_if_fail (style->klass->draw_vline != NULL);
 796
 797   (*style->klass->draw_vline) (style, window, state_type, NULL, NULL, NULL, y1, y2, x);
 798 }
 799
 800
 801 void
 802 gtk_draw_shadow (GtkStyle      *style,
 803                  GdkWindow     *window,
 804                  GtkStateType   state_type,
 805                  GtkShadowType  shadow_type,
 806                  gint           x,
 807                  gint           y,
 808                  gint           width,
 809                  gint           height)
 810 {
 811   g_return_if_fail (style != NULL);
 812   g_return_if_fail (style->klass != NULL);
 813   g_return_if_fail (style->klass->draw_shadow != NULL);
 814
 815    (*style->klass->draw_shadow) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 816 }
 817
 818 void
 819 gtk_draw_polygon (GtkStyle      *style,
 820                   GdkWindow     *window,
 821                   GtkStateType   state_type,
 822                   GtkShadowType  shadow_type,
 823                   GdkPoint      *points,
 824                   gint           npoints,
 825                   gboolean       fill)
 826 {
 827   g_return_if_fail (style != NULL);
 828   g_return_if_fail (style->klass != NULL);
 829   g_return_if_fail (style->klass->draw_shadow != NULL);
 830
 831   (*style->klass->draw_polygon) (style, window, state_type, shadow_type, NULL, NULL, NULL, points, npoints, fill);
 832 }
 833
 834 void
 835 gtk_draw_arrow (GtkStyle      *style,
 836                 GdkWindow     *window,
 837                 GtkStateType   state_type,
 838                 GtkShadowType  shadow_type,
 839                 GtkArrowType   arrow_type,
 840                 gboolean       fill,
 841                 gint           x,
 842                 gint           y,
 843                 gint           width,
 844                 gint           height)
 845 {
 846   g_return_if_fail (style != NULL);
 847   g_return_if_fail (style->klass != NULL);
 848   g_return_if_fail (style->klass->draw_arrow != NULL);
 849
 850   (*style->klass->draw_arrow) (style, window, state_type, shadow_type, NULL, NULL, NULL, arrow_type, fill, x, y, width, height);
 851 }
 852
 853
 854 void
 855 gtk_draw_diamond (GtkStyle      *style,
 856                   GdkWindow     *window,
 857                   GtkStateType   state_type,
 858                   GtkShadowType  shadow_type,
 859                   gint           x,
 860                   gint           y,
 861                   gint           width,
 862                   gint           height)
 863 {
 864   g_return_if_fail (style != NULL);
 865   g_return_if_fail (style->klass != NULL);
 866   g_return_if_fail (style->klass->draw_diamond != NULL);
 867
 868   (*style->klass->draw_diamond) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 869 }
 870
 871
 872 void
 873 gtk_draw_oval (GtkStyle      *style,
 874                GdkWindow     *window,
 875                GtkStateType   state_type,
 876                GtkShadowType  shadow_type,
 877                gint           x,
 878                gint           y,
 879                gint           width,
 880                gint           height)
 881 {
 882   g_return_if_fail (style != NULL);
 883   g_return_if_fail (style->klass != NULL);
 884   g_return_if_fail (style->klass->draw_oval != NULL);
 885
 886   (*style->klass->draw_oval) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 887 }
 888
 889 void
 890 gtk_draw_string (GtkStyle      *style,
 891                  GdkWindow     *window,
 892                  GtkStateType   state_type,
 893                  gint           x,
 894                  gint           y,
 895                  const gchar   *string)
 896 {
 897   g_return_if_fail (style != NULL);
 898   g_return_if_fail (style->klass != NULL);
 899   g_return_if_fail (style->klass->draw_oval != NULL);
 900
 901   (*style->klass->draw_string) (style, window, state_type, NULL, NULL, NULL, x, y, string);
 902 }
 903
 904 void
 905 gtk_draw_box (GtkStyle      *style,
 906                  GdkWindow     *window,
 907                  GtkStateType   state_type,
 908                  GtkShadowType  shadow_type,
 909                  gint           x,
 910                  gint           y,
 911                  gint           width,
 912                  gint           height)
 913 {
 914    g_return_if_fail (style != NULL);
 915    g_return_if_fail (style->klass != NULL);
 916    g_return_if_fail (style->klass->draw_box != NULL);
 917
 918    (*style->klass->draw_box) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 919 }
 920
 921 void
 922 gtk_draw_flat_box (GtkStyle      *style,
 923                    GdkWindow     *window,
 924                    GtkStateType   state_type,
 925                    GtkShadowType  shadow_type,
 926                    gint           x,
 927                    gint           y,
 928                    gint           width,
 929                    gint           height)
 930 {
 931    g_return_if_fail (style != NULL);
 932    g_return_if_fail (style->klass != NULL);
 933    g_return_if_fail (style->klass->draw_flat_box != NULL);
 934
 935    (*style->klass->draw_flat_box) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 936 }
 937
 938 void
 939 gtk_draw_check   (GtkStyle      *style,
 940                   GdkWindow     *window,
 941                   GtkStateType   state_type,
 942                   GtkShadowType  shadow_type,
 943                   gint           x,
 944                   gint           y,
 945                   gint           width,
 946                   gint           height)
 947 {
 948    g_return_if_fail (style != NULL);
 949    g_return_if_fail (style->klass != NULL);
 950    g_return_if_fail (style->klass->draw_check != NULL);
 951
 952    (*style->klass->draw_check) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 953 }
 954
 955 void
 956 gtk_draw_option  (GtkStyle      *style,
 957                   GdkWindow     *window,
 958                   GtkStateType   state_type,
 959                   GtkShadowType  shadow_type,
 960                   gint           x,
 961                   gint           y,
 962                   gint           width,
 963                   gint           height)
 964 {
 965    g_return_if_fail (style != NULL);
 966    g_return_if_fail (style->klass != NULL);
 967    g_return_if_fail (style->klass->draw_option != NULL);
 968
 969    (*style->klass->draw_option) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 970 }
 971
 972 void
 973 gtk_draw_cross   (GtkStyle      *style,
 974                   GdkWindow     *window,
 975                   GtkStateType   state_type,
 976                   GtkShadowType  shadow_type,
 977                   gint           x,
 978                   gint           y,
 979                   gint           width,
 980                   gint           height)
 981 {
 982    g_return_if_fail (style != NULL);
 983    g_return_if_fail (style->klass != NULL);
 984    g_return_if_fail (style->klass->draw_cross != NULL);
 985
 986    (*style->klass->draw_cross) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 987 }
 988
 989 void
 990 gtk_draw_ramp    (GtkStyle      *style,
 991                   GdkWindow     *window,
 992                   GtkStateType   state_type,
 993                   GtkShadowType  shadow_type,
 994                   GtkArrowType   arrow_type,
 995                   gint           x,
 996                   gint           y,
 997                   gint           width,
 998                   gint           height)
 999 {
1000    g_return_if_fail (style != NULL);
1001    g_return_if_fail (style->klass != NULL);
1002    g_return_if_fail (style->klass->draw_ramp != NULL);
1003
1004    (*style->klass->draw_ramp) (style, window, state_type, shadow_type, NULL, NULL, NULL, arrow_type, x, y, width, height);
1005 }
1006
1007 void
1008 gtk_draw_tab     (GtkStyle      *style,
1009                   GdkWindow     *window,
1010                   GtkStateType   state_type,
1011                   GtkShadowType  shadow_type,
1012                   gint           x,
1013                   gint           y,
1014                   gint           width,
1015                   gint           height)
1016 {
1017    g_return_if_fail (style != NULL);
1018    g_return_if_fail (style->klass != NULL);
1019    g_return_if_fail (style->klass->draw_tab != NULL);
1020
1021    (*style->klass->draw_tab) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
1022 }
1023
1024 void
1025 gtk_draw_shadow_gap (GtkStyle       *style,
1026                      GdkWindow      *window,
1027                      GtkStateType    state_type,
1028                      GtkShadowType   shadow_type,
1029                      gint            x,
1030                      gint            y,
1031                      gint            width,
1032                      gint            height,
1033                      GtkPositionType gap_side,
1034                      gint            gap_x,
1035                      gint            gap_width)
1036 {
1037    g_return_if_fail (style != NULL);
1038    g_return_if_fail (style->klass != NULL);
1039    g_return_if_fail (style->klass->draw_shadow_gap != NULL);
1040
1041    (*style->klass->draw_shadow_gap) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side, gap_x, gap_width);
1042 }
1043
1044 void
1045 gtk_draw_box_gap (GtkStyle       *style,
1046                   GdkWindow      *window,
1047                   GtkStateType    state_type,
1048                   GtkShadowType   shadow_type,
1049                   gint            x,
1050                   gint            y,
1051                   gint            width,
1052                   gint            height,
1053                   GtkPositionType gap_side,
1054                   gint            gap_x,
1055                   gint            gap_width)
1056 {
1057    g_return_if_fail (style != NULL);
1058    g_return_if_fail (style->klass != NULL);
1059    g_return_if_fail (style->klass->draw_box_gap != NULL);
1060
1061    (*style->klass->draw_box_gap) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side, gap_x, gap_width);
1062 }
1063
1064 void
1065 gtk_draw_extension (GtkStyle       *style,
1066                     GdkWindow      *window,
1067                     GtkStateType    state_type,
1068                     GtkShadowType   shadow_type,
1069                     gint            x,
1070                     gint            y,
1071                     gint            width,
1072                     gint            height,
1073                     GtkPositionType gap_side)
1074 {
1075    g_return_if_fail (style != NULL);
1076    g_return_if_fail (style->klass != NULL);
1077    g_return_if_fail (style->klass->draw_extension != NULL);
1078
1079    (*style->klass->draw_extension) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side);
1080 }
1081
1082 void
1083 gtk_draw_focus  (GtkStyle      *style,
1084                  GdkWindow     *window,
1085                  gint           x,
1086                  gint           y,
1087                  gint           width,
1088                  gint           height)
1089 {
1090    g_return_if_fail (style != NULL);
1091    g_return_if_fail (style->klass != NULL);
1092    g_return_if_fail (style->klass->draw_focus != NULL);
1093
1094    (*style->klass->draw_focus) (style, window, NULL, NULL, NULL, x, y, width, height);
1095 }
1096
1097 void
1098 gtk_draw_slider  (GtkStyle      *style,
1099                   GdkWindow     *window,
1100                   GtkStateType   state_type,
1101                   GtkShadowType  shadow_type,
1102                   gint           x,
1103                   gint           y,
1104                   gint           width,
1105                   gint           height,
1106                   GtkOrientation orientation)
1107 {
1108    g_return_if_fail (style != NULL);
1109    g_return_if_fail (style->klass != NULL);
1110    g_return_if_fail (style->klass->draw_slider != NULL);
1111
1112    (*style->klass->draw_slider) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, orientation);
1113 }
1114
1115 void
1116 gtk_draw_handle  (GtkStyle      *style,
1117                   GdkWindow     *window,
1118                   GtkStateType   state_type,
1119                   GtkShadowType  shadow_type,
1120                   gint           x,
1121                   gint           y,
1122                   gint           width,
1123                   gint           height,
1124                   GtkOrientation orientation)
1125 {
1126    g_return_if_fail (style != NULL);
1127    g_return_if_fail (style->klass != NULL);
1128    g_return_if_fail (style->klass->draw_handle != NULL);
1129
1130    (*style->klass->draw_handle) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, orientation);
1131 }
1132
1133 /* Default functions */
1134 void
1135 gtk_style_apply_default_pixmap(GtkStyle     *style,
1136                                GdkWindow    *window,
1137                                GtkStateType  state_type,
1138                                GdkRectangle *area,
1139                                gint x,
1140                                gint y,
1141                                gint width,
1142                                gint height)
1143 {
1144   GdkRectangle new_rect, old_rect;
1145   GdkGC       *gc;
1146
1147   if ((!style->bg_pixmap[state_type]) ||
1148       (gdk_window_get_type(window) == GDK_WINDOW_PIXMAP))
1149     {
1150       gc = style->bg_gc[state_type];
1151
1152       old_rect.x = x;
1153       old_rect.y = y;
1154       old_rect.width = width;
1155       old_rect.height = height;
1156
1157       if (area)
1158         {
1159           if (gdk_rectangle_intersect(area, &old_rect, &new_rect))
1160             gdk_draw_rectangle(window, gc, TRUE,
1161                                new_rect.x, new_rect.y, new_rect.width, new_rect.height);
1162         }
1163       else
1164         gdk_draw_rectangle(window, gc, TRUE,
1165                            x, y, width, height);
1166     }
1167   else
1168     {
1169       if (style->bg_pixmap[state_type] == (GdkPixmap*) GDK_PARENT_RELATIVE)
1170         gdk_window_set_back_pixmap(window, NULL, TRUE);
1171       else
1172         gdk_window_set_back_pixmap(window, style->bg_pixmap[state_type], FALSE);
1173
1174       old_rect.x = x;
1175       old_rect.y = y;
1176       old_rect.width = width;
1177       old_rect.height = height;
1178
1179       if ((area) && (gdk_rectangle_intersect(area, &old_rect, &new_rect)))
1180         gdk_window_clear_area(window, new_rect.x, new_rect.y, new_rect.width, new_rect.height);
1181       else
1182         gdk_window_clear_area(window, x, y, width, height);
1183     }
1184 }
1185
1186 static void
1187 gtk_default_draw_hline (GtkStyle     *style,
1188                         GdkWindow    *window,
1189                         GtkStateType  state_type,
1190                         GdkRectangle  *area,
1191                         GtkWidget     *widget,
1192                         gchar         *detail,
1193                         gint          x1,
1194                         gint          x2,
1195                         gint          y)
1196 {
1197    gint thickness_light;
1198    gint thickness_dark;
1199    gint i;
1200
1201    g_return_if_fail (style != NULL);
1202    g_return_if_fail (window != NULL);
1203
1204    thickness_light = style->klass->ythickness / 2;
1205    thickness_dark = style->klass->ythickness - thickness_light;
1206
1207    if (area)
1208      {
1209         gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
1210         gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
1211      }
1212
1213    if (detail && !strcmp (detail, "label"))
1214      {
1215        if (state_type == GTK_STATE_INSENSITIVE)
1216          gdk_draw_line (window, style->white_gc, x1 + 1, y + 1, x2 + 1, y + 1);
1217        gdk_draw_line (window, style->fg_gc[state_type], x1, y, x2, y);
1218      }
1219    else
1220      {
1221        for (i = 0; i < thickness_dark; i++)
1222          {
1223            gdk_draw_line (window, style->light_gc[state_type], x2 - i - 1, y + i, x2, y + i);
1224            gdk_draw_line (window, style->dark_gc[state_type], x1, y + i, x2 - i - 1, y + i);
1225          }
1226
1227        y += thickness_dark;
1228        for (i = 0; i < thickness_light; i++)
1229          {
1230            gdk_draw_line (window, style->dark_gc[state_type], x1, y + i, x1 + thickness_light - i - 1, y + i);
1231            gdk_draw_line (window, style->light_gc[state_type], x1 + thickness_light - i - 1, y + i, x2, y + i);
1232          }
1233      }
1234
1235    if (area)
1236      {
1237         gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
1238         gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
1239      }
1240 }
1241
1242
1243 static void
1244 gtk_default_draw_vline (GtkStyle     *style,
1245                         GdkWindow    *window,
1246                         GtkStateType  state_type,
1247                         GdkRectangle  *area,
1248                         GtkWidget     *widget,
1249                         gchar         *detail,
1250                         gint          y1,
1251                         gint          y2,
1252                         gint          x)
1253 {
1254    gint thickness_light;
1255    gint thickness_dark;
1256    gint i;
1257
1258    g_return_if_fail (style != NULL);
1259    g_return_if_fail (window != NULL);
1260
1261    thickness_light = style->klass->xthickness / 2;
1262    thickness_dark = style->klass->xthickness - thickness_light;
1263
1264    if (area)
1265      {
1266         gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
1267         gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
1268      }
1269    for (i = 0; i < thickness_dark; i++)
1270      {
1271         gdk_draw_line (window, style->light_gc[state_type], x + i, y2 - i - 1, x + i, y2);
1272       gdk_draw_line (window, style->dark_gc[state_type], x + i, y1, x + i, y2 - i - 1);
1273      }
1274
1275    x += thickness_dark;
1276    for (i = 0; i < thickness_light; i++)
1277      {
1278         gdk_draw_line (window, style->dark_gc[state_type], x + i, y1, x + i, y1 + thickness_light - i);
1279         gdk_draw_line (window, style->light_gc[state_type], x + i, y1 + thickness_light - i, x + i, y2);
1280      }
1281    if (area)
1282      {
1283         gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
1284         gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
1285      }
1286 }
1287
1288
1289 static void
1290 gtk_default_draw_shadow (GtkStyle      *style,
1291                          GdkWindow     *window,
1292                          GtkStateType   state_type,
1293                          GtkShadowType  shadow_type,
1294                          GdkRectangle  *area,
1295                          GtkWidget     *widget,
1296                          gchar         *detail,
1297                          gint           x,
1298                          gint           y,
1299                          gint           width,
1300                          gint           height)
1301 {
1302   GdkGC *gc1 = NULL;
1303   GdkGC *gc2 = NULL;
1304   gint thickness_light;
1305   gint thickness_dark;
1306   gint i;
1307
1308   g_return_if_fail (style != NULL);
1309   g_return_if_fail (window != NULL);
1310
1311   if ((width == -1) && (height == -1))
1312     gdk_window_get_size (window, &width, &height);
1313   else if (width == -1)
1314     gdk_window_get_size (window, &width, NULL);
1315   else if (height == -1)
1316     gdk_window_get_size (window, NULL, &height);
1317
1318   switch (shadow_type)
1319     {
1320     case GTK_SHADOW_NONE:
1321       return;
1322     case GTK_SHADOW_IN:
1323     case GTK_SHADOW_ETCHED_IN:
1324       gc1 = style->light_gc[state_type];
1325       gc2 = style->dark_gc[state_type];
1326       break;
1327     case GTK_SHADOW_OUT:
1328     case GTK_SHADOW_ETCHED_OUT:
1329       gc1 = style->dark_gc[state_type];
1330       gc2 = style->light_gc[state_type];
1331       break;
1332     }
1333
1334    if (area)
1335      {
1336        gdk_gc_set_clip_rectangle (gc1, area);
1337        gdk_gc_set_clip_rectangle (gc2, area);
1338        if ((shadow_type == GTK_SHADOW_IN) ||
1339            (shadow_type == GTK_SHADOW_OUT))
1340          {
1341            gdk_gc_set_clip_rectangle (style->black_gc, area);
1342            gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
1343          }
1344      }
1345    switch (shadow_type)
1346     {
1347     case GTK_SHADOW_NONE:
1348       break;
1349
1350     case GTK_SHADOW_IN:
1351       gdk_draw_line (window, gc1,
1352                      x, y + height - 1, x + width - 1, y + height - 1);
1353       gdk_draw_line (window, gc1,
1354                      x + width - 1, y, x + width - 1, y + height - 1);
1355
1356       gdk_draw_line (window, style->bg_gc[state_type],
1357                      x + 1, y + height - 2, x + width - 2, y + height - 2);
1358       gdk_draw_line (window, style->bg_gc[state_type],
1359                      x + width - 2, y + 1, x + width - 2, y + height - 2);
1360
1361       gdk_draw_line (window, style->black_gc,
1362                      x + 1, y + 1, x + width - 2, y + 1);
1363       gdk_draw_line (window, style->black_gc,
1364                      x + 1, y + 1, x + 1, y + height - 2);
1365
1366       gdk_draw_line (window, gc2,
1367                      x, y, x + width - 1, y);
1368       gdk_draw_line (window, gc2,
1369                      x, y, x, y + height - 1);
1370       break;
1371
1372     case GTK_SHADOW_OUT:
1373       gdk_draw_line (window, gc1,
1374                      x + 1, y + height - 2, x + width - 2, y + height - 2);
1375       gdk_draw_line (window, gc1,
1376                      x + width - 2, y + 1, x + width - 2, y + height - 2);
1377
1378       gdk_draw_line (window, gc2,
1379                      x, y, x + width - 1, y);
1380       gdk_draw_line (window, gc2,
1381                      x, y, x, y + height - 1);
1382
1383       gdk_draw_line (window, style->bg_gc[state_type],
1384                      x + 1, y + 1, x + width - 2, y + 1);
1385       gdk_draw_line (window, style->bg_gc[state_type],
1386                      x + 1, y + 1, x + 1, y + height - 2);
1387
1388       gdk_draw_line (window, style->black_gc,
1389                      x, y + height - 1, x + width - 1, y + height - 1);
1390       gdk_draw_line (window, style->black_gc,
1391                      x + width - 1, y, x + width - 1, y + height - 1);
1392       break;
1393
1394     case GTK_SHADOW_ETCHED_IN:
1395     case GTK_SHADOW_ETCHED_OUT:
1396       thickness_light = 1;
1397       thickness_dark = 1;
1398
1399       for (i = 0; i < thickness_dark; i++)
1400         {
1401           gdk_draw_line (window, gc1,
1402                          x + i,
1403                          y + height - i - 1,
1404                          x + width - i - 1,
1405                          y + height - i - 1);
1406           gdk_draw_line (window, gc1,
1407                          x + width - i - 1,
1408                          y + i,
1409                          x + width - i - 1,
1410                          y + height - i - 1);
1411
1412           gdk_draw_line (window, gc2,
1413                          x + i,
1414                          y + i,
1415                          x + width - i - 2,
1416                          y + i);
1417           gdk_draw_line (window, gc2,
1418                          x + i,
1419                          y + i,
1420                          x + i,
1421                          y + height - i - 2);
1422         }
1423
1424       for (i = 0; i < thickness_light; i++)
1425         {
1426           gdk_draw_line (window, gc1,
1427                          x + thickness_dark + i,
1428                          y + thickness_dark + i,
1429                          x + width - thickness_dark - i - 1,
1430                          y + thickness_dark + i);
1431           gdk_draw_line (window, gc1,
1432                          x + thickness_dark + i,
1433                          y + thickness_dark + i,
1434                          x + thickness_dark + i,
1435                          y + height - thickness_dark - i - 1);
1436
1437           gdk_draw_line (window, gc2,
1438                          x + thickness_dark + i,
1439                          y + height - thickness_light - i - 1,
1440                          x + width - thickness_light - 1,
1441                          y + height - thickness_light - i - 1);
1442           gdk_draw_line (window, gc2,
1443                          x + width - thickness_light - i - 1,
1444                          y + thickness_dark + i,
1445                          x + width - thickness_light - i - 1,
1446                          y + height - thickness_light - 1);
1447         }
1448       break;
1449     }
1450    if (area)
1451      {
1452         gdk_gc_set_clip_rectangle (gc1, NULL);
1453         gdk_gc_set_clip_rectangle (gc2, NULL);
1454         if ((shadow_type == GTK_SHADOW_IN) ||
1455             (shadow_type == GTK_SHADOW_OUT))
1456           {
1457             gdk_gc_set_clip_rectangle (style->black_gc, NULL);
1458             gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
1459           }
1460      }
1461 }
1462
1463
1464 static void
1465 gtk_default_draw_polygon (GtkStyle      *style,
1466                           GdkWindow     *window,
1467                           GtkStateType   state_type,
1468                           GtkShadowType  shadow_type,
1469                           GdkRectangle  *area,
1470                           GtkWidget     *widget,
1471                           gchar         *detail,
1472                           GdkPoint      *points,
1473                           gint           npoints,
1474                           gboolean       fill)
1475 {
1476 #ifndef M_PI
1477 #define M_PI    3.14159265358979323846
1478 #endif /* M_PI */
1479 #ifndef M_PI_4
1480 #define M_PI_4  0.78539816339744830962
1481 #endif /* M_PI_4 */
1482
1483   static const gdouble pi_over_4 = M_PI_4;
1484   static const gdouble pi_3_over_4 = M_PI_4 * 3;
1485
1486   GdkGC *gc1;
1487   GdkGC *gc2;
1488   GdkGC *gc3;
1489   GdkGC *gc4;
1490   gdouble angle;
1491   gint xadjust;
1492   gint yadjust;
1493   gint i;
1494
1495   g_return_if_fail (style != NULL);
1496   g_return_if_fail (window != NULL);
1497   g_return_if_fail (points != NULL);
1498
1499   switch (shadow_type)
1500     {
1501     case GTK_SHADOW_IN:
1502       gc1 = style->bg_gc[state_type];
1503       gc2 = style->dark_gc[state_type];
1504       gc3 = style->light_gc[state_type];
1505       gc4 = style->black_gc;
1506       break;
1507      case GTK_SHADOW_ETCHED_IN:
1508       gc1 = style->light_gc[state_type];
1509       gc2 = style->dark_gc[state_type];
1510       gc3 = style->dark_gc[state_type];
1511       gc4 = style->light_gc[state_type];
1512       break;
1513     case GTK_SHADOW_OUT:
1514       gc1 = style->dark_gc[state_type];
1515       gc2 = style->light_gc[state_type];
1516       gc3 = style->black_gc;
1517       gc4 = style->bg_gc[state_type];
1518       break;
1519      case GTK_SHADOW_ETCHED_OUT:
1520       gc1 = style->dark_gc[state_type];
1521       gc2 = style->light_gc[state_type];
1522       gc3 = style->light_gc[state_type];
1523       gc4 = style->dark_gc[state_type];
1524       break;
1525     default:
1526       return;
1527     }
1528
1529    if (area)
1530      {
1531         gdk_gc_set_clip_rectangle (gc1, area);
1532         gdk_gc_set_clip_rectangle (gc2, area);
1533         gdk_gc_set_clip_rectangle (gc3, area);
1534         gdk_gc_set_clip_rectangle (gc4, area);
1535      }
1536
1537    if (fill)
1538     gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points, npoints);
1539
1540   npoints--;
1541
1542   for (i = 0; i < npoints; i++)
1543     {
1544       if ((points[i].x == points[i+1].x) &&
1545           (points[i].y == points[i+1].y))
1546         {
1547           angle = 0;
1548         }
1549       else
1550         {
1551           angle = atan2 (points[i+1].y - points[i].y,
1552                          points[i+1].x - points[i].x);
1553         }
1554
1555       if ((angle > -pi_3_over_4) && (angle < pi_over_4))
1556         {
1557           if (angle > -pi_over_4)
1558             {
1559               xadjust = 0;
1560               yadjust = 1;
1561             }
1562           else
1563             {
1564               xadjust = 1;
1565               yadjust = 0;
1566             }
1567
1568           gdk_draw_line (window, gc1,
1569                          points[i].x-xadjust, points[i].y-yadjust,
1570                          points[i+1].x-xadjust, points[i+1].y-yadjust);
1571           gdk_draw_line (window, gc3,
1572                          points[i].x, points[i].y,
1573                          points[i+1].x, points[i+1].y);
1574         }
1575       else
1576         {
1577           if ((angle < -pi_3_over_4) || (angle > pi_3_over_4))
1578             {
1579               xadjust = 0;
1580               yadjust = 1;
1581             }
1582           else
1583             {
1584               xadjust = 1;
1585               yadjust = 0;
1586             }
1587
1588           gdk_draw_line (window, gc4,
1589                          points[i].x+xadjust, points[i].y+yadjust,
1590                          points[i+1].x+xadjust, points[i+1].y+yadjust);
1591           gdk_draw_line (window, gc2,
1592                          points[i].x, points[i].y,
1593                          points[i+1].x, points[i+1].y);
1594         }
1595     }
1596    if (area)
1597      {
1598         gdk_gc_set_clip_rectangle (gc1, NULL);
1599         gdk_gc_set_clip_rectangle (gc2, NULL);
1600         gdk_gc_set_clip_rectangle (gc3, NULL);
1601         gdk_gc_set_clip_rectangle (gc4, NULL);
1602      }
1603 }
1604
1605 static void
1606 gtk_default_draw_arrow (GtkStyle      *style,
1607                         GdkWindow     *window,
1608                         GtkStateType   state_type,
1609                         GtkShadowType  shadow_type,
1610                         GdkRectangle  *area,
1611                         GtkWidget     *widget,
1612                         gchar         *detail,
1613                         GtkArrowType   arrow_type,
1614                         gboolean       fill,
1615                         gint           x,
1616                         gint           y,
1617                         gint           width,
1618                         gint           height)
1619 {
1620    GdkGC *gc1;
1621    GdkGC *gc2;
1622    GdkGC *gc3;
1623    GdkGC *gc4;
1624    gint half_width;
1625    gint half_height;
1626    GdkPoint points[3];
1627
1628    g_return_if_fail (style != NULL);
1629    g_return_if_fail (window != NULL);
1630
1631    switch (shadow_type)
1632      {
1633       case GTK_SHADOW_IN:
1634         gc1 = style->bg_gc[state_type];
1635         gc2 = style->dark_gc[state_type];
1636         gc3 = style->light_gc[state_type];
1637         gc4 = style->black_gc;
1638         break;
1639       case GTK_SHADOW_OUT:
1640         gc1 = style->dark_gc[state_type];
1641         gc2 = style->light_gc[state_type];
1642         gc3 = style->black_gc;
1643         gc4 = style->bg_gc[state_type];
1644         break;
1645       case GTK_SHADOW_ETCHED_IN:
1646         gc1 = style->light_gc[state_type];
1647         gc2 = style->dark_gc[state_type];
1648         gc3 = NULL;
1649         gc4 = NULL;
1650         break;
1651       case GTK_SHADOW_ETCHED_OUT:
1652         gc1 = style->dark_gc[state_type];
1653         gc2 = style->light_gc[state_type];
1654         gc3 = NULL;
1655         gc4 = NULL;
1656         break;
1657       default:
1658         return;
1659      }
1660
1661    if ((width == -1) && (height == -1))
1662      gdk_window_get_size (window, &width, &height);
1663    else if (width == -1)
1664      gdk_window_get_size (window, &width, NULL);
1665    else if (height == -1)
1666      gdk_window_get_size (window, NULL, &height);
1667
1668    half_width = width / 2;
1669    half_height = height / 2;
1670
1671    if (area)
1672      {
1673         gdk_gc_set_clip_rectangle (gc1, area);
1674         gdk_gc_set_clip_rectangle (gc2, area);
1675         if ((gc3) && (gc4))
1676           {
1677              gdk_gc_set_clip_rectangle (gc3, area);
1678              gdk_gc_set_clip_rectangle (gc4, area);
1679           }
1680      }
1681
1682    switch (arrow_type)
1683      {
1684       case GTK_ARROW_UP:
1685         if (fill)
1686           {
1687              points[0].x = x + half_width;
1688              points[0].y = y;
1689              points[1].x = x;
1690              points[1].y = y + height - 1;
1691              points[2].x = x + width - 1;
1692              points[2].y = y + height - 1;
1693
1694              gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points, 3);
1695           }
1696
1697         switch (shadow_type)
1698           {
1699            case GTK_SHADOW_IN:
1700            case GTK_SHADOW_OUT:
1701
1702              gdk_draw_line (window, gc1,
1703                             x + 1, y + height - 2,
1704                             x + width - 2, y + height - 2);
1705              gdk_draw_line (window, gc3,
1706                             x + 0, y + height - 1,
1707                             x + width - 1, y + height - 1);
1708
1709              gdk_draw_line (window, gc1,
1710                             x + width - 2, y + height - 1,
1711                             x + half_width, y + 1);
1712              gdk_draw_line (window, gc3,
1713                             x + width - 1, y + height - 1,
1714                             x + half_width, y);
1715
1716              gdk_draw_line (window, gc4,
1717                             x + half_width, y + 1,
1718                             x + 1, y + height - 1);
1719              gdk_draw_line (window, gc2,
1720                             x + half_width, y,
1721                             x, y + height - 1);
1722              break;
1723
1724            case GTK_SHADOW_ETCHED_IN:
1725            case GTK_SHADOW_ETCHED_OUT:
1726              gdk_draw_line (window, gc1,
1727                             x + half_width, y + 1,
1728                             x + 1, y + height - 1);
1729              gdk_draw_line (window, gc1,
1730                             x + 1, y + height - 1,
1731                             x + width - 1, y + height - 1);
1732              gdk_draw_line (window, gc1,
1733                             x + width - 1, y + height - 1,
1734                             x + half_width + 1, y + 1);
1735
1736              points[0].x = x + half_width;
1737              points[0].y = y;
1738              points[1].x = x;
1739              points[1].y = y + height - 2;
1740              points[2].x = x + width - 2;
1741              points[2].y = y + height - 2;
1742
1743              gdk_draw_polygon (window, gc2, FALSE, points, 3);
1744              break;
1745
1746            default:
1747              break;
1748           }
1749         break;
1750
1751       case GTK_ARROW_DOWN:
1752         if (fill)
1753           {
1754              points[0].x = x + width - 1;
1755              points[0].y = y;
1756           points[1].x = x;
1757              points[1].y = y;
1758              points[2].x = x + half_width;
1759              points[2].y = y + height - 1;
1760
1761              gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points, 3);
1762           }
1763         switch (shadow_type)
1764           {
1765            case GTK_SHADOW_IN:
1766            case GTK_SHADOW_OUT:
1767              gdk_draw_line (window, gc4,
1768                             x + width - 2,
1769                             y + 1, x + 1, y + 1);
1770              gdk_draw_line (window, gc2,
1771                             x + width - 1, y,
1772                             x, y);
1773
1774              gdk_draw_line (window, gc4,
1775                             x + 1, y,
1776                             x + half_width, y + height - 2);
1777              gdk_draw_line (window, gc2,
1778                             x, y,
1779                             x + half_width, y + height - 1);
1780
1781              gdk_draw_line (window, gc1,
1782                             x + half_width, y + height - 2,
1783                             x + width - 2, y);
1784              gdk_draw_line (window, gc3,
1785                             x + half_width, y + height - 1,
1786                             x + width - 1, y);
1787              break;
1788
1789            case GTK_SHADOW_ETCHED_IN:
1790            case GTK_SHADOW_ETCHED_OUT:
1791              gdk_draw_line (window, gc1,
1792                             x + width - 1, y + 1,
1793                             x + 1, y + 1);
1794              gdk_draw_line (window, gc1,
1795                             x + 1, y + 1,
1796                             x + half_width + 1, y + height - 1);
1797              gdk_draw_line (window, gc1,
1798                             x + half_width + 1, y + height - 2,
1799                             x + width - 1, y);
1800
1801              points[0].x = x + width - 2;
1802              points[0].y = y;
1803              points[1].x = x;
1804              points[1].y = y;
1805              points[2].x = x + half_width;
1806              points[2].y = y + height - 2;
1807
1808              gdk_draw_polygon (window, gc2, FALSE, points, 3);
1809              break;
1810
1811            default:
1812              break;
1813           }
1814         break;
1815       case GTK_ARROW_LEFT:
1816       if (fill)
1817           {
1818              points[0].x = x;
1819              points[0].y = y + half_height;
1820              points[1].x = x + width - 1;
1821              points[1].y = y + height - 1;
1822              points[2].x = x + width - 1;
1823              points[2].y = y;
1824
1825              gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points, 3);
1826           }
1827
1828         switch (shadow_type)
1829           {
1830            case GTK_SHADOW_IN:
1831            case GTK_SHADOW_OUT:
1832              gdk_draw_line (window, gc1,
1833                             x + 1, y + half_height,
1834                             x + width - 1, y + height - 1);
1835              gdk_draw_line (window, gc3,
1836                             x, y + half_height,
1837                             x + width - 1, y + height - 1);
1838
1839              gdk_draw_line (window, gc1,
1840                             x + width - 2, y + height - 1,
1841                             x + width - 2, y + 1);
1842              gdk_draw_line (window, gc3,
1843                             x + width - 1, y + height - 1,
1844                             x + width - 1, y);
1845
1846              gdk_draw_line (window, gc4,
1847                             x + width - 1, y + 1,
1848                             x + 1, y + half_height);
1849              gdk_draw_line (window, gc2,
1850                             x + width - 1, y,
1851                             x, y + half_height);
1852              break;
1853
1854            case GTK_SHADOW_ETCHED_IN:
1855            case GTK_SHADOW_ETCHED_OUT:
1856              gdk_draw_line (window, gc1,
1857                             x + width - 1, y + 1,
1858                             x + 1, y + half_height);
1859              gdk_draw_line (window, gc1,
1860                             x + 1, y + half_height + 1,
1861                             x + width - 1, y + height - 1);
1862              gdk_draw_line (window, gc1,
1863                             x + width - 1, y + height - 1,
1864                             x + width - 1, y + 1);
1865
1866              points[0].x = x + width - 2;
1867              points[0].y = y;
1868              points[1].x = x;
1869              points[1].y = y + half_height;
1870              points[2].x = x + width - 2;
1871              points[2].y = y + height - 2;
1872
1873              gdk_draw_polygon (window, gc2, FALSE, points, 3);
1874              break;
1875
1876            default:
1877              break;
1878           }
1879         break;
1880       case GTK_ARROW_RIGHT:
1881         if (fill)
1882           {
1883              points[0].x = x + width - 1;
1884              points[0].y = y + half_height;
1885              points[1].x = x;
1886              points[1].y = y;
1887              points[2].x = x;
1888              points[2].y = y + height - 1;
1889
1890              gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points, 3);
1891           }
1892
1893         switch (shadow_type)
1894           {
1895            case GTK_SHADOW_IN:
1896            case GTK_SHADOW_OUT:
1897              gdk_draw_line (window, gc4,
1898                             x + width - 1, y + half_height,
1899                             x + 1, y + 1);
1900              gdk_draw_line (window, gc2,
1901                             x + width - 1, y + half_height,
1902                             x, y);
1903              gdk_draw_line (window, gc4,
1904                             x + 1, y + 1,
1905                             x + 1, y + height - 2);
1906              gdk_draw_line (window, gc2,
1907                             x, y,
1908                             x, y + height - 1);
1909
1910              gdk_draw_line (window, gc1,
1911                             x + 1, y + height - 2,
1912                             x + width - 1, y + half_height);
1913              gdk_draw_line (window, gc3,
1914                             x, y + height - 1,
1915                             x + width - 1, y + half_height);
1916              break;
1917
1918            case GTK_SHADOW_ETCHED_IN:
1919         case GTK_SHADOW_ETCHED_OUT:
1920              gdk_draw_line (window, gc1,
1921                             x + width - 1, y + half_height + 1,
1922                             x + 1, y + 1);
1923              gdk_draw_line (window, gc1,
1924                             x + 1, y + 1,
1925                             x + 1, y + height - 1);
1926              gdk_draw_line (window, gc1,
1927                             x + 1, y + height - 1,
1928                             x + width - 1, y + half_height + 1);
1929
1930              points[0].x = x + width - 2;
1931              points[0].y = y + half_height;
1932              points[1].x = x;
1933              points[1].y = y;
1934              points[2].x = x;
1935              points[2].y = y + height - 1;
1936
1937              gdk_draw_polygon (window, gc2, FALSE, points, 3);
1938              break;
1939
1940            default:
1941              break;
1942           }
1943         break;
1944      }
1945    if (area)
1946      {
1947         gdk_gc_set_clip_rectangle (gc1, NULL);
1948         gdk_gc_set_clip_rectangle (gc2, NULL);
1949         if (gc3)
1950           {
1951              gdk_gc_set_clip_rectangle (gc3, NULL);
1952              gdk_gc_set_clip_rectangle (gc4, NULL);
1953           }
1954      }
1955 }
1956
1957 static void
1958 gtk_default_draw_diamond (GtkStyle      *style,
1959                           GdkWindow     *window,
1960                           GtkStateType   state_type,
1961                           GtkShadowType  shadow_type,
1962                           GdkRectangle  *area,
1963                           GtkWidget     *widget,
1964                           gchar         *detail,
1965                           gint           x,
1966                           gint           y,
1967                           gint           width,
1968                           gint           height)
1969 {
1970    gint half_width;
1971    gint half_height;
1972
1973    g_return_if_fail (style != NULL);
1974    g_return_if_fail (window != NULL);
1975
1976    if ((width == -1) && (height == -1))
1977      gdk_window_get_size (window, &width, &height);
1978    else if (width == -1)
1979      gdk_window_get_size (window, &width, NULL);
1980    else if (height == -1)
1981      gdk_window_get_size (window, NULL, &height);
1982
1983    half_width = width / 2;
1984    half_height = height / 2;
1985
1986    if (area)
1987      {
1988         gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
1989         gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
1990         gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
1991         gdk_gc_set_clip_rectangle (style->black_gc, area);
1992      }
1993    switch (shadow_type)
1994      {
1995       case GTK_SHADOW_IN:
1996         gdk_draw_line (window, style->bg_gc[state_type],
1997                        x + 2, y + half_height,
1998                        x + half_width, y + height - 2);
1999         gdk_draw_line (window, style->bg_gc[state_type],
2000                        x + half_width, y + height - 2,
2001                        x + width - 2, y + half_height);
2002         gdk_draw_line (window, style->light_gc[state_type],
2003                        x + 1, y + half_height,
2004                        x + half_width, y + height - 1);
2005         gdk_draw_line (window, style->light_gc[state_type],
2006                        x + half_width, y + height - 1,
2007                        x + width - 1, y + half_height);
2008         gdk_draw_line (window, style->light_gc[state_type],
2009                        x, y + half_height,
2010                        x + half_width, y + height);
2011         gdk_draw_line (window, style->light_gc[state_type],
2012                        x + half_width, y + height,
2013                      x + width, y + half_height);
2014
2015         gdk_draw_line (window, style->black_gc,
2016                        x + 2, y + half_height,
2017                        x + half_width, y + 2);
2018         gdk_draw_line (window, style->black_gc,
2019                        x + half_width, y + 2,
2020                        x + width - 2, y + half_height);
2021         gdk_draw_line (window, style->dark_gc[state_type],
2022                        x + 1, y + half_height,
2023                      x + half_width, y + 1);
2024         gdk_draw_line (window, style->dark_gc[state_type],
2025                        x + half_width, y + 1,
2026                        x + width - 1, y + half_height);
2027         gdk_draw_line (window, style->dark_gc[state_type],
2028                        x, y + half_height,
2029                        x + half_width, y);
2030         gdk_draw_line (window, style->dark_gc[state_type],
2031                        x + half_width, y,
2032                        x + width, y + half_height);
2033         break;
2034       case GTK_SHADOW_OUT:
2035         gdk_draw_line (window, style->dark_gc[state_type],
2036                        x + 2, y + half_height,
2037                        x + half_width, y + height - 2);
2038         gdk_draw_line (window, style->dark_gc[state_type],
2039                        x + half_width, y + height - 2,
2040                        x + width - 2, y + half_height);
2041         gdk_draw_line (window, style->dark_gc[state_type],
2042                        x + 1, y + half_height,
2043                        x + half_width, y + height - 1);
2044         gdk_draw_line (window, style->dark_gc[state_type],
2045                        x + half_width, y + height - 1,
2046                        x + width - 1, y + half_height);
2047         gdk_draw_line (window, style->black_gc,
2048                        x, y + half_height,
2049                        x + half_width, y + height);
2050         gdk_draw_line (window, style->black_gc,
2051                        x + half_width, y + height,
2052                        x + width, y + half_height);
2053
2054         gdk_draw_line (window, style->bg_gc[state_type],
2055                        x + 2, y + half_height,
2056                        x + half_width, y + 2);
2057         gdk_draw_line (window, style->bg_gc[state_type],
2058                        x + half_width, y + 2,
2059                        x + width - 2, y + half_height);
2060         gdk_draw_line (window, style->light_gc[state_type],
2061                        x + 1, y + half_height,
2062                        x + half_width, y + 1);
2063         gdk_draw_line (window, style->light_gc[state_type],
2064                        x + half_width, y + 1,
2065                      x + width - 1, y + half_height);
2066         gdk_draw_line (window, style->light_gc[state_type],
2067                        x, y + half_height,
2068                        x + half_width, y);
2069         gdk_draw_line (window, style->light_gc[state_type],
2070                        x + half_width, y,
2071                        x + width, y + half_height);
2072         break;
2073       default:
2074         break;
2075      }
2076    if (area)
2077      {
2078         gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
2079         gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
2080         gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
2081         gdk_gc_set_clip_rectangle (style->black_gc, NULL);
2082      }
2083 }
2084
2085
2086 static void
2087 gtk_default_draw_oval (GtkStyle      *style,
2088                        GdkWindow     *window,
2089                        GtkStateType   state_type,
2090                        GtkShadowType  shadow_type,
2091                        GdkRectangle  *area,
2092                        GtkWidget     *widget,
2093                        gchar         *detail,
2094                        gint           x,
2095                        gint           y,
2096                        gint           width,
2097                        gint           height)
2098 {
2099   g_return_if_fail (style != NULL);
2100   g_return_if_fail (window != NULL);
2101 }
2102
2103 static void
2104 gtk_default_draw_string (GtkStyle      *style,
2105                          GdkWindow     *window,
2106                          GtkStateType   state_type,
2107                          GdkRectangle  *area,
2108                          GtkWidget     *widget,
2109                          gchar         *detail,
2110                          gint           x,
2111                          gint           y,
2112                          const gchar   *string)
2113 {
2114   g_return_if_fail (style != NULL);
2115   g_return_if_fail (window != NULL);
2116
2117    if (area)
2118      {
2119         gdk_gc_set_clip_rectangle (style->white_gc, area);
2120         gdk_gc_set_clip_rectangle (style->fg_gc[state_type], area);
2121      }
2122    if (state_type == GTK_STATE_INSENSITIVE)
2123      gdk_draw_string (window, style->font, style->white_gc, x + 1, y + 1, string);
2124    gdk_draw_string (window, style->font, style->fg_gc[state_type], x, y, string);
2125    if (area)
2126      {
2127         gdk_gc_set_clip_rectangle (style->white_gc, NULL);
2128         gdk_gc_set_clip_rectangle (style->fg_gc[state_type], NULL);
2129      }
2130 }
2131
2132 static void
2133 gtk_default_draw_box     (GtkStyle      *style,
2134                           GdkWindow     *window,
2135                           GtkStateType   state_type,
2136                           GtkShadowType  shadow_type,
2137                           GdkRectangle  *area,
2138                           GtkWidget     *widget,
2139                           gchar         *detail,
2140                           gint           x,
2141                           gint           y,
2142                           gint           width,
2143                           gint           height)
2144 {
2145    g_return_if_fail (style != NULL);
2146    g_return_if_fail (window != NULL);
2147
2148    if ((width == -1) && (height == -1))
2149      gdk_window_get_size (window, &width, &height);
2150    else if (width == -1)
2151      gdk_window_get_size (window, &width, NULL);
2152    else if (height == -1)
2153      gdk_window_get_size (window, NULL, &height);
2154
2155   if ((!style->bg_pixmap[state_type]) ||
2156       (gdk_window_get_type(window) == GDK_WINDOW_PIXMAP))
2157     {
2158       if (area)
2159         {
2160           gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
2161         }
2162       gdk_draw_rectangle(window, style->bg_gc[state_type], TRUE,
2163                          x, y, width, height);
2164       if (area)
2165         {
2166           gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
2167         }
2168     }
2169   else
2170     gtk_style_apply_default_pixmap(style, window, state_type, area, x, y, width, height);
2171   gtk_paint_shadow (style, window, state_type, shadow_type, area, widget, detail,
2172                     x, y, width, height);
2173 }
2174
2175 static void
2176 gtk_default_draw_flat_box (GtkStyle      *style,
2177                            GdkWindow     *window,
2178                            GtkStateType   state_type,
2179                            GtkShadowType  shadow_type,
2180                            GdkRectangle  *area,
2181                            GtkWidget     *widget,
2182                            gchar         *detail,
2183                            gint           x,
2184                            gint           y,
2185                            gint           width,
2186                            gint           height)
2187 {
2188   GdkGC *gc1;
2189
2190   g_return_if_fail (style != NULL);
2191   g_return_if_fail (window != NULL);
2192
2193   if ((width == -1) && (height == -1))
2194     gdk_window_get_size (window, &width, &height);
2195   else if (width == -1)
2196     gdk_window_get_size (window, &width, NULL);
2197   else if (height == -1)
2198     gdk_window_get_size (window, NULL, &height);
2199
2200   if ((detail) && (!strcmp("text",detail)) && (state_type == GTK_STATE_SELECTED))
2201     gc1 = style->bg_gc[GTK_STATE_SELECTED];
2202   else if ((detail) && (!strcmp("viewportbin",detail)))
2203     gc1 = style->bg_gc[GTK_STATE_NORMAL];
2204   else if ((detail) && (!strcmp("entry_bg",detail)))
2205     gc1 = style->base_gc[state_type];
2206   else
2207     gc1 = style->bg_gc[state_type];
2208
2209   if ((!style->bg_pixmap[state_type]) || (gc1 != style->bg_gc[state_type]) ||
2210       (gdk_window_get_type(window) == GDK_WINDOW_PIXMAP))
2211     {
2212       if (area)
2213         {
2214           gdk_gc_set_clip_rectangle (gc1, area);
2215         }
2216       gdk_draw_rectangle (window, gc1, TRUE,
2217                           x, y, width, height);
2218       if ((detail) && (!strcmp("tooltip",detail)))
2219         gdk_draw_rectangle (window, style->black_gc, FALSE,
2220                             x, y, width - 1, height - 1);
2221       if (area)
2222         {
2223           gdk_gc_set_clip_rectangle (gc1, NULL);
2224         }
2225     }
2226   else
2227     gtk_style_apply_default_pixmap(style, window, state_type, area, x, y, width, height);
2228 }
2229
2230 static void
2231 gtk_default_draw_check   (GtkStyle      *style,
2232                           GdkWindow     *window,
2233                           GtkStateType   state_type,
2234                           GtkShadowType  shadow_type,
2235                           GdkRectangle  *area,
2236                           GtkWidget     *widget,
2237                           gchar         *detail,
2238                           gint           x,
2239                           gint           y,
2240                           gint           width,
2241                           gint           height)
2242 {
2243    gtk_paint_box (style, window, state_type, shadow_type, area, widget, detail,
2244                   x, y, width, height);
2245 }
2246
2247 static void
2248 gtk_default_draw_option  (GtkStyle      *style,
2249                           GdkWindow     *window,
2250                           GtkStateType   state_type,
2251                           GtkShadowType  shadow_type,
2252                           GdkRectangle  *area,
2253                           GtkWidget     *widget,
2254                           gchar         *detail,
2255                           gint           x,
2256                           gint           y,
2257                           gint           width,
2258                           gint           height)
2259 {
2260    gtk_paint_diamond (style, window, state_type, shadow_type, area, widget,
2261                      detail, x, y, width, height);
2262 }
2263
2264 static void
2265 gtk_default_draw_cross   (GtkStyle      *style,
2266                           GdkWindow     *window,
2267                           GtkStateType   state_type,
2268                           GtkShadowType  shadow_type,
2269                           GdkRectangle  *area,
2270                           GtkWidget     *widget,
2271                           gchar         *detail,
2272                           gint           x,
2273                           gint           y,
2274                           gint           width,
2275                           gint           height)
2276 {
2277    g_return_if_fail (style != NULL);
2278    g_return_if_fail (window != NULL);
2279 }
2280
2281 static void
2282 gtk_default_draw_ramp    (GtkStyle      *style,
2283                           GdkWindow     *window,
2284                           GtkStateType   state_type,
2285                           GtkShadowType  shadow_type,
2286                           GdkRectangle  *area,
2287                           GtkWidget     *widget,
2288                           gchar         *detail,
2289                           GtkArrowType   arrow_type,
2290                           gint           x,
2291                           gint           y,
2292                           gint           width,
2293                           gint           height)
2294 {
2295    g_return_if_fail (style != NULL);
2296    g_return_if_fail (window != NULL);
2297 }
2298
2299 static void gtk_default_draw_tab     (GtkStyle      *style,
2300                                       GdkWindow     *window,
2301                                       GtkStateType   state_type,
2302                                       GtkShadowType  shadow_type,
2303                                       GdkRectangle  *area,
2304                                       GtkWidget     *widget,
2305                                       gchar         *detail,
2306                                       gint           x,
2307                                       gint           y,
2308                                       gint           width,
2309                                       gint           height)
2310 {
2311    g_return_if_fail (style != NULL);
2312    g_return_if_fail (window != NULL);
2313
2314    gtk_paint_box (style, window, state_type, shadow_type, area, widget, detail,
2315                       x, y, width, height);
2316 }
2317
2318 static void
2319 gtk_default_draw_shadow_gap (GtkStyle       *style,
2320                              GdkWindow      *window,
2321                              GtkStateType    state_type,
2322                              GtkShadowType   shadow_type,
2323                              GdkRectangle   *area,
2324                              GtkWidget      *widget,
2325                              gchar          *detail,
2326                              gint            x,
2327                              gint            y,
2328                              gint            width,
2329                              gint            height,
2330                              GtkPositionType gap_side,
2331                              gint            gap_x,
2332                              gint            gap_width)
2333 {
2334   GdkGC *gc1 = NULL;
2335   GdkGC *gc2 = NULL;
2336   GdkGC *gc3 = NULL;
2337   GdkGC *gc4 = NULL;
2338
2339   g_return_if_fail (style != NULL);
2340   g_return_if_fail (window != NULL);
2341
2342   if ((width == -1) && (height == -1))
2343     gdk_window_get_size (window, &width, &height);
2344   else if (width == -1)
2345     gdk_window_get_size (window, &width, NULL);
2346   else if (height == -1)
2347     gdk_window_get_size (window, NULL, &height);
2348
2349   switch (shadow_type)
2350     {
2351      case GTK_SHADOW_NONE:
2352       return;
2353      case GTK_SHADOW_IN:
2354       gc1 = style->dark_gc[state_type];
2355       gc2 = style->black_gc;
2356       gc3 = style->bg_gc[state_type];
2357       gc4 = style->light_gc[state_type];
2358       break;
2359      case GTK_SHADOW_ETCHED_IN:
2360       gc1 = style->dark_gc[state_type];
2361       gc2 = style->light_gc[state_type];
2362       gc3 = style->dark_gc[state_type];
2363       gc4 = style->light_gc[state_type];
2364       break;
2365      case GTK_SHADOW_OUT:
2366       gc1 = style->light_gc[state_type];
2367       gc2 = style->bg_gc[state_type];
2368       gc3 = style->dark_gc[state_type];
2369       gc4 = style->black_gc;
2370       break;
2371      case GTK_SHADOW_ETCHED_OUT:
2372       gc1 = style->light_gc[state_type];
2373       gc2 = style->dark_gc[state_type];
2374       gc3 = style->light_gc[state_type];
2375       gc4 = style->dark_gc[state_type];
2376       break;
2377     }
2378   if (area)
2379     {
2380       gdk_gc_set_clip_rectangle (gc1, area);
2381       gdk_gc_set_clip_rectangle (gc2, area);
2382       gdk_gc_set_clip_rectangle (gc3, area);
2383       gdk_gc_set_clip_rectangle (gc4, area);
2384     }
2385
2386   switch (shadow_type)
2387     {
2388     case GTK_SHADOW_NONE:
2389     case GTK_SHADOW_IN:
2390     case GTK_SHADOW_OUT:
2391     case GTK_SHADOW_ETCHED_IN:
2392     case GTK_SHADOW_ETCHED_OUT:
2393       switch (gap_side)
2394         {
2395         case GTK_POS_TOP:
2396           gdk_draw_line (window, gc1,
2397                          x, y, x, y + height - 1);
2398           gdk_draw_line (window, gc2,
2399                          x + 1, y, x + 1, y + height - 2);
2400
2401           gdk_draw_line (window, gc3,
2402                          x + 1, y + height - 2, x + width - 2, y + height - 2);
2403           gdk_draw_line (window, gc3,
2404                          x + width - 2, y, x + width - 2, y + height - 2);
2405           gdk_draw_line (window, gc4,
2406                          x, y + height - 1, x + width - 1, y + height - 1);
2407           gdk_draw_line (window, gc4,
2408                          x + width - 1, y, x + width - 1, y + height - 1);
2409           if (gap_x > 0)
2410             {
2411               gdk_draw_line (window, gc1,
2412                              x, y, x + gap_x - 1, y);
2413               gdk_draw_line (window, gc2,
2414                              x + 1, y + 1, x + gap_x - 1, y + 1);
2415               gdk_draw_line (window, gc2,
2416                              x + gap_x, y, x + gap_x, y);
2417             }
2418           if ((width - (gap_x + gap_width)) > 0)
2419             {
2420               gdk_draw_line (window, gc1,
2421                              x + gap_x + gap_width, y, x + width - 2, y);
2422               gdk_draw_line (window, gc2,
2423                              x + gap_x + gap_width, y + 1, x + width - 2, y + 1);
2424               gdk_draw_line (window, gc2,
2425                              x + gap_x + gap_width - 1, y, x + gap_x + gap_width - 1, y);
2426             }
2427           break;
2428         case GTK_POS_BOTTOM:
2429           gdk_draw_line (window, gc1,
2430                          x, y, x + width - 1, y);
2431           gdk_draw_line (window, gc1,
2432                          x, y, x, y + height - 1);
2433           gdk_draw_line (window, gc2,
2434                          x + 1, y + 1, x + width - 2, y + 1);
2435           gdk_draw_line (window, gc2,
2436                          x + 1, y + 1, x + 1, y + height - 1);
2437
2438           gdk_draw_line (window, gc3,
2439                          x + width - 2, y + 1, x + width - 2, y + height - 1);
2440           gdk_draw_line (window, gc4,
2441                          x + width - 1, y, x + width - 1, y + height - 1);
2442           if (gap_x > 0)
2443             {
2444               gdk_draw_line (window, gc4,
2445                              x, y + height - 1, x + gap_x - 1, y + height - 1);
2446               gdk_draw_line (window, gc3,
2447                              x + 1, y + height - 2, x + gap_x - 1, y + height - 2);
2448               gdk_draw_line (window, gc3,
2449                              x + gap_x, y + height - 1, x + gap_x, y + height - 1);
2450             }
2451           if ((width - (gap_x + gap_width)) > 0)
2452             {
2453               gdk_draw_line (window, gc4,
2454                              x + gap_x + gap_width, y + height - 1, x + width - 2, y + height - 1);
2455               gdk_draw_line (window, gc3,
2456                              x + gap_x + gap_width, y + height - 2, x + width - 2, y + height - 2);
2457               gdk_draw_line (window, gc3,
2458                              x + gap_x + gap_width - 1, y + height - 1, x + gap_x + gap_width - 1, y + height - 1);
2459             }
2460           break;
2461         case GTK_POS_LEFT:
2462           gdk_draw_line (window, gc1,
2463                          x, y, x + width - 1, y);
2464           gdk_draw_line (window, gc2,
2465                          x, y + 1, x + width - 2, y + 1);
2466
2467           gdk_draw_line (window, gc3,
2468                          x, y + height - 2, x + width - 2, y + height - 2);
2469           gdk_draw_line (window, gc3,
2470                          x + width - 2, y + 1, x + width - 2, y + height - 2);
2471           gdk_draw_line (window, gc4,
2472                          x, y + height - 1, x + width - 1, y + height - 1);
2473           gdk_draw_line (window, gc4,
2474                          x + width - 1, y, x + width - 1, y + height - 1);
2475           if (gap_x > 0)
2476             {
2477               gdk_draw_line (window, gc1,
2478                              x, y, x, y + gap_x - 1);
2479               gdk_draw_line (window, gc2,
2480                              x + 1, y + 1, x + 1, y + gap_x - 1);
2481               gdk_draw_line (window, gc2,
2482                              x, y + gap_x, x, y + gap_x);
2483             }
2484           if ((width - (gap_x + gap_width)) > 0)
2485             {
2486               gdk_draw_line (window, gc1,
2487                              x, y + gap_x + gap_width, x, y + height - 2);
2488               gdk_draw_line (window, gc2,
2489                              x + 1, y + gap_x + gap_width, x + 1, y + height - 2);
2490               gdk_draw_line (window, gc2,
2491                              x, y + gap_x + gap_width - 1, x, y + gap_x + gap_width - 1);
2492             }
2493           break;
2494         case GTK_POS_RIGHT:
2495           gdk_draw_line (window, gc1,
2496                          x, y, x + width - 1, y);
2497           gdk_draw_line (window, gc1,
2498                          x, y, x, y + height - 1);
2499           gdk_draw_line (window, gc2,
2500                          x + 1, y + 1, x + width - 1, y + 1);
2501           gdk_draw_line (window, gc2,
2502                          x + 1, y + 1, x + 1, y + height - 2);
2503
2504           gdk_draw_line (window, gc3,
2505                          x + 1, y + height - 2, x + width - 1, y + height - 2);
2506           gdk_draw_line (window, gc4,
2507                          x, y + height - 1, x + width - 1, y + height - 1);
2508           if (gap_x > 0)
2509             {
2510               gdk_draw_line (window, gc4,
2511                              x + width - 1, y, x + width - 1, y + gap_x - 1);
2512               gdk_draw_line (window, gc3,
2513                              x + width - 2, y + 1, x + width - 2, y + gap_x - 1);
2514               gdk_draw_line (window, gc3,
2515                              x + width - 1, y + gap_x, x + width - 1, y + gap_x);
2516             }
2517           if ((width - (gap_x + gap_width)) > 0)
2518             {
2519               gdk_draw_line (window, gc4,
2520                              x + width - 1, y + gap_x + gap_width, x + width - 1, y + height - 2);
2521               gdk_draw_line (window, gc3,
2522                              x + width - 2, y + gap_x + gap_width, x + width - 2, y + height - 2);
2523               gdk_draw_line (window, gc3,
2524                              x + width - 1, y + gap_x + gap_width - 1, x + width - 1, y + gap_x + gap_width - 1);
2525             }
2526           break;
2527         }
2528     }
2529   if (area)
2530     {
2531       gdk_gc_set_clip_rectangle (gc1, NULL);
2532       gdk_gc_set_clip_rectangle (gc2, NULL);
2533       gdk_gc_set_clip_rectangle (gc3, NULL);
2534       gdk_gc_set_clip_rectangle (gc4, NULL);
2535     }
2536 }
2537
2538 static void
2539 gtk_default_draw_box_gap (GtkStyle       *style,
2540                           GdkWindow      *window,
2541                           GtkStateType    state_type,
2542                           GtkShadowType   shadow_type,
2543                           GdkRectangle   *area,
2544                           GtkWidget      *widget,
2545                           gchar          *detail,
2546                           gint            x,
2547                           gint            y,
2548                           gint            width,
2549                           gint            height,
2550                           GtkPositionType gap_side,
2551                           gint            gap_x,
2552                           gint            gap_width)
2553 {
2554   GdkGC *gc1 = NULL;
2555   GdkGC *gc2 = NULL;
2556   GdkGC *gc3 = NULL;
2557   GdkGC *gc4 = NULL;
2558
2559   g_return_if_fail (style != NULL);
2560   g_return_if_fail (window != NULL);
2561
2562   gtk_style_apply_default_pixmap(style, window, state_type, area,
2563                                  x, y, width, height);
2564
2565   if ((width == -1) && (height == -1))
2566     gdk_window_get_size (window, &width, &height);
2567   else if (width == -1)
2568     gdk_window_get_size (window, &width, NULL);
2569   else if (height == -1)
2570     gdk_window_get_size (window, NULL, &height);
2571
2572   switch (shadow_type)
2573     {
2574      case GTK_SHADOW_NONE:
2575       return;
2576      case GTK_SHADOW_IN:
2577       gc1 = style->dark_gc[state_type];
2578       gc2 = style->black_gc;
2579       gc3 = style->bg_gc[state_type];
2580       gc4 = style->light_gc[state_type];
2581       break;
2582      case GTK_SHADOW_ETCHED_IN:
2583       gc1 = style->dark_gc[state_type];
2584       gc2 = style->light_gc[state_type];
2585       gc3 = style->dark_gc[state_type];
2586       gc4 = style->light_gc[state_type];
2587       break;
2588      case GTK_SHADOW_OUT:
2589       gc1 = style->light_gc[state_type];
2590       gc2 = style->bg_gc[state_type];
2591       gc3 = style->dark_gc[state_type];
2592       gc4 = style->black_gc;
2593       break;
2594      case GTK_SHADOW_ETCHED_OUT:
2595       gc1 = style->light_gc[state_type];
2596       gc2 = style->dark_gc[state_type];
2597       gc3 = style->light_gc[state_type];
2598       gc4 = style->dark_gc[state_type];
2599       break;
2600     }
2601   if (area)
2602     {
2603       gdk_gc_set_clip_rectangle (gc1, area);
2604       gdk_gc_set_clip_rectangle (gc2, area);
2605       gdk_gc_set_clip_rectangle (gc3, area);
2606       gdk_gc_set_clip_rectangle (gc4, area);
2607     }
2608
2609   switch (shadow_type)
2610     {
2611     case GTK_SHADOW_NONE:
2612     case GTK_SHADOW_IN:
2613     case GTK_SHADOW_OUT:
2614     case GTK_SHADOW_ETCHED_IN:
2615     case GTK_SHADOW_ETCHED_OUT:
2616       switch (gap_side)
2617         {
2618         case GTK_POS_TOP:
2619           gdk_draw_line (window, gc1,
2620                          x, y, x, y + height - 1);
2621           gdk_draw_line (window, gc2,
2622                          x + 1, y, x + 1, y + height - 2);
2623
2624           gdk_draw_line (window, gc3,
2625                          x + 1, y + height - 2, x + width - 2, y + height - 2);
2626           gdk_draw_line (window, gc3,
2627                          x + width - 2, y, x + width - 2, y + height - 2);
2628           gdk_draw_line (window, gc4,
2629                          x, y + height - 1, x + width - 1, y + height - 1);
2630           gdk_draw_line (window, gc4,
2631                          x + width - 1, y, x + width - 1, y + height - 1);
2632           if (gap_x > 0)
2633             {
2634               gdk_draw_line (window, gc1,
2635                              x, y, x + gap_x - 1, y);
2636               gdk_draw_line (window, gc2,
2637                              x + 1, y + 1, x + gap_x - 1, y + 1);
2638               gdk_draw_line (window, gc2,
2639                              x + gap_x, y, x + gap_x, y);
2640             }
2641           if ((width - (gap_x + gap_width)) > 0)
2642             {
2643               gdk_draw_line (window, gc1,
2644                              x + gap_x + gap_width, y, x + width - 2, y);
2645               gdk_draw_line (window, gc2,
2646                              x + gap_x + gap_width, y + 1, x + width - 2, y + 1);
2647               gdk_draw_line (window, gc2,
2648                              x + gap_x + gap_width - 1, y, x + gap_x + gap_width - 1, y);
2649             }
2650           break;
2651         case  GTK_POS_BOTTOM:
2652           gdk_draw_line (window, gc1,
2653                          x, y, x + width - 1, y);
2654           gdk_draw_line (window, gc1,
2655                          x, y, x, y + height - 1);
2656           gdk_draw_line (window, gc2,
2657                          x + 1, y + 1, x + width - 2, y + 1);
2658           gdk_draw_line (window, gc2,
2659                          x + 1, y + 1, x + 1, y + height - 1);
2660
2661           gdk_draw_line (window, gc3,
2662                          x + width - 2, y + 1, x + width - 2, y + height - 1);
2663           gdk_draw_line (window, gc4,
2664                          x + width - 1, y, x + width - 1, y + height - 1);
2665           if (gap_x > 0)
2666             {
2667               gdk_draw_line (window, gc4,
2668                              x, y + height - 1, x + gap_x - 1, y + height - 1);
2669               gdk_draw_line (window, gc3,
2670                              x + 1, y + height - 2, x + gap_x - 1, y + height - 2);
2671               gdk_draw_line (window, gc3,
2672                              x + gap_x, y + height - 1, x + gap_x, y + height - 1);
2673             }
2674           if ((width - (gap_x + gap_width)) > 0)
2675             {
2676               gdk_draw_line (window, gc4,
2677                              x + gap_x + gap_width, y + height - 1, x + width - 2, y + height - 1);
2678               gdk_draw_line (window, gc3,
2679                              x + gap_x + gap_width, y + height - 2, x + width - 2, y + height - 2);
2680               gdk_draw_line (window, gc3,
2681                              x + gap_x + gap_width - 1, y + height - 1, x + gap_x + gap_width - 1, y + height - 1);
2682             }
2683           break;
2684         case GTK_POS_LEFT:
2685           gdk_draw_line (window, gc1,
2686                          x, y, x + width - 1, y);
2687           gdk_draw_line (window, gc2,
2688                          x, y + 1, x + width - 2, y + 1);
2689
2690           gdk_draw_line (window, gc3,
2691                          x, y + height - 2, x + width - 2, y + height - 2);
2692           gdk_draw_line (window, gc3,
2693                          x + width - 2, y + 1, x + width - 2, y + height - 2);
2694           gdk_draw_line (window, gc4,
2695                          x, y + height - 1, x + width - 1, y + height - 1);
2696           gdk_draw_line (window, gc4,
2697                          x + width - 1, y, x + width - 1, y + height - 1);
2698           if (gap_x > 0)
2699             {
2700               gdk_draw_line (window, gc1,
2701                              x, y, x, y + gap_x - 1);
2702               gdk_draw_line (window, gc2,
2703                              x + 1, y + 1, x + 1, y + gap_x - 1);
2704               gdk_draw_line (window, gc2,
2705                              x, y + gap_x, x, y + gap_x);
2706             }
2707           if ((width - (gap_x + gap_width)) > 0)
2708             {
2709               gdk_draw_line (window, gc1,
2710                              x, y + gap_x + gap_width, x, y + height - 2);
2711               gdk_draw_line (window, gc2,
2712                              x + 1, y + gap_x + gap_width, x + 1, y + height - 2);
2713               gdk_draw_line (window, gc2,
2714                              x, y + gap_x + gap_width - 1, x, y + gap_x + gap_width - 1);
2715             }
2716           break;
2717         case GTK_POS_RIGHT:
2718           gdk_draw_line (window, gc1,
2719                          x, y, x + width - 1, y);
2720           gdk_draw_line (window, gc1,
2721                          x, y, x, y + height - 1);
2722           gdk_draw_line (window, gc2,
2723                          x + 1, y + 1, x + width - 1, y + 1);
2724           gdk_draw_line (window, gc2,
2725                          x + 1, y + 1, x + 1, y + height - 2);
2726
2727           gdk_draw_line (window, gc3,
2728                          x + 1, y + height - 2, x + width - 1, y + height - 2);
2729           gdk_draw_line (window, gc4,
2730                          x, y + height - 1, x + width - 1, y + height - 1);
2731           if (gap_x > 0)
2732             {
2733               gdk_draw_line (window, gc4,
2734                              x + width - 1, y, x + width - 1, y + gap_x - 1);
2735               gdk_draw_line (window, gc3,
2736                              x + width - 2, y + 1, x + width - 2, y + gap_x - 1);
2737               gdk_draw_line (window, gc3,
2738                              x + width - 1, y + gap_x, x + width - 1, y + gap_x);
2739             }
2740           if ((width - (gap_x + gap_width)) > 0)
2741             {
2742               gdk_draw_line (window, gc4,
2743                              x + width - 1, y + gap_x + gap_width, x + width - 1, y + height - 2);
2744               gdk_draw_line (window, gc3,
2745                              x + width - 2, y + gap_x + gap_width, x + width - 2, y + height - 2);
2746               gdk_draw_line (window, gc3,
2747                              x + width - 1, y + gap_x + gap_width - 1, x + width - 1, y + gap_x + gap_width - 1);
2748             }
2749           break;
2750         }
2751     }
2752   if (area)
2753     {
2754       gdk_gc_set_clip_rectangle (gc1, NULL);
2755       gdk_gc_set_clip_rectangle (gc2, NULL);
2756       gdk_gc_set_clip_rectangle (gc3, NULL);
2757       gdk_gc_set_clip_rectangle (gc4, NULL);
2758     }
2759 }
2760
2761 static void
2762 gtk_default_draw_extension (GtkStyle       *style,
2763                             GdkWindow      *window,
2764                             GtkStateType    state_type,
2765                             GtkShadowType   shadow_type,
2766                             GdkRectangle   *area,
2767                             GtkWidget      *widget,
2768                             gchar          *detail,
2769                             gint            x,
2770                             gint            y,
2771                             gint            width,
2772                             gint            height,
2773                             GtkPositionType gap_side)
2774 {
2775   GdkGC *gc1 = NULL;
2776   GdkGC *gc2 = NULL;
2777   GdkGC *gc3 = NULL;
2778   GdkGC *gc4 = NULL;
2779
2780   g_return_if_fail (style != NULL);
2781   g_return_if_fail (window != NULL);
2782
2783   gtk_style_apply_default_pixmap(style, window, GTK_STATE_NORMAL, area,
2784                                  x, y, width, height);
2785
2786   if ((width == -1) && (height == -1))
2787     gdk_window_get_size (window, &width, &height);
2788   else if (width == -1)
2789     gdk_window_get_size (window, &width, NULL);
2790   else if (height == -1)
2791     gdk_window_get_size (window, NULL, &height);
2792
2793   switch (shadow_type)
2794     {
2795      case GTK_SHADOW_NONE:
2796       return;
2797      case GTK_SHADOW_IN:
2798       gc1 = style->dark_gc[state_type];
2799       gc2 = style->black_gc;
2800       gc3 = style->bg_gc[state_type];
2801       gc4 = style->light_gc[state_type];
2802       break;
2803      case GTK_SHADOW_ETCHED_IN:
2804       gc1 = style->dark_gc[state_type];
2805       gc2 = style->light_gc[state_type];
2806       gc3 = style->dark_gc[state_type];
2807       gc4 = style->light_gc[state_type];
2808       break;
2809      case GTK_SHADOW_OUT:
2810       gc1 = style->light_gc[state_type];
2811       gc2 = style->bg_gc[state_type];
2812       gc3 = style->dark_gc[state_type];
2813       gc4 = style->black_gc;
2814       break;
2815      case GTK_SHADOW_ETCHED_OUT:
2816       gc1 = style->light_gc[state_type];
2817       gc2 = style->dark_gc[state_type];
2818       gc3 = style->light_gc[state_type];
2819       gc4 = style->dark_gc[state_type];
2820       break;
2821     }
2822   if (area)
2823     {
2824       gdk_gc_set_clip_rectangle (gc1, area);
2825       gdk_gc_set_clip_rectangle (gc2, area);
2826       gdk_gc_set_clip_rectangle (gc3, area);
2827       gdk_gc_set_clip_rectangle (gc4, area);
2828     }
2829    switch (shadow_type)
2830     {
2831     case GTK_SHADOW_NONE:
2832     case GTK_SHADOW_IN:
2833     case GTK_SHADOW_OUT:
2834     case GTK_SHADOW_ETCHED_IN:
2835     case GTK_SHADOW_ETCHED_OUT:
2836       switch (gap_side)
2837         {
2838         case GTK_POS_TOP:
2839           gtk_style_apply_default_pixmap(style, window, state_type, area,
2840                                          x + style->klass->xthickness,
2841                                          y,
2842                                          width - (2 * style->klass->xthickness),
2843                                          height - (style->klass->ythickness));
2844           gdk_draw_line (window, gc1,
2845                          x, y, x, y + height - 2);
2846           gdk_draw_line (window, gc2,
2847                          x + 1, y, x + 1, y + height - 2);
2848
2849           gdk_draw_line (window, gc3,
2850                          x + 2, y + height - 2, x + width - 2, y + height - 2);
2851           gdk_draw_line (window, gc3,
2852                          x + width - 2, y, x + width - 2, y + height - 2);
2853           gdk_draw_line (window, gc4,
2854                          x + 1, y + height - 1, x + width - 2, y + height - 1);
2855           gdk_draw_line (window, gc4,
2856                          x + width - 1, y, x + width - 1, y + height - 2);
2857           break;
2858         case GTK_POS_BOTTOM:
2859           gtk_style_apply_default_pixmap(style, window, state_type, area,
2860                                          x + style->klass->xthickness,
2861                                          y + style->klass->ythickness,
2862                                          width - (2 * style->klass->xthickness),
2863                                          height - (style->klass->ythickness));
2864           gdk_draw_line (window, gc1,
2865                          x + 1, y, x + width - 2, y);
2866           gdk_draw_line (window, gc1,
2867                          x, y + 1, x, y + height - 1);
2868           gdk_draw_line (window, gc2,
2869                          x + 1, y + 1, x + width - 2, y + 1);
2870           gdk_draw_line (window, gc2,
2871                          x + 1, y + 1, x + 1, y + height - 1);
2872
2873           gdk_draw_line (window, gc3,
2874                          x + width - 2, y + 2, x + width - 2, y + height - 1);
2875           gdk_draw_line (window, gc4,
2876                          x + width - 1, y + 1, x + width - 1, y + height - 1);
2877           break;
2878         case GTK_POS_LEFT:
2879           gtk_style_apply_default_pixmap(style, window, state_type, area,
2880                                          x,
2881                                          y + style->klass->ythickness,
2882                                          width - (style->klass->xthickness),
2883                                          height - (2 * style->klass->ythickness));
2884           gdk_draw_line (window, gc1,
2885                          x, y, x + width - 2, y);
2886           gdk_draw_line (window, gc2,
2887                          x + 1, y + 1, x + width - 2, y + 1);
2888
2889           gdk_draw_line (window, gc3,
2890                          x, y + height - 2, x + width - 2, y + height - 2);
2891           gdk_draw_line (window, gc3,
2892                          x + width - 2, y + 2, x + width - 2, y + height - 2);
2893           gdk_draw_line (window, gc4,
2894                          x, y + height - 1, x + width - 2, y + height - 1);
2895           gdk_draw_line (window, gc4,
2896                          x + width - 1, y + 1, x + width - 1, y + height - 2);
2897           break;
2898         case GTK_POS_RIGHT:
2899           gtk_style_apply_default_pixmap(style, window, state_type, area,
2900                                          x + style->klass->xthickness,
2901                                          y + style->klass->ythickness,
2902                                          width - (style->klass->xthickness),
2903                                          height - (2 * style->klass->ythickness));
2904           gdk_draw_line (window, gc1,
2905                          x + 1, y, x + width - 1, y);
2906           gdk_draw_line (window, gc1,
2907                          x, y + 1, x, y + height - 2);
2908           gdk_draw_line (window, gc2,
2909                          x + 1, y + 1, x + width - 1, y + 1);
2910           gdk_draw_line (window, gc2,
2911                          x + 1, y + 1, x + 1, y + height - 2);
2912
2913           gdk_draw_line (window, gc3,
2914                          x + 2, y + height - 2, x + width - 1, y + height - 2);
2915           gdk_draw_line (window, gc4,
2916                          x + 1, y + height - 1, x + width - 1, y + height - 1);
2917           break;
2918         }
2919     }
2920   if (area)
2921     {
2922       gdk_gc_set_clip_rectangle (gc1, NULL);
2923       gdk_gc_set_clip_rectangle (gc2, NULL);
2924       gdk_gc_set_clip_rectangle (gc3, NULL);
2925       gdk_gc_set_clip_rectangle (gc4, NULL);
2926     }
2927 }
2928
2929 static void
2930 gtk_default_draw_focus (GtkStyle      *style,
2931                         GdkWindow     *window,
2932                         GdkRectangle  *area,
2933                         GtkWidget     *widget,
2934                         gchar         *detail,
2935                         gint           x,
2936                         gint           y,
2937                         gint           width,
2938                         gint           height)
2939 {
2940    g_return_if_fail (style != NULL);
2941    g_return_if_fail (window != NULL);
2942
2943    if ((width == -1) && (height == -1))
2944      {
2945         gdk_window_get_size (window, &width, &height);
2946         width -= 1;
2947         height -= 1;
2948      }
2949    else if (width == -1)
2950      {
2951         gdk_window_get_size (window, &width, NULL);
2952         width -= 1;
2953      }
2954    else if (height == -1)
2955      {
2956         gdk_window_get_size (window, NULL, &height);
2957         height -= 1;
2958      }
2959    if (area)
2960      {
2961         gdk_gc_set_clip_rectangle (style->black_gc, area);
2962      }
2963    if (detail && !strcmp (detail, "add-mode"))
2964      {
2965        gdk_gc_set_line_attributes (style->black_gc, 1, GDK_LINE_ON_OFF_DASH, 0, 0);
2966        gdk_gc_set_dashes (style->black_gc, 0, "\4\4", 2);
2967
2968        gdk_draw_rectangle (window,
2969                            style->black_gc, FALSE,
2970                            x, y, width, height);
2971
2972        gdk_gc_set_line_attributes (style->black_gc, 1, GDK_LINE_SOLID, 0, 0);
2973      }
2974    else
2975      {
2976        gdk_draw_rectangle (window,
2977                            style->black_gc, FALSE,
2978                            x, y, width, height);
2979      }
2980    if (area)
2981      {
2982         gdk_gc_set_clip_rectangle (style->black_gc, NULL);
2983      }
2984 }
2985
2986 static void
2987 gtk_default_draw_slider (GtkStyle      *style,
2988                          GdkWindow     *window,
2989                          GtkStateType   state_type,
2990                          GtkShadowType  shadow_type,
2991                          GdkRectangle  *area,
2992                          GtkWidget     *widget,
2993                          gchar         *detail,
2994                          gint           x,
2995                          gint           y,
2996                          gint           width,
2997                          gint           height,
2998                          GtkOrientation orientation)
2999 {
3000    g_return_if_fail (style != NULL);
3001    g_return_if_fail (window != NULL);
3002
3003    if ((width == -1) && (height == -1))
3004      gdk_window_get_size (window, &width, &height);
3005    else if (width == -1)
3006      gdk_window_get_size (window, &width, NULL);
3007    else if (height == -1)
3008      gdk_window_get_size (window, NULL, &height);
3009
3010    gtk_paint_box (style, window, state_type, shadow_type,
3011                   area, widget, detail, x, y, width, height);
3012    if (orientation == GTK_ORIENTATION_HORIZONTAL)
3013      gtk_paint_vline (style, window, state_type, area, widget, detail,
3014                      style->klass->ythickness,
3015                      height - style->klass->ythickness - 1, width / 2);
3016    else
3017      gtk_paint_hline (style, window, state_type, area, widget, detail,
3018                       style->klass->xthickness,
3019                       width - style->klass->xthickness - 1, height / 2);
3020 }
3021
3022 static void
3023 gtk_default_draw_handle  (GtkStyle      *style,
3024                           GdkWindow     *window,
3025                           GtkStateType   state_type,
3026                           GtkShadowType  shadow_type,
3027                           GdkRectangle  *area,
3028                           GtkWidget     *widget,
3029                           gchar         *detail,
3030                           gint           x,
3031                           gint           y,
3032                           gint           width,
3033                           gint           height,
3034                           GtkOrientation orientation)
3035 {
3036    gint xx, yy;
3037    gint xthick, ythick;
3038    GdkGC *light_gc, *dark_gc;
3039    GdkRectangle dest;
3040
3041    g_return_if_fail (style != NULL);
3042    g_return_if_fail (window != NULL);
3043
3044    if ((width == -1) && (height == -1))
3045      gdk_window_get_size (window, &width, &height);
3046    else if (width == -1)
3047      gdk_window_get_size (window, &width, NULL);
3048    else if (height == -1)
3049      gdk_window_get_size (window, NULL, &height);
3050
3051    gtk_paint_box (style, window, state_type, shadow_type, area, widget,
3052                   detail, x, y, width, height);
3053
3054    light_gc = style->light_gc[state_type];
3055    dark_gc = style->dark_gc[state_type];
3056
3057    xthick = style->klass->xthickness;
3058    ythick = style->klass->ythickness;
3059
3060    dest.x = x + xthick;
3061    dest.y = y + ythick;
3062    dest.width = width - (xthick * 2);
3063    dest.height = height - (ythick * 2);
3064
3065    gdk_gc_set_clip_rectangle (light_gc, &dest);
3066    gdk_gc_set_clip_rectangle (dark_gc, &dest);
3067
3068    for (yy = y + ythick; yy < (y + height - ythick); yy += 3)
3069      for (xx = x + xthick; xx < (x + width - xthick); xx += 6)
3070      {
3071         gdk_draw_point (window, light_gc, xx, yy);
3072         gdk_draw_point (window, dark_gc, xx + 1, yy + 1);
3073
3074         gdk_draw_point (window, light_gc, xx + 3, yy + 1);
3075         gdk_draw_point (window, dark_gc, xx + 4, yy + 2);
3076      }
3077    gdk_gc_set_clip_rectangle (light_gc, NULL);
3078    gdk_gc_set_clip_rectangle (dark_gc, NULL);
3079 }
3080
3081 static void
3082 gtk_style_shade (GdkColor *a,
3083                  GdkColor *b,
3084                  gdouble   k)
3085 {
3086   gdouble red;
3087   gdouble green;
3088   gdouble blue;
3089
3090   red = (gdouble) a->red / 65535.0;
3091   green = (gdouble) a->green / 65535.0;
3092   blue = (gdouble) a->blue / 65535.0;
3093
3094   rgb_to_hls (&red, &green, &blue);
3095
3096   green *= k;
3097   if (green > 1.0)
3098     green = 1.0;
3099   else if (green < 0.0)
3100     green = 0.0;
3101
3102   blue *= k;
3103   if (blue > 1.0)
3104     blue = 1.0;
3105   else if (blue < 0.0)
3106     blue = 0.0;
3107
3108   hls_to_rgb (&red, &green, &blue);
3109
3110   b->red = red * 65535.0;
3111   b->green = green * 65535.0;
3112   b->blue = blue * 65535.0;
3113 }
3114
3115 static void
3116 rgb_to_hls (gdouble *r,
3117             gdouble *g,
3118             gdouble *b)
3119 {
3120   gdouble min;
3121   gdouble max;
3122   gdouble red;
3123   gdouble green;
3124   gdouble blue;
3125   gdouble h, l, s;
3126   gdouble delta;
3127
3128   red = *r;
3129   green = *g;
3130   blue = *b;
3131
3132   if (red > green)
3133     {
3134       if (red > blue)
3135         max = red;
3136       else
3137         max = blue;
3138
3139       if (green < blue)
3140         min = green;
3141       else
3142         min = blue;
3143     }
3144   else
3145     {
3146       if (green > blue)
3147         max = green;
3148       else
3149         max = blue;
3150
3151       if (red < blue)
3152         min = red;
3153       else
3154         min = blue;
3155     }
3156
3157   l = (max + min) / 2;
3158   s = 0;
3159   h = 0;
3160
3161   if (max != min)
3162     {
3163       if (l <= 0.5)
3164         s = (max - min) / (max + min);
3165       else
3166         s = (max - min) / (2 - max - min);
3167
3168       delta = max -min;
3169       if (red == max)
3170         h = (green - blue) / delta;
3171       else if (green == max)
3172         h = 2 + (blue - red) / delta;
3173       else if (blue == max)
3174         h = 4 + (red - green) / delta;
3175
3176       h *= 60;
3177       if (h < 0.0)
3178         h += 360;
3179     }
3180
3181   *r = h;
3182   *g = l;
3183   *b = s;
3184 }
3185
3186 static void
3187 hls_to_rgb (gdouble *h,
3188             gdouble *l,
3189             gdouble *s)
3190 {
3191   gdouble hue;
3192   gdouble lightness;
3193   gdouble saturation;
3194   gdouble m1, m2;
3195   gdouble r, g, b;
3196
3197   lightness = *l;
3198   saturation = *s;
3199
3200   if (lightness <= 0.5)
3201     m2 = lightness * (1 + saturation);
3202   else
3203     m2 = lightness + saturation - lightness * saturation;
3204   m1 = 2 * lightness - m2;
3205
3206   if (saturation == 0)
3207     {
3208       *h = lightness;
3209       *l = lightness;
3210       *s = lightness;
3211     }
3212   else
3213     {
3214       hue = *h + 120;
3215       while (hue > 360)
3216         hue -= 360;
3217       while (hue < 0)
3218         hue += 360;
3219
3220       if (hue < 60)
3221         r = m1 + (m2 - m1) * hue / 60;
3222       else if (hue < 180)
3223         r = m2;
3224       else if (hue < 240)
3225         r = m1 + (m2 - m1) * (240 - hue) / 60;
3226       else
3227         r = m1;
3228
3229       hue = *h;
3230       while (hue > 360)
3231         hue -= 360;
3232       while (hue < 0)
3233         hue += 360;
3234
3235       if (hue < 60)
3236         g = m1 + (m2 - m1) * hue / 60;
3237       else if (hue < 180)
3238         g = m2;
3239       else if (hue < 240)
3240         g = m1 + (m2 - m1) * (240 - hue) / 60;
3241       else
3242         g = m1;
3243
3244       hue = *h - 120;
3245       while (hue > 360)
3246         hue -= 360;
3247       while (hue < 0)
3248         hue += 360;
3249
3250       if (hue < 60)
3251         b = m1 + (m2 - m1) * hue / 60;
3252       else if (hue < 180)
3253         b = m2;
3254       else if (hue < 240)
3255         b = m1 + (m2 - m1) * (240 - hue) / 60;
3256       else
3257         b = m1;
3258
3259       *h = r;
3260       *l = g;
3261       *s = b;
3262     }
3263 }
3264
3265 void
3266 gtk_paint_hline (GtkStyle      *style,
3267                  GdkWindow     *window,
3268                  GtkStateType   state_type,
3269                  GdkRectangle  *area,
3270                  GtkWidget     *widget,
3271                  gchar         *detail,
3272                  gint          x1,
3273                  gint          x2,
3274                  gint          y)
3275 {
3276   g_return_if_fail (style != NULL);
3277   g_return_if_fail (style->klass != NULL);
3278   g_return_if_fail (style->klass->draw_hline != NULL);
3279
3280   (*style->klass->draw_hline) (style, window, state_type, area, widget, detail, x1, x2, y);
3281 }
3282
3283 void
3284 gtk_paint_vline (GtkStyle      *style,
3285                  GdkWindow     *window,
3286                  GtkStateType   state_type,
3287                  GdkRectangle  *area,
3288                  GtkWidget     *widget,
3289                  gchar         *detail,
3290                  gint          y1,
3291                  gint          y2,
3292                  gint          x)
3293 {
3294   g_return_if_fail (style != NULL);
3295   g_return_if_fail (style->klass != NULL);
3296   g_return_if_fail (style->klass->draw_vline != NULL);
3297
3298   (*style->klass->draw_vline) (style, window, state_type, area, widget, detail, y1, y2, x);
3299 }
3300
3301 void
3302 gtk_paint_shadow (GtkStyle     *style,
3303                   GdkWindow    *window,
3304                   GtkStateType  state_type,
3305                   GtkShadowType shadow_type,
3306                   GdkRectangle  *area,
3307                   GtkWidget     *widget,
3308                   gchar         *detail,
3309                   gint         x,
3310                   gint         y,
3311                   gint         width,
3312                   gint         height)
3313 {
3314   g_return_if_fail (style != NULL);
3315   g_return_if_fail (style->klass != NULL);
3316   g_return_if_fail (style->klass->draw_shadow != NULL);
3317
3318   (*style->klass->draw_shadow) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
3319 }
3320
3321 void
3322 gtk_paint_polygon (GtkStyle      *style,
3323                    GdkWindow     *window,
3324                    GtkStateType   state_type,
3325                    GtkShadowType  shadow_type,
3326                    GdkRectangle  *area,
3327                    GtkWidget     *widget,
3328                    gchar         *detail,
3329                    GdkPoint      *points,
3330                    gint           npoints,
3331                    gboolean       fill)
3332 {
3333   g_return_if_fail (style != NULL);
3334   g_return_if_fail (style->klass != NULL);
3335   g_return_if_fail (style->klass->draw_shadow != NULL);
3336
3337   (*style->klass->draw_polygon) (style, window, state_type, shadow_type, area, widget, detail, points, npoints, fill);
3338 }
3339
3340 void
3341 gtk_paint_arrow (GtkStyle      *style,
3342                  GdkWindow     *window,
3343                  GtkStateType   state_type,
3344                  GtkShadowType  shadow_type,
3345                  GdkRectangle  *area,
3346                  GtkWidget     *widget,
3347                  gchar         *detail,
3348                  GtkArrowType   arrow_type,
3349                  gboolean       fill,
3350                  gint           x,
3351                  gint           y,
3352                  gint           width,
3353                  gint           height)
3354 {
3355   g_return_if_fail (style != NULL);
3356   g_return_if_fail (style->klass != NULL);
3357   g_return_if_fail (style->klass->draw_arrow != NULL);
3358
3359   (*style->klass->draw_arrow) (style, window, state_type, shadow_type, area, widget, detail, arrow_type, fill, x, y, width, height);
3360 }
3361
3362 void
3363 gtk_paint_diamond (GtkStyle      *style,
3364                    GdkWindow     *window,
3365                    GtkStateType   state_type,
3366                    GtkShadowType  shadow_type,
3367                    GdkRectangle  *area,
3368                    GtkWidget     *widget,
3369                    gchar         *detail,
3370                    gint        x,
3371                    gint        y,
3372                    gint        width,
3373                    gint        height)
3374 {
3375   g_return_if_fail (style != NULL);
3376   g_return_if_fail (style->klass != NULL);
3377   g_return_if_fail (style->klass->draw_diamond != NULL);
3378
3379   (*style->klass->draw_diamond) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
3380 }
3381
3382 void
3383 gtk_paint_oval (GtkStyle      *style,
3384                 GdkWindow     *window,
3385                 GtkStateType   state_type,
3386                 GtkShadowType  shadow_type,
3387                 GdkRectangle  *area,
3388                 GtkWidget     *widget,
3389                 gchar         *detail,
3390                 gint           x,
3391                 gint           y,
3392                 gint           width,
3393                 gint           height)
3394 {
3395   g_return_if_fail (style != NULL);
3396   g_return_if_fail (style->klass != NULL);
3397   g_return_if_fail (style->klass->draw_oval != NULL);
3398
3399   (*style->klass->draw_oval) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
3400 }
3401
3402 void
3403 gtk_paint_string (GtkStyle      *style,
3404                   GdkWindow     *window,
3405                   GtkStateType   state_type,
3406                   GdkRectangle  *area,
3407                   GtkWidget     *widget,
3408                   gchar         *detail,
3409                   gint         x,
3410                   gint         y,
3411                   const gchar   *string)
3412 {
3413   g_return_if_fail (style != NULL);
3414   g_return_if_fail (style->klass != NULL);
3415   g_return_if_fail (style->klass->draw_oval != NULL);
3416
3417   (*style->klass->draw_string) (style, window, state_type, area, widget, detail, x, y, string);
3418 }
3419
3420 void
3421 gtk_paint_box (GtkStyle      *style,
3422                GdkWindow     *window,
3423                GtkStateType   state_type,
3424                GtkShadowType  shadow_type,
3425                GdkRectangle  *area,
3426                GtkWidget     *widget,
3427                gchar         *detail,
3428                gint            x,
3429                gint            y,
3430                gint            width,
3431                gint            height)
3432 {
3433   g_return_if_fail (style != NULL);
3434   g_return_if_fail (style->klass != NULL);
3435   g_return_if_fail (style->klass->draw_box != NULL);
3436
3437   (*style->klass->draw_box) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
3438 }
3439
3440 void
3441 gtk_paint_flat_box (GtkStyle      *style,
3442                     GdkWindow     *window,
3443                     GtkStateType   state_type,
3444                     GtkShadowType  shadow_type,
3445                     GdkRectangle  *area,
3446                     GtkWidget     *widget,
3447                     gchar         *detail,
3448                     gint           x,
3449                     gint           y,
3450                     gint           width,
3451                     gint           height)
3452 {
3453   g_return_if_fail (style != NULL);
3454   g_return_if_fail (style->klass != NULL);
3455   g_return_if_fail (style->klass->draw_flat_box != NULL);
3456
3457   (*style->klass->draw_flat_box) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
3458 }
3459
3460 void
3461 gtk_paint_check (GtkStyle      *style,
3462                  GdkWindow     *window,
3463                  GtkStateType   state_type,
3464                  GtkShadowType  shadow_type,
3465                  GdkRectangle  *area,
3466                  GtkWidget     *widget,
3467                  gchar         *detail,
3468                  gint           x,
3469                  gint           y,
3470                  gint           width,
3471                  gint           height)
3472 {
3473   g_return_if_fail (style != NULL);
3474   g_return_if_fail (style->klass != NULL);
3475   g_return_if_fail (style->klass->draw_check != NULL);
3476
3477   (*style->klass->draw_check) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
3478 }
3479
3480 void
3481 gtk_paint_option (GtkStyle      *style,
3482                   GdkWindow     *window,
3483                   GtkStateType   state_type,
3484                   GtkShadowType  shadow_type,
3485                   GdkRectangle  *area,
3486                   GtkWidget     *widget,
3487                   gchar         *detail,
3488                   gint           x,
3489                   gint           y,
3490                   gint           width,
3491                   gint           height)
3492 {
3493   g_return_if_fail (style != NULL);
3494   g_return_if_fail (style->klass != NULL);
3495   g_return_if_fail (style->klass->draw_option != NULL);
3496
3497   (*style->klass->draw_option) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
3498 }
3499
3500 void
3501 gtk_paint_cross (GtkStyle      *style,
3502                  GdkWindow     *window,
3503                  GtkStateType   state_type,
3504                  GtkShadowType  shadow_type,
3505                  GdkRectangle  *area,
3506                  GtkWidget     *widget,
3507                  gchar         *detail,
3508                  gint           x,
3509                  gint           y,
3510                  gint           width,
3511                  gint           height)
3512 {
3513   g_return_if_fail (style != NULL);
3514   g_return_if_fail (style->klass != NULL);
3515   g_return_if_fail (style->klass->draw_cross != NULL);
3516
3517   (*style->klass->draw_cross) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
3518 }
3519
3520 void
3521 gtk_paint_ramp (GtkStyle      *style,
3522                 GdkWindow     *window,
3523                 GtkStateType   state_type,
3524                 GtkShadowType  shadow_type,
3525                 GdkRectangle  *area,
3526                 GtkWidget     *widget,
3527                 gchar         *detail,
3528                 GtkArrowType   arrow_type,
3529                 gint           x,
3530                 gint           y,
3531                 gint           width,
3532                 gint           height)
3533 {
3534   g_return_if_fail (style != NULL);
3535   g_return_if_fail (style->klass != NULL);
3536   g_return_if_fail (style->klass->draw_ramp != NULL);
3537
3538   (*style->klass->draw_ramp) (style, window, state_type, shadow_type, area, widget, detail, arrow_type, x, y, width, height);
3539 }
3540
3541 void
3542 gtk_paint_tab (GtkStyle      *style,
3543                GdkWindow     *window,
3544                GtkStateType   state_type,
3545                GtkShadowType  shadow_type,
3546                GdkRectangle  *area,
3547                GtkWidget     *widget,
3548                gchar         *detail,
3549                gint           x,
3550                gint           y,
3551                gint           width,
3552                gint           height)
3553 {
3554   g_return_if_fail (style != NULL);
3555   g_return_if_fail (style->klass != NULL);
3556   g_return_if_fail (style->klass->draw_tab != NULL);
3557
3558   (*style->klass->draw_tab) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
3559 }
3560
3561 void
3562 gtk_paint_shadow_gap (GtkStyle       *style,
3563                       GdkWindow      *window,
3564                       GtkStateType    state_type,
3565                       GtkShadowType   shadow_type,
3566                       GdkRectangle   *area,
3567                       GtkWidget      *widget,
3568                       gchar          *detail,
3569                       gint            x,
3570                       gint            y,
3571                       gint            width,
3572                       gint            height,
3573                       GtkPositionType gap_side,
3574                       gint            gap_x,
3575                       gint            gap_width)
3576 {
3577   g_return_if_fail (style != NULL);
3578   g_return_if_fail (style->klass != NULL);
3579   g_return_if_fail (style->klass->draw_shadow_gap != NULL);
3580
3581   (*style->klass->draw_shadow_gap) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
3582 }
3583
3584
3585 void
3586 gtk_paint_box_gap (GtkStyle       *style,
3587                    GdkWindow      *window,
3588                    GtkStateType    state_type,
3589                    GtkShadowType   shadow_type,
3590                    GdkRectangle   *area,
3591                    GtkWidget      *widget,
3592                    gchar          *detail,
3593                    gint            x,
3594                    gint            y,
3595                    gint            width,
3596                    gint            height,
3597                    GtkPositionType gap_side,
3598                    gint            gap_x,
3599                    gint            gap_width)
3600 {
3601   g_return_if_fail (style != NULL);
3602   g_return_if_fail (style->klass != NULL);
3603   g_return_if_fail (style->klass->draw_box_gap != NULL);
3604
3605   (*style->klass->draw_box_gap) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
3606 }
3607
3608 void
3609 gtk_paint_extension (GtkStyle       *style,
3610                      GdkWindow      *window,
3611                      GtkStateType    state_type,
3612                      GtkShadowType   shadow_type,
3613                      GdkRectangle   *area,
3614                      GtkWidget      *widget,
3615                      gchar          *detail,
3616                      gint            x,
3617                      gint            y,
3618                      gint            width,
3619                      gint            height,
3620                      GtkPositionType gap_side)
3621 {
3622   g_return_if_fail (style != NULL);
3623   g_return_if_fail (style->klass != NULL);
3624   g_return_if_fail (style->klass->draw_extension != NULL);
3625
3626   (*style->klass->draw_extension) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side);
3627 }
3628
3629 void
3630 gtk_paint_focus (GtkStyle      *style,
3631                  GdkWindow     *window,
3632                  GdkRectangle  *area,
3633                  GtkWidget     *widget,
3634                  gchar         *detail,
3635                  gint           x,
3636                  gint           y,
3637                  gint           width,
3638                  gint           height)
3639 {
3640   g_return_if_fail (style != NULL);
3641   g_return_if_fail (style->klass != NULL);
3642   g_return_if_fail (style->klass->draw_focus != NULL);
3643
3644   (*style->klass->draw_focus) (style, window, area, widget, detail, x, y, width, height);
3645 }
3646
3647 void
3648 gtk_paint_slider (GtkStyle      *style,
3649                   GdkWindow     *window,
3650                   GtkStateType   state_type,
3651                   GtkShadowType  shadow_type,
3652                   GdkRectangle  *area,
3653                   GtkWidget     *widget,
3654                   gchar         *detail,
3655                   gint           x,
3656                   gint           y,
3657                   gint           width,
3658                   gint           height,
3659                   GtkOrientation orientation)
3660 {
3661   g_return_if_fail (style != NULL);
3662   g_return_if_fail (style->klass != NULL);
3663   g_return_if_fail (style->klass->draw_slider != NULL);
3664
3665   (*style->klass->draw_slider) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
3666 }
3667
3668 void
3669 gtk_paint_handle (GtkStyle      *style,
3670                   GdkWindow     *window,
3671                   GtkStateType   state_type,
3672                   GtkShadowType  shadow_type,
3673                   GdkRectangle  *area,
3674                   GtkWidget     *widget,
3675                   gchar         *detail,
3676                   gint           x,
3677                   gint           y,
3678                   gint           width,
3679                   gint           height,
3680                   GtkOrientation orientation)
3681 {
3682   g_return_if_fail (style != NULL);
3683   g_return_if_fail (style->klass != NULL);
3684   g_return_if_fail (style->klass->draw_handle != NULL);
3685
3686   (*style->klass->draw_handle) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
3687 }