libs/clearlooks-newer/clearlooks_style.c

   1 /* Clearlooks theme engine
   2  * Copyright (C) 2005 Richard Stellingwerff.
   3  * Copyright (C) 2007 Benjamin Berg <benjamin@sipsolutions.net>.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  */
  21
  22 #include <gtk/gtk.h>
  23 #include <cairo.h>
  24 #include <math.h>
  25 #include <string.h>
  26
  27 #include <ge-support.h>
  28 #include "clearlooks_style.h"
  29 #include "clearlooks_rc_style.h"
  30 #include "clearlooks_draw.h"
  31 #include "support.h"
  32
  33 /* #define DEBUG 1 */
  34
  35 #define DETAIL(xx)   ((detail) && (!strcmp(xx, detail)))
  36
  37 #define DRAW_ARGS    GtkStyle       *style, \
  38                      GdkWindow      *window, \
  39                      GtkStateType    state_type, \
  40                      GtkShadowType   shadow_type, \
  41                      GdkRectangle   *area, \
  42                      GtkWidget      *widget, \
  43                      const gchar    *detail, \
  44                      gint            x, \
  45                      gint            y, \
  46                      gint            width, \
  47                      gint            height
  48
  49 #ifdef HAVE_ANIMATION
  50 #include "animation.h"
  51 #endif
  52
  53 #define STYLE_FUNCTION(function) (clearlooks_style_class->style_functions[CLEARLOOKS_STYLE (style)->style].function)
  54
  55 static ClearlooksStyleClass *clearlooks_style_class;
  56 static GtkStyleClass *clearlooks_parent_class;
  57
  58 static void
  59 clearlooks_set_widget_parameters (GtkWidget            *widget,
  60                                   const GtkStyle       *style,
  61                                   GtkStateType          state_type,
  62                                   WidgetParameters     *params)
  63 {
  64         params->style_functions = &(clearlooks_style_class->style_functions[CLEARLOOKS_STYLE (style)->style]);
  65
  66         params->active      = (state_type == GTK_STATE_ACTIVE);
  67         params->prelight    = (state_type == GTK_STATE_PRELIGHT);
  68         params->disabled    = (state_type == GTK_STATE_INSENSITIVE);
  69         params->state_type  = (ClearlooksStateType)state_type;
  70         params->corners     = CR_CORNER_ALL;
  71         params->ltr         = ge_widget_is_ltr ((GtkWidget*)widget);
  72         params->focus       = widget && GTK_WIDGET_HAS_FOCUS (widget);
  73         params->is_default  = widget && GE_WIDGET_HAS_DEFAULT (widget);
  74         params->enable_glow = FALSE;
  75         params->radius      = CLEARLOOKS_STYLE (style)->radius;
  76
  77         if (!params->active && widget && GE_IS_TOGGLE_BUTTON (widget))
  78                 params->active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
  79
  80         params->xthickness = style->xthickness;
  81         params->ythickness = style->ythickness;
  82
  83         /* This is used in GtkEntry to fake transparency. The reason to do this
  84          * is that the entry has it's entire background filled with base[STATE].
  85          * This is not a very good solution as it will eg. fail if one changes
  86          * the background color of a notebook. */
  87         params->parentbg = CLEARLOOKS_STYLE (style)->colors.bg[state_type];
  88         clearlooks_get_parent_bg (widget, &params->parentbg);
  89 }
  90
  91 static void
  92 clearlooks_style_draw_flat_box (DRAW_ARGS)
  93 {
  94         if (detail &&
  95             state_type == GTK_STATE_SELECTED && (
  96             !strncmp ("cell_even", detail, 9) ||
  97             !strncmp ("cell_odd", detail, 8)))
  98         {
  99                 WidgetParameters params;
 100                 ClearlooksStyle  *clearlooks_style;
 101                 ClearlooksColors *colors;
 102                 cairo_t          *cr;
 103
 104                 CHECK_ARGS
 105                 SANITIZE_SIZE
 106
 107                 clearlooks_style = CLEARLOOKS_STYLE (style);
 108                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 109                 colors = &clearlooks_style->colors;
 110                 cr = ge_gdk_drawable_to_cairo (window, area);
 111
 112                 /* XXX: We could expose the side details by setting params->corners accordingly
 113                  *      or adding another option. */
 114                 STYLE_FUNCTION (draw_selected_cell) (cr, colors, &params, x, y, width, height);
 115
 116                 cairo_destroy (cr);
 117         }
 118         else if (DETAIL ("tooltip"))
 119         {
 120                 WidgetParameters params;
 121                 ClearlooksStyle  *clearlooks_style;
 122                 ClearlooksColors *colors;
 123                 cairo_t          *cr;
 124
 125                 CHECK_ARGS
 126                 SANITIZE_SIZE
 127
 128                 clearlooks_style = CLEARLOOKS_STYLE (style);
 129                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 130                 colors = &clearlooks_style->colors;
 131                 cr = ge_gdk_drawable_to_cairo (window, area);
 132
 133                 STYLE_FUNCTION (draw_tooltip) (cr, colors, &params, x, y, width, height);
 134
 135                 cairo_destroy (cr);
 136         }
 137         else if ((CLEARLOOKS_STYLE (style)->style == CL_STYLE_GLOSSY || CLEARLOOKS_STYLE (style)->style == CL_STYLE_GUMMY) &&
 138                  ((DETAIL("checkbutton") || DETAIL("radiobutton")) && state_type == GTK_STATE_PRELIGHT))
 139         {
 140                 /* XXX: Don't draw any check/radiobutton bg in GLOSSY or GUMMY mode. */
 141         }
 142         else
 143         {
 144                 clearlooks_parent_class->draw_flat_box (style, window, state_type,
 145                                              shadow_type,
 146                                              area, widget, detail,
 147                                              x, y, width, height);
 148         }
 149 }
 150
 151 static void
 152 clearlooks_style_draw_shadow (DRAW_ARGS)
 153 {
 154         ClearlooksStyle  *clearlooks_style = CLEARLOOKS_STYLE (style);
 155         ClearlooksColors *colors = &clearlooks_style->colors;
 156         cairo_t          *cr     = ge_gdk_drawable_to_cairo (window, area);
 157
 158         CHECK_ARGS
 159         SANITIZE_SIZE
 160
 161         if ((DETAIL ("entry") && !(widget && widget->parent && GE_IS_TREE_VIEW (widget->parent))) ||
 162             (DETAIL ("frame") && ge_is_in_combo_box (widget)))
 163         {
 164                 WidgetParameters params;
 165
 166                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 167
 168                 /* Override the entries state type, because we are too lame to handle this via
 169                  * the focus ring, and GtkEntry doesn't even set the INSENSITIVE state ... */
 170                 if (state_type == GTK_STATE_NORMAL && widget && GE_IS_ENTRY (widget))
 171                         params.state_type = GTK_WIDGET_STATE (widget);
 172
 173                 if (widget && (ge_is_in_combo_box (widget) || GE_IS_SPIN_BUTTON (widget)))
 174                 {
 175                         width += style->xthickness;
 176                         if (!params.ltr)
 177                                 x -= style->xthickness;
 178
 179                         if (params.ltr)
 180                                 params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
 181                         else
 182                                 params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
 183                 }
 184
 185                 STYLE_FUNCTION (draw_entry) (cr, &clearlooks_style->colors, &params,
 186                                        x, y, width, height);
 187         }
 188         else if (DETAIL ("frame") && widget && GE_IS_STATUSBAR (widget->parent))
 189         {
 190                 WidgetParameters params;
 191
 192                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 193
 194                 gtk_style_apply_default_background (style, window, TRUE, state_type,
 195                                                     area, x, y, width, height);
 196
 197                 STYLE_FUNCTION (draw_statusbar) (cr, colors, &params,
 198                                            x, y, width, height);
 199         }
 200         else if (DETAIL ("frame"))
 201         {
 202                 WidgetParameters params;
 203                 FrameParameters  frame;
 204                 frame.shadow  = shadow_type;
 205                 frame.gap_x   = -1;                 /* No gap will be drawn */
 206                 frame.border  = &colors->shade[4];
 207
 208                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 209                 params.corners = CR_CORNER_NONE;
 210
 211                 if (widget && !g_str_equal ("XfcePanelWindow", gtk_widget_get_name (gtk_widget_get_toplevel (widget))))
 212                         STYLE_FUNCTION(draw_frame) (cr, colors, &params, &frame,
 213                                                x, y, width, height);
 214         }
 215         else if (DETAIL ("scrolled_window") || DETAIL ("viewport") || detail == NULL)
 216         {
 217                 CairoColor *border = (CairoColor*)&colors->shade[5];
 218                 cairo_rectangle (cr, x+0.5, y+0.5, width-1, height-1);
 219                 ge_cairo_set_color (cr, border);
 220                 cairo_set_line_width (cr, 1);
 221                 cairo_stroke (cr);
 222         }
 223         else
 224         {
 225                 WidgetParameters params;
 226                 FrameParameters frame;
 227
 228                 frame.shadow = shadow_type;
 229                 frame.gap_x  = -1;
 230                 frame.border = &colors->shade[5];
 231                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 232                 params.corners = CR_CORNER_ALL;
 233
 234                 STYLE_FUNCTION(draw_frame) (cr, colors, &params, &frame, x, y, width, height);
 235         }
 236
 237         cairo_destroy (cr);
 238 }
 239
 240 static void
 241 clearlooks_style_draw_box_gap (DRAW_ARGS,
 242                   GtkPositionType gap_side,
 243                   gint            gap_x,
 244                   gint            gap_width)
 245 {
 246         ClearlooksStyle  *clearlooks_style = CLEARLOOKS_STYLE (style);
 247         ClearlooksColors *colors = &clearlooks_style->colors;
 248         cairo_t          *cr;
 249
 250         CHECK_ARGS
 251         SANITIZE_SIZE
 252
 253         cr = ge_gdk_drawable_to_cairo (window, area);
 254
 255         if (DETAIL ("notebook"))
 256         {
 257                 WidgetParameters params;
 258                 FrameParameters  frame;
 259                 gboolean start, end;
 260
 261                 frame.shadow    = shadow_type;
 262                 frame.gap_side  = gap_side;
 263                 frame.gap_x     = gap_x;
 264                 frame.gap_width = gap_width;
 265                 frame.border    = &colors->shade[5];
 266
 267                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 268
 269                 clearlooks_get_notebook_tab_position (widget, &start, &end);
 270
 271                 params.corners = CR_CORNER_ALL;
 272                 switch (gap_side) {
 273                         case GTK_POS_LEFT:
 274                                 if (start)
 275                                         params.corners ^= CR_CORNER_TOPLEFT;
 276                                 if (end)
 277                                         params.corners ^= CR_CORNER_BOTTOMLEFT;
 278                         break;
 279                         case GTK_POS_RIGHT:
 280                                 if (start)
 281                                         params.corners ^= CR_CORNER_TOPRIGHT;
 282                                 if (end)
 283                                         params.corners ^= CR_CORNER_BOTTOMRIGHT;
 284                         break;
 285                         case GTK_POS_TOP:
 286                                 if (ge_widget_is_ltr (widget)) {
 287                                         if (start)
 288                                                 params.corners ^= CR_CORNER_TOPLEFT;
 289                                         if (end)
 290                                                 params.corners ^= CR_CORNER_TOPRIGHT;
 291                                 } else {
 292                                         if (start)
 293                                                 params.corners ^= CR_CORNER_TOPRIGHT;
 294                                         if (end)
 295                                                 params.corners ^= CR_CORNER_TOPLEFT;
 296                                 }
 297                         break;
 298                         case GTK_POS_BOTTOM:
 299                                 if (ge_widget_is_ltr (widget)) {
 300                                         if (start)
 301                                                 params.corners ^= CR_CORNER_BOTTOMLEFT;
 302                                         if (end)
 303                                                 params.corners ^= CR_CORNER_BOTTOMRIGHT;
 304                                 } else {
 305                                         if (start)
 306                                                 params.corners ^= CR_CORNER_BOTTOMRIGHT;
 307                                         if (end)
 308                                                 params.corners ^= CR_CORNER_BOTTOMLEFT;
 309                                 }
 310                         break;
 311                 }
 312
 313                 /* Fill the background with bg[NORMAL] */
 314                 ge_cairo_rounded_rectangle (cr, x, y, width, height, params.radius, params.corners);
 315                 ge_cairo_set_color (cr, &colors->bg[GTK_STATE_NORMAL]);
 316                 cairo_fill (cr);
 317
 318                 STYLE_FUNCTION(draw_frame) (cr, colors, &params, &frame,
 319                                        x, y, width, height);
 320         }
 321         else
 322         {
 323                 clearlooks_parent_class->draw_box_gap (style, window, state_type, shadow_type,
 324                                                                            area, widget, detail,
 325                                                                            x, y, width, height,
 326                                                                            gap_side, gap_x, gap_width);
 327         }
 328
 329         cairo_destroy (cr);
 330 }
 331
 332 static void
 333 clearlooks_style_draw_extension (DRAW_ARGS, GtkPositionType gap_side)
 334 {
 335         ClearlooksStyle  *clearlooks_style = CLEARLOOKS_STYLE (style);
 336         ClearlooksColors *colors = &clearlooks_style->colors;
 337         cairo_t          *cr;
 338
 339         CHECK_ARGS
 340         SANITIZE_SIZE
 341
 342         cr = ge_gdk_drawable_to_cairo (window, area);
 343
 344         if (DETAIL ("tab"))
 345         {
 346                 WidgetParameters params;
 347                 TabParameters    tab;
 348
 349                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 350
 351                 tab.gap_side = (ClearlooksGapSide)gap_side;
 352
 353                 switch (gap_side)
 354                 {
 355                         case CL_GAP_BOTTOM:
 356                                 params.corners = CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT;
 357                                 break;
 358                         case CL_GAP_TOP:
 359                                 params.corners = CR_CORNER_BOTTOMLEFT | CR_CORNER_BOTTOMRIGHT;
 360                                 break;
 361                         case CL_GAP_RIGHT:
 362                                 params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
 363                                 break;
 364                         case CL_GAP_LEFT:
 365                                 params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
 366                 }
 367
 368                 STYLE_FUNCTION(draw_tab) (cr, colors, &params, &tab,
 369                                      x, y, width, height);
 370         }
 371         else
 372         {
 373                 clearlooks_parent_class->draw_extension (style, window, state_type, shadow_type, area,
 374                                               widget, detail, x, y, width, height,
 375                                               gap_side);
 376
 377         }
 378
 379         cairo_destroy (cr);
 380 }
 381
 382 static void
 383 clearlooks_style_draw_handle (DRAW_ARGS, GtkOrientation orientation)
 384 {
 385         ClearlooksStyle  *clearlooks_style = CLEARLOOKS_STYLE (style);
 386         ClearlooksColors *colors = &clearlooks_style->colors;
 387         cairo_t          *cr;
 388         gboolean         is_horizontal;
 389
 390         CHECK_ARGS
 391         SANITIZE_SIZE
 392
 393         cr = ge_gdk_drawable_to_cairo (window, area);
 394
 395         /* Evil hack to work around broken orientation for toolbars */
 396         is_horizontal = (width > height);
 397
 398         if (DETAIL ("handlebox"))
 399         {
 400                 WidgetParameters params;
 401                 HandleParameters handle;
 402
 403                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 404                 handle.type = CL_HANDLE_TOOLBAR;
 405                 handle.horizontal = is_horizontal;
 406
 407                 /* Is this ever true? -Daniel */
 408                 if (GE_IS_TOOLBAR (widget) && shadow_type != GTK_SHADOW_NONE)
 409                 {
 410                         ToolbarParameters toolbar;
 411
 412                         clearlooks_set_toolbar_parameters (&toolbar, widget, window, x, y);
 413
 414                         toolbar.style = clearlooks_style->toolbarstyle;
 415
 416                         cairo_save (cr);
 417                         STYLE_FUNCTION(draw_toolbar) (cr, colors, &params, &toolbar, x, y, width, height);
 418                         cairo_restore (cr);
 419                 }
 420
 421                 STYLE_FUNCTION(draw_handle) (cr, colors, &params, &handle,
 422                                         x, y, width, height);
 423         }
 424         else if (DETAIL ("paned"))
 425         {
 426                 WidgetParameters params;
 427                 HandleParameters handle;
 428
 429                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 430                 handle.type = CL_HANDLE_SPLITTER;
 431                 handle.horizontal = orientation == GTK_ORIENTATION_HORIZONTAL;
 432
 433                 STYLE_FUNCTION(draw_handle) (cr, colors, &params, &handle,
 434                                         x, y, width, height);
 435         }
 436         else
 437         {
 438                 WidgetParameters params;
 439                 HandleParameters handle;
 440
 441                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 442                 handle.type = CL_HANDLE_TOOLBAR;
 443                 handle.horizontal = is_horizontal;
 444
 445                 /* Is this ever true? -Daniel */
 446                 if (GE_IS_TOOLBAR (widget) && shadow_type != GTK_SHADOW_NONE)
 447                 {
 448                         ToolbarParameters toolbar;
 449
 450                         clearlooks_set_toolbar_parameters (&toolbar, widget, window, x, y);
 451
 452                         toolbar.style = clearlooks_style->toolbarstyle;
 453
 454                         cairo_save (cr);
 455                         STYLE_FUNCTION(draw_toolbar) (cr, colors, &params, &toolbar, x, y, width, height);
 456                         cairo_restore (cr);
 457                 }
 458
 459                 STYLE_FUNCTION(draw_handle) (cr, colors, &params, &handle,
 460                                         x, y, width, height);
 461         }
 462
 463         cairo_destroy (cr);
 464 }
 465
 466 static void
 467 clearlooks_style_draw_box (DRAW_ARGS)
 468 {
 469         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
 470         const ClearlooksColors *colors;
 471         cairo_t *cr;
 472
 473         cr     = ge_gdk_drawable_to_cairo (window, area);
 474         colors = &clearlooks_style->colors;
 475
 476         CHECK_ARGS
 477         SANITIZE_SIZE
 478
 479         if (DETAIL ("menubar") && !ge_is_panel_widget_item(widget))
 480         {
 481                 WidgetParameters params;
 482                 MenuBarParameters menubar;
 483
 484                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 485
 486                 menubar.style = clearlooks_style->menubarstyle;
 487
 488                 STYLE_FUNCTION(draw_menubar) (cr, colors, &params, &menubar,
 489                                          x, y, width, height);
 490         }
 491         else if (DETAIL ("button") && widget && widget->parent &&
 492                   (GE_IS_TREE_VIEW(widget->parent) ||
 493                    GE_IS_CLIST (widget->parent) ||
 494                    ge_object_is_a (G_OBJECT(widget->parent), "ETree"))) /* ECanvas inside ETree */
 495         {
 496                 WidgetParameters params;
 497                 ListViewHeaderParameters header;
 498
 499                 gint columns, column_index;
 500                 gboolean resizable = TRUE;
 501
 502                 /* XXX: This makes unknown treeview header CL_ORDER_MIDDLE, in need for something nicer */
 503                 columns = 3;
 504                 column_index = 1;
 505
 506                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 507
 508                 params.corners = CR_CORNER_NONE;
 509
 510                 if (GE_IS_TREE_VIEW (widget->parent))
 511                 {
 512                         clearlooks_treeview_get_header_index (GTK_TREE_VIEW(widget->parent),
 513                                                                                    widget, &column_index, &columns,
 514                                                                                    &resizable);
 515                 }
 516                 else if (GE_IS_CLIST (widget->parent))
 517                 {
 518                         clearlooks_clist_get_header_index (GTK_CLIST(widget->parent),
 519                                                                                 widget, &column_index, &columns);
 520                 }
 521
 522                 header.resizable = resizable;
 523
 524                 if (column_index == 0)
 525                         header.order = params.ltr ? CL_ORDER_FIRST : CL_ORDER_LAST;
 526                 else if (column_index == columns-1)
 527                         header.order = params.ltr ? CL_ORDER_LAST : CL_ORDER_FIRST;
 528                 else
 529                         header.order = CL_ORDER_MIDDLE;
 530
 531                 gtk_style_apply_default_background (style, window, FALSE, state_type, area, x, y, width, height);
 532
 533                 STYLE_FUNCTION(draw_list_view_header) (cr, colors, &params, &header,
 534                                                   x, y, width, height);
 535         }
 536         else if (DETAIL ("button") || DETAIL ("buttondefault"))
 537         {
 538                 WidgetParameters params;
 539                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 540
 541                 if (ge_is_in_combo_box(widget))
 542                 {
 543                         if (params.ltr)
 544                                 params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
 545                         else
 546                                 params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
 547
 548                         if (params.xthickness > 2)
 549                         {
 550                                 if (params.ltr)
 551                                         x--;
 552                                 width++;
 553                         }
 554                 }
 555                 else
 556                 {
 557                         params.corners    = CR_CORNER_ALL;
 558                         /* if (!(ge_is_combo_box (widget, FALSE))) */
 559                         params.enable_glow = TRUE;
 560                 }
 561
 562                 if (GE_IS_TOGGLE_BUTTON (widget) &&
 563                     gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
 564                         params.active = TRUE;
 565
 566                 STYLE_FUNCTION(draw_button) (cr, &clearlooks_style->colors, &params,
 567                                              x, y, width, height);
 568         }
 569         else if (DETAIL ("spinbutton_up") || DETAIL ("spinbutton_down"))
 570         {
 571                 if (state_type == GTK_STATE_ACTIVE)
 572                 {
 573                         WidgetParameters params;
 574                         clearlooks_set_widget_parameters (widget, style, state_type, &params);
 575
 576                         if (style->xthickness == 3)
 577                         {
 578                                 width++;
 579                                 if (params.ltr)
 580                                         x--;
 581                         }
 582
 583                         if (DETAIL ("spinbutton_up"))
 584                         {
 585                                 height+=2;
 586                                 if (params.ltr)
 587                                         params.corners = CR_CORNER_TOPRIGHT;
 588                                 else
 589                                         params.corners = CR_CORNER_TOPLEFT;
 590                         }
 591                         else
 592                         {
 593                                 if (params.ltr)
 594                                         params.corners = CR_CORNER_BOTTOMRIGHT;
 595                                 else
 596                                         params.corners = CR_CORNER_BOTTOMLEFT;
 597                         }
 598
 599                         STYLE_FUNCTION(draw_spinbutton_down) (cr, &clearlooks_style->colors, &params, x, y, width, height);
 600                 }
 601         }
 602         else if (DETAIL ("spinbutton"))
 603         {
 604                 WidgetParameters params;
 605
 606                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 607
 608                 if (params.ltr)
 609                         params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
 610                 else
 611                         params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
 612
 613                 if (style->xthickness == 3)
 614                 {
 615                         if (params.ltr)
 616                                 x--;
 617                         width++;
 618                 }
 619
 620                 STYLE_FUNCTION(draw_spinbutton) (cr, &clearlooks_style->colors, &params,
 621                                             x, y, width, height);
 622         }
 623         else if (detail && g_str_has_prefix (detail, "trough") && GE_IS_SCALE (widget))
 624         {
 625                 WidgetParameters params;
 626                 SliderParameters slider;
 627
 628                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 629                 params.corners    = CR_CORNER_NONE;
 630
 631                 slider.lower = DETAIL ("trough-lower");
 632                 slider.fill_level = DETAIL ("trough-fill-level") || DETAIL ("trough-fill-level-full");
 633
 634                 slider.horizontal = (GTK_RANGE (widget)->orientation == GTK_ORIENTATION_HORIZONTAL);
 635
 636                 STYLE_FUNCTION(draw_scale_trough) (cr, &clearlooks_style->colors,
 637                                               &params, &slider,
 638                                               x, y, width, height);
 639         }
 640         else if (DETAIL ("trough") && widget && GE_IS_PROGRESS_BAR (widget))
 641         {
 642                 WidgetParameters params;
 643
 644                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 645
 646                 STYLE_FUNCTION(draw_progressbar_trough) (cr, colors, &params,
 647                                                     x, y, width, height);
 648         }
 649         else if (DETAIL ("trough") && widget && (GE_IS_VSCROLLBAR (widget) || GE_IS_HSCROLLBAR (widget)))
 650         {
 651                 WidgetParameters params;
 652                 ScrollBarParameters scrollbar;
 653
 654                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 655                 params.corners = CR_CORNER_NONE;
 656
 657                 scrollbar.horizontal = TRUE;
 658                 scrollbar.junction   = clearlooks_scrollbar_get_junction (widget);
 659
 660                 if (GE_IS_RANGE (widget))
 661                         scrollbar.horizontal = GTK_RANGE (widget)->orientation == GTK_ORIENTATION_HORIZONTAL;
 662
 663                 if (scrollbar.horizontal)
 664                 {
 665                         x += 2;
 666                         width -= 4;
 667                 }
 668                 else
 669                 {
 670                         y += 2;
 671                         height -= 4;
 672                 }
 673
 674                 STYLE_FUNCTION(draw_scrollbar_trough) (cr, colors, &params, &scrollbar,
 675                                                   x, y, width, height);
 676         }
 677         else if (DETAIL ("bar"))
 678         {
 679                 WidgetParameters      params;
 680                 ProgressBarParameters progressbar;
 681                 gdouble               elapsed = 0.0;
 682
 683 #ifdef HAVE_ANIMATION
 684                 if(clearlooks_style->animation && CL_IS_PROGRESS_BAR (widget))
 685                 {
 686                         gboolean activity_mode = GTK_PROGRESS (widget)->activity_mode;
 687
 688                         if (!activity_mode)
 689                                 clearlooks_animation_progressbar_add ((gpointer)widget);
 690                 }
 691
 692                 elapsed = clearlooks_animation_elapsed (widget);
 693 #endif
 694
 695                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 696
 697                 if (widget && GE_IS_PROGRESS_BAR (widget))
 698                 {
 699                         progressbar.orientation = gtk_progress_bar_get_orientation (GTK_PROGRESS_BAR (widget));
 700                         progressbar.value = gtk_progress_bar_get_fraction(GTK_PROGRESS_BAR(widget));
 701                         progressbar.pulsing = GTK_PROGRESS (widget)->activity_mode;
 702                 }
 703                 else
 704                 {
 705                         progressbar.orientation = CL_ORIENTATION_LEFT_TO_RIGHT;
 706                         progressbar.value = 0;
 707                         progressbar.pulsing = FALSE;
 708                 }
 709
 710                 if (!params.ltr)
 711                 {
 712                         if (progressbar.orientation == (ClearlooksOrientation)GTK_PROGRESS_LEFT_TO_RIGHT)
 713                                 progressbar.orientation = GTK_PROGRESS_RIGHT_TO_LEFT;
 714                         else if (progressbar.orientation == (ClearlooksOrientation)GTK_PROGRESS_RIGHT_TO_LEFT)
 715                                 progressbar.orientation = GTK_PROGRESS_LEFT_TO_RIGHT;
 716                 }
 717
 718                 /* Following is a hack to have a larger clip area, the one passed in
 719                  * does not allow for the shadow. */
 720                 if (area)
 721                 {
 722                         GdkRectangle tmp = *area;
 723                         if (!progressbar.pulsing)
 724                         {
 725                                 switch (progressbar.orientation)
 726                                 {
 727                                         case GTK_PROGRESS_RIGHT_TO_LEFT:
 728                                                 tmp.x -= 1;
 729                                                 /* fallthrough */
 730                                         case GTK_PROGRESS_LEFT_TO_RIGHT:
 731                                                 tmp.width += 1;
 732                                                 break;
 733                                         case GTK_PROGRESS_BOTTOM_TO_TOP:
 734                                                 tmp.y -= 1;
 735                                                 /* fallthrough */
 736                                         case GTK_PROGRESS_TOP_TO_BOTTOM:
 737                                                 tmp.height += 1;
 738                                                 break;
 739                                 }
 740                         }
 741                         else
 742                         {
 743                                 if (progressbar.orientation == (ClearlooksOrientation)GTK_PROGRESS_RIGHT_TO_LEFT ||
 744                                     progressbar.orientation == (ClearlooksOrientation)GTK_PROGRESS_LEFT_TO_RIGHT)
 745                                 {
 746                                         tmp.x -= 1;
 747                                         tmp.width += 2;
 748                                 }
 749                                 else
 750                                 {
 751                                         tmp.y -= 1;
 752                                         tmp.height += 2;
 753                                 }
 754                         }
 755
 756                         cairo_reset_clip (cr);
 757                         gdk_cairo_rectangle (cr, &tmp);
 758                         cairo_clip (cr);
 759                 }
 760
 761                 STYLE_FUNCTION(draw_progressbar_fill) (cr, colors, &params, &progressbar,
 762                                                   x, y, width, height,
 763                                                   10 - (int)(elapsed * 10.0) % 10);
 764         }
 765         else if (DETAIL ("optionmenu"))
 766         {
 767                 WidgetParameters params;
 768                 OptionMenuParameters optionmenu;
 769
 770                 GtkRequisition indicator_size;
 771                 GtkBorder indicator_spacing;
 772
 773                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 774
 775                 params.enable_glow = TRUE;
 776
 777                 ge_option_menu_get_props (widget, &indicator_size, &indicator_spacing);
 778
 779                 if (ge_widget_is_ltr (widget))
 780                         optionmenu.linepos = width - (indicator_size.width + indicator_spacing.left + indicator_spacing.right) - 1;
 781                 else
 782                         optionmenu.linepos = (indicator_size.width + indicator_spacing.left + indicator_spacing.right) + 1;
 783
 784                 STYLE_FUNCTION(draw_optionmenu) (cr, colors, &params, &optionmenu,
 785                                                  x, y, width, height);
 786         }
 787         else if (DETAIL ("menuitem"))
 788         {
 789                 WidgetParameters params;
 790                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 791
 792                 if (widget && GE_IS_MENU_BAR (widget->parent))
 793                 {
 794                         params.corners = CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT;
 795                         height += 1;
 796                         STYLE_FUNCTION(draw_menubaritem) (cr, colors, &params, x, y, width, height);
 797                 }
 798                 else
 799                 {
 800                         params.corners = CR_CORNER_ALL;
 801                         STYLE_FUNCTION(draw_menuitem) (cr, colors, &params, x, y, width, height);
 802                 }
 803         }
 804         else if (DETAIL ("hscrollbar") || DETAIL ("vscrollbar")) /* This can't be "stepper" for scrollbars ... */
 805         {
 806                 WidgetParameters    params;
 807                 ScrollBarParameters scrollbar;
 808                 ScrollBarStepperParameters stepper;
 809                 GdkRectangle this_rectangle;
 810
 811                 this_rectangle.x = x;
 812                 this_rectangle.y = y;
 813                 this_rectangle.width  = width;
 814                 this_rectangle.height = height;
 815
 816                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 817                 params.corners = CR_CORNER_NONE;
 818
 819                 scrollbar.has_color  = FALSE;
 820                 scrollbar.horizontal = TRUE;
 821                 scrollbar.junction   = clearlooks_scrollbar_get_junction (widget);
 822
 823                 if (clearlooks_style->colorize_scrollbar || clearlooks_style->has_scrollbar_color) {
 824                         scrollbar.has_color = TRUE;
 825                 }
 826
 827                 scrollbar.horizontal = DETAIL ("hscrollbar");
 828
 829                 stepper.stepper = clearlooks_scrollbar_get_stepper (widget, &this_rectangle);
 830
 831                 STYLE_FUNCTION(draw_scrollbar_stepper) (cr, colors, &params, &scrollbar, &stepper,
 832                                                         x, y, width, height);
 833         }
 834         else if (DETAIL ("toolbar") || DETAIL ("handlebox_bin") || DETAIL ("dockitem_bin"))
 835         {
 836                 WidgetParameters  params;
 837                 ToolbarParameters toolbar;
 838
 839                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 840                 clearlooks_set_toolbar_parameters (&toolbar, widget, window, x, y);
 841
 842                 toolbar.style = clearlooks_style->toolbarstyle;
 843
 844                 /* Only draw the shadows on horizontal toolbars */
 845                 if (shadow_type != GTK_SHADOW_NONE && height < 2*width )
 846                         STYLE_FUNCTION(draw_toolbar) (cr, colors, &params, &toolbar, x, y, width, height);
 847         }
 848         else if (DETAIL ("trough"))
 849         {
 850
 851         }
 852         else if (DETAIL ("menu"))
 853         {
 854                 WidgetParameters params;
 855
 856                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 857
 858                 STYLE_FUNCTION(draw_menu_frame) (cr, colors, &params, x, y, width, height);
 859         }
 860         else if (DETAIL ("hseparator") || DETAIL ("vseparator"))
 861         {
 862                 const gchar *new_detail = detail;
 863                 /* Draw a normal separator, we just use this because it gives more control
 864                  * over sizing (currently). */
 865
 866                 /* This isn't nice ... but it seems like the best cleanest way to me right now.
 867                  * It will get slightly nicer in the future hopefully. */
 868                 if (GE_IS_MENU_ITEM (widget))
 869                         new_detail = "menuitem";
 870
 871                 if (DETAIL ("hseparator")) {
 872                         gtk_paint_hline (style, window, state_type, area, widget, new_detail,
 873                                          x, x + width - 1, y + height/2);
 874                 } else
 875                         gtk_paint_vline (style, window, state_type, area, widget, new_detail,
 876                                          y, y + height - 1, x + width/2);
 877         }
 878         else
 879         {
 880                 clearlooks_parent_class->draw_box (style, window, state_type, shadow_type, area,
 881                                         widget, detail, x, y, width, height);
 882         }
 883
 884         cairo_destroy (cr);
 885 }
 886
 887 static void
 888 clearlooks_style_draw_slider (DRAW_ARGS, GtkOrientation orientation)
 889 {
 890         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
 891         const ClearlooksColors *colors;
 892         cairo_t *cr;
 893
 894         cr     = ge_gdk_drawable_to_cairo (window, area);
 895         colors = &clearlooks_style->colors;
 896
 897         CHECK_ARGS
 898         SANITIZE_SIZE
 899
 900         if (DETAIL ("hscale") || DETAIL ("vscale"))
 901         {
 902                 WidgetParameters params;
 903                 SliderParameters slider;
 904
 905                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 906
 907                 slider.horizontal = (orientation == GTK_ORIENTATION_HORIZONTAL);
 908                 slider.lower = FALSE;
 909                 slider.fill_level = FALSE;
 910
 911                 if (clearlooks_style->style == CL_STYLE_GLOSSY) /* XXX! */
 912                         params.corners = CR_CORNER_ALL;
 913
 914                 STYLE_FUNCTION(draw_slider_button) (cr, &clearlooks_style->colors,
 915                                                &params, &slider,
 916                                                x, y, width, height);
 917         }
 918         else if (DETAIL ("slider"))
 919         {
 920                 WidgetParameters    params;
 921                 ScrollBarParameters scrollbar;
 922
 923                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
 924                 params.corners = CR_CORNER_NONE;
 925
 926                 scrollbar.has_color  = FALSE;
 927                 scrollbar.horizontal = (orientation == GTK_ORIENTATION_HORIZONTAL);
 928                 scrollbar.junction   = clearlooks_scrollbar_get_junction (widget);
 929
 930                 if (clearlooks_style->colorize_scrollbar) {
 931                         scrollbar.color = colors->spot[1];
 932                         scrollbar.has_color = TRUE;
 933                 }
 934
 935                 /* Set scrollbar color */
 936                 if (clearlooks_style->has_scrollbar_color)
 937                 {
 938                         ge_gdk_color_to_cairo (&clearlooks_style->scrollbar_color, &scrollbar.color);
 939                         scrollbar.has_color = TRUE;
 940                 }
 941
 942                 if ((clearlooks_style->style == CL_STYLE_GLOSSY || clearlooks_style->style == CL_STYLE_GUMMY)
 943                         && !scrollbar.has_color)
 944                         scrollbar.color = colors->bg[0];
 945
 946                 STYLE_FUNCTION(draw_scrollbar_slider) (cr, colors, &params, &scrollbar,
 947                                                        x, y, width, height);
 948         }
 949         else
 950         {
 951                 clearlooks_parent_class->draw_slider (style, window, state_type, shadow_type, area,
 952                                            widget, detail, x, y, width, height, orientation);
 953         }
 954
 955         cairo_destroy (cr);
 956 }
 957
 958 static void
 959 clearlooks_style_draw_option (DRAW_ARGS)
 960 {
 961         const ClearlooksColors *colors;
 962         WidgetParameters params;
 963         CheckboxParameters checkbox;
 964         cairo_t *cr;
 965         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
 966
 967         (void) detail;
 968
 969         CHECK_ARGS
 970         SANITIZE_SIZE
 971
 972         cr = ge_gdk_drawable_to_cairo (window, area);
 973         colors = &clearlooks_style->colors;
 974
 975         checkbox.shadow_type = shadow_type;
 976         checkbox.in_menu = (widget && GTK_IS_MENU(widget->parent));
 977
 978         clearlooks_set_widget_parameters (widget, style, state_type, &params);
 979
 980         STYLE_FUNCTION(draw_radiobutton) (cr, colors, &params, &checkbox, x, y, width, height);
 981
 982         cairo_destroy (cr);
 983 }
 984
 985 static void
 986 clearlooks_style_draw_check (DRAW_ARGS)
 987 {
 988         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
 989         WidgetParameters params;
 990         CheckboxParameters checkbox;
 991         cairo_t *cr;
 992
 993         CHECK_ARGS
 994         SANITIZE_SIZE
 995
 996         cr = ge_gdk_drawable_to_cairo (window, area);
 997
 998         clearlooks_set_widget_parameters (widget, style, state_type, &params);
 999
1000         params.corners = CR_CORNER_ALL;
1001
1002         checkbox.shadow_type = shadow_type;
1003         checkbox.in_cell = DETAIL("cellcheck");
1004
1005         checkbox.in_menu = (widget && widget->parent && GTK_IS_MENU(widget->parent));
1006
1007         STYLE_FUNCTION(draw_checkbox) (cr, &clearlooks_style->colors, &params, &checkbox,
1008                                   x, y, width, height);
1009
1010         cairo_destroy (cr);
1011 }
1012
1013 static void
1014 clearlooks_style_draw_vline (GtkStyle               *style,
1015                              GdkWindow              *window,
1016                              GtkStateType            state_type,
1017                              GdkRectangle           *area,
1018                              GtkWidget              *widget,
1019                              const gchar            *detail,
1020                              gint                    y1,
1021                              gint                    y2,
1022                              gint                    x)
1023 {
1024         const ClearlooksColors *colors;
1025         SeparatorParameters separator;
1026         cairo_t *cr;
1027
1028         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1029
1030         (void) state_type;
1031         (void) widget;
1032         (void) detail;
1033
1034         separator.horizontal = FALSE;
1035
1036         CHECK_ARGS
1037
1038         colors = &clearlooks_style->colors;
1039
1040         cr = ge_gdk_drawable_to_cairo (window, area);
1041
1042         /* There is no such thing as a vertical menu separator
1043          * (and even if, a normal one should be better on menu bars) */
1044         STYLE_FUNCTION(draw_separator) (cr, colors, NULL, &separator,
1045                                         x, y1, 2, y2-y1+1);
1046
1047         cairo_destroy (cr);
1048 }
1049
1050 static void
1051 clearlooks_style_draw_hline (GtkStyle               *style,
1052                              GdkWindow              *window,
1053                              GtkStateType            state_type,
1054                              GdkRectangle           *area,
1055                              GtkWidget              *widget,
1056                              const gchar            *detail,
1057                              gint                    x1,
1058                              gint                    x2,
1059                              gint                    y)
1060 {
1061         const ClearlooksColors *colors;
1062         cairo_t *cr;
1063         SeparatorParameters separator;
1064         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1065
1066         (void) state_type;
1067         (void) widget;
1068
1069         CHECK_ARGS
1070
1071         colors = &clearlooks_style->colors;
1072
1073         cr = ge_gdk_drawable_to_cairo (window, area);
1074
1075         separator.horizontal = TRUE;
1076
1077         if (!DETAIL ("menuitem"))
1078                 STYLE_FUNCTION(draw_separator) (cr, colors, NULL, &separator,
1079                                                 x1, y, x2-x1+1, 2);
1080         else
1081                 STYLE_FUNCTION(draw_menu_item_separator) (cr, colors, NULL, &separator,
1082                                                            x1, y, x2-x1+1, 2);
1083
1084         cairo_destroy (cr);
1085 }
1086
1087 static void
1088 clearlooks_style_draw_shadow_gap (DRAW_ARGS,
1089                  GtkPositionType gap_side,
1090                  gint            gap_x,
1091                  gint            gap_width)
1092 {
1093         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1094         const ClearlooksColors *colors;
1095         cairo_t *cr;
1096
1097         CHECK_ARGS
1098         SANITIZE_SIZE
1099
1100         cr     = ge_gdk_drawable_to_cairo (window, area);
1101         colors = &clearlooks_style->colors;
1102
1103         if (DETAIL ("frame"))
1104         {
1105                 WidgetParameters params;
1106                 FrameParameters  frame;
1107
1108                 frame.shadow    = shadow_type;
1109                 frame.gap_side  = gap_side;
1110                 frame.gap_x     = gap_x;
1111                 frame.gap_width = gap_width;
1112                 frame.border    = &colors->shade[5];
1113
1114                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
1115
1116                 params.corners = CR_CORNER_ALL;
1117
1118                 STYLE_FUNCTION(draw_frame) (cr, colors, &params, &frame,
1119                                        x, y, width, height);
1120         }
1121         else
1122         {
1123                 clearlooks_parent_class->draw_shadow_gap (style, window, state_type, shadow_type, area,
1124                                                                            widget, detail, x, y, width, height,
1125                                                                            gap_side, gap_x, gap_width);
1126         }
1127
1128         cairo_destroy (cr);
1129 }
1130
1131 static void
1132 clearlooks_style_draw_resize_grip (GtkStyle       *style,
1133                   GdkWindow      *window,
1134                   GtkStateType    state_type,
1135                   GdkRectangle   *area,
1136                   GtkWidget      *widget,
1137                   const gchar    *detail,
1138                   GdkWindowEdge   edge,
1139                   gint            x,
1140                   gint            y,
1141                   gint            width,
1142                   gint            height)
1143 {
1144         ClearlooksColors *colors;
1145         cairo_t *cr;
1146         WidgetParameters params;
1147         ResizeGripParameters grip;
1148         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1149
1150         (void) detail;
1151         colors = &clearlooks_style->colors;
1152
1153         CHECK_ARGS
1154         SANITIZE_SIZE
1155
1156         grip.edge = (ClearlooksWindowEdge)edge;
1157
1158         g_return_if_fail (window != NULL);
1159
1160         cr = ge_gdk_drawable_to_cairo (window, area);
1161
1162         clearlooks_set_widget_parameters (widget, style, state_type, &params);
1163
1164         STYLE_FUNCTION(draw_resize_grip) (cr, colors, &params, &grip,
1165                                      x, y, width, height);
1166
1167         cairo_destroy (cr);
1168 }
1169
1170 static void
1171 clearlooks_style_draw_tab (DRAW_ARGS)
1172 {
1173         ClearlooksColors *colors;
1174         WidgetParameters params;
1175         ArrowParameters  arrow;
1176         cairo_t *cr;
1177         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1178
1179         (void) shadow_type;
1180         (void) detail;
1181         colors = &clearlooks_style->colors;
1182
1183         CHECK_ARGS
1184         SANITIZE_SIZE
1185
1186         cr = ge_gdk_drawable_to_cairo (window, area);
1187
1188         clearlooks_set_widget_parameters (widget, style, state_type, &params);
1189         arrow.type      = CL_ARROW_COMBO;
1190         arrow.direction = CL_DIRECTION_DOWN;
1191
1192         STYLE_FUNCTION(draw_arrow) (cr, colors, &params, &arrow, x, y, width, height);
1193
1194         cairo_destroy (cr);
1195 }
1196
1197 static void
1198 clearlooks_style_draw_arrow (GtkStyle  *style,
1199                        GdkWindow     *window,
1200                        GtkStateType   state_type,
1201                        GtkShadowType  shadow,
1202                        GdkRectangle  *area,
1203                        GtkWidget     *widget,
1204                        const gchar   *detail,
1205                        GtkArrowType   arrow_type,
1206                        gboolean       fill,
1207                        gint           x,
1208                        gint           y,
1209                        gint           width,
1210                        gint           height)
1211 {
1212         ClearlooksColors *colors;
1213         WidgetParameters params;
1214         ArrowParameters  arrow;
1215         cairo_t *cr;
1216         ClearlooksStyle  *clearlooks_style = CLEARLOOKS_STYLE (style);
1217
1218         (void) shadow;
1219         (void) detail;
1220         (void) fill;
1221
1222         cr = ge_gdk_drawable_to_cairo (window, area);
1223         colors = &clearlooks_style->colors;
1224
1225         CHECK_ARGS
1226         SANITIZE_SIZE
1227
1228         if (arrow_type == GTK_ARROW_NONE) {
1229                 cairo_destroy (cr);
1230                 return;
1231         }
1232
1233         clearlooks_set_widget_parameters (widget, style, state_type, &params);
1234         arrow.type = CL_ARROW_NORMAL;
1235         arrow.direction = (ClearlooksDirection)arrow_type;
1236
1237         if (ge_is_combo_box (widget, FALSE) && !ge_is_combo_box_entry (widget))
1238         {
1239                 arrow.type = CL_ARROW_COMBO;
1240         }
1241
1242         /* I have no idea why, but the arrow of GtkCombo is larger than in other places.
1243          * Subtracting 3 seems to fix this. */
1244         if (widget && widget->parent && GE_IS_COMBO (widget->parent->parent))
1245         {
1246                 if (params.ltr)
1247                         x += 1;
1248                 else
1249                         x += 2;
1250                 width -= 3;
1251         }
1252
1253         STYLE_FUNCTION(draw_arrow) (cr, colors, &params, &arrow, x, y, width, height);
1254
1255         cairo_destroy (cr);
1256 }
1257
1258 static void
1259 clearlooks_style_init_from_rc (GtkStyle * style,
1260                                GtkRcStyle * rc_style)
1261 {
1262         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1263
1264         clearlooks_parent_class->init_from_rc (style, rc_style);
1265
1266         g_assert ((CLEARLOOKS_RC_STYLE (rc_style)->style < CL_NUM_STYLES));
1267         clearlooks_style->style         = CLEARLOOKS_RC_STYLE (rc_style)->style;
1268
1269         clearlooks_style->menubarstyle      = CLEARLOOKS_RC_STYLE (rc_style)->menubarstyle;
1270         clearlooks_style->toolbarstyle      = CLEARLOOKS_RC_STYLE (rc_style)->toolbarstyle;
1271         clearlooks_style->has_scrollbar_color = CLEARLOOKS_RC_STYLE (rc_style)->flags & CL_FLAG_SCROLLBAR_COLOR;
1272         clearlooks_style->colorize_scrollbar = CLEARLOOKS_RC_STYLE (rc_style)->colorize_scrollbar;
1273         clearlooks_style->animation         = CLEARLOOKS_RC_STYLE (rc_style)->animation;
1274         clearlooks_style->radius            = CLAMP (CLEARLOOKS_RC_STYLE (rc_style)->radius, 0.0, 10.0);
1275
1276         if (clearlooks_style->has_scrollbar_color)
1277                 clearlooks_style->scrollbar_color = CLEARLOOKS_RC_STYLE (rc_style)->scrollbar_color;
1278 }
1279
1280 static void
1281 clearlooks_style_realize (GtkStyle * style)
1282 {
1283         ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1284         double shades[] = {1.15, 0.95, 0.896, 0.82, 0.7, 0.665, 0.475, 0.45, 0.4};
1285         CairoColor spot_color;
1286         CairoColor bg_normal;
1287         double contrast;
1288         int i;
1289
1290         clearlooks_parent_class->realize (style);
1291
1292         contrast = CLEARLOOKS_RC_STYLE (style->rc_style)->contrast;
1293
1294         /* Lighter to darker */
1295         ge_gdk_color_to_cairo (&style->bg[GTK_STATE_NORMAL], &bg_normal);
1296
1297         for (i = 0; i < 9; i++)
1298         {
1299                 ge_shade_color(&bg_normal, (shades[i]-0.7) * contrast + 0.7, &clearlooks_style->colors.shade[i]);
1300         }
1301
1302         ge_gdk_color_to_cairo (&style->bg[GTK_STATE_SELECTED], &spot_color);
1303
1304         ge_shade_color(&spot_color, 1.42, &clearlooks_style->colors.spot[0]);
1305         ge_shade_color(&spot_color, 1.05, &clearlooks_style->colors.spot[1]);
1306         ge_shade_color(&spot_color, 0.65, &clearlooks_style->colors.spot[2]);
1307
1308         for (i=0; i<5; i++)
1309         {
1310                 ge_gdk_color_to_cairo (&style->fg[i], &clearlooks_style->colors.fg[i]);
1311                 ge_gdk_color_to_cairo (&style->bg[i], &clearlooks_style->colors.bg[i]);
1312                 ge_gdk_color_to_cairo (&style->base[i], &clearlooks_style->colors.base[i]);
1313                 ge_gdk_color_to_cairo (&style->text[i], &clearlooks_style->colors.text[i]);
1314         }
1315 }
1316
1317 static void
1318 clearlooks_style_draw_focus (GtkStyle *style, GdkWindow *window, GtkStateType state_type,
1319             GdkRectangle *area, GtkWidget *widget, const gchar *detail,
1320             gint x, gint y, gint width, gint height)
1321 {
1322         cairo_t *cr;
1323         gboolean free_dash_list = FALSE;
1324         gint line_width = 1;
1325         gint8 *dash_list = (gint8 *)"\1\1";
1326
1327         if (widget)
1328         {
1329                 gtk_widget_style_get (widget,
1330                                       "focus-line-width", &line_width,
1331                                       "focus-line-pattern",
1332                                       (gchar *) & dash_list, NULL);
1333
1334                 free_dash_list = TRUE;
1335         }
1336
1337         if (detail && !strcmp (detail, "add-mode"))
1338         {
1339                 if (free_dash_list)
1340                         g_free (dash_list);
1341
1342                 dash_list = (gint8 *)"\4\4";
1343                 free_dash_list = FALSE;
1344         }
1345
1346         CHECK_ARGS
1347         SANITIZE_SIZE
1348
1349         cr = gdk_cairo_create (window);
1350
1351         if (detail && !strcmp (detail, "colorwheel_light"))
1352                 cairo_set_source_rgb (cr, 0., 0., 0.);
1353         else if (detail && !strcmp (detail, "colorwheel_dark"))
1354                 cairo_set_source_rgb (cr, 1., 1., 1.);
1355         else
1356                 ge_cairo_set_gdk_color_with_alpha (cr, &style->fg[state_type],
1357                                                        0.7);
1358
1359         cairo_set_line_width (cr, line_width);
1360
1361         if (dash_list[0])
1362         {
1363                 gint n_dashes = strlen ((gchar *)dash_list);
1364                 gdouble *dashes = g_new (gdouble, n_dashes);
1365                 gdouble total_length = 0;
1366                 gdouble dash_offset;
1367                 gint i;
1368
1369                 for (i = 0; i < n_dashes; i++)
1370                 {
1371                         dashes[i] = dash_list[i];
1372                         total_length += dash_list[i];
1373                 }
1374
1375                 /* The dash offset here aligns the pattern to integer pixels
1376                  * by starting the dash at the right side of the left border
1377                  * Negative dash offsets in cairo don't work
1378                  * (https://bugs.freedesktop.org/show_bug.cgi?id=2729)
1379                  */
1380                 dash_offset = -line_width / 2.;
1381                 while (dash_offset < 0)
1382                         dash_offset += total_length;
1383
1384                 cairo_set_dash (cr, dashes, n_dashes, dash_offset);
1385                 g_free (dashes);
1386         }
1387
1388         if (area)
1389         {
1390                 gdk_cairo_rectangle (cr, area);
1391                 cairo_clip (cr);
1392         }
1393
1394         cairo_rectangle (cr,
1395                          x + line_width / 2.,
1396                          y + line_width / 2.,
1397                          width - line_width, height - line_width);
1398         cairo_stroke (cr);
1399         cairo_destroy (cr);
1400
1401         if (free_dash_list)
1402                 g_free (dash_list);
1403 }
1404
1405 static void
1406 clearlooks_style_copy (GtkStyle * style, GtkStyle * src)
1407 {
1408         ClearlooksStyle * cl_style = CLEARLOOKS_STYLE (style);
1409         ClearlooksStyle * cl_src = CLEARLOOKS_STYLE (src);
1410
1411         cl_style->colors              = cl_src->colors;
1412         cl_style->menubarstyle        = cl_src->menubarstyle;
1413         cl_style->toolbarstyle        = cl_src->toolbarstyle;
1414         cl_style->scrollbar_color     = cl_src->scrollbar_color;
1415         cl_style->has_scrollbar_color = cl_src->has_scrollbar_color;
1416         cl_style->colorize_scrollbar  = cl_src->colorize_scrollbar;
1417         cl_style->animation           = cl_src->animation;
1418         cl_style->radius              = cl_src->radius;
1419         cl_style->style               = cl_src->style;
1420
1421         clearlooks_parent_class->copy (style, src);
1422 }
1423
1424 static void
1425 clearlooks_style_unrealize (GtkStyle * style)
1426 {
1427         clearlooks_parent_class->unrealize (style);
1428 }
1429
1430 static GdkPixbuf *
1431 set_transparency (const GdkPixbuf *pixbuf, gdouble alpha_percent)
1432 {
1433         GdkPixbuf *target;
1434         guchar *data, *current;
1435         guint x, y, rowstride, height, width;
1436
1437         g_return_val_if_fail (pixbuf != NULL, NULL);
1438         g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
1439
1440         /* Returns a copy of pixbuf with it's non-completely-transparent pixels to
1441            have an alpha level "alpha_percent" of their original value. */
1442
1443         target = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
1444
1445         if (alpha_percent == 1.0)
1446                 return target;
1447         width = gdk_pixbuf_get_width (target);
1448         height = gdk_pixbuf_get_height (target);
1449         rowstride = gdk_pixbuf_get_rowstride (target);
1450         data = gdk_pixbuf_get_pixels (target);
1451
1452         for (y = 0; y < height; y++) {
1453                 for (x = 0; x < width; x++) {
1454                         /* The "4" is the number of chars per pixel, in this case, RGBA,
1455                            the 3 means "skip to the alpha" */
1456                         current = data + (y * rowstride) + (x * 4) + 3;
1457                         *(current) = (guchar) (*(current) * alpha_percent);
1458                 }
1459         }
1460
1461         return target;
1462 }
1463
1464 static GdkPixbuf*
1465 scale_or_ref (GdkPixbuf *src,
1466               int width,
1467               int height)
1468 {
1469         if (width == gdk_pixbuf_get_width (src) &&
1470             height == gdk_pixbuf_get_height (src)) {
1471                 return g_object_ref (src);
1472         } else {
1473                 return gdk_pixbuf_scale_simple (src,
1474                                         width, height,
1475                                         GDK_INTERP_BILINEAR);
1476         }
1477 }
1478
1479 static void
1480 clearlooks_style_draw_layout (GtkStyle * style,
1481              GdkWindow * window,
1482              GtkStateType state_type,
1483              gboolean use_text,
1484              GdkRectangle * area,
1485              GtkWidget * widget,
1486              const gchar * detail, gint x, gint y, PangoLayout * layout)
1487 {
1488         GdkGC *gc;
1489
1490         (void) detail;
1491         g_return_if_fail (GTK_IS_STYLE (style));
1492         g_return_if_fail (window != NULL);
1493
1494         gc = use_text ? style->text_gc[state_type] : style->fg_gc[state_type];
1495
1496         if (area)
1497                 gdk_gc_set_clip_rectangle (gc, area);
1498
1499         if (state_type == GTK_STATE_INSENSITIVE) {
1500                 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1501                 ClearlooksColors *colors = &clearlooks_style->colors;
1502
1503                 WidgetParameters params;
1504                 GdkColor etched;
1505                 CairoColor temp;
1506
1507                 clearlooks_set_widget_parameters (widget, style, state_type, &params);
1508
1509                 if (GTK_WIDGET_NO_WINDOW (widget))
1510                         ge_shade_color (&params.parentbg, 1.2, &temp);
1511                 else
1512                         ge_shade_color (&colors->bg[widget->state], 1.2, &temp);
1513
1514                 etched.red = (int) (temp.r * 65535);
1515                 etched.green = (int) (temp.g * 65535);
1516                 etched.blue = (int) (temp.b * 65535);
1517
1518                 gdk_draw_layout_with_colors (window, gc, x + 1, y + 1, layout, &etched, NULL);
1519                 gdk_draw_layout (window, gc, x, y, layout);
1520         }
1521         else
1522                 gdk_draw_layout (window, gc, x, y, layout);
1523
1524         if (area)
1525                 gdk_gc_set_clip_rectangle (gc, NULL);
1526 }
1527
1528 static GdkPixbuf *
1529 clearlooks_style_draw_render_icon (GtkStyle            *style,
1530              const GtkIconSource *source,
1531              GtkTextDirection     direction,
1532              GtkStateType         state,
1533              GtkIconSize          size,
1534              GtkWidget           *widget,
1535              const char          *detail)
1536 {
1537         int width;
1538         int height;
1539         GdkPixbuf *scaled;
1540         GdkPixbuf *stated;
1541         GdkPixbuf *base_pixbuf;
1542         GdkScreen *screen;
1543         GtkSettings *settings;
1544
1545         width = 1;
1546         height = 1;
1547
1548         (void) direction;
1549         (void) detail;
1550
1551         /* Oddly, style can be NULL in this function, because
1552          * GtkIconSet can be used without a style and if so
1553          * it uses this function.
1554          */
1555
1556         base_pixbuf = gtk_icon_source_get_pixbuf (source);
1557
1558         g_return_val_if_fail (base_pixbuf != NULL, NULL);
1559
1560         if (widget && gtk_widget_has_screen (widget)) {
1561                 screen = gtk_widget_get_screen (widget);
1562                 settings = gtk_settings_get_for_screen (screen);
1563         } else if (style->colormap) {
1564                 screen = gdk_colormap_get_screen (style->colormap);
1565                 settings = gtk_settings_get_for_screen (screen);
1566         } else {
1567                 settings = gtk_settings_get_default ();
1568                 GTK_NOTE (MULTIHEAD,
1569                           g_warning ("Using the default screen for gtk_default_render_icon()"));
1570         }
1571
1572
1573         if (size != (GtkIconSize) -1 && !gtk_icon_size_lookup_for_settings (settings, size, &width, &height)) {
1574                 g_warning (G_STRLOC ": invalid icon size '%d'", size);
1575                 return NULL;
1576         }
1577
1578         /* If the size was wildcarded, and we're allowed to scale, then scale; otherwise,
1579          * leave it alone.
1580          */
1581         if (size != (GtkIconSize)-1 && gtk_icon_source_get_size_wildcarded (source))
1582                 scaled = scale_or_ref (base_pixbuf, width, height);
1583         else
1584                 scaled = g_object_ref (base_pixbuf);
1585
1586         /* If the state was wildcarded, then generate a state. */
1587         if (gtk_icon_source_get_state_wildcarded (source)) {
1588                 if (state == GTK_STATE_INSENSITIVE) {
1589                         stated = set_transparency (scaled, 0.3);
1590                         gdk_pixbuf_saturate_and_pixelate (stated, stated,
1591                                                           0.1, FALSE);
1592
1593                         g_object_unref (scaled);
1594                 } else if (state == GTK_STATE_PRELIGHT) {
1595                         stated = gdk_pixbuf_copy (scaled);
1596
1597                         gdk_pixbuf_saturate_and_pixelate (scaled, stated,
1598                                                           1.2, FALSE);
1599
1600                         g_object_unref (scaled);
1601                 } else {
1602                         stated = scaled;
1603                 }
1604         }
1605         else
1606                 stated = scaled;
1607
1608   return stated;
1609 }
1610
1611 static void
1612 clearlooks_style_init (ClearlooksStyle * style)
1613 {
1614         (void) style;
1615 }
1616
1617 static void
1618 clearlooks_style_class_init (ClearlooksStyleClass * klass)
1619 {
1620         GtkStyleClass *style_class = GTK_STYLE_CLASS (klass);
1621
1622         clearlooks_style_class = CLEARLOOKS_STYLE_CLASS (klass);
1623         clearlooks_parent_class = g_type_class_peek_parent (klass);
1624
1625         style_class->copy             = clearlooks_style_copy;
1626         style_class->realize          = clearlooks_style_realize;
1627         style_class->unrealize        = clearlooks_style_unrealize;
1628         style_class->init_from_rc     = clearlooks_style_init_from_rc;
1629         style_class->draw_handle      = clearlooks_style_draw_handle;
1630         style_class->draw_slider      = clearlooks_style_draw_slider;
1631         style_class->draw_shadow_gap  = clearlooks_style_draw_shadow_gap;
1632         style_class->draw_focus       = clearlooks_style_draw_focus;
1633         style_class->draw_box         = clearlooks_style_draw_box;
1634         style_class->draw_shadow      = clearlooks_style_draw_shadow;
1635         style_class->draw_box_gap     = clearlooks_style_draw_box_gap;
1636         style_class->draw_extension   = clearlooks_style_draw_extension;
1637         style_class->draw_option      = clearlooks_style_draw_option;
1638         style_class->draw_check       = clearlooks_style_draw_check;
1639         style_class->draw_flat_box    = clearlooks_style_draw_flat_box;
1640         style_class->draw_vline       = clearlooks_style_draw_vline;
1641         style_class->draw_hline       = clearlooks_style_draw_hline;
1642         style_class->draw_resize_grip = clearlooks_style_draw_resize_grip;
1643         style_class->draw_tab         = clearlooks_style_draw_tab;
1644         style_class->draw_arrow       = clearlooks_style_draw_arrow;
1645         style_class->draw_layout      = clearlooks_style_draw_layout;
1646         style_class->render_icon      = clearlooks_style_draw_render_icon;
1647
1648         clearlooks_register_style_classic (&clearlooks_style_class->style_functions[CL_STYLE_CLASSIC]);
1649         clearlooks_style_class->style_functions[CL_STYLE_GLOSSY] = clearlooks_style_class->style_functions[CL_STYLE_CLASSIC];
1650         clearlooks_register_style_glossy (&clearlooks_style_class->style_functions[CL_STYLE_GLOSSY]);
1651         clearlooks_style_class->style_functions[CL_STYLE_INVERTED] = clearlooks_style_class->style_functions[CL_STYLE_CLASSIC];
1652         clearlooks_register_style_inverted (&clearlooks_style_class->style_functions[CL_STYLE_INVERTED]);
1653         clearlooks_style_class->style_functions[CL_STYLE_GUMMY] = clearlooks_style_class->style_functions[CL_STYLE_CLASSIC];
1654         clearlooks_register_style_gummy (&clearlooks_style_class->style_functions[CL_STYLE_GUMMY]);
1655 }
1656
1657 GType clearlooks_type_style = 0;
1658
1659 void
1660 clearlooks_style_register_type (GTypeModule * module)
1661 {
1662         static const GTypeInfo object_info =
1663         {
1664                 sizeof (ClearlooksStyleClass),
1665                 (GBaseInitFunc) NULL,
1666                 (GBaseFinalizeFunc) NULL,
1667                 (GClassInitFunc) clearlooks_style_class_init,
1668                 NULL,         /* class_finalize */
1669                 NULL,         /* class_data */
1670                 sizeof (ClearlooksStyle),
1671                 0,            /* n_preallocs */
1672                 (GInstanceInitFunc) clearlooks_style_init,
1673                 NULL
1674         };
1675
1676         clearlooks_type_style = g_type_module_register_type (module,
1677                                                              GTK_TYPE_STYLE,
1678                                                              "ClearlooksStyle",
1679                                                              &object_info, 0);
1680 }