src/gtk/Style.d

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