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