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

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