gtkD/src/gtk/Style.d

   1 /*
   2  * This file is part of gtkD.
   3  *
   4  * gtkD is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * gtkD 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
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with gtkD; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  = GtkStyle.html
  26  * outPack = gtk
  27  * outFile = Style
  28  * strct   = GtkStyle
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = Style
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_style_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  *      - glib.Str
  46  *      - gtk.Style
  47  *      - gdk.Window
  48  *      - gdk.Rectangle
  49  *      - gdk.Pixbuf
  50  *      - gtk.IconSource
  51  *      - gtk.Widget
  52  *      - gdk.Font
  53  *      - gdk.Drawable
  54  * structWrap:
  55  *      - GdkDrawable* -> Drawable
  56  *      - GdkFont* -> Font
  57  *      - GdkPixbuf* -> Pixbuf
  58  *      - GdkRectangle* -> Rectangle
  59  *      - GdkWindow* -> Window
  60  *      - GtkIconSource* -> IconSource
  61  *      - GtkStyle* -> Style
  62  *      - GtkWidget* -> Widget
  63  * module aliases:
  64  * local aliases:
  65  */
  66
  67 module gtk.Style;
  68
  69 version(noAssert)
  70 {
  71         version(Tango)
  72         {
  73                 import tango.io.Stdout; // use the tango loging?
  74         }
  75 }
  76
  77 private import gtkc.gtktypes;
  78
  79 private import gtkc.gtk;
  80
  81
  82 private import glib.Str;
  83 private import gtk.Style;
  84 private import gdk.Window;
  85 private import gdk.Rectangle;
  86 private import gdk.Pixbuf;
  87 private import gtk.IconSource;
  88 private import gtk.Widget;
  89 private import gdk.Font;
  90 private import gdk.Drawable;
  91
  92
  93
  94
  95 /**
  96  * Description
  97  */
  98 private import gobject.ObjectG;
  99 public class Style : ObjectG
 100 {
 101
 102         /** the main Gtk struct */
 103         protected GtkStyle* gtkStyle;
 104
 105
 106         public GtkStyle* getStyleStruct()
 107         {
 108                 return gtkStyle;
 109         }
 110
 111
 112         /** the main Gtk struct as a void* */
 113         protected void* getStruct()
 114         {
 115                 return cast(void*)gtkStyle;
 116         }
 117
 118         /**
 119          * Sets our main struct and passes it to the parent class
 120          */
 121         public this (GtkStyle* gtkStyle)
 122         {
 123                 version(noAssert)
 124                 {
 125                         if ( gtkStyle is null )
 126                         {
 127                                 int zero = 0;
 128                                 version(Tango)
 129                                 {
 130                                         Stdout("struct gtkStyle is null on constructor").newline;
 131                                 }
 132                                 else
 133                                 {
 134                                         printf("struct gtkStyle is null on constructor");
 135                                 }
 136                                 zero = zero / zero;
 137                         }
 138                 }
 139                 else
 140                 {
 141                         assert(gtkStyle !is null, "struct gtkStyle is null on constructor");
 142                 }
 143                 super(cast(GObject*)gtkStyle);
 144                 this.gtkStyle = gtkStyle;
 145         }
 146
 147         /**
 148          */
 149
 150         // imports for the signal processing
 151         private import gobject.Signals;
 152         private import gtkc.gdktypes;
 153         int[char[]] connectedSignals;
 154
 155         void delegate(Style)[] onRealizeListeners;
 156         void addOnRealize(void delegate(Style) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 157         {
 158                 if ( !("realize" in connectedSignals) )
 159                 {
 160                         Signals.connectData(
 161                         getStruct(),
 162                         "realize",
 163                         cast(GCallback)&callBackRealize,
 164                         cast(void*)this,
 165                         null,
 166                         connectFlags);
 167                         connectedSignals["realize"] = 1;
 168                 }
 169                 onRealizeListeners ~= dlg;
 170         }
 171         extern(C) static void callBackRealize(GtkStyle* styleStruct, Style style)
 172         {
 173                 bool consumed = false;
 174
 175                 foreach ( void delegate(Style) dlg ; style.onRealizeListeners )
 176                 {
 177                         dlg(style);
 178                 }
 179
 180                 return consumed;
 181         }
 182
 183         void delegate(Style)[] onUnrealizeListeners;
 184         void addOnUnrealize(void delegate(Style) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 185         {
 186                 if ( !("unrealize" in connectedSignals) )
 187                 {
 188                         Signals.connectData(
 189                         getStruct(),
 190                         "unrealize",
 191                         cast(GCallback)&callBackUnrealize,
 192                         cast(void*)this,
 193                         null,
 194                         connectFlags);
 195                         connectedSignals["unrealize"] = 1;
 196                 }
 197                 onUnrealizeListeners ~= dlg;
 198         }
 199         extern(C) static void callBackUnrealize(GtkStyle* styleStruct, Style style)
 200         {
 201                 bool consumed = false;
 202
 203                 foreach ( void delegate(Style) dlg ; style.onUnrealizeListeners )
 204                 {
 205                         dlg(style);
 206                 }
 207
 208                 return consumed;
 209         }
 210
 211
 212
 213
 214         /**
 215          * Creates a new GtkStyle.
 216          * Returns:
 217          *  a new GtkStyle.
 218          */
 219         public this ()
 220         {
 221                 // GtkStyle* gtk_style_new (void);
 222                 this(cast(GtkStyle*)gtk_style_new() );
 223         }
 224
 225         /**
 226          * style:
 227          * Returns:
 228          */
 229         public Style copy()
 230         {
 231                 // GtkStyle* gtk_style_copy (GtkStyle *style);
 232                 return new Style( gtk_style_copy(gtkStyle) );
 233         }
 234
 235         /**
 236          * Attaches a style to a window; this process allocates the
 237          * colors and creates the GC's for the style - it specializes
 238          * it to a particular visual and colormap. The process may
 239          * involve the creation of a new style if the style has already
 240          * been attached to a window with a different style and colormap.
 241          * Since this function may return a new object, you have to use it
 242          * in the following way:
 243          * style = gtk_style_attach (style, window)
 244          * style:
 245          *  a GtkStyle.
 246          * window:
 247          *  a GdkWindow.
 248          * Returns:
 249          *  Either style, or a newly-created GtkStyle.
 250          *  If the style is newly created, the style parameter
 251          *  will be unref'ed, and the new style will have
 252          *  a reference count belonging to the caller.
 253          */
 254         public Style attach(Window window)
 255         {
 256                 // GtkStyle* gtk_style_attach (GtkStyle *style,  GdkWindow *window);
 257                 return new Style( gtk_style_attach(gtkStyle, (window is null) ? null : window.getWindowStruct()) );
 258         }
 259
 260         /**
 261          * Detaches a style from a window. If the style is not attached
 262          * to any windows anymore, it is unrealized. See gtk_style_attach().
 263          * style:
 264          *  a GtkStyle
 265          */
 266         public void detach()
 267         {
 268                 // void gtk_style_detach (GtkStyle *style);
 269                 gtk_style_detach(gtkStyle);
 270         }
 271
 272         /**
 273          * Warning
 274          * gtk_style_ref is deprecated and should not be used in newly-written code.
 275          * Deprecated equivalent of g_object_ref().
 276          * style:
 277          *  a GtkStyle.
 278          * Returns:
 279          *  style.
 280          */
 281         public Style doref()
 282         {
 283                 // GtkStyle* gtk_style_ref (GtkStyle *style);
 284                 return new Style( gtk_style_ref(gtkStyle) );
 285         }
 286
 287         /**
 288          * Warning
 289          * gtk_style_unref is deprecated and should not be used in newly-written code.
 290          * Deprecated equivalent of g_object_unref().
 291          * style:
 292          *  a GtkStyle.
 293          */
 294         public void unref()
 295         {
 296                 // void gtk_style_unref (GtkStyle *style);
 297                 gtk_style_unref(gtkStyle);
 298         }
 299
 300         /**
 301          * Sets the background of window to the background color or pixmap
 302          * specified by style for the given state.
 303          * style:
 304          *  a GtkStyle
 305          * window:
 306          *  a GdkWindow
 307          * state_type:
 308          *  a state
 309          */
 310         public void setBackground(Window window, GtkStateType stateType)
 311         {
 312                 // void gtk_style_set_background (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type);
 313                 gtk_style_set_background(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType);
 314         }
 315
 316         /**
 317          * style:
 318          * window:
 319          * set_bg:
 320          * state_type:
 321          * area:
 322          * x:
 323          * y:
 324          * width:
 325          * height:
 326          */
 327         public void applyDefaultBackground(Window window, int setBg, GtkStateType stateType, Rectangle area, int x, int y, int width, int height)
 328         {
 329                 // void gtk_style_apply_default_background (GtkStyle *style,  GdkWindow *window,  gboolean set_bg,  GtkStateType state_type,  GdkRectangle *area,  gint x,  gint y,  gint width,  gint height);
 330                 gtk_style_apply_default_background(gtkStyle, (window is null) ? null : window.getWindowStruct(), setBg, stateType, (area is null) ? null : area.getRectangleStruct(), x, y, width, height);
 331         }
 332
 333
 334         /**
 335          * Looks up color_name in the style's logical color mappings,
 336          * filling in color and returning TRUE if found, otherwise
 337          * returning FALSE. Do not cache the found mapping, because
 338          * it depends on the GtkStyle and might change when a theme
 339          * switch occurs.
 340          * style:
 341          *  a GtkStyle
 342          * color_name:
 343          *  the name of the logical color to look up
 344          * color:
 345          *  the GdkColor to fill in
 346          * Returns:
 347          *  TRUE if the mapping was found.
 348          * Since 2.10
 349          */
 350         public int lookupColor(char[] colorName, GdkColor* color)
 351         {
 352                 // gboolean gtk_style_lookup_color (GtkStyle *style,  const gchar *color_name,  GdkColor *color);
 353                 return gtk_style_lookup_color(gtkStyle, Str.toStringz(colorName), color);
 354         }
 355
 356         /**
 357          * style:
 358          * stock_id:
 359          * Returns:
 360          */
 361         public GtkIconSet* lookupIconSet(char[] stockId)
 362         {
 363                 // GtkIconSet* gtk_style_lookup_icon_set (GtkStyle *style,  const gchar *stock_id);
 364                 return gtk_style_lookup_icon_set(gtkStyle, Str.toStringz(stockId));
 365         }
 366
 367         /**
 368          * Renders the icon specified by source at the given size
 369          * according to the given parameters and returns the result in a
 370          * pixbuf.
 371          * style:
 372          *  a GtkStyle
 373          * source:
 374          *  the GtkIconSource specifying the icon to render
 375          * direction:
 376          *  a text direction
 377          * state:
 378          *  a state
 379          * size:
 380          *  the size to render the icon at. A size of (GtkIconSize)-1
 381          *  means render at the size of the source and don't scale.
 382          * widget:
 383          *  the widget
 384          * detail:
 385          *  a style detail
 386          * Returns:
 387          *  a newly-created GdkPixbuf containing the rendered icon
 388          */
 389         public Pixbuf renderIcon(IconSource source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, Widget widget, char[] detail)
 390         {
 391                 // GdkPixbuf* gtk_style_render_icon (GtkStyle *style,  const GtkIconSource *source,  GtkTextDirection direction,  GtkStateType state,  GtkIconSize size,  GtkWidget *widget,  const gchar *detail);
 392                 return new Pixbuf( gtk_style_render_icon(gtkStyle, (source is null) ? null : source.getIconSourceStruct(), direction, state, size, (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail)) );
 393         }
 394
 395         /**
 396          * Warning
 397          * gtk_style_get_font is deprecated and should not be used in newly-written code.
 398          * Gets the GdkFont to use for the given style. This is
 399          * meant only as a replacement for direct access to style->font
 400          * and should not be used in new code. New code should
 401          * use style->font_desc instead.
 402          * style:
 403          *  a GtkStyle
 404          * Returns:
 405          *  the GdkFont for the style. This font is owned
 406          *  by the style; if you want to keep around a copy, you must
 407          *  call gdk_font_ref().
 408          */
 409         public Font getFont()
 410         {
 411                 // GdkFont* gtk_style_get_font (GtkStyle *style);
 412                 return new Font( gtk_style_get_font(gtkStyle) );
 413         }
 414
 415         /**
 416          * Warning
 417          * gtk_style_set_font is deprecated and should not be used in newly-written code.
 418          * Sets the GdkFont to use for a given style. This is
 419          * meant only as a replacement for direct access to style->font
 420          * and should not be used in new code. New code should
 421          * use style->font_desc instead.
 422          * style:
 423          *  a GtkStyle.
 424          * font:
 425          *  a GdkFont, or NULL to use the GdkFont corresponding
 426          *  to style->font_desc.
 427          */
 428         public void setFont(Font font)
 429         {
 430                 // void gtk_style_set_font (GtkStyle *style,  GdkFont *font);
 431                 gtk_style_set_font(gtkStyle, (font is null) ? null : font.getFontStruct());
 432         }
 433
 434         /**
 435          * Warning
 436          * gtk_draw_hline is deprecated and should not be used in newly-written code. Use gtk_paint_hline() instead.
 437          * Draws a horizontal line from (x1, y) to (x2, y) in window
 438          * using the given style and state.
 439          * style:
 440          *  a GtkStyle
 441          * window:
 442          *  a GdkWindow
 443          * state_type:
 444          *  a state
 445          * x1:
 446          *  the starting x coordinate
 447          * x2:
 448          *  the ending x coordinate
 449          * y:
 450          *  the y coordinate
 451          */
 452         public void drawHline(Window window, GtkStateType stateType, int x1, int x2, int y)
 453         {
 454                 // void gtk_draw_hline (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  gint x1,  gint x2,  gint y);
 455                 gtk_draw_hline(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, x1, x2, y);
 456         }
 457
 458         /**
 459          * Warning
 460          * gtk_draw_vline is deprecated and should not be used in newly-written code. Use gtk_paint_vline() instead.
 461          * Draws a vertical line from (x, y1_) to (x, y2_) in window
 462          * using the given style and state.
 463          * style:
 464          *  a GtkStyle
 465          * window:
 466          *  a GdkWindow
 467          * state_type:
 468          *  a state
 469          * y1_:
 470          *  the starting y coordinate
 471          * y2_:
 472          *  the ending y coordinate
 473          * x:
 474          *  the x coordinate
 475          */
 476         public void drawVline(Window window, GtkStateType stateType, int y1_, int y2_, int x)
 477         {
 478                 // void gtk_draw_vline (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  gint y1_,  gint y2_,  gint x);
 479                 gtk_draw_vline(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, y1_, y2_, x);
 480         }
 481
 482         /**
 483          * Warning
 484          * gtk_draw_shadow is deprecated and should not be used in newly-written code. Use gtk_paint_shadow() instead.
 485          * Draws a shadow around the given rectangle in window
 486          * using the given style and state and shadow type.
 487          * style:
 488          *  a GtkStyle
 489          * window:
 490          *  a GdkWindow
 491          * state_type:
 492          *  a state
 493          * shadow_type:
 494          *  type of shadow to draw
 495          * x:
 496          *  x origin of the rectangle
 497          * y:
 498          *  y origin of the rectangle
 499          * width:
 500          *  width of the rectangle
 501          * height:
 502          *  width of the rectangle
 503          */
 504         public void drawShadow(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height)
 505         {
 506                 // void gtk_draw_shadow (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height);
 507                 gtk_draw_shadow(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height);
 508         }
 509
 510         /**
 511          * Warning
 512          * gtk_draw_polygon is deprecated and should not be used in newly-written code. Use gtk_paint_polygon() instead.
 513          * Draws a polygon on window with the given parameters.
 514          * style:
 515          *  a GtkStyle
 516          * window:
 517          *  a GdkWindow
 518          * state_type:
 519          *  a state
 520          * shadow_type:
 521          *  type of shadow to draw
 522          * points:
 523          *  an array of GdkPoints
 524          * npoints:
 525          *  length of points
 526          * fill:
 527          *  TRUE if the polygon should be filled
 528          */
 529         public void drawPolygon(Window window, GtkStateType stateType, GtkShadowType shadowType, GdkPoint* points, int npoints, int fill)
 530         {
 531                 // void gtk_draw_polygon (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkPoint *points,  gint npoints,  gboolean fill);
 532                 gtk_draw_polygon(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, points, npoints, fill);
 533         }
 534
 535         /**
 536          * Warning
 537          * gtk_draw_arrow is deprecated and should not be used in newly-written code. Use gtk_paint_arrow() instead.
 538          * Draws an arrow in the given rectangle on window using the given
 539          * parameters. arrow_type determines the direction of the arrow.
 540          * style:
 541          *  a GtkStyle
 542          * window:
 543          *  a GdkWindow
 544          * state_type:
 545          *  a state
 546          * shadow_type:
 547          *  the type of shadow to draw
 548          * arrow_type:
 549          *  the type of arrow to draw
 550          * fill:
 551          *  TRUE if the arrow tip should be filled
 552          * x:
 553          *  x origin of the rectangle to draw the arrow in
 554          * y:
 555          *  y origin of the rectangle to draw the arrow in
 556          * width:
 557          *  width of the rectangle to draw the arrow in
 558          * height:
 559          *  height of the rectangle to draw the arrow in
 560          */
 561         public void drawArrow(Window window, GtkStateType stateType, GtkShadowType shadowType, GtkArrowType arrowType, int fill, int x, int y, int width, int height)
 562         {
 563                 // void gtk_draw_arrow (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GtkArrowType arrow_type,  gboolean fill,  gint x,  gint y,  gint width,  gint height);
 564                 gtk_draw_arrow(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, arrowType, fill, x, y, width, height);
 565         }
 566
 567         /**
 568          * Warning
 569          * gtk_draw_diamond is deprecated and should not be used in newly-written code. Use gtk_paint_diamond() instead.
 570          * Draws a diamond in the given rectangle on window using the given
 571          * parameters.
 572          * style:
 573          *  a GtkStyle
 574          * window:
 575          *  a GdkWindow
 576          * state_type:
 577          *  a state
 578          * shadow_type:
 579          *  the type of shadow to draw
 580          * x:
 581          *  x origin of the rectangle to draw the diamond in
 582          * y:
 583          *  y origin of the rectangle to draw the diamond in
 584          * width:
 585          *  width of the rectangle to draw the diamond in
 586          * height:
 587          *  height of the rectangle to draw the diamond in
 588          */
 589         public void drawDiamond(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height)
 590         {
 591                 // void gtk_draw_diamond (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height);
 592                 gtk_draw_diamond(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height);
 593         }
 594
 595         /**
 596          * Warning
 597          * gtk_draw_string is deprecated and should not be used in newly-written code. Use gtk_paint_layout() instead.
 598          * Draws a text string on window with the given parameters.
 599          * style:
 600          *  a GtkStyle
 601          * window:
 602          *  a GdkWindow
 603          * state_type:
 604          *  a state
 605          * x:
 606          *  x origin
 607          * y:
 608          *  y origin
 609          * string:
 610          *  the string to draw
 611          */
 612         public void drawString(Window window, GtkStateType stateType, int x, int y, char[] string)
 613         {
 614                 // void gtk_draw_string (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  gint x,  gint y,  const gchar *string);
 615                 gtk_draw_string(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, x, y, Str.toStringz(string));
 616         }
 617
 618         /**
 619          * Warning
 620          * gtk_draw_box is deprecated and should not be used in newly-written code. Use gtk_paint_box() instead.
 621          * Draws a box on window with the given parameters.
 622          * style:
 623          *  a GtkStyle
 624          * window:
 625          *  a GdkWindow
 626          * state_type:
 627          *  a state
 628          * shadow_type:
 629          *  the type of shadow to draw
 630          * x:
 631          *  x origin of the box
 632          * y:
 633          *  y origin of the box
 634          * width:
 635          *  the width of the box
 636          * height:
 637          *  the height of the box
 638          */
 639         public void drawBox(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height)
 640         {
 641                 // void gtk_draw_box (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height);
 642                 gtk_draw_box(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height);
 643         }
 644
 645         /**
 646          * Warning
 647          * gtk_draw_box_gap is deprecated and should not be used in newly-written code. Use gtk_paint_box_gap() instead.
 648          * Draws a box in window using the given style and state and shadow type,
 649          * leaving a gap in one side.
 650          * style:
 651          *  a GtkStyle
 652          * window:
 653          *  a GdkWindow
 654          * state_type:
 655          *  a state
 656          * shadow_type:
 657          *  type of shadow to draw
 658          * x:
 659          *  x origin of the rectangle
 660          * y:
 661          *  y origin of the rectangle
 662          * width:
 663          *  width of the rectangle
 664          * height:
 665          *  width of the rectangle
 666          * gap_side:
 667          *  side in which to leave the gap
 668          * gap_x:
 669          *  starting position of the gap
 670          * gap_width:
 671          *  width of the gap
 672          */
 673         public void drawBoxGap(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height, GtkPositionType gapSide, int gapX, int gapWidth)
 674         {
 675                 // void gtk_draw_box_gap (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height,  GtkPositionType gap_side,  gint gap_x,  gint gap_width);
 676                 gtk_draw_box_gap(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height, gapSide, gapX, gapWidth);
 677         }
 678
 679         /**
 680          * Warning
 681          * gtk_draw_check is deprecated and should not be used in newly-written code. Use gtk_paint_check() instead.
 682          * Draws a check button indicator in the given rectangle on window with
 683          * the given parameters.
 684          * style:
 685          *  a GtkStyle
 686          * window:
 687          *  a GdkWindow
 688          * state_type:
 689          *  a state
 690          * shadow_type:
 691          *  the type of shadow to draw
 692          * x:
 693          *  x origin of the rectangle to draw the check in
 694          * y:
 695          *  y origin of the rectangle to draw the check in
 696          * width:
 697          *  the width of the rectangle to draw the check in
 698          * height:
 699          *  the height of the rectangle to draw the check in
 700          */
 701         public void drawCheck(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height)
 702         {
 703                 // void gtk_draw_check (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height);
 704                 gtk_draw_check(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height);
 705         }
 706
 707         /**
 708          * Warning
 709          * gtk_draw_extension is deprecated and should not be used in newly-written code. Use gtk_paint_extension() instead.
 710          * Draws an extension, i.e. a notebook tab.
 711          * style:
 712          *  a GtkStyle
 713          * window:
 714          *  a GdkWindow
 715          * state_type:
 716          *  a state
 717          * shadow_type:
 718          *  type of shadow to draw
 719          * x:
 720          *  x origin of the extension
 721          * y:
 722          *  y origin of the extension
 723          * width:
 724          *  width of the extension
 725          * height:
 726          *  width of the extension
 727          * gap_side:
 728          *  the side on to which the extension is attached
 729          */
 730         public void drawExtension(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height, GtkPositionType gapSide)
 731         {
 732                 // void gtk_draw_extension (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height,  GtkPositionType gap_side);
 733                 gtk_draw_extension(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height, gapSide);
 734         }
 735
 736         /**
 737          * Warning
 738          * gtk_draw_flat_box is deprecated and should not be used in newly-written code. Use gtk_paint_flat_box() instead.
 739          * Draws a flat box on window with the given parameters.
 740          * style:
 741          *  a GtkStyle
 742          * window:
 743          *  a GdkWindow
 744          * state_type:
 745          *  a state
 746          * shadow_type:
 747          *  the type of shadow to draw
 748          * x:
 749          *  x origin of the box
 750          * y:
 751          *  y origin of the box
 752          * width:
 753          *  the width of the box
 754          * height:
 755          *  the height of the box
 756          */
 757         public void drawFlatBox(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height)
 758         {
 759                 // void gtk_draw_flat_box (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height);
 760                 gtk_draw_flat_box(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height);
 761         }
 762
 763         /**
 764          * Warning
 765          * gtk_draw_focus is deprecated and should not be used in newly-written code. Use gtk_paint_focus() instead.
 766          * Draws a focus indicator around the given rectangle on window using the
 767          * given style.
 768          * style:
 769          *  a GtkStyle
 770          * window:
 771          *  a GdkWindow
 772          * x:
 773          *  the x origin of the rectangle around which to draw a focus indicator
 774          * y:
 775          *  the y origin of the rectangle around which to draw a focus indicator
 776          * width:
 777          *  the width of the rectangle around which to draw a focus indicator
 778          * height:
 779          *  the height of the rectangle around which to draw a focus indicator
 780          */
 781         public void drawFocus(Window window, int x, int y, int width, int height)
 782         {
 783                 // void gtk_draw_focus (GtkStyle *style,  GdkWindow *window,  gint x,  gint y,  gint width,  gint height);
 784                 gtk_draw_focus(gtkStyle, (window is null) ? null : window.getWindowStruct(), x, y, width, height);
 785         }
 786
 787         /**
 788          * Warning
 789          * gtk_draw_handle is deprecated and should not be used in newly-written code. Use gtk_paint_handle() instead.
 790          * Draws a handle as used in GtkHandleBox and GtkPaned.
 791          * style:
 792          *  a GtkStyle
 793          * window:
 794          *  a GdkWindow
 795          * state_type:
 796          *  a state
 797          * shadow_type:
 798          *  type of shadow to draw
 799          * x:
 800          *  x origin of the handle
 801          * y:
 802          *  y origin of the handle
 803          * width:
 804          *  with of the handle
 805          * height:
 806          *  height of the handle
 807          * orientation:
 808          *  the orientation of the handle
 809          */
 810         public void drawHandle(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height, GtkOrientation orientation)
 811         {
 812                 // void gtk_draw_handle (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height,  GtkOrientation orientation);
 813                 gtk_draw_handle(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height, orientation);
 814         }
 815
 816         /**
 817          * Warning
 818          * gtk_draw_option is deprecated and should not be used in newly-written code. Use gtk_paint_option() instead.
 819          * Draws a radio button indicator in the given rectangle on window with
 820          * the given parameters.
 821          * style:
 822          *  a GtkStyle
 823          * window:
 824          *  a GdkWindow
 825          * state_type:
 826          *  a state
 827          * shadow_type:
 828          *  the type of shadow to draw
 829          * x:
 830          *  x origin of the rectangle to draw the option in
 831          * y:
 832          *  y origin of the rectangle to draw the option in
 833          * width:
 834          *  the width of the rectangle to draw the option in
 835          * height:
 836          *  the height of the rectangle to draw the option in
 837          */
 838         public void drawOption(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height)
 839         {
 840                 // void gtk_draw_option (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height);
 841                 gtk_draw_option(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height);
 842         }
 843
 844         /**
 845          * Warning
 846          * gtk_draw_shadow_gap is deprecated and should not be used in newly-written code. Use gtk_paint_shadow_gap() instead.
 847          * Draws a shadow around the given rectangle in window
 848          * using the given style and state and shadow type, leaving a
 849          * gap in one side.
 850          * style:
 851          *  a GtkStyle
 852          * window:
 853          *  a GdkWindow
 854          * state_type:
 855          *  a state
 856          * shadow_type:
 857          *  type of shadow to draw
 858          * x:
 859          *  x origin of the rectangle
 860          * y:
 861          *  y origin of the rectangle
 862          * width:
 863          *  width of the rectangle
 864          * height:
 865          *  width of the rectangle
 866          * gap_side:
 867          *  side in which to leave the gap
 868          * gap_x:
 869          *  starting position of the gap
 870          * gap_width:
 871          *  width of the gap
 872          */
 873         public void drawShadowGap(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height, GtkPositionType gapSide, int gapX, int gapWidth)
 874         {
 875                 // void gtk_draw_shadow_gap (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height,  GtkPositionType gap_side,  gint gap_x,  gint gap_width);
 876                 gtk_draw_shadow_gap(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height, gapSide, gapX, gapWidth);
 877         }
 878
 879         /**
 880          * Warning
 881          * gtk_draw_slider is deprecated and should not be used in newly-written code.
 882          * style:
 883          * window:
 884          * state_type:
 885          * shadow_type:
 886          * x:
 887          * y:
 888          * width:
 889          * height:
 890          * orientation:
 891          */
 892         public void drawSlider(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height, GtkOrientation orientation)
 893         {
 894                 // void gtk_draw_slider (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height,  GtkOrientation orientation);
 895                 gtk_draw_slider(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height, orientation);
 896         }
 897
 898         /**
 899          * Warning
 900          * gtk_draw_tab is deprecated and should not be used in newly-written code. Use gtk_paint_tab() instead.
 901          * Draws an option menu tab (i.e. the up and down pointing arrows)
 902          * in the given rectangle on window using the given parameters.
 903          * style:
 904          *  a GtkStyle
 905          * window:
 906          *  a GdkWindow
 907          * state_type:
 908          *  a state
 909          * shadow_type:
 910          *  the type of shadow to draw
 911          * x:
 912          *  x origin of the rectangle to draw the tab in
 913          * y:
 914          *  y origin of the rectangle to draw the tab in
 915          * width:
 916          *  the width of the rectangle to draw the tab in
 917          * height:
 918          *  the height of the rectangle to draw the tab in
 919          */
 920         public void drawTab(Window window, GtkStateType stateType, GtkShadowType shadowType, int x, int y, int width, int height)
 921         {
 922                 // void gtk_draw_tab (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  gint x,  gint y,  gint width,  gint height);
 923                 gtk_draw_tab(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, x, y, width, height);
 924         }
 925
 926         /**
 927          * Warning
 928          * gtk_draw_expander is deprecated and should not be used in newly-written code. Use gtk_paint_expander() instead.
 929          * Draws an expander as used in GtkTreeView.
 930          * style:
 931          *  a GtkStyle
 932          * window:
 933          *  a GdkWindow
 934          * state_type:
 935          *  a state
 936          * x:
 937          *  the x position to draw the expander at
 938          * y:
 939          *  the y position to draw the expander at
 940          * expander_style:
 941          *  the style to draw the expander in
 942          */
 943         public void drawExpander(Window window, GtkStateType stateType, int x, int y, GtkExpanderStyle expanderStyle)
 944         {
 945                 // void gtk_draw_expander (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  gint x,  gint y,  GtkExpanderStyle expander_style);
 946                 gtk_draw_expander(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, x, y, expanderStyle);
 947         }
 948
 949         /**
 950          * Warning
 951          * gtk_draw_layout is deprecated and should not be used in newly-written code.
 952          * style:
 953          * window:
 954          * state_type:
 955          * use_text:
 956          * x:
 957          * y:
 958          * layout:
 959          */
 960         public void drawLayout(Window window, GtkStateType stateType, int useText, int x, int y, PangoLayout* layout)
 961         {
 962                 // void gtk_draw_layout (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  gboolean use_text,  gint x,  gint y,  PangoLayout *layout);
 963                 gtk_draw_layout(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, useText, x, y, layout);
 964         }
 965
 966         /**
 967          * Warning
 968          * gtk_draw_resize_grip is deprecated and should not be used in newly-written code. Use gtk_paint_resize_grip() instead.
 969          * Draws a resize grip in the given rectangle on window using the given
 970          * parameters.
 971          * style:
 972          *  a GtkStyle
 973          * window:
 974          *  a GdkWindow
 975          * state_type:
 976          *  a state
 977          * edge:
 978          *  the edge in which to draw the resize grip
 979          * x:
 980          *  the x origin of the rectangle in which to draw the resize grip
 981          * y:
 982          *  the y origin of the rectangle in which to draw the resize grip
 983          * width:
 984          *  the width of the rectangle in which to draw the resize grip
 985          * height:
 986          *  the height of the rectangle in which to draw the resize grip
 987          */
 988         public void drawResizeGrip(Window window, GtkStateType stateType, GdkWindowEdge edge, int x, int y, int width, int height)
 989         {
 990                 // void gtk_draw_resize_grip (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GdkWindowEdge edge,  gint x,  gint y,  gint width,  gint height);
 991                 gtk_draw_resize_grip(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, edge, x, y, width, height);
 992         }
 993
 994         /**
 995          * Draws an arrow in the given rectangle on window using the given
 996          * parameters. arrow_type determines the direction of the arrow.
 997          * style:
 998          *  a GtkStyle
 999          * window:
1000          *  a GdkWindow
1001          * state_type:
1002          *  a state
1003          * shadow_type:
1004          *  the type of shadow to draw
1005          * area:
1006          *  clip rectangle, or NULL if the
1007          *  output should not be clipped
1008          * widget:
1009          *  the widget (may be NULL)
1010          * detail:
1011          *  a style detail (may be NULL)
1012          * arrow_type:
1013          *  the type of arrow to draw
1014          * fill:
1015          *  TRUE if the arrow tip should be filled
1016          * x:
1017          *  x origin of the rectangle to draw the arrow in
1018          * y:
1019          *  y origin of the rectangle to draw the arrow in
1020          * width:
1021          *  width of the rectangle to draw the arrow in
1022          * height:
1023          *  height of the rectangle to draw the arrow in
1024          */
1025         public void paintArrow(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, GtkArrowType arrowType, int fill, int x, int y, int width, int height)
1026         {
1027                 // void gtk_paint_arrow (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  GtkArrowType arrow_type,  gboolean fill,  gint x,  gint y,  gint width,  gint height);
1028                 gtk_paint_arrow(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), arrowType, fill, x, y, width, height);
1029         }
1030
1031         /**
1032          * Draws a box on window with the given parameters.
1033          * style:
1034          *  a GtkStyle
1035          * window:
1036          *  a GdkWindow
1037          * state_type:
1038          *  a state
1039          * shadow_type:
1040          *  the type of shadow to draw
1041          * area:
1042          *  clip rectangle, or NULL if the
1043          *  output should not be clipped
1044          * widget:
1045          *  the widget (may be NULL)
1046          * detail:
1047          *  a style detail (may be NULL)
1048          * x:
1049          *  x origin of the box
1050          * y:
1051          *  y origin of the box
1052          * width:
1053          *  the width of the box
1054          * height:
1055          *  the height of the box
1056          */
1057         public void paintBox(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height)
1058         {
1059                 // void gtk_paint_box (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  gint width,  gint height);
1060                 gtk_paint_box(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height);
1061         }
1062
1063         /**
1064          * Draws a box in window using the given style and state and shadow type,
1065          * leaving a gap in one side.
1066          * style:
1067          *  a GtkStyle
1068          * window:
1069          *  a GdkWindow
1070          * state_type:
1071          *  a state
1072          * shadow_type:
1073          *  type of shadow to draw
1074          * area:
1075          *  clip rectangle, or NULL if the
1076          *  output should not be clipped
1077          * widget:
1078          *  the widget (may be NULL)
1079          * detail:
1080          *  a style detail (may be NULL)
1081          * x:
1082          *  x origin of the rectangle
1083          * y:
1084          *  y origin of the rectangle
1085          * width:
1086          *  width of the rectangle
1087          * height:
1088          *  width of the rectangle
1089          * gap_side:
1090          *  side in which to leave the gap
1091          * gap_x:
1092          *  starting position of the gap
1093          * gap_width:
1094          *  width of the gap
1095          */
1096         public void paintBoxGap(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height, GtkPositionType gapSide, int gapX, int gapWidth)
1097         {
1098                 // void gtk_paint_box_gap (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  gchar *detail,  gint x,  gint y,  gint width,  gint height,  GtkPositionType gap_side,  gint gap_x,  gint gap_width);
1099                 gtk_paint_box_gap(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height, gapSide, gapX, gapWidth);
1100         }
1101
1102         /**
1103          * Draws a check button indicator in the given rectangle on window with
1104          * the given parameters.
1105          * style:
1106          *  a GtkStyle
1107          * window:
1108          *  a GdkWindow
1109          * state_type:
1110          *  a state
1111          * shadow_type:
1112          *  the type of shadow to draw
1113          * area:
1114          *  clip rectangle, or NULL if the
1115          *  output should not be clipped
1116          * widget:
1117          *  the widget (may be NULL)
1118          * detail:
1119          *  a style detail (may be NULL)
1120          * x:
1121          *  x origin of the rectangle to draw the check in
1122          * y:
1123          *  y origin of the rectangle to draw the check in
1124          * width:
1125          *  the width of the rectangle to draw the check in
1126          * height:
1127          *  the height of the rectangle to draw the check in
1128          */
1129         public void paintCheck(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height)
1130         {
1131                 // void gtk_paint_check (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  gint width,  gint height);
1132                 gtk_paint_check(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height);
1133         }
1134
1135         /**
1136          * Draws a diamond in the given rectangle on window using the given
1137          * parameters.
1138          * style:
1139          *  a GtkStyle
1140          * window:
1141          *  a GdkWindow
1142          * state_type:
1143          *  a state
1144          * shadow_type:
1145          *  the type of shadow to draw
1146          * area:
1147          *  clip rectangle, or NULL if the
1148          *  output should not be clipped
1149          * widget:
1150          *  the widget (may be NULL)
1151          * detail:
1152          *  a style detail (may be NULL)
1153          * x:
1154          *  x origin of the rectangle to draw the diamond in
1155          * y:
1156          *  y origin of the rectangle to draw the diamond in
1157          * width:
1158          *  width of the rectangle to draw the diamond in
1159          * height:
1160          *  height of the rectangle to draw the diamond in
1161          */
1162         public void paintDiamond(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height)
1163         {
1164                 // void gtk_paint_diamond (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  gint width,  gint height);
1165                 gtk_paint_diamond(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height);
1166         }
1167
1168         /**
1169          * Draws an extension, i.e. a notebook tab.
1170          * style:
1171          *  a GtkStyle
1172          * window:
1173          *  a GdkWindow
1174          * state_type:
1175          *  a state
1176          * shadow_type:
1177          *  type of shadow to draw
1178          * area:
1179          *  clip rectangle, or NULL if the
1180          *  output should not be clipped
1181          * widget:
1182          *  the widget (may be NULL)
1183          * detail:
1184          *  a style detail (may be NULL)
1185          * x:
1186          *  x origin of the extension
1187          * y:
1188          *  y origin of the extension
1189          * width:
1190          *  width of the extension
1191          * height:
1192          *  width of the extension
1193          * gap_side:
1194          *  the side on to which the extension is attached
1195          */
1196         public void paintExtension(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height, GtkPositionType gapSide)
1197         {
1198                 // void gtk_paint_extension (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  gchar *detail,  gint x,  gint y,  gint width,  gint height,  GtkPositionType gap_side);
1199                 gtk_paint_extension(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height, gapSide);
1200         }
1201
1202         /**
1203          * Draws a flat box on window with the given parameters.
1204          * style:
1205          *  a GtkStyle
1206          * window:
1207          *  a GdkWindow
1208          * state_type:
1209          *  a state
1210          * shadow_type:
1211          *  the type of shadow to draw
1212          * area:
1213          *  clip rectangle, or NULL if the
1214          *  output should not be clipped
1215          * widget:
1216          *  the widget (may be NULL)
1217          * detail:
1218          *  a style detail (may be NULL)
1219          * x:
1220          *  x origin of the box
1221          * y:
1222          *  y origin of the box
1223          * width:
1224          *  the width of the box
1225          * height:
1226          *  the height of the box
1227          */
1228         public void paintFlatBox(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height)
1229         {
1230                 // void gtk_paint_flat_box (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  gint width,  gint height);
1231                 gtk_paint_flat_box(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height);
1232         }
1233
1234         /**
1235          * Draws a focus indicator around the given rectangle on window using the
1236          * given style.
1237          * style:
1238          *  a GtkStyle
1239          * window:
1240          *  a GdkWindow
1241          * state_type:
1242          *  a state
1243          * area:
1244          *  clip rectangle, or NULL if the
1245          *  output should not be clipped
1246          * widget:
1247          *  the widget (may be NULL)
1248          * detail:
1249          *  a style detail (may be NULL)
1250          * x:
1251          *  the x origin of the rectangle around which to draw a focus indicator
1252          * y:
1253          *  the y origin of the rectangle around which to draw a focus indicator
1254          * width:
1255          *  the width of the rectangle around which to draw a focus indicator
1256          * height:
1257          *  the height of the rectangle around which to draw a focus indicator
1258          */
1259         public void paintFocus(Window window, GtkStateType stateType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height)
1260         {
1261                 // void gtk_paint_focus (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  gint width,  gint height);
1262                 gtk_paint_focus(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height);
1263         }
1264
1265         /**
1266          * Draws a handle as used in GtkHandleBox and GtkPaned.
1267          * style:
1268          *  a GtkStyle
1269          * window:
1270          *  a GdkWindow
1271          * state_type:
1272          *  a state
1273          * shadow_type:
1274          *  type of shadow to draw
1275          * area:
1276          *  clip rectangle, or NULL if the
1277          *  output should not be clipped
1278          * widget:
1279          *  the widget (may be NULL)
1280          * detail:
1281          *  a style detail (may be NULL)
1282          * x:
1283          *  x origin of the handle
1284          * y:
1285          *  y origin of the handle
1286          * width:
1287          *  with of the handle
1288          * height:
1289          *  height of the handle
1290          * orientation:
1291          *  the orientation of the handle
1292          */
1293         public void paintHandle(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height, GtkOrientation orientation)
1294         {
1295                 // void gtk_paint_handle (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  gint width,  gint height,  GtkOrientation orientation);
1296                 gtk_paint_handle(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height, orientation);
1297         }
1298
1299         /**
1300          * Draws a horizontal line from (x1, y) to (x2, y) in window
1301          * using the given style and state.
1302          * style:
1303          *  a GtkStyle
1304          * window:
1305          *  a GdkWindow
1306          * state_type:
1307          *  a state
1308          * area:
1309          *  rectangle to which the output is clipped, or NULL if the
1310          *  output should not be clipped
1311          * widget:
1312          *  the widget (may be NULL)
1313          * detail:
1314          *  a style detail (may be NULL)
1315          * x1:
1316          *  the starting x coordinate
1317          * x2:
1318          *  the ending x coordinate
1319          * y:
1320          *  the y coordinate
1321          */
1322         public void paintHline(Window window, GtkStateType stateType, Rectangle area, Widget widget, char[] detail, int x1, int x2, int y)
1323         {
1324                 // void gtk_paint_hline (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x1,  gint x2,  gint y);
1325                 gtk_paint_hline(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x1, x2, y);
1326         }
1327
1328         /**
1329          * Draws a radio button indicator in the given rectangle on window with
1330          * the given parameters.
1331          * style:
1332          *  a GtkStyle
1333          * window:
1334          *  a GdkWindow
1335          * state_type:
1336          *  a state
1337          * shadow_type:
1338          *  the type of shadow to draw
1339          * area:
1340          *  clip rectangle, or NULL if the
1341          *  output should not be clipped
1342          * widget:
1343          *  the widget (may be NULL)
1344          * detail:
1345          *  a style detail (may be NULL)
1346          * x:
1347          *  x origin of the rectangle to draw the option in
1348          * y:
1349          *  y origin of the rectangle to draw the option in
1350          * width:
1351          *  the width of the rectangle to draw the option in
1352          * height:
1353          *  the height of the rectangle to draw the option in
1354          */
1355         public void paintOption(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height)
1356         {
1357                 // void gtk_paint_option (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  gint width,  gint height);
1358                 gtk_paint_option(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height);
1359         }
1360
1361         /**
1362          * Draws a polygon on window with the given parameters.
1363          * style:
1364          *  a GtkStyle
1365          * window:
1366          *  a GdkWindow
1367          * state_type:
1368          *  a state
1369          * shadow_type:
1370          *  type of shadow to draw
1371          * area:
1372          *  clip rectangle, or NULL if the
1373          *  output should not be clipped
1374          * widget:
1375          *  the widget (may be NULL)
1376          * detail:
1377          *  a style detail (may be NULL)
1378          * points:
1379          *  an array of GdkPoints
1380          * npoints:
1381          *  length of points
1382          * fill:
1383          *  TRUE if the polygon should be filled
1384          */
1385         public void paintPolygon(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, GdkPoint* points, int npoints, int fill)
1386         {
1387                 // void gtk_paint_polygon (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  GdkPoint *points,  gint npoints,  gboolean fill);
1388                 gtk_paint_polygon(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), points, npoints, fill);
1389         }
1390
1391         /**
1392          * Draws a shadow around the given rectangle in window
1393          * using the given style and state and shadow type.
1394          * style:
1395          *  a GtkStyle
1396          * window:
1397          *  a GdkWindow
1398          * state_type:
1399          *  a state
1400          * shadow_type:
1401          *  type of shadow to draw
1402          * area:
1403          *  clip rectangle or NULL if the
1404          *  output should not be clipped
1405          * widget:
1406          *  the widget (may be NULL)
1407          * detail:
1408          *  a style detail (may be NULL)
1409          * x:
1410          *  x origin of the rectangle
1411          * y:
1412          *  y origin of the rectangle
1413          * width:
1414          *  width of the rectangle
1415          * height:
1416          *  width of the rectangle
1417          */
1418         public void paintShadow(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height)
1419         {
1420                 // void gtk_paint_shadow (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  gint width,  gint height);
1421                 gtk_paint_shadow(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height);
1422         }
1423
1424         /**
1425          * Draws a shadow around the given rectangle in window
1426          * using the given style and state and shadow type, leaving a
1427          * gap in one side.
1428          * style:
1429          *  a GtkStyle
1430          * window:
1431          *  a GdkWindow
1432          * state_type:
1433          *  a state
1434          * shadow_type:
1435          *  type of shadow to draw
1436          * area:
1437          *  clip rectangle, or NULL if the
1438          *  output should not be clipped
1439          * widget:
1440          *  the widget (may be NULL)
1441          * detail:
1442          *  a style detail (may be NULL)
1443          * x:
1444          *  x origin of the rectangle
1445          * y:
1446          *  y origin of the rectangle
1447          * width:
1448          *  width of the rectangle
1449          * height:
1450          *  width of the rectangle
1451          * gap_side:
1452          *  side in which to leave the gap
1453          * gap_x:
1454          *  starting position of the gap
1455          * gap_width:
1456          *  width of the gap
1457          */
1458         public void paintShadowGap(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height, GtkPositionType gapSide, int gapX, int gapWidth)
1459         {
1460                 // void gtk_paint_shadow_gap (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  gchar *detail,  gint x,  gint y,  gint width,  gint height,  GtkPositionType gap_side,  gint gap_x,  gint gap_width);
1461                 gtk_paint_shadow_gap(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height, gapSide, gapX, gapWidth);
1462         }
1463
1464         /**
1465          * Draws a slider in the given rectangle on window using the
1466          * given style and orientation.
1467          * style:
1468          *  a GtkStyle
1469          * window:
1470          *  a GdkWindow
1471          * state_type:
1472          *  a state
1473          * shadow_type:
1474          *  a shadow
1475          * area:
1476          *  clip rectangle, or NULL if the
1477          *  output should not be clipped
1478          * widget:
1479          *  the widget (may be NULL)
1480          * detail:
1481          *  a style detail (may be NULL)
1482          * x:
1483          *  the x origin of the rectangle in which to draw a slider
1484          * y:
1485          *  the y origin of the rectangle in which to draw a slider
1486          * width:
1487          *  the width of the rectangle in which to draw a slider
1488          * height:
1489          *  the height of the rectangle in which to draw a slider
1490          * orientation:
1491          *  the orientation to be used
1492          */
1493         public void paintSlider(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height, GtkOrientation orientation)
1494         {
1495                 // void gtk_paint_slider (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  gint width,  gint height,  GtkOrientation orientation);
1496                 gtk_paint_slider(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height, orientation);
1497         }
1498
1499         /**
1500          * Warning
1501          * gtk_paint_string is deprecated and should not be used in newly-written code. Use gtk_paint_layout() instead.
1502          * Draws a text string on window with the given parameters.
1503          * style:
1504          *  a GtkStyle
1505          * window:
1506          *  a GdkWindow
1507          * state_type:
1508          *  a state
1509          * area:
1510          *  clip rectangle, or NULL if the
1511          *  output should not be clipped
1512          * widget:
1513          *  the widget (may be NULL)
1514          * detail:
1515          *  a style detail (may be NULL)
1516          * x:
1517          *  x origin
1518          * y:
1519          *  y origin
1520          * string:
1521          *  the string to draw
1522          */
1523         public void paintString(Window window, GtkStateType stateType, Rectangle area, Widget widget, char[] detail, int x, int y, char[] string)
1524         {
1525                 // void gtk_paint_string (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  const gchar *string);
1526                 gtk_paint_string(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, Str.toStringz(string));
1527         }
1528
1529         /**
1530          * Draws an option menu tab (i.e. the up and down pointing arrows)
1531          * in the given rectangle on window using the given parameters.
1532          * style:
1533          *  a GtkStyle
1534          * window:
1535          *  a GdkWindow
1536          * state_type:
1537          *  a state
1538          * shadow_type:
1539          *  the type of shadow to draw
1540          * area:
1541          *  clip rectangle, or NULL if the
1542          *  output should not be clipped
1543          * widget:
1544          *  the widget (may be NULL)
1545          * detail:
1546          *  a style detail (may be NULL)
1547          * x:
1548          *  x origin of the rectangle to draw the tab in
1549          * y:
1550          *  y origin of the rectangle to draw the tab in
1551          * width:
1552          *  the width of the rectangle to draw the tab in
1553          * height:
1554          *  the height of the rectangle to draw the tab in
1555          */
1556         public void paintTab(Window window, GtkStateType stateType, GtkShadowType shadowType, Rectangle area, Widget widget, char[] detail, int x, int y, int width, int height)
1557         {
1558                 // void gtk_paint_tab (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GtkShadowType shadow_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  gint width,  gint height);
1559                 gtk_paint_tab(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, shadowType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, width, height);
1560         }
1561
1562         /**
1563          * Draws a vertical line from (x, y1_) to (x, y2_) in window
1564          * using the given style and state.
1565          * style:
1566          *  a GtkStyle
1567          * window:
1568          *  a GdkWindow
1569          * state_type:
1570          *  a state
1571          * area:
1572          *  rectangle to which the output is clipped, or NULL if the
1573          *  output should not be clipped
1574          * widget:
1575          *  the widget (may be NULL)
1576          * detail:
1577          *  a style detail (may be NULL)
1578          * y1_:
1579          *  the starting y coordinate
1580          * y2_:
1581          *  the ending y coordinate
1582          * x:
1583          *  the x coordinate
1584          */
1585         public void paintVline(Window window, GtkStateType stateType, Rectangle area, Widget widget, char[] detail, int y1_, int y2_, int x)
1586         {
1587                 // void gtk_paint_vline (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint y1_,  gint y2_,  gint x);
1588                 gtk_paint_vline(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), y1_, y2_, x);
1589         }
1590
1591         /**
1592          * Draws an expander as used in GtkTreeView. x and y specify the
1593          * center the expander. The size of the expander is determined by the
1594          * "expander-size" style property of widget. (If widget is not
1595          * specified or doesn't have an "expander-size" property, an
1596          * unspecified default size will be used, since the caller doesn't
1597          * have sufficient information to position the expander, this is
1598          * likely not useful.) The expander is expander_size pixels tall
1599          * in the collapsed position and expander_size pixels wide in the
1600          * expanded position.
1601          * style:
1602          *  a GtkStyle
1603          * window:
1604          *  a GdkWindow
1605          * state_type:
1606          *  a state
1607          * area:
1608          *  clip rectangle, or NULL if the
1609          *  output should not be clipped
1610          * widget:
1611          *  the widget (may be NULL)
1612          * detail:
1613          *  a style detail (may be NULL)
1614          * x:
1615          *  the x position to draw the expander at
1616          * y:
1617          *  the y position to draw the expander at
1618          * expander_style:
1619          *  the style to draw the expander in; determines
1620          *  whether the expander is collapsed, expanded, or in an
1621          *  intermediate state.
1622          */
1623         public void paintExpander(Window window, GtkStateType stateType, Rectangle area, Widget widget, char[] detail, int x, int y, GtkExpanderStyle expanderStyle)
1624         {
1625                 // void gtk_paint_expander (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  GtkExpanderStyle expander_style);
1626                 gtk_paint_expander(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, expanderStyle);
1627         }
1628
1629         /**
1630          * Draws a layout on window using the given parameters.
1631          * style:
1632          *  a GtkStyle
1633          * window:
1634          *  a GdkWindow
1635          * state_type:
1636          *  a state
1637          * use_text:
1638          *  whether to use the text or foreground
1639          *  graphics context of style
1640          * area:
1641          *  clip rectangle, or NULL if the
1642          *  output should not be clipped
1643          * widget:
1644          *  the widget (may be NULL)
1645          * detail:
1646          *  a style detail (may be NULL)
1647          * x:
1648          *  x origin
1649          * y:
1650          *  y origin
1651          * layout:
1652          *  the layout to draw
1653          */
1654         public void paintLayout(Window window, GtkStateType stateType, int useText, Rectangle area, Widget widget, char[] detail, int x, int y, PangoLayout* layout)
1655         {
1656                 // void gtk_paint_layout (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  gboolean use_text,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  gint x,  gint y,  PangoLayout *layout);
1657                 gtk_paint_layout(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, useText, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), x, y, layout);
1658         }
1659
1660         /**
1661          * Draws a resize grip in the given rectangle on window using the given
1662          * parameters.
1663          * style:
1664          *  a GtkStyle
1665          * window:
1666          *  a GdkWindow
1667          * state_type:
1668          *  a state
1669          * area:
1670          *  clip rectangle, or NULL if the
1671          *  output should not be clipped
1672          * widget:
1673          *  the widget (may be NULL)
1674          * detail:
1675          *  a style detail (may be NULL)
1676          * edge:
1677          *  the edge in which to draw the resize grip
1678          * x:
1679          *  the x origin of the rectangle in which to draw the resize grip
1680          * y:
1681          *  the y origin of the rectangle in which to draw the resize grip
1682          * width:
1683          *  the width of the rectangle in which to draw the resize grip
1684          * height:
1685          *  the height of the rectangle in which to draw the resize grip
1686          */
1687         public void paintResizeGrip(Window window, GtkStateType stateType, Rectangle area, Widget widget, char[] detail, GdkWindowEdge edge, int x, int y, int width, int height)
1688         {
1689                 // void gtk_paint_resize_grip (GtkStyle *style,  GdkWindow *window,  GtkStateType state_type,  GdkRectangle *area,  GtkWidget *widget,  const gchar *detail,  GdkWindowEdge edge,  gint x,  gint y,  gint width,  gint height);
1690                 gtk_paint_resize_grip(gtkStyle, (window is null) ? null : window.getWindowStruct(), stateType, (area is null) ? null : area.getRectangleStruct(), (widget is null) ? null : widget.getWidgetStruct(), Str.toStringz(detail), edge, x, y, width, height);
1691         }
1692
1693         /**
1694          * Draws a text caret on drawable at location. This is not a style function
1695          * but merely a convenience function for drawing the standard cursor shape.
1696          * widget:
1697          *  a GtkWidget
1698          * drawable:
1699          *  a GdkDrawable
1700          * area:
1701          *  rectangle to which the output is clipped, or NULL if the
1702          *  output should not be clipped
1703          * location:
1704          *  location where to draw the cursor (location->width is ignored)
1705          * is_primary:
1706          *  if the cursor should be the primary cursor color.
1707          * direction:
1708          *  whether the cursor is left-to-right or
1709          *  right-to-left. Should never be GTK_TEXT_DIR_NONE
1710          * draw_arrow:
1711          *  TRUE to draw a directional arrow on the
1712          *  cursor. Should be FALSE unless the cursor is split.
1713          * Since 2.4
1714          */
1715         public static void drawInsertionCursor(Widget widget, Drawable drawable, Rectangle area, Rectangle location, int isPrimary, GtkTextDirection direction, int drawArrow)
1716         {
1717                 // void gtk_draw_insertion_cursor (GtkWidget *widget,  GdkDrawable *drawable,  GdkRectangle *area,  GdkRectangle *location,  gboolean is_primary,  GtkTextDirection direction,  gboolean draw_arrow);
1718                 gtk_draw_insertion_cursor((widget is null) ? null : widget.getWidgetStruct(), (drawable is null) ? null : drawable.getDrawableStruct(), (area is null) ? null : area.getRectangleStruct(), (location is null) ? null : location.getRectangleStruct(), isPrimary, direction, drawArrow);
1719         }
1720
1721
1722         /**
1723          * Copies a GtkBorder structure.
1724          * border_:
1725          *  a GtkBorder.
1726          * Returns:
1727          *  a copy of border_.
1728          */
1729         public static GtkBorder* borderCopy(GtkBorder* border)
1730         {
1731                 // GtkBorder* gtk_border_copy (const GtkBorder *border_);
1732                 return gtk_border_copy(border);
1733         }
1734
1735         /**
1736          * Frees a GtkBorder structure.
1737          * border_:
1738          *  a GtkBorder.
1739          */
1740         public static void borderFree(GtkBorder* border)
1741         {
1742                 // void gtk_border_free (GtkBorder *border_);
1743                 gtk_border_free(border);
1744         }
1745
1746
1747
1748 }