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

   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 Lesser 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  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #ifndef __GTK_STYLE_H__
  28 #define __GTK_STYLE_H__
  29
  30
  31 #include <gdk/gdk.h>
  32 #include <gtk/gtkenums.h>
  33 #include <pango/pango.h>
  34
  35 #ifdef __cplusplus
  36 extern "C" {
  37 #endif /* __cplusplus */
  38
  39 typedef struct _GtkStyle       GtkStyle;
  40 typedef struct _GtkStyleClass  GtkStyleClass;
  41
  42 #define GTK_TYPE_STYLE              (gtk_style_get_type ())
  43 #define GTK_STYLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_STYLE, GtkStyle))
  44 #define GTK_STYLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STYLE, GtkStyleClass))
  45 #define GTK_IS_STYLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_STYLE))
  46 #define GTK_IS_STYLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STYLE))
  47 #define GTK_STYLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STYLE, GtkStyleClass))
  48
  49 /* Some forward declarations needed to rationalize the header
  50  * files.
  51  */
  52 typedef struct _GtkThemeEngine GtkThemeEngine;
  53 typedef struct _GtkRcStyle     GtkRcStyle;
  54 typedef struct _GtkIconSet     GtkIconSet;
  55 typedef struct _GtkIconSource  GtkIconSource;
  56
  57 /* We make this forward declaration here, since we pass
  58  * GtkWidgt's to the draw functions.
  59  */
  60 typedef struct _GtkWidget      GtkWidget;
  61
  62 /* This is used for having dynamic style changing stuff
  63  * fg, bg, light, dark, mid, text, base
  64  */
  65 #define GTK_STYLE_NUM_STYLECOLORS()     (7 * 5)
  66
  67 #define GTK_STYLE_ATTACHED(style)       (((GtkStyle*) (style))->attach_count > 0)
  68
  69 struct _GtkStyle
  70 {
  71   GObject parent_instance;
  72
  73   /*< public >*/
  74
  75   GdkColor fg[5];
  76   GdkColor bg[5];
  77   GdkColor light[5];
  78   GdkColor dark[5];
  79   GdkColor mid[5];
  80   GdkColor text[5];
  81   GdkColor base[5];
  82
  83   GdkColor black;
  84   GdkColor white;
  85   GdkFont *font;
  86   PangoFontDescription *font_desc;
  87
  88   gint xthickness;
  89   gint ythickness;
  90
  91   GdkGC *fg_gc[5];
  92   GdkGC *bg_gc[5];
  93   GdkGC *light_gc[5];
  94   GdkGC *dark_gc[5];
  95   GdkGC *mid_gc[5];
  96   GdkGC *text_gc[5];
  97   GdkGC *base_gc[5];
  98   GdkGC *black_gc;
  99   GdkGC *white_gc;
 100
 101   GdkPixmap *bg_pixmap[5];
 102
 103   /*< private >*/
 104
 105   gint attach_count;
 106
 107   gint depth;
 108   GdkColormap *colormap;
 109
 110   GtkRcStyle     *rc_style;     /* the Rc style from which this style
 111                                  * was created
 112                                  */
 113   GSList         *styles;
 114
 115   GSList         *icon_factories;
 116 };
 117
 118 struct _GtkStyleClass
 119 {
 120   GObjectClass parent_class;
 121
 122   /* Initialize for a particular colormap/depth
 123    * combination. style->colormap/style->depth will have
 124    * been set at this point. Will typically chain to parent.
 125    */
 126   void (*realize)               (GtkStyle               *style);
 127
 128   /* Clean up for a particular colormap/depth combination. Will
 129    * typically chain to parent.
 130    */
 131   void (*unrealize)             (GtkStyle               *style);
 132
 133   /* Make style an exact duplicate of src.
 134    */
 135   void (*copy)                  (GtkStyle               *style,
 136                                  GtkStyle               *src);
 137
 138   /* Create an empty style of the same type as this style.
 139    * The default implementation, which does
 140    * g_object_new (G_OBJECT_TYPE (style), NULL);
 141    * should work in most cases.
 142    */
 143   GtkStyle *(*clone)             (GtkStyle               *style);
 144
 145   /* Initialize the GtkStyle with the values in the GtkRcStyle.
 146    * should chain to the parent implementation.
 147    */
 148   void     (*init_from_rc)      (GtkStyle               *style,
 149                                  GtkRcStyle             *rc_style);
 150
 151   void (*set_background)        (GtkStyle               *style,
 152                                  GdkWindow              *window,
 153                                  GtkStateType            state_type);
 154
 155
 156   GdkPixbuf * (* render_icon)   (GtkStyle               *style,
 157                                  const GtkIconSource    *source,
 158                                  GtkTextDirection        direction,
 159                                  GtkStateType            state,
 160                                  GtkIconSize             size,
 161                                  GtkWidget              *widget,
 162                                  const gchar            *detail);
 163
 164   /* Drawing functions
 165    */
 166
 167   void (*draw_hline)            (GtkStyle               *style,
 168                                  GdkWindow              *window,
 169                                  GtkStateType            state_type,
 170                                  GdkRectangle           *area,
 171                                  GtkWidget              *widget,
 172                                  const gchar            *detail,
 173                                  gint                    x1,
 174                                  gint                    x2,
 175                                  gint                    y);
 176   void (*draw_vline)            (GtkStyle               *style,
 177                                  GdkWindow              *window,
 178                                  GtkStateType            state_type,
 179                                  GdkRectangle           *area,
 180                                  GtkWidget              *widget,
 181                                  const gchar            *detail,
 182                                  gint                    y1,
 183                                  gint                    y2,
 184                                  gint                    x);
 185   void (*draw_shadow)           (GtkStyle               *style,
 186                                  GdkWindow              *window,
 187                                  GtkStateType            state_type,
 188                                  GtkShadowType           shadow_type,
 189                                  GdkRectangle           *area,
 190                                  GtkWidget              *widget,
 191                                  const gchar            *detail,
 192                                  gint                    x,
 193                                  gint                    y,
 194                                  gint                    width,
 195                                  gint                    height);
 196   void (*draw_polygon)          (GtkStyle               *style,
 197                                  GdkWindow              *window,
 198                                  GtkStateType            state_type,
 199                                  GtkShadowType           shadow_type,
 200                                  GdkRectangle           *area,
 201                                  GtkWidget              *widget,
 202                                  const gchar            *detail,
 203                                  GdkPoint               *point,
 204                                  gint                    npoints,
 205                                  gboolean                fill);
 206   void (*draw_arrow)            (GtkStyle               *style,
 207                                  GdkWindow              *window,
 208                                  GtkStateType            state_type,
 209                                  GtkShadowType           shadow_type,
 210                                  GdkRectangle           *area,
 211                                  GtkWidget              *widget,
 212                                  const gchar            *detail,
 213                                  GtkArrowType            arrow_type,
 214                                  gboolean                fill,
 215                                  gint                    x,
 216                                  gint                    y,
 217                                  gint                    width,
 218                                  gint                    height);
 219   void (*draw_diamond)          (GtkStyle               *style,
 220                                  GdkWindow              *window,
 221                                  GtkStateType            state_type,
 222                                  GtkShadowType           shadow_type,
 223                                  GdkRectangle           *area,
 224                                  GtkWidget              *widget,
 225                                  const gchar            *detail,
 226                                  gint                    x,
 227                                  gint                    y,
 228                                  gint                    width,
 229                                  gint                    height);
 230   void (*draw_string)           (GtkStyle               *style,
 231                                  GdkWindow              *window,
 232                                  GtkStateType            state_type,
 233                                  GdkRectangle           *area,
 234                                  GtkWidget              *widget,
 235                                  const gchar            *detail,
 236                                  gint                    x,
 237                                  gint                    y,
 238                                  const gchar            *string);
 239   void (*draw_box)              (GtkStyle               *style,
 240                                  GdkWindow              *window,
 241                                  GtkStateType            state_type,
 242                                  GtkShadowType           shadow_type,
 243                                  GdkRectangle           *area,
 244                                  GtkWidget              *widget,
 245                                  const gchar            *detail,
 246                                  gint                    x,
 247                                  gint                    y,
 248                                  gint                    width,
 249                                  gint                    height);
 250   void (*draw_flat_box)         (GtkStyle               *style,
 251                                  GdkWindow              *window,
 252                                  GtkStateType            state_type,
 253                                  GtkShadowType           shadow_type,
 254                                  GdkRectangle           *area,
 255                                  GtkWidget              *widget,
 256                                  const gchar            *detail,
 257                                  gint                    x,
 258                                  gint                    y,
 259                                  gint                    width,
 260                                  gint                    height);
 261   void (*draw_check)            (GtkStyle               *style,
 262                                  GdkWindow              *window,
 263                                  GtkStateType            state_type,
 264                                  GtkShadowType           shadow_type,
 265                                  GdkRectangle           *area,
 266                                  GtkWidget              *widget,
 267                                  const gchar            *detail,
 268                                  gint                    x,
 269                                  gint                    y,
 270                                  gint                    width,
 271                                  gint                    height);
 272   void (*draw_option)           (GtkStyle               *style,
 273                                  GdkWindow              *window,
 274                                  GtkStateType            state_type,
 275                                  GtkShadowType           shadow_type,
 276                                  GdkRectangle           *area,
 277                                  GtkWidget              *widget,
 278                                  const gchar            *detail,
 279                                  gint                    x,
 280                                  gint                    y,
 281                                  gint                    width,
 282                                  gint                    height);
 283   void (*draw_tab)              (GtkStyle               *style,
 284                                  GdkWindow              *window,
 285                                  GtkStateType            state_type,
 286                                  GtkShadowType           shadow_type,
 287                                  GdkRectangle           *area,
 288                                  GtkWidget              *widget,
 289                                  const gchar            *detail,
 290                                  gint                    x,
 291                                  gint                    y,
 292                                  gint                    width,
 293                                  gint                    height);
 294   void (*draw_shadow_gap)       (GtkStyle               *style,
 295                                  GdkWindow              *window,
 296                                  GtkStateType            state_type,
 297                                  GtkShadowType           shadow_type,
 298                                  GdkRectangle           *area,
 299                                  GtkWidget              *widget,
 300                                  const gchar            *detail,
 301                                  gint                    x,
 302                                  gint                    y,
 303                                  gint                    width,
 304                                  gint                    height,
 305                                  GtkPositionType         gap_side,
 306                                  gint                    gap_x,
 307                                  gint                    gap_width);
 308   void (*draw_box_gap)          (GtkStyle               *style,
 309                                  GdkWindow              *window,
 310                                  GtkStateType            state_type,
 311                                  GtkShadowType           shadow_type,
 312                                  GdkRectangle           *area,
 313                                  GtkWidget              *widget,
 314                                  const gchar            *detail,
 315                                  gint                    x,
 316                                  gint                    y,
 317                                  gint                    width,
 318                                  gint                    height,
 319                                  GtkPositionType         gap_side,
 320                                  gint                    gap_x,
 321                                  gint                    gap_width);
 322   void (*draw_extension)        (GtkStyle               *style,
 323                                  GdkWindow              *window,
 324                                  GtkStateType            state_type,
 325                                  GtkShadowType           shadow_type,
 326                                  GdkRectangle           *area,
 327                                  GtkWidget              *widget,
 328                                  const gchar            *detail,
 329                                  gint                    x,
 330                                  gint                    y,
 331                                  gint                    width,
 332                                  gint                    height,
 333                                  GtkPositionType         gap_side);
 334   void (*draw_focus)            (GtkStyle               *style,
 335                                  GdkWindow              *window,
 336                                  GdkRectangle           *area,
 337                                  GtkWidget              *widget,
 338                                  const gchar            *detail,
 339                                  gint                    x,
 340                                  gint                    y,
 341                                  gint                    width,
 342                                  gint                    height);
 343   void (*draw_slider)           (GtkStyle               *style,
 344                                  GdkWindow              *window,
 345                                  GtkStateType            state_type,
 346                                  GtkShadowType           shadow_type,
 347                                  GdkRectangle           *area,
 348                                  GtkWidget              *widget,
 349                                  const gchar            *detail,
 350                                  gint                    x,
 351                                  gint                    y,
 352                                  gint                    width,
 353                                  gint                    height,
 354                                  GtkOrientation          orientation);
 355   void (*draw_handle)           (GtkStyle               *style,
 356                                  GdkWindow              *window,
 357                                  GtkStateType            state_type,
 358                                  GtkShadowType           shadow_type,
 359                                  GdkRectangle           *area,
 360                                  GtkWidget              *widget,
 361                                  const gchar            *detail,
 362                                  gint                    x,
 363                                  gint                    y,
 364                                  gint                    width,
 365                                  gint                    height,
 366                                  GtkOrientation          orientation);
 367
 368   void (*draw_expander)         (GtkStyle               *style,
 369                                  GdkWindow              *window,
 370                                  GtkStateType            state_type,
 371                                  GdkRectangle           *area,
 372                                  GtkWidget              *widget,
 373                                  const gchar            *detail,
 374                                  gint                    x,
 375                                  gint                    y,
 376                                  gboolean                is_open);
 377   void (*draw_layout)           (GtkStyle               *style,
 378                                  GdkWindow              *window,
 379                                  GtkStateType            state_type,
 380                                  GdkRectangle           *area,
 381                                  GtkWidget              *widget,
 382                                  const gchar            *detail,
 383                                  gint                    x,
 384                                  gint                    y,
 385                                  PangoLayout            *layout);
 386
 387 };
 388
 389 GType     gtk_style_get_type                 (void) G_GNUC_CONST;
 390 GtkStyle* gtk_style_new                      (void);
 391 GtkStyle* gtk_style_copy                     (GtkStyle      *style);
 392 GtkStyle* gtk_style_attach                   (GtkStyle      *style,
 393                                               GdkWindow     *window);
 394 void      gtk_style_detach                   (GtkStyle     *style);
 395 GtkStyle* gtk_style_ref                      (GtkStyle     *style);
 396 void      gtk_style_unref                    (GtkStyle     *style);
 397 void      gtk_style_set_background           (GtkStyle     *style,
 398                                               GdkWindow    *window,
 399                                               GtkStateType  state_type);
 400 void      gtk_style_apply_default_background (GtkStyle     *style,
 401                                               GdkWindow    *window,
 402                                               gboolean      set_bg,
 403                                               GtkStateType  state_type,
 404                                               GdkRectangle *area,
 405                                               gint          x,
 406                                               gint          y,
 407                                               gint          width,
 408                                               gint          height);
 409
 410 GtkIconSet* gtk_style_lookup_icon_set (GtkStyle            *style,
 411                                        const gchar         *stock_id);
 412 GdkPixbuf * gtk_style_render_icon     (GtkStyle            *style,
 413                                        const GtkIconSource *source,
 414                                        GtkTextDirection     direction,
 415                                        GtkStateType         state,
 416                                        GtkIconSize          size,
 417                                        GtkWidget           *widget,
 418                                        const gchar         *detail);
 419 void gtk_draw_hline      (GtkStyle        *style,
 420                           GdkWindow       *window,
 421                           GtkStateType     state_type,
 422                           gint             x1,
 423                           gint             x2,
 424                           gint             y);
 425 void gtk_draw_vline      (GtkStyle        *style,
 426                           GdkWindow       *window,
 427                           GtkStateType     state_type,
 428                           gint             y1,
 429                           gint             y2,
 430                           gint             x);
 431 void gtk_draw_shadow     (GtkStyle        *style,
 432                           GdkWindow       *window,
 433                           GtkStateType     state_type,
 434                           GtkShadowType    shadow_type,
 435                           gint             x,
 436                           gint             y,
 437                           gint             width,
 438                           gint             height);
 439 void gtk_draw_polygon    (GtkStyle        *style,
 440                           GdkWindow       *window,
 441                           GtkStateType     state_type,
 442                           GtkShadowType    shadow_type,
 443                           GdkPoint        *points,
 444                           gint             npoints,
 445                           gboolean         fill);
 446 void gtk_draw_arrow      (GtkStyle        *style,
 447                           GdkWindow       *window,
 448                           GtkStateType     state_type,
 449                           GtkShadowType    shadow_type,
 450                           GtkArrowType     arrow_type,
 451                           gboolean         fill,
 452                           gint             x,
 453                           gint             y,
 454                           gint             width,
 455                           gint             height);
 456 void gtk_draw_diamond    (GtkStyle        *style,
 457                           GdkWindow       *window,
 458                           GtkStateType     state_type,
 459                           GtkShadowType    shadow_type,
 460                           gint             x,
 461                           gint             y,
 462                           gint             width,
 463                           gint             height);
 464 #ifndef GTK_DISABLE_DEPRECATED
 465 void gtk_draw_string     (GtkStyle        *style,
 466                           GdkWindow       *window,
 467                           GtkStateType     state_type,
 468                           gint             x,
 469                           gint             y,
 470                           const gchar     *string);
 471 #endif /* GTK_DISABLE_DEPRECATED */
 472 void gtk_draw_box        (GtkStyle        *style,
 473                           GdkWindow       *window,
 474                           GtkStateType     state_type,
 475                           GtkShadowType    shadow_type,
 476                           gint             x,
 477                           gint             y,
 478                           gint             width,
 479                           gint             height);
 480 void gtk_draw_flat_box   (GtkStyle        *style,
 481                           GdkWindow       *window,
 482                           GtkStateType     state_type,
 483                           GtkShadowType    shadow_type,
 484                           gint             x,
 485                           gint             y,
 486                           gint             width,
 487                           gint             height);
 488 void gtk_draw_check      (GtkStyle        *style,
 489                           GdkWindow       *window,
 490                           GtkStateType     state_type,
 491                           GtkShadowType    shadow_type,
 492                           gint             x,
 493                           gint             y,
 494                           gint             width,
 495                           gint             height);
 496 void gtk_draw_option     (GtkStyle        *style,
 497                           GdkWindow       *window,
 498                           GtkStateType     state_type,
 499                           GtkShadowType    shadow_type,
 500                           gint             x,
 501                           gint             y,
 502                           gint             width,
 503                           gint             height);
 504 void gtk_draw_tab        (GtkStyle        *style,
 505                           GdkWindow       *window,
 506                           GtkStateType     state_type,
 507                           GtkShadowType    shadow_type,
 508                           gint             x,
 509                           gint             y,
 510                           gint             width,
 511                           gint             height);
 512 void gtk_draw_shadow_gap (GtkStyle        *style,
 513                           GdkWindow       *window,
 514                           GtkStateType     state_type,
 515                           GtkShadowType    shadow_type,
 516                           gint             x,
 517                           gint             y,
 518                           gint             width,
 519                           gint             height,
 520                           GtkPositionType  gap_side,
 521                           gint             gap_x,
 522                           gint             gap_width);
 523 void gtk_draw_box_gap    (GtkStyle        *style,
 524                           GdkWindow       *window,
 525                           GtkStateType     state_type,
 526                           GtkShadowType    shadow_type,
 527                           gint             x,
 528                           gint             y,
 529                           gint             width,
 530                           gint             height,
 531                           GtkPositionType  gap_side,
 532                           gint             gap_x,
 533                           gint             gap_width);
 534 void gtk_draw_extension  (GtkStyle        *style,
 535                           GdkWindow       *window,
 536                           GtkStateType     state_type,
 537                           GtkShadowType    shadow_type,
 538                           gint             x,
 539                           gint             y,
 540                           gint             width,
 541                           gint             height,
 542                           GtkPositionType  gap_side);
 543 void gtk_draw_focus      (GtkStyle        *style,
 544                           GdkWindow       *window,
 545                           gint             x,
 546                           gint             y,
 547                           gint             width,
 548                           gint             height);
 549 void gtk_draw_slider     (GtkStyle        *style,
 550                           GdkWindow       *window,
 551                           GtkStateType     state_type,
 552                           GtkShadowType    shadow_type,
 553                           gint             x,
 554                           gint             y,
 555                           gint             width,
 556                           gint             height,
 557                           GtkOrientation   orientation);
 558 void gtk_draw_handle     (GtkStyle        *style,
 559                           GdkWindow       *window,
 560                           GtkStateType     state_type,
 561                           GtkShadowType    shadow_type,
 562                           gint             x,
 563                           gint             y,
 564                           gint             width,
 565                           gint             height,
 566                           GtkOrientation   orientation);
 567 void gtk_draw_expander   (GtkStyle        *style,
 568                           GdkWindow       *window,
 569                           GtkStateType     state_type,
 570                           gint             x,
 571                           gint             y,
 572                           gboolean         is_open);
 573 void gtk_draw_layout     (GtkStyle        *style,
 574                           GdkWindow       *window,
 575                           GtkStateType     state_type,
 576                           gint             x,
 577                           gint             y,
 578                           PangoLayout     *layout);
 579
 580 void gtk_paint_hline      (GtkStyle        *style,
 581                            GdkWindow       *window,
 582                            GtkStateType     state_type,
 583                            GdkRectangle    *area,
 584                            GtkWidget       *widget,
 585                            const gchar     *detail,
 586                            gint             x1,
 587                            gint             x2,
 588                            gint             y);
 589 void gtk_paint_vline      (GtkStyle        *style,
 590                            GdkWindow       *window,
 591                            GtkStateType     state_type,
 592                            GdkRectangle    *area,
 593                            GtkWidget       *widget,
 594                            const gchar     *detail,
 595                            gint             y1,
 596                            gint             y2,
 597                            gint             x);
 598 void gtk_paint_shadow     (GtkStyle        *style,
 599                            GdkWindow       *window,
 600                            GtkStateType     state_type,
 601                            GtkShadowType    shadow_type,
 602                            GdkRectangle    *area,
 603                            GtkWidget       *widget,
 604                            const gchar     *detail,
 605                            gint             x,
 606                            gint             y,
 607                            gint             width,
 608                            gint             height);
 609 void gtk_paint_polygon    (GtkStyle        *style,
 610                            GdkWindow       *window,
 611                            GtkStateType     state_type,
 612                            GtkShadowType    shadow_type,
 613                            GdkRectangle    *area,
 614                            GtkWidget       *widget,
 615                            const gchar     *detail,
 616                            GdkPoint        *points,
 617                            gint             npoints,
 618                            gboolean         fill);
 619 void gtk_paint_arrow      (GtkStyle        *style,
 620                            GdkWindow       *window,
 621                            GtkStateType     state_type,
 622                            GtkShadowType    shadow_type,
 623                            GdkRectangle    *area,
 624                            GtkWidget       *widget,
 625                            const gchar     *detail,
 626                            GtkArrowType     arrow_type,
 627                            gboolean         fill,
 628                            gint             x,
 629                            gint             y,
 630                            gint             width,
 631                            gint             height);
 632 void gtk_paint_diamond    (GtkStyle        *style,
 633                            GdkWindow       *window,
 634                            GtkStateType     state_type,
 635                            GtkShadowType    shadow_type,
 636                            GdkRectangle    *area,
 637                            GtkWidget       *widget,
 638                            const gchar     *detail,
 639                            gint             x,
 640                            gint             y,
 641                            gint             width,
 642                            gint             height);
 643 #ifndef GTK_DISABLE_DEPRECATED
 644 void gtk_paint_string     (GtkStyle        *style,
 645                            GdkWindow       *window,
 646                            GtkStateType     state_type,
 647                            GdkRectangle    *area,
 648                            GtkWidget       *widget,
 649                            const gchar     *detail,
 650                            gint             x,
 651                            gint             y,
 652                            const gchar     *string);
 653 #endif /* GTK_DISABLE_DEPRECATED */
 654 void gtk_paint_box        (GtkStyle        *style,
 655                            GdkWindow       *window,
 656                            GtkStateType     state_type,
 657                            GtkShadowType    shadow_type,
 658                            GdkRectangle    *area,
 659                            GtkWidget       *widget,
 660                            const gchar     *detail,
 661                            gint             x,
 662                            gint             y,
 663                            gint             width,
 664                            gint             height);
 665 void gtk_paint_flat_box   (GtkStyle        *style,
 666                            GdkWindow       *window,
 667                            GtkStateType     state_type,
 668                            GtkShadowType    shadow_type,
 669                            GdkRectangle    *area,
 670                            GtkWidget       *widget,
 671                            const gchar     *detail,
 672                            gint             x,
 673                            gint             y,
 674                            gint             width,
 675                            gint             height);
 676 void gtk_paint_check      (GtkStyle        *style,
 677                            GdkWindow       *window,
 678                            GtkStateType     state_type,
 679                            GtkShadowType    shadow_type,
 680                            GdkRectangle    *area,
 681                            GtkWidget       *widget,
 682                            const gchar     *detail,
 683                            gint             x,
 684                            gint             y,
 685                            gint             width,
 686                            gint             height);
 687 void gtk_paint_option     (GtkStyle        *style,
 688                            GdkWindow       *window,
 689                            GtkStateType     state_type,
 690                            GtkShadowType    shadow_type,
 691                            GdkRectangle    *area,
 692                            GtkWidget       *widget,
 693                            const gchar     *detail,
 694                            gint             x,
 695                            gint             y,
 696                            gint             width,
 697                            gint             height);
 698 void gtk_paint_tab        (GtkStyle        *style,
 699                            GdkWindow       *window,
 700                            GtkStateType     state_type,
 701                            GtkShadowType    shadow_type,
 702                            GdkRectangle    *area,
 703                            GtkWidget       *widget,
 704                            const gchar     *detail,
 705                            gint             x,
 706                            gint             y,
 707                            gint             width,
 708                            gint             height);
 709 void gtk_paint_shadow_gap (GtkStyle        *style,
 710                            GdkWindow       *window,
 711                            GtkStateType     state_type,
 712                            GtkShadowType    shadow_type,
 713                            GdkRectangle    *area,
 714                            GtkWidget       *widget,
 715                            gchar           *detail,
 716                            gint             x,
 717                            gint             y,
 718                            gint             width,
 719                            gint             height,
 720                            GtkPositionType  gap_side,
 721                            gint             gap_x,
 722                            gint             gap_width);
 723 void gtk_paint_box_gap    (GtkStyle        *style,
 724                            GdkWindow       *window,
 725                            GtkStateType     state_type,
 726                            GtkShadowType    shadow_type,
 727                            GdkRectangle    *area,
 728                            GtkWidget       *widget,
 729                            gchar           *detail,
 730                            gint             x,
 731                            gint             y,
 732                            gint             width,
 733                            gint             height,
 734                            GtkPositionType  gap_side,
 735                            gint             gap_x,
 736                            gint             gap_width);
 737 void gtk_paint_extension  (GtkStyle        *style,
 738                            GdkWindow       *window,
 739                            GtkStateType     state_type,
 740                            GtkShadowType    shadow_type,
 741                            GdkRectangle    *area,
 742                            GtkWidget       *widget,
 743                            gchar           *detail,
 744                            gint             x,
 745                            gint             y,
 746                            gint             width,
 747                            gint             height,
 748                            GtkPositionType  gap_side);
 749 void gtk_paint_focus      (GtkStyle        *style,
 750                            GdkWindow       *window,
 751                            GdkRectangle    *area,
 752                            GtkWidget       *widget,
 753                            const gchar     *detail,
 754                            gint             x,
 755                            gint             y,
 756                            gint             width,
 757                            gint             height);
 758 void gtk_paint_slider     (GtkStyle        *style,
 759                            GdkWindow       *window,
 760                            GtkStateType     state_type,
 761                            GtkShadowType    shadow_type,
 762                            GdkRectangle    *area,
 763                            GtkWidget       *widget,
 764                            const gchar     *detail,
 765                            gint             x,
 766                            gint             y,
 767                            gint             width,
 768                            gint             height,
 769                            GtkOrientation   orientation);
 770 void gtk_paint_handle     (GtkStyle        *style,
 771                            GdkWindow       *window,
 772                            GtkStateType     state_type,
 773                            GtkShadowType    shadow_type,
 774                            GdkRectangle    *area,
 775                            GtkWidget       *widget,
 776                            const gchar     *detail,
 777                            gint             x,
 778                            gint             y,
 779                            gint             width,
 780                            gint             height,
 781                            GtkOrientation   orientation);
 782 void gtk_paint_expander   (GtkStyle        *style,
 783                            GdkWindow       *window,
 784                            GtkStateType     state_type,
 785                            GdkRectangle    *area,
 786                            GtkWidget       *widget,
 787                            const gchar     *detail,
 788                            gint             x,
 789                            gint             y,
 790                            gboolean         is_open);
 791 void gtk_paint_layout     (GtkStyle        *style,
 792                            GdkWindow       *window,
 793                            GtkStateType     state_type,
 794                            GdkRectangle    *area,
 795                            GtkWidget       *widget,
 796                            const gchar     *detail,
 797                            gint             x,
 798                            gint             y,
 799                            PangoLayout     *layout);
 800
 801
 802 #ifdef __cplusplus
 803 }
 804 #endif /* __cplusplus */
 805
 806
 807 #endif /* __GTK_STYLE_H__ */