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