gtkD/wrap/APILookupGdk.txt

   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
  20 #
  21 ###
  22 #####
  23 # Definitions for wrapping Gdk
  24 #####
  25 ###
  26 #
  27
  28
  29 addTypedefs: start
  30
  31 public import gtkc.glibtypes;
  32 public import gtkc.gobjecttypes;
  33 public import gtkc.pangotypes;
  34 public import gtkc.gdkpixbuftypes;
  35
  36 alias void* GdkAtom;
  37 alias void* GdkNativeWindow;
  38
  39
  40 addTypedefs: end
  41
  42 addAliases: start
  43 addAliases: end
  44
  45 addEnums: start
  46 addEnums: end
  47
  48 addStructs: start
  49 addStructs: end
  50
  51 addTypes: start
  52 addTypes: end
  53
  54 addFuncts: start
  55 addFuncts: end
  56
  57 addUnions: start
  58 addUnions: end
  59
  60 addConstants: start
  61 addConstants: end
  62
  63
  64 # must start with wrap
  65
  66 wrap: gdk
  67
  68 ###########################################################
  69 ### Gdk ###################################################
  70 ###########################################################
  71
  72 file: gdk-General.html
  73 class: Gdk
  74 prefix: gdk_
  75 import: glib.Str
  76 import: gdk.Window
  77 structWrap: GdkWindow* Window
  78 import: gdk.Cursor
  79 structWrap: GdkCursor* Cursor
  80 outFile: Gdk
  81
  82 #file: multihead.html
  83 #struct:
  84 #class:
  85 #prefix:
  86 #outFile:
  87
  88 file: GdkDisplay.html
  89 struct: GdkDisplay
  90 class: Display
  91 prefix: gdk_display_
  92 import: glib.Str
  93 import: gdk.Display
  94 structWrap: GdkDisplay* Display
  95 import: gdk.Screen
  96 structWrap: GdkScreen* Screen
  97 import: glib.ListG
  98 structWrap: GList* ListG
  99 import: gdk.Event
 100 structWrap: GdkEvent* Event
 101 #import: gdk.Screen*
 102 #structWrap: GdkScreen** Screen*
 103 #import: gdk.ModifierType
 104 #structWrap: GdkModifierType* ModifierType
 105 import: gdk.Window
 106 structWrap: GdkWindow* Window
 107 #import: gdk.DisplayPointerHooks
 108 #structWrap: GdkDisplayPointerHooks* DisplayPointerHooks
 109 #import: gdk.Atom
 110 #structWrap: GdkAtom* Atom
 111 outFile: Display
 112
 113 file: GdkDisplayManager.html
 114 struct: GdkDisplayManager
 115 class: DisplayManager
 116 prefix: gdk_display_manager_
 117 import: gdk.DisplayManager
 118 structWrap: GdkDisplayManager* DisplayManager
 119 import: gdk.Display
 120 structWrap: GdkDisplay* Display
 121 import: glib.ListSG
 122 structWrap: GSList* ListSG
 123 import: gdk.Device
 124 structWrap: GdkDevice* Device
 125 outFile: DisplayManager
 126
 127 file: GdkScreen.html
 128 struct: GdkScreen
 129 class: Screen
 130 prefix: gdk_screen_
 131 import: gtkc.cairoLibtypes
 132 import: glib.Str
 133 import: gdk.Screen
 134 structWrap: GdkScreen* Screen
 135 import: gdk.Colormap
 136 structWrap: GdkColormap* Colormap
 137 import: gdk.Visual
 138 structWrap: GdkVisual* Visual
 139 import: gdk.Window
 140 structWrap: GdkWindow* Window
 141 import: gdk.Display
 142 structWrap: GdkDisplay* Display
 143 import: glib.ListG
 144 structWrap: GList* ListG
 145 import: gdk.Rectangle
 146 structWrap: GdkRectangle* Rectangle
 147 import: gdk.Event
 148 structWrap: GdkEvent* Event
 149 import: gobject.Value
 150 structWrap: GValue* Value
 151 outFile: Screen
 152
 153 file: gdk-Points-Rectangles-and-Regions.html
 154
 155 struct: GdkRectangle
 156 class: Rectangle
 157 prefix: gdk_rectangle_
 158 noprefix: gdk_region_
 159 import: gdk.Rectangle
 160 structWrap: GdkRectangle* Rectangle
 161 outFile: Rectangle
 162
 163 struct: GdkRegion
 164 class: Region
 165 prefix: gdk_region_
 166 strictPrefix: Yes
 167 import: gdk.Region
 168 structWrap: GdkRegion* Region
 169 #import: gdk.Point
 170 #structWrap: GdkPoint* Point
 171 import: gdk.Rectangle
 172 structWrap: GdkRectangle* Rectangle
 173 #import: gdk.Rectangle*
 174 #structWrap: GdkRectangle** Rectangle*
 175 #import: gdk.Span
 176 #structWrap: GdkSpan* Span
 177 outFile: Region
 178
 179 file: gdk-Graphics-Contexts.html
 180 struct: GdkGC
 181 class: GC
 182 prefix: gdk_gc_
 183 import: gdk.Drawable
 184 structWrap: GdkDrawable* Drawable
 185 #import: gdk.GCValues
 186 #structWrap: GdkGCValues* GCValues
 187 import: gdk.Screen
 188 structWrap: GdkScreen* Screen
 189 import: gdk.GC
 190 structWrap: GdkGC* GC
 191 import: gdk.Color
 192 structWrap: GdkColor* Color
 193 import: gdk.Font
 194 structWrap: GdkFont* Font
 195 import: gdk.Pixmap
 196 structWrap: GdkPixmap* Pixmap
 197 import: gdk.Bitmap
 198 structWrap: GdkBitmap* Bitmap
 199 #import: gdk.Rectangle
 200 #structWrap: GdkRectangle* Rectangle
 201 import: gdk.Region
 202 structWrap: GdkRegion* Region
 203 import: gdk.Colormap
 204 structWrap: GdkColormap* Colormap
 205 outFile: GC
 206
 207 file: gdk-Drawing-Primitives.html
 208 struct: GdkDrawable
 209 class: Drawable
 210 prefix: gdk_drawable_
 211 prefix: gdk_
 212 import: glib.Str
 213 import: gdk.Drawable
 214 structWrap: GdkDrawable* Drawable
 215 import: gdk.Display
 216 structWrap: GdkDisplay* Display
 217 import: gdk.Screen
 218 structWrap: GdkScreen* Screen
 219 import: gdk.Visual
 220 structWrap: GdkVisual* Visual
 221 import: gdk.Colormap
 222 structWrap: GdkColormap* Colormap
 223 import: gdk.Region
 224 structWrap: GdkRegion* Region
 225 import: gdk.GC
 226 structWrap: GdkGC* GC
 227 #import: gdk.Point
 228 #structWrap: GdkPoint* Point
 229 import: gdk.Pixbuf
 230 structWrap: GdkPixbuf* Pixbuf
 231 #import: gdk.Segment
 232 #structWrap: GdkSegment* Segment
 233 #import: gdk.Trapezoid
 234 #structWrap: GdkTrapezoid* Trapezoid
 235 import: gdk.Color
 236 structWrap: GdkColor* Color
 237 import: gdk.Font
 238 structWrap: GdkFont* Font
 239 #import: gdk.WChar
 240 #structWrap: GdkWChar* WChar
 241 import: gdk.ImageGdk
 242 structWrap: GdkImage* ImageGdk
 243
 244 import: pango.PgContext
 245 structWrap: PangoContext* PgContext
 246 import: pango.PgItem
 247 structWrap: PangoItem* PgItem
 248 import: pango.PgLayout
 249 structWrap: PangoLayout* PgLayout
 250 import: pango.PgFontDescription
 251 structWrap: PangoFontDescription* PgFontDescription
 252 import: pango.PgFontMetrics
 253 structWrap: PangoFontMetrics* PgFontMetrics
 254 import: pango.PgFontFamily
 255 structWrap: PangoFontFamily* PgFontFamily
 256 import: pango.PgFontFace
 257 structWrap: PangoFontFace* PgFontFace
 258 import: pango.PgFontMap
 259 structWrap: PangoFontMap* PgFontMap
 260 import: pango.PgFontsetSimple
 261 structWrap: PangoFontsetSimple* PgFontsetSimple
 262 import: pango.PgAttribute
 263 structWrap: PangoAttribute* PgAttribute
 264 import: pango.PgAttributeList
 265 structWrap: PangoAttributeList* PgAttributeList
 266 import: pango.PgLanguage
 267 structWrap: PangoLanguage* PgLanguage
 268 import: pango.PgTabArray
 269 structWrap: PangoTabArray* PgTabArray
 270 import: pango.PgLayout
 271 structWrap: PangoLayout* PgLayout
 272 import: pango.PgLayoutIter
 273 structWrap: PangoLayoutIter* PgLayoutIter
 274 import: pango.PgScriptIter
 275 structWrap: PangoScriptIter* PgScriptIter
 276
 277 code: start
 278         /**
 279          * Draws an outlined or filled polygon.
 280          * drawable:
 281          *  a GdkDrawable (a GdkWindow or a GdkPixmap).
 282          * gc:
 283          *  a GdkGC.
 284          * filled:
 285          *  TRUE if the polygon should be filled. The polygon is closed
 286          *  automatically, connecting the last point to the first point if
 287          *  necessary.
 288          * points:
 289          *  an array of GdkPoint structures specifying the points making
 290          *  up the polygon.
 291          */
 292         public void drawPolygon(GC gc, int filled, GdkPoint[] points)
 293         {
 294                 // void gdk_draw_polygon (GdkDrawable *drawable,  GdkGC *gc,  gboolean filled,  GdkPoint *points,  gint npoints);
 295                 gdk_draw_polygon(gdkDrawable, gc.getGCStruct(), filled, points.ptr, points.length);
 296         }
 297
 298         public void drawPixbuf(Pixbuf pixbuf, int destX, int destY)
 299         {
 300                 drawPixbuf(null, pixbuf, destX, destY);
 301         }
 302         public void drawPixbuf(GC gc, Pixbuf pixbuf, int destX, int destY)
 303         {
 304                 if ( pixbuf is null ) return;
 305                 gdk_draw_pixbuf(gdkDrawable,
 306                                                 (gc is null) ? null : gc.getGCStruct(),
 307                                                 pixbuf.getPixbufStruct(),
 308                                                 0, 0, destX, destY,
 309                                                 pixbuf.getWidth(), pixbuf.getHeight(),
 310                                                 GdkRgbDither.NORMAL,
 311                                                 0, 0);
 312         }
 313
 314
 315
 316
 317 code: end
 318
 319 outFile: Drawable
 320
 321 file: gdk-Bitmaps-and-Pixmaps.html
 322
 323 struct: GdkPixmap
 324 class: Pixmap
 325 prefix: gdk_pixmap_
 326 noprefix: gdk_bitmap_
 327 import: glib.Str
 328 import: gdk.Drawable
 329 structWrap: GdkDrawable* Drawable
 330 import: gdk.Pixmap
 331 structWrap: GdkPixmap* Pixmap
 332 import: gdk.Color
 333 structWrap: GdkColor* Color
 334 #import: gdk.Bitmap*
 335 #structWrap: GdkBitmap** Bitmap*
 336 import: gdk.Colormap
 337 structWrap: GdkColormap* Colormap
 338 outFile: Pixmap
 339
 340 struct: GdkBitmap
 341 class: Bitmap
 342 prefix: gdk_bitmap_
 343 strictPrefix: Yes
 344 import: glib.Str
 345 import: gdk.Bitmap
 346 structWrap: GdkBitmap* Bitmap
 347 import: gdk.Drawable
 348 structWrap: GdkDrawable* Drawable
 349 outFile: Bitmap
 350
 351 file: gdk-GdkRGB.html
 352 class: RGB
 353 prefix: gdk_
 354 import: gdk.Drawable
 355 structWrap: GdkDrawable* Drawable
 356 import: gdk.GC
 357 structWrap: GdkGC* GC
 358 #import: gdk.RgbCmap
 359 #structWrap: GdkRgbCmap* RgbCmap
 360 import: gdk.Colormap
 361 structWrap: GdkColormap* Colormap
 362 import: gdk.Color
 363 structWrap: GdkColor* Color
 364 import: gdk.Visual
 365 structWrap: GdkVisual* Visual
 366 outFile: RGB
 367
 368 file: gdk-Images.html
 369 struct: GdkImage
 370 class: ImageGdk
 371 prefix: gdk_image_
 372 import: gdk.Visual
 373 structWrap: GdkVisual* Visual
 374 import: gdk.Drawable
 375 structWrap: GdkDrawable* Drawable
 376 import: gdk.Colormap
 377 structWrap: GdkColormap* Colormap
 378 outFile: ImageGdk
 379
 380 ## move to GdkPixbuf? no?
 381 ## extend GdkPixbuf? Yes?
 382
 383
 384
 385 file: gdk-Pixbufs.html
 386 struct: GdkPixbuf
 387 class: Pixbuf
 388 prefix: gdk_pixbuf_
 389 import: glib.Str
 390 import: glib.Str
 391 prefix: gdk_pixbuf_
 392 noprefix: gdk_pixbuf_ref
 393 noprefix: gdk_pixbuf_unref
 394 #import: g.Error*
 395 #structWrap: GError** Error*
 396 #import: gdkpixbuf.Pixbuf
 397 structWrap: GdkPixbuf* Pixbuf
 398 import: gdkpixbuf.PixbufFormat
 399 structWrap: GdkPixbufFormat* PixbufFormat
 400 import: gdk.Drawable
 401 structWrap: GdkDrawable* Drawable
 402 import: gdk.Bitmap
 403 structWrap: GdkBitmap* Bitmap
 404 import: gdk.Colormap
 405 structWrap: GdkColormap* Colormap
 406 import: gdk.ImageGdk
 407 structWrap: GdkImage* ImageGdk
 408
 409 # this will create a new pixbuf but the wrapper will pass the existing pixbuf struct
 410 nocode: gdk_pixbuf_get_from_drawable
 411
 412 code: start
 413         /**
 414          * Transfers image data from a GdkDrawable and converts it to an RGB(A)
 415          * representation inside a GdkPixbuf. In other words, copies
 416          * image data from a server-side drawable to a client-side RGB(A) buffer.
 417          * This allows you to efficiently read individual pixels on the client side.
 418          * If the drawable src has no colormap (gdk_drawable_get_colormap()
 419          * returns NULL), then a suitable colormap must be specified.
 420          * Typically a GdkWindow or a pixmap created by passing a GdkWindow
 421          * to gdk_pixmap_new() will already have a colormap associated with
 422          * it. If the drawable has a colormap, the cmap argument will be
 423          * ignored. If the drawable is a bitmap (1 bit per pixel pixmap),
 424          * then a colormap is not required; pixels with a value of 1 are
 425          * assumed to be white, and pixels with a value of 0 are assumed to be
 426          * black. For taking screenshots, gdk_colormap_get_system() returns
 427          * the correct colormap to use.
 428          * If the specified destination pixbuf dest is NULL, then this
 429          * function will create an RGB pixbuf with 8 bits per channel and no
 430          * alpha, with the same size specified by the width and height
 431          * arguments. In this case, the dest_x and dest_y arguments must be
 432          * specified as 0. If the specified destination pixbuf is not NULL
 433          * and it contains alpha information, then the filled pixels will be
 434          * set to full opacity (alpha = 255).
 435          * If the specified drawable is a pixmap, then the requested source
 436          * rectangle must be completely contained within the pixmap, otherwise
 437          * the function will return NULL. For pixmaps only (not for windows)
 438          * passing -1 for width or height is allowed to mean the full width
 439          * or height of the pixmap.
 440          * If the specified drawable is a window, and the window is off the
 441          * screen, then there is no image data in the obscured/offscreen
 442          * regions to be placed in the pixbuf. The contents of portions of the
 443          * pixbuf corresponding to the offscreen region are undefined.
 444          * If the window you're obtaining data from is partially obscured by
 445          * other windows, then the contents of the pixbuf areas corresponding
 446          * to the obscured regions are undefined.
 447          * If the target drawable is not mapped (typically because it's
 448          * iconified/minimized or not on the current workspace), then NULL
 449          * will be returned.
 450          * If memory can't be allocated for the return value, NULL will be returned
 451          * instead.
 452          * (In short, there are several ways this function can fail, and if it fails
 453          *  it returns NULL; so check the return value.)
 454          * This function calls gdk_drawable_get_image() internally and
 455          * converts the resulting image to a GdkPixbuf, so the
 456          * documentation for gdk_drawable_get_image() may also be relevant.
 457          * dest:
 458          *  Destination pixbuf, or NULL if a new pixbuf should be created.
 459          * src:
 460          *  Source drawable.
 461          * cmap:
 462          *  A colormap if src doesn't have one set.
 463          * src_x:
 464          *  Source X coordinate within drawable.
 465          * src_y:
 466          *  Source Y coordinate within drawable.
 467          * dest_x:
 468          *  Destination X coordinate in pixbuf, or 0 if dest is NULL.
 469          * dest_y:
 470          *  Destination Y coordinate in pixbuf, or 0 if dest is NULL.
 471          * width:
 472          *  Width in pixels of region to get.
 473          * height:
 474          *  Height in pixels of region to get.
 475          * Returns:
 476          *  The same pixbuf as dest if it was non-NULL, or a newly-created
 477          * pixbuf with a reference count of 1 if no destination pixbuf was specified, or NULL on error
 478          */
 479         public Pixbuf getFromDrawable(Drawable src, Colormap cmap, int srcX, int srcY, int destX, int destY, int width, int height)
 480         {
 481                 // GdkPixbuf* gdk_pixbuf_get_from_drawable (GdkPixbuf *dest,  GdkDrawable *src,  GdkColormap *cmap,  int src_x,  int src_y,  int dest_x,  int dest_y,  int width,  int height);
 482                 return new Pixbuf( gdk_pixbuf_get_from_drawable(null, (src is null) ? null : src.getDrawableStruct(), (cmap is null) ? null : cmap.getColormapStruct(), srcX, srcY, destX, destY, width, height) );
 483         }
 484
 485         /**
 486          * SetFromDrawable is different from GetFrom Drawable as it doesn't create a new pixbuf
 487          */
 488         public void setFromDrawable(Drawable src, int srcX, int srcY, int width, int height)
 489         {
 490                 gdk_pixbuf_get_from_drawable(
 491                                         gdkPixbuf,      // gdkPixbuf
 492                                         src.getDrawableStruct(),
 493                                         null, // colormap
 494                                         srcX, srcY,
 495                                         0, 0,           // destination x and y
 496                                         width, height);
 497         }
 498
 499         /**
 500          * Creates a new Pixbuf from a drawable.
 501          * this is a simplyfied GetFromDrawable
 502          */
 503         this(Drawable src, int srcX, int srcY, int width, int height)
 504         {
 505                 GdkPixbuf* pb = gdk_pixbuf_get_from_drawable(
 506                                         null,   // gdkPixbuf
 507                                         src.getDrawableStruct(),
 508                                         null, // colormap
 509                                         srcX, srcY,
 510                                         0, 0,           // destination x and y
 511                                         width, height);
 512                 this(pb);
 513         }
 514
 515 code: end
 516
 517 openFile: Pixbuf
 518
 519 file: ../gdk-pixbuf/gdk-pixbuf-creating.html
 520 struct: GdkPixbuf
 521 class: Pixbuf
 522
 523 text: start
 524 gdk_pixbuf_get_type ()
 525
 526 GType         gdk_pixbuf_get_type           ();
 527 <hr>
 528 text: end
 529
 530 mergeFile: Pixbuf
 531
 532 file: ../gdk-pixbuf/gdk-pixbuf-gdk-pixbuf.html
 533 mergeFile:  Pixbuf
 534
 535 file: ../gdk-pixbuf/gdk-pixbuf-refcounting.html
 536 mergeFile:  Pixbuf
 537
 538 file: ../gdk-pixbuf/gdk-pixbuf-file-loading.html
 539 noprefix: gdk_pixbuf_get_file_info
 540 mergeFile:  Pixbuf
 541
 542 file: ../gdk-pixbuf/gdk-pixbuf-file-saving.html
 543 mergeFile:  Pixbuf
 544
 545 file: ../gdk-pixbuf/gdk-pixbuf-scaling.html
 546 mergeFile:  Pixbuf
 547
 548 file: ../gdk-pixbuf/gdk-pixbuf-util.html
 549 closeFile:  Pixbuf
 550
 551 file: gdk-Colormaps-and-Colors.html
 552
 553 struct: GdkColormap
 554 class: Colormap
 555 prefix: gdk_colormap_
 556 noprefix: gdk_color_
 557 import: gdk.Visual
 558 structWrap: GdkVisual* Visual
 559 import: gdk.Colormap
 560 structWrap: GdkColormap* Colormap
 561 import: gdk.Color
 562 structWrap: GdkColor* Color
 563 import: gdk.Screen
 564 structWrap: GdkScreen* Screen
 565 outFile: Colormap
 566
 567 struct: GdkColor
 568 class: Color
 569 prefix: gdk_color_
 570 import: glib.Str
 571 strictPrefix: Yes
 572 import: gdk.Color
 573 structWrap: GdkColor* Color
 574 import: gdk.Colormap
 575 structWrap: GdkColormap* Colormap
 576
 577 code: start
 578
 579         static Color _black;
 580         static Color _white;
 581
 582         /**
 583          * Creates a new Color
 584          */
 585         this()
 586         {
 587                 this(new GdkColor);
 588         }
 589
 590         this(ubyte red, ubyte green, ubyte blue)
 591         {
 592                 this();
 593                 set8(red, green, blue);
 594         }
 595
 596         /**
 597          * Creates a new Color with RGB values
 598          * @param red
 599          * @param green
 600          * @param blue
 601          */
 602         this(guint16 red, guint16 green, guint16 blue)
 603         {
 604                 this();
 605                 //printf("Color.this red , green , blue = %d %d %d\n", red, green, blue);
 606                 set(red,green,blue);
 607         }
 608
 609         this(uint rgb)
 610         {
 611                 this();
 612                 //printf("Color.this uint %X\n",rgb);
 613                 set( ((rgb&0xFFFF)),((rgb&0xFFFF00000000)>>32),(rgb&0xFFFF0000)>>16);
 614         }
 615
 616         this(int rgb)
 617         {
 618                 this();
 619                 //printf("Color.this int %X\n",rgb);
 620                 set8( cast(byte)((rgb&0xFF0000)>>16),cast(byte)((rgb&0x00FF00)>>8),cast(byte)(rgb&0xFF));
 621         }
 622
 623         static Color black()
 624         {
 625                 if ( !_black )
 626                 {
 627                         _black = new Color(cast(ubyte)0,cast(ubyte)0,cast(ubyte)0);
 628                 }
 629                 return _black;
 630         }
 631         static Color white()
 632         {
 633                 if ( !_white )
 634                 {
 635                         _white = new Color(cast(ubyte)255,cast(ubyte)255,cast(ubyte)255);
 636                 }
 637                 return _white;
 638         }
 639
 640         /**
 641          * Sets the Color with RGB values
 642          * @param red
 643          * @param green
 644          * @param blue
 645          */
 646         void set(guint16 red, guint16 green, guint16 blue)
 647         {
 648                 //printf("Color.set %X %X %X\n",red,green,blue);
 649                 gdkColor.red = red;
 650                 gdkColor.green = green;
 651                 gdkColor.blue = blue;
 652                 gdkColor.pixel = (red&0xFF00 << 8) | (green&0xFF00) | (blue >> 8) ;
 653                 //printf("Color.pixel %X \n",gdkColor.pixel);
 654                 //allocColor();
 655                 //printf("set pixel = %X\n", gdkColor.pixel);
 656         }
 657
 658         void set8(ubyte red, ubyte green, ubyte blue)
 659         {
 660                 //printf("Color.set %X %X %X\n",red,green,blue);
 661
 662                 gdkColor.red = red * 257;
 663                 gdkColor.green = green * 257;
 664                 gdkColor.blue = blue * 257;
 665                 gdkColor.pixel = (red << 16) | (green << 8 ) | blue;
 666                 //printf("set8 pixel = %X\n", gdkColor.pixel);
 667         }
 668
 669         uint getValue()
 670         {
 671                 return (gdkColor.red <<32) | (gdkColor.green << 16) | (gdkColor.blue);
 672         }
 673
 674         int getValue24()
 675         {
 676                 return ((gdkColor.red&0xFF00)<<8 ) | ((gdkColor.green&0xFF00)) | ((gdkColor.blue&0xFF00) >>8);
 677         }
 678
 679         uint getPixelValue()
 680         {
 681                 return gdkColor.pixel;
 682         }
 683
 684 code: end
 685 outFile: Color
 686
 687 file: gdk-Visuals.html
 688 struct: GdkVisual
 689 class: Visual
 690 prefix: gdk_visual_
 691 #import: gdk.VisualType*
 692 #structWrap: GdkVisualType** VisualType*
 693 import: glib.ListG
 694 structWrap: GList* ListG
 695 import: gdk.Visual
 696 structWrap: GdkVisual* Visual
 697 import: gdk.Screen
 698 structWrap: GdkScreen* Screen
 699 outFile: Visual
 700
 701 file: gdk-Fonts.html
 702 struct: GdkFont
 703 class: Font
 704 prefix: gdk_font_
 705 prefix: gdk_
 706 import: glib.Str
 707 import: gdk.Font
 708 structWrap: GdkFont* Font
 709 import: gdk.Display
 710 structWrap: GdkDisplay* Display
 711 #import: gdk.WChar
 712 #structWrap: GdkWChar* WChar
 713
 714 code: start
 715         /**
 716          * Create and loads a font
 717          */
 718         public this(char[] fontName)
 719         {
 720                 this(gdk_font_load(Str.toStringz(fontName)));
 721         }
 722 code: end
 723 outFile: Font
 724
 725 file: gdk-Cursors.html
 726 struct: GdkCursor
 727 class: Cursor
 728 prefix: gdk_cursor_
 729 import: glib.Str
 730 import: gdk.Pixmap
 731 structWrap: GdkPixmap* Pixmap
 732 import: gdk.Color
 733 structWrap: GdkColor* Color
 734 import: gdk.Display
 735 structWrap: GdkDisplay* Display
 736 import: gdk.Pixbuf
 737 structWrap: GdkPixbuf* Pixbuf
 738 import: gdk.Cursor
 739 structWrap: GdkCursor* Cursor
 740 outFile: Cursor
 741
 742 file: gdk-Windows.html
 743 struct: GdkWindow
 744 class: Window
 745 prefix: gdk_window_
 746 noprefix: gdk_window_invalidate_maybe_recurse
 747 import: glib.Str
 748 #import: gdk.WindowAttr
 749 #structWrap: GdkWindowAttr* WindowAttr
 750 import: gdk.Window
 751 structWrap: GdkWindow* Window
 752 import: gdk.Region
 753 structWrap: GdkRegion* Region
 754 #import: gdk.Geometry
 755 #structWrap: GdkGeometry* Geometry
 756 import: gdk.Rectangle
 757 structWrap: GdkRectangle* Rectangle
 758 #import: gdk.Drawable*
 759 #structWrap: GdkDrawable** Drawable*
 760 import: gdk.Bitmap
 761 structWrap: GdkBitmap* Bitmap
 762 import: gdk.Color
 763 structWrap: GdkColor* Color
 764 import: gdk.Pixmap
 765 structWrap: GdkPixmap* Pixmap
 766 import: gdk.Cursor
 767 structWrap: GdkCursor* Cursor
 768 import: glib.ListG
 769 structWrap: GList* ListG
 770 #import: gdk.ModifierType
 771 #structWrap: GdkModifierType* ModifierType
 772 #import: gdk.WMDecoration
 773 #structWrap: GdkWMDecoration* WMDecoration
 774 #import: gdk.PointerHooks
 775 #structWrap: GdkPointerHooks* PointerHooks
 776 outFile: Window
 777
 778 file: gdk-Events.html
 779 struct: GdkEvent
 780 class: Event
 781 prefix: gdk_event_
 782 import: glib.Str
 783 import: gdk.Event
 784 structWrap: GdkEvent* Event
 785 import: gdk.Window
 786 structWrap: GdkWindow* Window
 787 #import: gdk.ModifierType
 788 #structWrap: GdkModifierType* ModifierType
 789 import: gdk.Display
 790 structWrap: GdkDisplay* Display
 791 import: gdk.Screen
 792 structWrap: GdkScreen* Screen
 793 import: gobject.Value
 794 structWrap: GValue* Value
 795
 796 code: start
 797         public static bool isDoubleClick(GdkEventButton* eventButton, int buttonNumber=1)
 798         {
 799                 return eventButton.button==buttonNumber
 800                                 && eventButton.type == EventType.DOUBLE_BUTTON_PRESS;
 801         }
 802
 803         public static bool isTrippleClick(GdkEventButton* eventButton, int buttonNumber=1)
 804         {
 805                 return eventButton.button==buttonNumber
 806                                 && eventButton.type == EventType.TRIPPLE_BUTTON_PRESS;
 807         }
 808
 809 code: end
 810
 811 outFile: Event
 812
 813 file: gdk-Event-Structures.html
 814 #struct:
 815 #class:
 816 #prefix:
 817 outFile: EventStruct
 818
 819 file: gdk-Keyboard-Handling.html
 820 struct: GdkKeymap
 821 class: Keymap
 822 prefix: gdk_keymap_
 823 import: glib.Str
 824 import: gdk.Keymap
 825 structWrap: GdkKeymap* Keymap
 826 import: gdk.Display
 827 structWrap: GdkDisplay* Display
 828 #import: gdk.KeymapKey
 829 #structWrap: GdkKeymapKey* KeymapKey
 830 #import: gdk.ModifierType
 831 #structWrap: GdkModifierType* ModifierType
 832 #import: gdk.KeymapKey*
 833 #structWrap: GdkKeymapKey** KeymapKey*
 834 outFile: Keymap
 835
 836 file: gdk-Selections.html
 837 class: Selection
 838 prefix: gdk_selection_
 839 import: gdk.Window
 840 structWrap: GdkWindow* Window
 841 import: gdk.Display
 842 structWrap: GdkDisplay* Display
 843 #import: gdk.Atom
 844 #structWrap: GdkAtom* Atom
 845 outFile: Selection
 846
 847 file: gdk-Drag-and-Drop.html
 848 struct: GdkDragContext
 849 class: DragContext
 850 prefix: gdk-drag_context_
 851 import: gdk.DragContext
 852 structWrap: GdkDragContext* DragContext
 853 import: gdk.Window
 854 structWrap: GdkWindow* Window
 855 #import: gdk.Window*
 856 #structWrap: GdkWindow** Window*
 857 #import: gdk.DragProtocol
 858 #structWrap: GdkDragProtocol* DragProtocol
 859 import: gdk.Screen
 860 structWrap: GdkScreen* Screen
 861 import: glib.ListG
 862 structWrap: GList* ListG
 863 import: gdk.Display
 864 structWrap: GdkDisplay* Display
 865 outFile: DragContext
 866
 867 # no struct
 868 #file: gdk-Properties-and-Atoms.html
 869 #struct:
 870 #class:
 871 #prefix:
 872 #outFile:
 873
 874 file: gdk-Threads.html
 875 #class:
 876 #prefix:
 877 outFile: Threads
 878
 879 file: gdk-Input.html
 880 class: Input
 881 prefix: gdk_input_
 882 outFile: Input
 883
 884 file: gdk-Input-Devices.html
 885 struct: GdkDevice
 886 class: Device
 887 prefix: gdk_device_
 888 import: glib.ListG
 889 structWrap: GList* ListG
 890 import: gdk.Device
 891 structWrap: GdkDevice* Device
 892 import: gdk.Window
 893 structWrap: GdkWindow* Window
 894 outFile: Device
 895
 896 #file: gdk-Pango-Interaction.html
 897 #struct:
 898 #class:
 899 #prefix:
 900 #outFile:
 901
 902
 903
 904 file: gdk-X-Window-System-Interaction.html
 905 #struct: GdkDrawable #we're not wrapping a struct ATM
 906 #we're just putting these methods to be static.
 907 class: X11
 908 prefix: gdk_x11_
 909 import: gdk.Drawable
 910 structWrap: GdkDrawable* Drawable
 911 import: gdk.Display
 912 structWrap: GdkDisplay* Display
 913 import: gdk.Window
 914 structWrap: GdkWindow* Window
 915 #more types should added here like atom, visual, image, etc...
 916 #for now we just disable all the stuff with X types in them
 917 #only thing left is XID which is just an uint.
 918 nocode: gdkx_visual_get
 919 nocode: gdkx_colormap_get
 920 nocode: gdk_pixmap_foreign_new
 921 nocode: gdk_pixmap_foreign_new_for_display
 922 nocode: gdk_pixmap_foreign_new_for_screen
 923 nocode: gdk_window_foreign_new_for_display
 924 nocode: gdk_xid_table_lookup_for_display
 925 nocode: gdk_window_lookup_for_display
 926 nocode: gdk_pixmap_lookup_for_display
 927 nocode: gdk_x11_lookup_xdisplay
 928 nocode: gdk_net_wm_supports
 929 nocode: gdk_x11_screen_supports_net_wm_hint
 930 nocode: gdk_x11_screen_get_window_manager_name
 931 nocode: gdk_x11_screen_lookup_visual
 932 nocode: gdk_x11_display_get_user_time
 933 nocode: gdk_x11_colormap_foreign_new
 934 nocode: gdk_x11_colormap_get_xcolormap
 935 nocode: gdk_x11_colormap_get_xdisplay
 936 nocode: gdk_x11_cursor_get_xcursor
 937 nocode: gdk_x11_cursor_get_xdisplay
 938 nocode: gdk_x11_display_get_xdisplay
 939 nocode: gdk_x11_display_grab
 940 nocode: gdk_x11_display_ungrab
 941 nocode: gdk_x11_display_set_cursor_theme
 942 nocode: gdk_x11_register_standard_event_type
 943 nocode: gdk_x11_drawable_get_xdisplay
 944 nocode: gdk_x11_font_get_xdisplay
 945 nocode: gdk_x11_gc_get_xdisplay
 946 nocode: gdk_x11_gc_get_xgc
 947 nocode: gdk_x11_get_default_root_xwindow
 948 nocode: gdk_x11_get_default_xdisplay
 949 nocode: gdk_x11_image_get_xdisplay
 950 nocode: gdk_x11_image_get_ximage
 951 nocode: gdk_x11_screen_get_screen_number
 952 nocode: gdk_x11_screen_get_xscreen
 953 nocode: gdk_x11_visual_get_xvisual
 954 nocode: gdk_x11_atom_to_xatom
 955 nocode: gdk_x11_atom_to_xatom_for_display
 956 nocode: gdk_x11_xatom_to_atom
 957 nocode: gdk_x11_xatom_to_atom_for_display
 958 nocode: gdk_x11_get_xatom_by_name
 959 nocode: gdk_x11_get_xatom_by_name_for_display
 960 nocode: gdk_x11_get_xatom_name
 961 nocode: gdk_x11_get_xatom_name_for_display
 962 outFile: X11
 963
 964
 965 ############## cairo interaction ###############
 966
 967
 968 file: gdk-Cairo-Interaction.html
 969
 970 prefix: gdk_cairo_
 971 import: cairoLib.Cairo
 972 structWrap: cairo_t* Cairo
 973 structWrap: GdkDrawable* Drawable
 974 structWrap: GdkColor* Color
 975 structWrap: GdkPixbuf* Pixbuf
 976 structWrap: GdkPixmap* Pixmap
 977 structWrap: GdkRectangle* Rectangle
 978 structWrap: GdkRegion* Region
 979
 980 nocode: gdk_cairo_create
 981 nocode: gdk_cairo_set_source_color
 982 nocode: gdk_cairo_set_source_pixbuf
 983 nocode: gdk_cairo_set_source_pixmap
 984 nocode: gdk_cairo_rectangle
 985 nocode: gdk_cairo_region
 986
 987 code: start
 988
 989         /**
 990          * This file is not used,
 991          *
 992          * It is here just to tell you to look at
 993          * cairoLib.Cairo class for the methods that where here..
 994          */
 995
 996
 997 code: end
 998 outFile: GdkCairo
 999
1000
1001