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