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