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 #if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
  28 #error "Only <gtk/gtk.h> can be included directly."
  29 #endif
  30
  31 #ifndef __GTK_STYLE_H__
  32 #define __GTK_STYLE_H__
  33
  34
  35 #include <gdk/gdk.h>
  36 #include <gtk/gtkenums.h>
  37
  38
  39 G_BEGIN_DECLS
  40
  41 #define GTK_TYPE_STYLE              (gtk_style_get_type ())
  42 #define GTK_STYLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_STYLE, GtkStyle))
  43 #define GTK_STYLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STYLE, GtkStyleClass))
  44 #define GTK_IS_STYLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_STYLE))
  45 #define GTK_IS_STYLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STYLE))
  46 #define GTK_STYLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STYLE, GtkStyleClass))
  47
  48 #define GTK_TYPE_BORDER             (gtk_border_get_type ())
  49
  50 /* Some forward declarations needed to rationalize the header
  51  * files.
  52  */
  53 typedef struct _GtkBorder      GtkBorder;
  54 typedef struct _GtkStyle       GtkStyle;
  55 typedef struct _GtkStyleClass  GtkStyleClass;
  56 typedef struct _GtkThemeEngine GtkThemeEngine;
  57 typedef struct _GtkRcStyle     GtkRcStyle;
  58 typedef struct _GtkIconSet     GtkIconSet;
  59 typedef struct _GtkIconSource  GtkIconSource;
  60 typedef struct _GtkRcProperty  GtkRcProperty;
  61 typedef struct _GtkSettings    GtkSettings;
  62 typedef gboolean (*GtkRcPropertyParser) (const GParamSpec *pspec,
  63                                          const GString    *rc_string,
  64                                          GValue           *property_value);
  65
  66 /* We make this forward declaration here, since we pass
  67  * GtkWidget's to the draw functions.
  68  */
  69 typedef struct _GtkWidget      GtkWidget;
  70
  71 /**
  72  * GTK_STYLE_ATTACHED:
  73  * @style: a #GtkStyle.
  74  *
  75  * Returns whether the style is attached to a window.
  76  */
  77 #define GTK_STYLE_ATTACHED(style)       (GTK_STYLE (style)->attach_count > 0)
  78
  79 struct _GtkStyle
  80 {
  81   GObject parent_instance;
  82
  83   /*< public >*/
  84
  85   GdkColor fg[5];
  86   GdkColor bg[5];
  87   GdkColor light[5];
  88   GdkColor dark[5];
  89   GdkColor mid[5];
  90   GdkColor text[5];
  91   GdkColor base[5];
  92   GdkColor text_aa[5];          /* Halfway between text/base */
  93
  94   GdkColor black;
  95   GdkColor white;
  96   PangoFontDescription *font_desc;
  97
  98   gint xthickness;
  99   gint ythickness;
 100
 101   cairo_pattern_t *background[5];
 102
 103   /*< private >*/
 104
 105   gint attach_count;
 106
 107   GdkVisual *visual;
 108   PangoFontDescription *private_font_desc; /* Font description for style->private_font or %NULL */
 109
 110   /* the RcStyle from which this style was created */
 111   GtkRcStyle     *rc_style;
 112
 113   GSList         *styles;         /* of type GtkStyle* */
 114   GArray         *property_cache;
 115   GSList         *icon_factories; /* of type GtkIconFactory* */
 116 };
 117
 118 struct _GtkStyleClass
 119 {
 120   GObjectClass parent_class;
 121
 122   /* Initialize for a particular visual. style->visual
 123    * will have been set at this point. Will typically chain
 124    * to parent.
 125    */
 126   void (*realize)               (GtkStyle               *style);
 127
 128   /* Clean up for a particular visual. Will typically chain
 129    * 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                                  cairo_t                *cr,
 169                                  GtkStateType            state_type,
 170                                  GtkWidget              *widget,
 171                                  const gchar            *detail,
 172                                  gint                    x1,
 173                                  gint                    x2,
 174                                  gint                    y);
 175   void (*draw_vline)            (GtkStyle               *style,
 176                                  cairo_t                *cr,
 177                                  GtkStateType            state_type,
 178                                  GtkWidget              *widget,
 179                                  const gchar            *detail,
 180                                  gint                    y1_,
 181                                  gint                    y2_,
 182                                  gint                    x);
 183   void (*draw_shadow)           (GtkStyle               *style,
 184                                  cairo_t                *cr,
 185                                  GtkStateType            state_type,
 186                                  GtkShadowType           shadow_type,
 187                                  GtkWidget              *widget,
 188                                  const gchar            *detail,
 189                                  gint                    x,
 190                                  gint                    y,
 191                                  gint                    width,
 192                                  gint                    height);
 193   void (*draw_arrow)            (GtkStyle               *style,
 194                                  cairo_t                *cr,
 195                                  GtkStateType            state_type,
 196                                  GtkShadowType           shadow_type,
 197                                  GtkWidget              *widget,
 198                                  const gchar            *detail,
 199                                  GtkArrowType            arrow_type,
 200                                  gboolean                fill,
 201                                  gint                    x,
 202                                  gint                    y,
 203                                  gint                    width,
 204                                  gint                    height);
 205   void (*draw_diamond)          (GtkStyle               *style,
 206                                  cairo_t                *cr,
 207                                  GtkStateType            state_type,
 208                                  GtkShadowType           shadow_type,
 209                                  GtkWidget              *widget,
 210                                  const gchar            *detail,
 211                                  gint                    x,
 212                                  gint                    y,
 213                                  gint                    width,
 214                                  gint                    height);
 215   void (*draw_box)              (GtkStyle               *style,
 216                                  cairo_t                *cr,
 217                                  GtkStateType            state_type,
 218                                  GtkShadowType           shadow_type,
 219                                  GtkWidget              *widget,
 220                                  const gchar            *detail,
 221                                  gint                    x,
 222                                  gint                    y,
 223                                  gint                    width,
 224                                  gint                    height);
 225   void (*draw_flat_box)         (GtkStyle               *style,
 226                                  cairo_t                *cr,
 227                                  GtkStateType            state_type,
 228                                  GtkShadowType           shadow_type,
 229                                  GtkWidget              *widget,
 230                                  const gchar            *detail,
 231                                  gint                    x,
 232                                  gint                    y,
 233                                  gint                    width,
 234                                  gint                    height);
 235   void (*draw_check)            (GtkStyle               *style,
 236                                  cairo_t                *cr,
 237                                  GtkStateType            state_type,
 238                                  GtkShadowType           shadow_type,
 239                                  GtkWidget              *widget,
 240                                  const gchar            *detail,
 241                                  gint                    x,
 242                                  gint                    y,
 243                                  gint                    width,
 244                                  gint                    height);
 245   void (*draw_option)           (GtkStyle               *style,
 246                                  cairo_t                *cr,
 247                                  GtkStateType            state_type,
 248                                  GtkShadowType           shadow_type,
 249                                  GtkWidget              *widget,
 250                                  const gchar            *detail,
 251                                  gint                    x,
 252                                  gint                    y,
 253                                  gint                    width,
 254                                  gint                    height);
 255   void (*draw_tab)              (GtkStyle               *style,
 256                                  cairo_t                *cr,
 257                                  GtkStateType            state_type,
 258                                  GtkShadowType           shadow_type,
 259                                  GtkWidget              *widget,
 260                                  const gchar            *detail,
 261                                  gint                    x,
 262                                  gint                    y,
 263                                  gint                    width,
 264                                  gint                    height);
 265   void (*draw_shadow_gap)       (GtkStyle               *style,
 266                                  cairo_t                *cr,
 267                                  GtkStateType            state_type,
 268                                  GtkShadowType           shadow_type,
 269                                  GtkWidget              *widget,
 270                                  const gchar            *detail,
 271                                  gint                    x,
 272                                  gint                    y,
 273                                  gint                    width,
 274                                  gint                    height,
 275                                  GtkPositionType         gap_side,
 276                                  gint                    gap_x,
 277                                  gint                    gap_width);
 278   void (*draw_box_gap)          (GtkStyle               *style,
 279                                  cairo_t                *cr,
 280                                  GtkStateType            state_type,
 281                                  GtkShadowType           shadow_type,
 282                                  GtkWidget              *widget,
 283                                  const gchar            *detail,
 284                                  gint                    x,
 285                                  gint                    y,
 286                                  gint                    width,
 287                                  gint                    height,
 288                                  GtkPositionType         gap_side,
 289                                  gint                    gap_x,
 290                                  gint                    gap_width);
 291   void (*draw_extension)        (GtkStyle               *style,
 292                                  cairo_t                *cr,
 293                                  GtkStateType            state_type,
 294                                  GtkShadowType           shadow_type,
 295                                  GtkWidget              *widget,
 296                                  const gchar            *detail,
 297                                  gint                    x,
 298                                  gint                    y,
 299                                  gint                    width,
 300                                  gint                    height,
 301                                  GtkPositionType         gap_side);
 302   void (*draw_focus)            (GtkStyle               *style,
 303                                  cairo_t                *cr,
 304                                  GtkStateType            state_type,
 305                                  GtkWidget              *widget,
 306                                  const gchar            *detail,
 307                                  gint                    x,
 308                                  gint                    y,
 309                                  gint                    width,
 310                                  gint                    height);
 311   void (*draw_slider)           (GtkStyle               *style,
 312                                  cairo_t                *cr,
 313                                  GtkStateType            state_type,
 314                                  GtkShadowType           shadow_type,
 315                                  GtkWidget              *widget,
 316                                  const gchar            *detail,
 317                                  gint                    x,
 318                                  gint                    y,
 319                                  gint                    width,
 320                                  gint                    height,
 321                                  GtkOrientation          orientation);
 322   void (*draw_handle)           (GtkStyle               *style,
 323                                  cairo_t                *cr,
 324                                  GtkStateType            state_type,
 325                                  GtkShadowType           shadow_type,
 326                                  GtkWidget              *widget,
 327                                  const gchar            *detail,
 328                                  gint                    x,
 329                                  gint                    y,
 330                                  gint                    width,
 331                                  gint                    height,
 332                                  GtkOrientation          orientation);
 333
 334   void (*draw_expander)         (GtkStyle               *style,
 335                                  cairo_t                *cr,
 336                                  GtkStateType            state_type,
 337                                  GtkWidget              *widget,
 338                                  const gchar            *detail,
 339                                  gint                    x,
 340                                  gint                    y,
 341                                  GtkExpanderStyle        expander_style);
 342   void (*draw_layout)           (GtkStyle               *style,
 343                                  cairo_t                *cr,
 344                                  GtkStateType            state_type,
 345                                  gboolean                use_text,
 346                                  GtkWidget              *widget,
 347                                  const gchar            *detail,
 348                                  gint                    x,
 349                                  gint                    y,
 350                                  PangoLayout            *layout);
 351   void (*draw_resize_grip)      (GtkStyle               *style,
 352                                  cairo_t                *cr,
 353                                  GtkStateType            state_type,
 354                                  GtkWidget              *widget,
 355                                  const gchar            *detail,
 356                                  GdkWindowEdge           edge,
 357                                  gint                    x,
 358                                  gint                    y,
 359                                  gint                    width,
 360                                  gint                    height);
 361   void (*draw_spinner)          (GtkStyle               *style,
 362                                  cairo_t                *cr,
 363                                  GtkStateType            state_type,
 364                                  GtkWidget              *widget,
 365                                  const gchar            *detail,
 366                                  guint                   step,
 367                                  gint                    x,
 368                                  gint                    y,
 369                                  gint                    width,
 370                                  gint                    height);
 371
 372   /* Padding for future expansion */
 373   void (*_gtk_reserved1)  (void);
 374   void (*_gtk_reserved2)  (void);
 375   void (*_gtk_reserved3)  (void);
 376   void (*_gtk_reserved4)  (void);
 377   void (*_gtk_reserved5)  (void);
 378   void (*_gtk_reserved6)  (void);
 379   void (*_gtk_reserved7)  (void);
 380   void (*_gtk_reserved8)  (void);
 381   void (*_gtk_reserved9)  (void);
 382   void (*_gtk_reserved10) (void);
 383   void (*_gtk_reserved11) (void);
 384 };
 385
 386 /**
 387  * GtkBorder:
 388  * @left: The width of the left border.
 389  * @right: The width of the right border.
 390  * @top: The width of the top border.
 391  * @bottom: The width of the bottom border.
 392  *
 393  * A struct that specifies a border around a rectangular area that can
 394  * be of different width on each side.
 395  */
 396 struct _GtkBorder
 397 {
 398   gint16 left;
 399   gint16 right;
 400   gint16 top;
 401   gint16 bottom;
 402 };
 403
 404 GType     gtk_style_get_type                 (void) G_GNUC_CONST;
 405 GtkStyle* gtk_style_new                      (void);
 406 GtkStyle* gtk_style_copy                     (GtkStyle     *style);
 407 GtkStyle* gtk_style_attach                   (GtkStyle     *style,
 408                                               GdkWindow    *window) G_GNUC_WARN_UNUSED_RESULT;
 409 void      gtk_style_detach                   (GtkStyle     *style);
 410 void      gtk_style_set_background           (GtkStyle     *style,
 411                                               GdkWindow    *window,
 412                                               GtkStateType  state_type);
 413 void      gtk_style_apply_default_background (GtkStyle     *style,
 414                                               cairo_t      *cr,
 415                                               GdkWindow    *window,
 416                                               GtkStateType  state_type,
 417                                               gint          x,
 418                                               gint          y,
 419                                               gint          width,
 420                                               gint          height);
 421
 422 GtkIconSet* gtk_style_lookup_icon_set        (GtkStyle     *style,
 423                                               const gchar  *stock_id);
 424 gboolean    gtk_style_lookup_color           (GtkStyle     *style,
 425                                               const gchar  *color_name,
 426                                               GdkColor     *color);
 427
 428 GdkPixbuf*  gtk_style_render_icon     (GtkStyle            *style,
 429                                        const GtkIconSource *source,
 430                                        GtkTextDirection     direction,
 431                                        GtkStateType         state,
 432                                        GtkIconSize          size,
 433                                        GtkWidget           *widget,
 434                                        const gchar         *detail);
 435
 436 void gtk_paint_hline             (GtkStyle           *style,
 437                                   cairo_t            *cr,
 438                                   GtkStateType        state_type,
 439                                   GtkWidget          *widget,
 440                                   const gchar        *detail,
 441                                   gint                x1,
 442                                   gint                x2,
 443                                   gint                y);
 444 void gtk_paint_vline             (GtkStyle           *style,
 445                                   cairo_t            *cr,
 446                                   GtkStateType        state_type,
 447                                   GtkWidget          *widget,
 448                                   const gchar        *detail,
 449                                   gint                y1_,
 450                                   gint                y2_,
 451                                   gint                x);
 452 void gtk_paint_shadow            (GtkStyle           *style,
 453                                   cairo_t            *cr,
 454                                   GtkStateType        state_type,
 455                                   GtkShadowType       shadow_type,
 456                                   GtkWidget          *widget,
 457                                   const gchar        *detail,
 458                                   gint                x,
 459                                   gint                y,
 460                                   gint                width,
 461                                   gint                height);
 462 void gtk_paint_arrow             (GtkStyle           *style,
 463                                   cairo_t            *cr,
 464                                   GtkStateType        state_type,
 465                                   GtkShadowType       shadow_type,
 466                                   GtkWidget          *widget,
 467                                   const gchar        *detail,
 468                                   GtkArrowType        arrow_type,
 469                                   gboolean            fill,
 470                                   gint                x,
 471                                   gint                y,
 472                                   gint                width,
 473                                   gint                height);
 474 void gtk_paint_diamond           (GtkStyle           *style,
 475                                   cairo_t            *cr,
 476                                   GtkStateType        state_type,
 477                                   GtkShadowType       shadow_type,
 478                                   GtkWidget          *widget,
 479                                   const gchar        *detail,
 480                                   gint                x,
 481                                   gint                y,
 482                                   gint                width,
 483                                   gint                height);
 484 void gtk_paint_box               (GtkStyle           *style,
 485                                   cairo_t            *cr,
 486                                   GtkStateType        state_type,
 487                                   GtkShadowType       shadow_type,
 488                                   GtkWidget          *widget,
 489                                   const gchar        *detail,
 490                                   gint                x,
 491                                   gint                y,
 492                                   gint                width,
 493                                   gint                height);
 494 void gtk_paint_flat_box          (GtkStyle           *style,
 495                                   cairo_t            *cr,
 496                                   GtkStateType        state_type,
 497                                   GtkShadowType       shadow_type,
 498                                   GtkWidget          *widget,
 499                                   const gchar        *detail,
 500                                   gint                x,
 501                                   gint                y,
 502                                   gint                width,
 503                                   gint                height);
 504 void gtk_paint_check             (GtkStyle           *style,
 505                                   cairo_t            *cr,
 506                                   GtkStateType        state_type,
 507                                   GtkShadowType       shadow_type,
 508                                   GtkWidget          *widget,
 509                                   const gchar        *detail,
 510                                   gint                x,
 511                                   gint                y,
 512                                   gint                width,
 513                                   gint                height);
 514 void gtk_paint_option            (GtkStyle           *style,
 515                                   cairo_t            *cr,
 516                                   GtkStateType        state_type,
 517                                   GtkShadowType       shadow_type,
 518                                   GtkWidget          *widget,
 519                                   const gchar        *detail,
 520                                   gint                x,
 521                                   gint                y,
 522                                   gint                width,
 523                                   gint                height);
 524 void gtk_paint_tab               (GtkStyle           *style,
 525                                   cairo_t            *cr,
 526                                   GtkStateType        state_type,
 527                                   GtkShadowType       shadow_type,
 528                                   GtkWidget          *widget,
 529                                   const gchar        *detail,
 530                                   gint                x,
 531                                   gint                y,
 532                                   gint                width,
 533                                   gint                height);
 534 void gtk_paint_shadow_gap        (GtkStyle           *style,
 535                                   cairo_t            *cr,
 536                                   GtkStateType        state_type,
 537                                   GtkShadowType       shadow_type,
 538                                   GtkWidget          *widget,
 539                                   const gchar        *detail,
 540                                   gint                x,
 541                                   gint                y,
 542                                   gint                width,
 543                                   gint                height,
 544                                   GtkPositionType     gap_side,
 545                                   gint                gap_x,
 546                                   gint                gap_width);
 547 void gtk_paint_box_gap           (GtkStyle           *style,
 548                                   cairo_t            *cr,
 549                                   GtkStateType        state_type,
 550                                   GtkShadowType       shadow_type,
 551                                   GtkWidget          *widget,
 552                                   const gchar        *detail,
 553                                   gint                x,
 554                                   gint                y,
 555                                   gint                width,
 556                                   gint                height,
 557                                   GtkPositionType     gap_side,
 558                                   gint                gap_x,
 559                                   gint                gap_width);
 560 void gtk_paint_extension         (GtkStyle           *style,
 561                                   cairo_t            *cr,
 562                                   GtkStateType        state_type,
 563                                   GtkShadowType       shadow_type,
 564                                   GtkWidget          *widget,
 565                                   const gchar        *detail,
 566                                   gint                x,
 567                                   gint                y,
 568                                   gint                width,
 569                                   gint                height,
 570                                   GtkPositionType     gap_side);
 571 void gtk_paint_focus             (GtkStyle           *style,
 572                                   cairo_t            *cr,
 573                                   GtkStateType        state_type,
 574                                   GtkWidget          *widget,
 575                                   const gchar        *detail,
 576                                   gint                x,
 577                                   gint                y,
 578                                   gint                width,
 579                                   gint                height);
 580 void gtk_paint_slider            (GtkStyle           *style,
 581                                   cairo_t            *cr,
 582                                   GtkStateType        state_type,
 583                                   GtkShadowType       shadow_type,
 584                                   GtkWidget          *widget,
 585                                   const gchar        *detail,
 586                                   gint                x,
 587                                   gint                y,
 588                                   gint                width,
 589                                   gint                height,
 590                                   GtkOrientation      orientation);
 591 void gtk_paint_handle            (GtkStyle           *style,
 592                                   cairo_t            *cr,
 593                                   GtkStateType        state_type,
 594                                   GtkShadowType       shadow_type,
 595                                   GtkWidget          *widget,
 596                                   const gchar        *detail,
 597                                   gint                x,
 598                                   gint                y,
 599                                   gint                width,
 600                                   gint                height,
 601                                   GtkOrientation      orientation);
 602 void gtk_paint_expander          (GtkStyle           *style,
 603                                   cairo_t            *cr,
 604                                   GtkStateType        state_type,
 605                                   GtkWidget          *widget,
 606                                   const gchar        *detail,
 607                                   gint                x,
 608                                   gint                y,
 609                                   GtkExpanderStyle    expander_style);
 610 void gtk_paint_layout            (GtkStyle           *style,
 611                                   cairo_t            *cr,
 612                                   GtkStateType        state_type,
 613                                   gboolean            use_text,
 614                                   GtkWidget          *widget,
 615                                   const gchar        *detail,
 616                                   gint                x,
 617                                   gint                y,
 618                                   PangoLayout        *layout);
 619 void gtk_paint_resize_grip       (GtkStyle           *style,
 620                                   cairo_t            *cr,
 621                                   GtkStateType        state_type,
 622                                   GtkWidget          *widget,
 623                                   const gchar        *detail,
 624                                   GdkWindowEdge       edge,
 625                                   gint                x,
 626                                   gint                y,
 627                                   gint                width,
 628                                   gint                height);
 629 void gtk_paint_spinner           (GtkStyle           *style,
 630                                   cairo_t            *cr,
 631                                   GtkStateType        state_type,
 632                                   GtkWidget          *widget,
 633                                   const gchar        *detail,
 634                                   guint               step,
 635                                   gint                x,
 636                                   gint                y,
 637                                   gint                width,
 638                                   gint                height);
 639
 640
 641 GType      gtk_border_get_type (void) G_GNUC_CONST;
 642 GtkBorder *gtk_border_new      (void) G_GNUC_MALLOC;
 643 GtkBorder *gtk_border_copy     (const GtkBorder *border_);
 644 void       gtk_border_free     (GtkBorder       *border_);
 645
 646 void gtk_style_get_style_property (GtkStyle    *style,
 647                                    GType        widget_type,
 648                                    const gchar *property_name,
 649                                    GValue      *value);
 650 void gtk_style_get_valist         (GtkStyle    *style,
 651                                    GType        widget_type,
 652                                    const gchar *first_property_name,
 653                                    va_list      var_args);
 654 void gtk_style_get                (GtkStyle    *style,
 655                                    GType        widget_type,
 656                                    const gchar *first_property_name,
 657                                    ...) G_GNUC_NULL_TERMINATED;
 658
 659 /* --- private API --- */
 660 const GValue* _gtk_style_peek_property_value (GtkStyle           *style,
 661                                               GType               widget_type,
 662                                               GParamSpec         *pspec,
 663                                               GtkRcPropertyParser parser);
 664
 665 void          _gtk_style_init_for_settings   (GtkStyle           *style,
 666                                               GtkSettings        *settings);
 667
 668 void          _gtk_style_shade               (const GdkColor     *a,
 669                                               GdkColor           *b,
 670                                               gdouble             k);
 671
 672 void   gtk_draw_insertion_cursor    (GtkWidget          *widget,
 673                                      cairo_t            *cr,
 674                                      const GdkRectangle *location,
 675                                      gboolean            is_primary,
 676                                      GtkTextDirection    direction,
 677                                      gboolean            draw_arrow);
 678 void   _gtk_widget_get_cursor_color (GtkWidget          *widget,
 679                                      GdkColor           *color);
 680
 681 G_END_DECLS
 682
 683 #endif /* __GTK_STYLE_H__ */