diff options
Diffstat (limited to 'packages/gtk2/src/gtk+/gdk')
29 files changed, 5849 insertions, 0 deletions
diff --git a/packages/gtk2/src/gtk+/gdk/gdk2.pas b/packages/gtk2/src/gtk+/gdk/gdk2.pas new file mode 100644 index 0000000000..3441960018 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdk2.pas @@ -0,0 +1,240 @@ +{ + GDK - The GIMP Drawing Kit + + Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +} +unit gdk2; // keep unit name lowercase for kylix + +{$IFDEF FPC} + {$mode objfpc} +{$ENDIF} +{$IFDEF VER140} + {$DEFINE KYLIX} +{$ENDIF} + +interface + +uses glib2, gdk2pixbuf, pango; + +const +// OS dependent defines +{$ifdef win32} + {$DEFINE GDK_WINDOWING_WIN32} + gdklib = 'libgdk-win32-2.0-0.dll'; + {$IFDEF FPC} + {$ifndef NO_SMART_LINK} + {$smartlink on} + {$endif} + {$ENDIF} + GDK_HAVE_WCHAR_H=1; + GDK_HAVE_WCTYPE_H=1; +{$else} + {$ifdef darwin} + gdklib = 'gdk-x11-2.0'; + {$linklib gtk-x11-2.0} + {$linklib gdk-x11-2.0} + {$linklib pango-1.0.0} + {$linklib glib-2.0.0} + {$linklib gobject-2.0.0} + {$linklib gdk_pixbuf-2.0.0} + {$linklib atk-1.0.0} + {$else} + {$ifdef UseCustomLibs} + gdklib = ''; + {$else} + gdklib = 'libgdk-x11-2.0.so'; + {$endif} + {$endif} +{$endif} + +{$IFNDEF KYLIX} + {$PACKRECORDS C} +{$ELSE} + {$ALIGN 4} + {$WEAKPACKAGEUNIT} + {$WARNINGS OFF} +{$ENDIF} + + +// the included header files: +{ + number of points to buffer before sending them off + to scanlines() : Must be an even number + } +const + NUMPTSTOBUFFER = 200; + GDK_MAX_TIMECOORD_AXES = 128; + +type + PGdkDeviceClass = ^TGdkDeviceClass; + TGdkDeviceClass = record + parent_class: TGObjectClass; + end; + + PGdkVisualClass = ^TGdkVisualClass; + TGdkVisualClass = record + parent_class: TGObjectClass; + end; + +{$DEFINE read_forward_definitions} +{$include gdkincludes.inc} +{$UNDEF read_forward_definitions} + +{$DEFINE read_interface_types} +{$include gdkincludes.inc} +{$UNDEF read_interface_types} + +{$DEFINE read_interface_rest} +{$include gdkincludes.inc} +{$UNDEF read_interface_rest} + +procedure gdk_parse_args(argc:Pgint; var argv:PPgchar); cdecl; external gdklib; +procedure gdk_init(argc:Pgint; var argv:PPgchar); cdecl; external gdklib; +function gdk_init_check(argc:Pgint; var argv:PPgchar):gboolean; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_exit(error_code:gint); cdecl; external gdklib; +{$endif} +{ GDK_DISABLE_DEPRECATED } + +function gdk_set_locale:Pgchar; cdecl; external gdklib; +function gdk_get_program_class:Pchar; cdecl; external gdklib; +procedure gdk_set_program_class(program_class:Pchar); cdecl; external gdklib; + +{ Push and pop error handlers for X errors } +procedure gdk_error_trap_push; cdecl; external gdklib; +function gdk_error_trap_pop:gint; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_set_use_xshm(use_xshm:gboolean); cdecl; external gdklib; +function gdk_get_use_xshm:gboolean; cdecl; external gdklib; +{$endif} +{ GDK_DISABLE_DEPRECATED } + +function gdk_get_display:Pgchar; cdecl; external gdklib; +function gdk_get_display_arg_name:Pgchar; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +function gdk_input_add_full(source:gint; condition:TGdkInputCondition; _function:TGdkInputFunction; data:gpointer; destroy:TGdkDestroyNotify):gint; cdecl; external gdklib; +function gdk_input_add(source:gint; condition:TGdkInputCondition; _function:TGdkInputFunction; data:gpointer):gint; cdecl; external gdklib; +procedure gdk_input_remove(tag:gint); cdecl; external gdklib; +{$endif} +{ GDK_DISABLE_DEPRECATED } + +function gdk_pointer_grab(window:PGdkWindow; owner_events:gboolean; event_mask:TGdkEventMask; confine_to:PGdkWindow; cursor:PGdkCursor; + time:guint32):TGdkGrabStatus; cdecl; external gdklib; +function gdk_keyboard_grab(window:PGdkWindow; owner_events:gboolean; time:guint32):TGdkGrabStatus; cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +procedure gdk_pointer_ungrab(time:guint32); cdecl; external gdklib; +procedure gdk_keyboard_ungrab(time:guint32); cdecl; external gdklib; +function gdk_pointer_is_grabbed:gboolean; cdecl; external gdklib; +function gdk_screen_width:gint; cdecl; external gdklib; +function gdk_screen_height:gint; cdecl; external gdklib; +function gdk_screen_width_mm:gint; cdecl; external gdklib; +function gdk_screen_height_mm:gint; cdecl; external gdklib; +procedure gdk_beep; cdecl; external gdklib; +{$endif} +{ GDK_MULTIHEAD_SAFE } + +procedure gdk_flush; cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +procedure gdk_set_double_click_time(msec:guint); cdecl; external gdklib; +{$endif} + +{ Rectangle utilities } +function gdk_rectangle_intersect(src1:PGdkRectangle; src2:PGdkRectangle; dest:PGdkRectangle):gboolean; cdecl; external gdklib; +procedure gdk_rectangle_union(src1:PGdkRectangle; src2:PGdkRectangle; dest:PGdkRectangle); cdecl; external gdklib; +function gdk_rectangle_get_type:GType; cdecl; external gdklib; +function GDK_TYPE_RECTANGLE : GType; + +{ Conversion functions between wide char and multibyte strings. } +function gdk_wcstombs(src:PGdkWChar):Pgchar; cdecl; external gdklib; +function gdk_mbstowcs(dest:PGdkWChar; src:Pgchar; dest_max:gint):gint; cdecl; external gdklib; +{ Miscellaneous } + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_event_send_client_message(event:PGdkEvent; xid:guint32):gboolean; cdecl; external gdklib; +procedure gdk_event_send_clientmessage_toall(event:PGdkEvent); cdecl; external gdklib; +{$endif} + +function gdk_event_send_client_message_for_display(display:PGdkDisplay; event:PGdkEvent; xid:guint32):gboolean; cdecl; external gdklib; + + +{$IFNDEF KYLIX} +{ Threading } +var + {$IFDEF WIN32} + gdk_threads_mutex : PGMutex; external gdklib name 'gdk_threads_mutex'; + {$ELSE} + gdk_threads_mutex : PGMutex; cvar; external; + {$ENDIF} +{$ENDIF} + +procedure gdk_threads_enter; cdecl; external gdklib; +procedure gdk_threads_leave; cdecl; external gdklib; +procedure gdk_threads_init; cdecl; external gdklib; + +procedure _GDK_THREADS_ENTER; +procedure _GDK_THREADS_LEAVE; + + + +implementation + +{$IFNDEF KYLIX} +{ There is a bug in the compiler. If an external variable is not used, it will + create code, that can be relocated by the linker. + So, use them in this hidden procedure. +} +procedure CheckUnusedVariable; [Public]; +begin + if (gdk_threads_mutex<>nil) then ; +end; +{$ENDIF} + +//------------------------------------------------------------------------------ + +function GDK_TYPE_RECTANGLE : GType; +begin + GDK_TYPE_RECTANGLE:=gdk_rectangle_get_type; +end; + +procedure _GDK_THREADS_ENTER; +begin +{$ifdef G_THREADS_ENABLED} + if (gdk_threads_mutex) then + g_mutex_lock (gdk_threads_mutex); +{$endif} +end; + +procedure _GDK_THREADS_LEAVE; +begin +{$ifdef G_THREADS_ENABLED} + if (gdk_threads_mutex) then + g_mutex_unlock (gdk_threads_mutex); +{$endif} +end; + +// call implementation parts of header files +{$DEFINE read_implementation} +{$include gdkincludes.inc} +{$UNDEF read_implementation} + +end. diff --git a/packages/gtk2/src/gtk+/gdk/gdkcolor.inc b/packages/gtk2/src/gtk+/gdk/gdkcolor.inc new file mode 100644 index 0000000000..c0df91699b --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkcolor.inc @@ -0,0 +1,141 @@ +// included by gdk2.pp + +{$IFDEF read_forward_definitions} +{ The color type. + A color consists of red, green and blue values in the + range 0-65535 and a pixel value. The pixel value is highly + dependent on the depth and colormap which this color will + be used to draw into. Therefore, sharing colors between + colormaps is a bad idea. + } + PGdkColor = ^TGdkColor; + TGdkColor = record + pixel : guint32; + red : guint16; + green : guint16; + blue : guint16; + end; + + PGdkColormap = ^TGdkColormap; +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PGdkColormapClass = ^TGdkColormapClass; + TGdkColormapClass = record + parent_class : TGObjectClass; + end; + + TGdkColormap = record + parent_instance : TGObject; + size : gint; + colors : PGdkColor; + visual : PGdkVisual; + windowing_data : gpointer; + screen : PGdkScreen; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} + +{ The colormap type. } +function GDK_TYPE_COLORMAP : GType; +function GDK_COLORMAP(anObject : pointer) : PGdkColormap; +function GDK_COLORMAP_CLASS(klass : pointer) : PGdkColormapClass; +function GDK_IS_COLORMAP(anObject : pointer) : boolean; +function GDK_IS_COLORMAP_CLASS(klass : pointer) : boolean; +function GDK_COLORMAP_GET_CLASS(obj : pointer) : PGdkColormapClass; + +function GDK_TYPE_COLOR : GType; + +function gdk_colormap_get_type:GType; cdecl; external gdklib; +function gdk_colormap_new(visual:PGdkVisual; allocate:gboolean):PGdkColormap; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +function gdk_colormap_ref(cmap:PGdkColormap):PGdkColormap; cdecl; external gdklib; +procedure gdk_colormap_unref(cmap:PGdkColormap); cdecl; external gdklib; +{$endif} + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_colormap_get_system:PGdkColormap; cdecl; external gdklib; +{$endif} + +{$ifndef GDK_DISABLE_DEPRECATED} +function gdk_colormap_get_system_size:gint; cdecl; external gdklib; +procedure gdk_colormap_change(colormap:PGdkColormap; ncolors:gint); cdecl; external gdklib; +{$endif} + +function gdk_colormap_alloc_colors(colormap:PGdkColormap; colors:PGdkColor; ncolors:gint; writeable:gboolean; best_match:gboolean; + success:Pgboolean):gint; cdecl; external gdklib; +function gdk_colormap_alloc_color(colormap:PGdkColormap; color:PGdkColor; writeable:gboolean; best_match:gboolean):gboolean; cdecl; external gdklib; +procedure gdk_colormap_free_colors(colormap:PGdkColormap; colors:PGdkColor; ncolors:gint); cdecl; external gdklib; +procedure gdk_colormap_query_color(colormap:PGdkColormap; pixel:gulong; result:PGdkColor); cdecl; external gdklib; +function gdk_colormap_get_visual(colormap:PGdkColormap):PGdkVisual; cdecl; external gdklib; +function gdk_color_copy(color:PGdkColor):PGdkColor; cdecl; external gdklib; +procedure gdk_color_free(color:PGdkColor); cdecl; external gdklib; +function gdk_color_parse(spec:Pgchar; color:PGdkColor):gint; cdecl; external gdklib; +function gdk_color_hash(colora:PGdkColor):guint; cdecl; external gdklib; +function gdk_color_equal(colora:PGdkColor; colorb:PGdkColor):gboolean; cdecl; external gdklib; +function gdk_color_get_type:GType; cdecl; external gdklib; + +{ The following functions are deprecated } +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_colors_store(colormap:PGdkColormap; colors:PGdkColor; ncolors:gint); cdecl; external gdklib; +function gdk_colors_alloc(colormap:PGdkColormap; contiguous:gboolean; planes:Pgulong; nplanes:gint; pixels:Pgulong; + npixels:gint):gint; cdecl; external gdklib; +procedure gdk_colors_free(colormap:PGdkColormap; pixels:Pgulong; npixels:gint; planes:gulong); cdecl; external gdklib; +function gdk_color_white(colormap:PGdkColormap; color:PGdkColor):gint; cdecl; external gdklib; +function gdk_color_black(colormap:PGdkColormap; color:PGdkColor):gint; cdecl; external gdklib; +function gdk_color_alloc(colormap:PGdkColormap; color:PGdkColor):gint; cdecl; external gdklib; +function gdk_color_change(colormap:PGdkColormap; color:PGdkColor):gint; cdecl; external gdklib; +{$endif} + +{ GDK_DISABLE_DEPRECATED } +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_COLORMAP : GType; +begin + GDK_TYPE_COLORMAP:=gdk_colormap_get_type; +end; + +function GDK_COLORMAP(anObject : pointer) : PGdkColormap; +begin + GDK_COLORMAP:=PGdkColormap(G_TYPE_CHECK_INSTANCE_CAST(anObject, + GDK_TYPE_COLORMAP)); +end; + +function GDK_COLORMAP_CLASS(klass : pointer) : PGdkColormapClass; +begin + GDK_COLORMAP_CLASS:=PGdkColormapClass(G_TYPE_CHECK_CLASS_CAST(klass, + GDK_TYPE_COLORMAP)); +end; + +function GDK_IS_COLORMAP(anObject : pointer) : boolean; +begin + GDK_IS_COLORMAP:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_COLORMAP); +end; + +function GDK_IS_COLORMAP_CLASS(klass : pointer) : boolean; +begin + GDK_IS_COLORMAP_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_COLORMAP); +end; + +function GDK_COLORMAP_GET_CLASS(obj : pointer) : PGdkColormapClass; +begin + GDK_COLORMAP_GET_CLASS:=PGdkColormapClass(G_TYPE_INSTANCE_GET_CLASS(obj, + GDK_TYPE_COLORMAP)); +end; + +function GDK_TYPE_COLOR : GType; +begin + GDK_TYPE_COLOR:=gdk_color_get_type; +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkcursor.inc b/packages/gtk2/src/gtk+/gdk/gdkcursor.inc new file mode 100644 index 0000000000..59ecd453c4 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkcursor.inc @@ -0,0 +1,138 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} + +{ Cursor types. } + PGdkCursorType = ^TGdkCursorType; + TGdkCursorType = gint; + + PGdkCursor = ^TGdkCursor; + TGdkCursor = record + _type : TGdkCursorType; + ref_count : guint; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +const + GDK_CURSOR_IS_PIXMAP = -(1); + GDK_X_CURSOR = 0; + GDK_ARROW = 2; + GDK_BASED_ARROW_DOWN = 4; + GDK_BASED_ARROW_UP = 6; + GDK_BOAT = 8; + GDK_BOGOSITY = 10; + GDK_BOTTOM_LEFT_CORNER = 12; + GDK_BOTTOM_RIGHT_CORNER = 14; + GDK_BOTTOM_SIDE = 16; + GDK_BOTTOM_TEE = 18; + GDK_BOX_SPIRAL = 20; + GDK_CENTER_PTR = 22; + GDK_CIRCLE = 24; + GDK_CLOCK = 26; + GDK_COFFEE_MUG = 28; + GDK_CROSS = 30; + GDK_CROSS_REVERSE = 32; + GDK_CROSSHAIR = 34; + GDK_DIAMOND_CROSS = 36; + GDK_DOT = 38; + GDK_DOTBOX = 40; + GDK_DOUBLE_ARROW = 42; + GDK_DRAFT_LARGE = 44; + GDK_DRAFT_SMALL = 46; + GDK_DRAPED_BOX = 48; + GDK_EXCHANGE = 50; + GDK_FLEUR = 52; + GDK_GOBBLER = 54; + GDK_GUMBY = 56; + GDK_HAND1 = 58; + GDK_HAND2 = 60; + GDK_HEART = 62; + GDK_ICON = 64; + GDK_IRON_CROSS = 66; + GDK_LEFT_PTR = 68; + GDK_LEFT_SIDE = 70; + GDK_LEFT_TEE = 72; + GDK_LEFTBUTTON = 74; + GDK_LL_ANGLE = 76; + GDK_LR_ANGLE = 78; + GDK_MAN = 80; + GDK_MIDDLEBUTTON = 82; + GDK_MOUSE = 84; + GDK_PENCIL = 86; + GDK_PIRATE = 88; + GDK_PLUS = 90; + GDK_QUESTION_ARROW = 92; + GDK_RIGHT_PTR = 94; + GDK_RIGHT_SIDE = 96; + GDK_RIGHT_TEE = 98; + GDK_RIGHTBUTTON = 100; + GDK_RTL_LOGO = 102; + GDK_SAILBOAT = 104; + GDK_SB_DOWN_ARROW = 106; + GDK_SB_H_DOUBLE_ARROW = 108; + GDK_SB_LEFT_ARROW = 110; + GDK_SB_RIGHT_ARROW = 112; + GDK_SB_UP_ARROW = 114; + GDK_SB_V_DOUBLE_ARROW = 116; + GDK_SHUTTLE = 118; + GDK_SIZING = 120; + GDK_SPIDER = 122; + GDK_SPRAYCAN = 124; + GDK_STAR = 126; + GDK_TARGET = 128; + GDK_TCROSS = 130; + GDK_TOP_LEFT_ARROW = 132; + GDK_TOP_LEFT_CORNER = 134; + GDK_TOP_RIGHT_CORNER = 136; + GDK_TOP_SIDE = 138; + GDK_TOP_TEE = 140; + GDK_TREK = 142; + GDK_UL_ANGLE = 144; + GDK_UMBRELLA = 146; + GDK_UR_ANGLE = 148; + GDK_WATCH = 150; + GDK_XTERM = 152; + GDK_LAST_CURSOR=GDK_XTERM+1; + +function GDK_TYPE_CURSOR : GType; + +{ Cursors } + +function gdk_cursor_get_type:GType; cdecl; external gdklib; +function gdk_cursor_new_for_screen(screen:PGdkScreen; cursor_type:TGdkCursorType):PGdkCursor; cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_cursor_new(cursor_type:TGdkCursorType):PGdkCursor; cdecl; external gdklib; +{$endif} + +function gdk_cursor_new_from_pixmap(source:PGdkPixmap; mask:PGdkPixmap; fg:PGdkColor; bg:PGdkColor; x:gint; + y:gint):PGdkCursor; cdecl; external gdklib; +function gdk_cursor_get_screen(cursor:PGdkCursor):PGdkScreen; cdecl; external gdklib; +function gdk_cursor_ref(cursor:PGdkCursor):PGdkCursor; cdecl; external gdklib; +procedure gdk_cursor_unref(cursor:PGdkCursor); cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_cursor_destroy(cursor:PGdkCursor); +{$endif} +{ GDK_DISABLE_DEPRECATED } + +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +procedure gdk_cursor_destroy(cursor:PGdkCursor); +begin + gdk_cursor_unref(cursor); +end; + +function GDK_TYPE_CURSOR : GType; +begin + GDK_TYPE_CURSOR:=gdk_cursor_get_type; +end; + +{$ENDIF} diff --git a/packages/gtk2/src/gtk+/gdk/gdkdisplay.inc b/packages/gtk2/src/gtk+/gdk/gdkdisplay.inc new file mode 100644 index 0000000000..fd4f8c065a --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkdisplay.inc @@ -0,0 +1,107 @@ +// included by gdk2.pp + +{$IFDEF read_forward_definitions} + PGdkDisplay = ^TGdkDisplay; +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{< private > } +{ Information for determining if the latest button click + is part of a double-click or triple-click + } +{ The last 2 button click times. } +{ The last 2 windows to receive button presses. } +{ The last 2 buttons to be pressed. } +{ Maximum time between clicks in msecs } + TGdkDisplay = record + parent_instance : TGObject; + queued_events : PGList; + queued_tail : PGList; + button_click_time : array[0..1] of guint32; + button_window : array[0..1] of PGdkWindow; + button_number : array[0..1] of guint; + double_click_time : guint; + end; + + PGdkDisplayClass = ^TGdkDisplayClass; + TGdkDisplayClass = record + parent_class : TGObjectClass; + get_display_name : function (display:PGdkDisplay):Pgchar; cdecl; + get_n_screens : function (display:PGdkDisplay):gint; cdecl; + get_screen : function (display:PGdkDisplay; screen_num:gint):PGdkScreen; cdecl; + get_default_screen : function (display:PGdkDisplay):PGdkScreen; cdecl; + end; +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function GDK_TYPE_DISPLAY : GType; +function GDK_DISPLAY_OBJECT(anObject : pointer) : PGdkDisplay; +function GDK_DISPLAY_CLASS(klass : pointer) : PGdkDisplayClass; +function GDK_IS_DISPLAY(anObject : pointer) : boolean; +function GDK_IS_DISPLAY_CLASS(klass : pointer) : boolean; +function GDK_DISPLAY_GET_CLASS(obj : pointer) : PGdkDisplayClass; + +//function gdk_display_get_type:GType; cdecl; external gdklib; +function gdk_display_open(display_name:Pgchar):PGdkDisplay; cdecl; external gdklib; +function gdk_display_get_name(display:PGdkDisplay):Pgchar; cdecl; external gdklib; +function gdk_display_get_n_screens(display:PGdkDisplay):gint; cdecl; external gdklib; +function gdk_display_get_screen(display:PGdkDisplay; screen_num:gint):PGdkScreen; cdecl; external gdklib; +function gdk_display_get_default_screen(display:PGdkDisplay):PGdkScreen; cdecl; external gdklib; +procedure gdk_display_pointer_ungrab(display:PGdkDisplay; time:guint32); cdecl; external gdklib; +procedure gdk_display_keyboard_ungrab(display:PGdkDisplay; time:guint32); cdecl; external gdklib; +function gdk_display_pointer_is_grabbed(display:PGdkDisplay):gboolean; cdecl; external gdklib; +procedure gdk_display_beep(display:PGdkDisplay); cdecl; external gdklib; +procedure gdk_display_sync(display:PGdkDisplay); cdecl; external gdklib; +procedure gdk_display_close(display:PGdkDisplay); cdecl; external gdklib; +function gdk_display_list_devices(display:PGdkDisplay):PGList; cdecl; external gdklib; +function gdk_display_get_event(display:PGdkDisplay):PGdkEvent; cdecl; external gdklib; +function gdk_display_peek_event(display:PGdkDisplay):PGdkEvent; cdecl; external gdklib; +procedure gdk_display_put_event(display:PGdkDisplay; event:PGdkEvent); cdecl; external gdklib; +procedure gdk_display_add_client_message_filter(display:PGdkDisplay; message_type:TGdkAtom; func:TGdkFilterFunc; data:gpointer); cdecl; external gdklib; +procedure gdk_display_set_double_click_time(display:PGdkDisplay; msec:guint); cdecl; external gdklib; +procedure gdk_display_set_sm_client_id(display:PGdkDisplay; sm_client_id:Pgchar); cdecl; external gdklib; +procedure gdk_set_default_display(display:PGdkDisplay); cdecl; external gdklib; +function gdk_get_default_display:PGdkDisplay; cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_DISPLAY : GType; +begin + GDK_TYPE_DISPLAY:=0; //gdk_display_get_type; +end; + +function GDK_DISPLAY_OBJECT(anObject : pointer) : PGdkDisplay; +begin + GDK_DISPLAY_OBJECT:=PGdkDisplay(G_TYPE_CHECK_INSTANCE_CAST(anObject, + GDK_TYPE_DISPLAY)); +end; + +function GDK_DISPLAY_CLASS(klass : pointer) : PGdkDisplayClass; +begin + GDK_DISPLAY_CLASS:=PGdkDisplayClass(G_TYPE_CHECK_CLASS_CAST(klass, + GDK_TYPE_DISPLAY)); +end; + +function GDK_IS_DISPLAY(anObject : pointer) : boolean; +begin + GDK_IS_DISPLAY:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_DISPLAY); +end; + +function GDK_IS_DISPLAY_CLASS(klass : pointer) : boolean; +begin + GDK_IS_DISPLAY_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_DISPLAY); +end; + +function GDK_DISPLAY_GET_CLASS(obj : pointer) : PGdkDisplayClass; +begin + GDK_DISPLAY_GET_CLASS:=PGdkDisplayClass(G_TYPE_INSTANCE_GET_CLASS(obj, + GDK_TYPE_DISPLAY)); +end; + +{$ENDIF} diff --git a/packages/gtk2/src/gtk+/gdk/gdkdnd.inc b/packages/gtk2/src/gtk+/gdk/gdkdnd.inc new file mode 100644 index 0000000000..03f5cfbfad --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkdnd.inc @@ -0,0 +1,140 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} + PGdkDragAction = ^TGdkDragAction; + TGdkDragAction = longint; // see below for possible values + +{ A root window with nobody claiming drags } +{ Not a valid drag window } +{ The simple WM_DROPFILES dnd } +{ The complex OLE2 dnd (not implemented) } +{ Intra-app } + PGdkDragProtocol = ^TGdkDragProtocol; + TGdkDragProtocol = (GDK_DRAG_PROTO_MOTIF,GDK_DRAG_PROTO_XDND, + GDK_DRAG_PROTO_ROOTWIN,GDK_DRAG_PROTO_NONE, + GDK_DRAG_PROTO_WIN32_DROPFILES,GDK_DRAG_PROTO_OLE2, + GDK_DRAG_PROTO_LOCAL); + +{< public > } +{< private > } + PGdkDragContext = ^TGdkDragContext; + TGdkDragContext = record + parent_instance : TGObject; + protocol : TGdkDragProtocol; + is_source : gboolean; + source_window : PGdkWindow; + dest_window : PGdkWindow; + targets : PGList; + actions : TGdkDragAction; + suggested_action : TGdkDragAction; + action : TGdkDragAction; + start_time : guint32; + windowing_data : gpointer; + end; + + PGdkDragContextClass = ^TGdkDragContextClass; + TGdkDragContextClass = record + parent_class : TGObjectClass; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +const + // values for TGdkDragAction + GDK_ACTION_DEFAULT = 1 shl 0; + GDK_ACTION_COPY = 1 shl 1; + GDK_ACTION_MOVE = 1 shl 2; + GDK_ACTION_LINK = 1 shl 3; + GDK_ACTION_PRIVATE = 1 shl 4; + GDK_ACTION_ASK = 1 shl 5; + + +{ Object that holds information about a drag in progress. + this is used on both source and destination sides. + } +function GDK_TYPE_DRAG_CONTEXT : GType; +function GDK_DRAG_CONTEXT(anObject : Pointer) : PGdkDragContext; +function GDK_DRAG_CONTEXT_CLASS(klass : Pointer) : PGdkDragContextClass; +function GDK_IS_DRAG_CONTEXT(anObject : Pointer) : boolean; +function GDK_IS_DRAG_CONTEXT_CLASS(klass : Pointer) : boolean; +function GDK_DRAG_CONTEXT_GET_CLASS(obj : Pointer) : PGdkDragContextClass; + + +{ Drag and Drop } + +function gdk_drag_context_get_type:GType; cdecl; external gdklib; +function gdk_drag_context_new:PGdkDragContext; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_drag_context_ref(context:PGdkDragContext); cdecl; external gdklib; +procedure gdk_drag_context_unref(context:PGdkDragContext); cdecl; external gdklib; +{$endif} + + +{ Destination side } + +procedure gdk_drag_status(context:PGdkDragContext; action:TGdkDragAction; time:guint32); cdecl; external gdklib; +procedure gdk_drop_reply(context:PGdkDragContext; ok:gboolean; time:guint32); cdecl; external gdklib; +procedure gdk_drop_finish(context:PGdkDragContext; success:gboolean; time:guint32); cdecl; external gdklib; +function gdk_drag_get_selection(context:PGdkDragContext):TGdkAtom; cdecl; external gdklib; + + +{ Source side } + +function gdk_drag_begin(window:PGdkWindow; targets:PGList):PGdkDragContext; cdecl; external gdklib; +function gdk_drag_get_protocol_for_display(display:PGdkDisplay; xid:guint32; protocol:PGdkDragProtocol):guint32; cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_drag_get_protocol(xid:guint32; protocol:PGdkDragProtocol):guint32; cdecl; external gdklib; +{$endif} + + +{ GDK_MULTIHEAD_SAFE } + +procedure gdk_drag_find_window(context:PGdkDragContext; drag_window:PGdkWindow; x_root:gint; y_root:gint; var dest_window:PGdkWindow; + protocol:PGdkDragProtocol); cdecl; external gdklib; +function gdk_drag_motion(context:PGdkDragContext; dest_window:PGdkWindow; protocol:TGdkDragProtocol; x_root:gint; y_root:gint; + suggested_action:TGdkDragAction; possible_actions:TGdkDragAction; time:guint32):gboolean; cdecl; external gdklib; +procedure gdk_drag_drop(context:PGdkDragContext; time:guint32); cdecl; external gdklib; +procedure gdk_drag_abort(context:PGdkDragContext; time:guint32); cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_DRAG_CONTEXT : GType; +begin + GDK_TYPE_DRAG_CONTEXT:=gdk_drag_context_get_type; +end; + +function GDK_DRAG_CONTEXT(anObject : Pointer) : PGdkDragContext; +begin + GDK_DRAG_CONTEXT:=PGdkDragContext(G_TYPE_CHECK_INSTANCE_CAST(anObject, + GDK_TYPE_DRAG_CONTEXT)); +end; + +function GDK_DRAG_CONTEXT_CLASS(klass : Pointer) : PGdkDragContextClass; +begin + GDK_DRAG_CONTEXT_CLASS:=PGdkDragContextClass(G_TYPE_CHECK_CLASS_CAST(klass,GDK_TYPE_DRAG_CONTEXT)); +end; + +function GDK_IS_DRAG_CONTEXT(anObject : Pointer) : boolean; +begin + GDK_IS_DRAG_CONTEXT:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_DRAG_CONTEXT); +end; + +function GDK_IS_DRAG_CONTEXT_CLASS(klass : Pointer) : boolean; +begin + GDK_IS_DRAG_CONTEXT_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_DRAG_CONTEXT); +end; + +function GDK_DRAG_CONTEXT_GET_CLASS(obj : Pointer) : PGdkDragContextClass; +begin + GDK_DRAG_CONTEXT_GET_CLASS:=PGdkDragContextClass(G_TYPE_INSTANCE_GET_CLASS( + obj,GDK_TYPE_DRAG_CONTEXT)); +end; + +{$ENDIF} diff --git a/packages/gtk2/src/gtk+/gdk/gdkdrawable.inc b/packages/gtk2/src/gtk+/gdk/gdkdrawable.inc new file mode 100644 index 0000000000..f023a228e6 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkdrawable.inc @@ -0,0 +1,225 @@ +// included by gdk2.pp + +{$IFDEF read_forward_definitions} + PGdkDrawable = ^TGdkDrawable; + TGdkDrawable = record + parent_instance : TGObject; + end; + + PGdkWindow = ^TGdkWindow; + TGdkWindow = TGdkDrawable; + + PGdkPixmap = ^TGdkPixmap; + TGdkPixmap = TGdkDrawable; + + PGdkBitmap = ^TGdkBitmap; + TGdkBitmap = TGdkDrawable; + +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + +{ Padding for future expansion } + PGdkDrawableClass = ^TGdkDrawableClass; + TGdkDrawableClass = record + parent_class : TGObjectClass; + create_gc : function (drawable:PGdkDrawable; values:PGdkGCValues; mask:TGdkGCValuesMask):PGdkGC; cdecl; + draw_rectangle : procedure (drawable:PGdkDrawable; gc:PGdkGC; filled:gint; x:gint; y:gint; + width:gint; height:gint); cdecl; + draw_arc : procedure (drawable:PGdkDrawable; gc:PGdkGC; filled:gint; x:gint; y:gint; + width:gint; height:gint; angle1:gint; angle2:gint); cdecl; + draw_polygon : procedure (drawable:PGdkDrawable; gc:PGdkGC; filled:gint; points:PGdkPoint; npoints:gint); cdecl; + draw_text : procedure (drawable:PGdkDrawable; font:PGdkFont; gc:PGdkGC; x:gint; y:gint; + text:Pgchar; text_length:gint); cdecl; + draw_text_wc : procedure (drawable:PGdkDrawable; font:PGdkFont; gc:PGdkGC; x:gint; y:gint; + text:PGdkWChar; text_length:gint); cdecl; + draw_drawable : procedure (drawable:PGdkDrawable; gc:PGdkGC; src:PGdkDrawable; xsrc:gint; ysrc:gint; + xdest:gint; ydest:gint; width:gint; height:gint); cdecl; + draw_points : procedure (drawable:PGdkDrawable; gc:PGdkGC; points:PGdkPoint; npoints:gint); cdecl; + draw_segments : procedure (drawable:PGdkDrawable; gc:PGdkGC; segs:PGdkSegment; nsegs:gint); cdecl; + draw_lines : procedure (drawable:PGdkDrawable; gc:PGdkGC; points:PGdkPoint; npoints:gint); cdecl; + draw_glyphs : procedure (drawable:PGdkDrawable; gc:PGdkGC; font:PPangoFont; x:gint; y:gint; + glyphs:PPangoGlyphString); cdecl; + draw_image : procedure (drawable:PGdkDrawable; gc:PGdkGC; image:PGdkImage; xsrc:gint; ysrc:gint; + xdest:gint; ydest:gint; width:gint; height:gint); cdecl; + get_depth : function (drawable:PGdkDrawable):gint; cdecl; + get_size : procedure (drawable:PGdkDrawable; width:Pgint; height:Pgint); cdecl; + set_colormap : procedure (drawable:PGdkDrawable; cmap:PGdkColormap); cdecl; + get_colormap : function (drawable:PGdkDrawable):PGdkColormap; cdecl; + get_visual : function (drawable:PGdkDrawable):PGdkVisual; cdecl; + get_screen : function (drawable:PGdkDrawable):PGdkScreen; cdecl; + get_image : function (drawable:PGdkDrawable; x:gint; y:gint; width:gint; height:gint):PGdkImage; cdecl; + get_clip_region : function (drawable:PGdkDrawable):PGdkRegion; cdecl; + get_visible_region : function (drawable:PGdkDrawable):PGdkRegion; cdecl; + get_composite_drawable : function (drawable:PGdkDrawable; x:gint; y:gint; width:gint; height:gint; + composite_x_offset:Pgint; composite_y_offset:Pgint):PGdkDrawable; cdecl; + _draw_pixbuf : procedure (drawable:PGdkDrawable; gc:PGdkGC; pixbuf:PGdkPixbuf; src_x:gint; src_y:gint; + dest_x:gint; dest_y:gint; width:gint; height:gint; dither:TGdkRgbDither; + x_dither:gint; y_dither:gint); cdecl; + _copy_to_image : function (drawable:PGdkDrawable; image:PGdkImage; src_x:gint; src_y:gint; dest_x:gint; + dest_y:gint; width:gint; height:gint):PGdkImage; cdecl; + _gdk_reserved1 : procedure ; cdecl; + _gdk_reserved2 : procedure ; cdecl; + _gdk_reserved3 : procedure ; cdecl; + _gdk_reserved4 : procedure ; cdecl; + _gdk_reserved5 : procedure ; cdecl; + _gdk_reserved6 : procedure ; cdecl; + _gdk_reserved7 : procedure ; cdecl; + _gdk_reserved9 : procedure ; cdecl; + _gdk_reserved10 : procedure ; cdecl; + _gdk_reserved11 : procedure ; cdecl; + _gdk_reserved12 : procedure ; cdecl; + _gdk_reserved13 : procedure ; cdecl; + _gdk_reserved14 : procedure ; cdecl; + _gdk_reserved15 : procedure ; cdecl; + _gdk_reserved16 : procedure ; cdecl; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} + +function GDK_TYPE_DRAWABLE : GType; +function GDK_DRAWABLE(anObject : Pointer) : PGdkDrawable; +function GDK_DRAWABLE_CLASS(klass : Pointer) : PGdkDrawableClass; +function GDK_IS_DRAWABLE(anObject : Pointer) : boolean; +function GDK_IS_DRAWABLE_CLASS(klass : Pointer) : boolean; +function GDK_DRAWABLE_GET_CLASS(obj : Pointer) : PGdkDrawableClass; + + +function gdk_drawable_get_type:GType; cdecl; external gdklib; +{ Manipulation of drawables } + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_drawable_set_data(drawable:PGdkDrawable; key:Pgchar; data:gpointer; destroy_func:TGDestroyNotify); cdecl; external gdklib; +function gdk_drawable_get_data(drawable:PGdkDrawable; key:Pgchar):gpointer; cdecl; external gdklib; +{$endif} +{ GDK_DISABLE_DEPRECATED } + +procedure gdk_drawable_get_size(drawable:PGdkDrawable; width:Pgint; height:Pgint); cdecl; external gdklib; +procedure gdk_drawable_set_colormap(drawable:PGdkDrawable; colormap:PGdkColormap); cdecl; external gdklib; +function gdk_drawable_get_colormap(drawable:PGdkDrawable):PGdkColormap; cdecl; external gdklib; +function gdk_drawable_get_visual(drawable:PGdkDrawable):PGdkVisual; cdecl; external gdklib; +function gdk_drawable_get_depth(drawable:PGdkDrawable):gint; cdecl; external gdklib; +function gdk_drawable_get_screen(drawable:PGdkDrawable):PGdkScreen; cdecl; external gdklib; +function gdk_drawable_get_display(drawable:PGdkDrawable):PGdkDisplay; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +function gdk_drawable_ref(drawable:PGdkDrawable):PGdkDrawable; cdecl; external gdklib; +procedure gdk_drawable_unref(drawable:PGdkDrawable); cdecl; external gdklib; +{$endif} +{ GDK_DISABLE_DEPRECATED } + + +{ Drawing } + +procedure gdk_draw_point(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint); cdecl; external gdklib; +procedure gdk_draw_line(drawable:PGdkDrawable; gc:PGdkGC; x1:gint; y1:gint; x2:gint; + y2:gint); cdecl; external gdklib; +procedure gdk_draw_rectangle(drawable:PGdkDrawable; gc:PGdkGC; filled:gint; x:gint; y:gint; + width:gint; height:gint); cdecl; external gdklib; +procedure gdk_draw_arc(drawable:PGdkDrawable; gc:PGdkGC; filled:gint; x:gint; y:gint; + width:gint; height:gint; angle1:gint; angle2:gint); cdecl; external gdklib; +procedure gdk_draw_polygon(drawable:PGdkDrawable; gc:PGdkGC; filled:gint; points:PGdkPoint; npoints:gint); cdecl; external gdklib; +{$IFDEF GTK2_2} +procedure gdk_draw_pixbuf(drawable: PGdkDrawable; gc:PGdkGC; src:PGdkPixbuf; + xsrc:gint; ysrc:gint; xdest:gint; ydest:gint; + width:gint; height:gint; dither:TGdkRgbDither; + x_dither:gint; y_dither:gint); cdecl; external gdklib; +{$ENDIF} + + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_draw_string(drawable:PGdkDrawable; font:PGdkFont; gc:PGdkGC; x:gint; y:gint; + _string:Pgchar); cdecl; external gdklib; +procedure gdk_draw_text(drawable:PGdkDrawable; font:PGdkFont; gc:PGdkGC; x:gint; y:gint; + text:Pgchar; text_length:gint); cdecl; external gdklib; +procedure gdk_draw_text_wc(drawable:PGdkDrawable; font:PGdkFont; gc:PGdkGC; x:gint; y:gint; + text:PGdkWChar; text_length:gint); cdecl; external gdklib; +{$endif} + + +{ GDK_DISABLE_DEPRECATED } + +procedure gdk_draw_drawable(drawable:PGdkDrawable; gc:PGdkGC; src:PGdkDrawable; xsrc:gint; ysrc:gint; + xdest:gint; ydest:gint; width:gint; height:gint); cdecl; external gdklib; +procedure gdk_draw_image(drawable:PGdkDrawable; gc:PGdkGC; image:PGdkImage; xsrc:gint; ysrc:gint; + xdest:gint; ydest:gint; width:gint; height:gint); cdecl; external gdklib; +procedure gdk_draw_points(drawable:PGdkDrawable; gc:PGdkGC; points:PGdkPoint; npoints:gint); cdecl; external gdklib; +procedure gdk_draw_segments(drawable:PGdkDrawable; gc:PGdkGC; segs:PGdkSegment; nsegs:gint); cdecl; external gdklib; +procedure gdk_draw_lines(drawable:PGdkDrawable; gc:PGdkGC; points:PGdkPoint; npoints:gint); cdecl; external gdklib; +procedure gdk_draw_glyphs(drawable:PGdkDrawable; gc:PGdkGC; font:PPangoFont; x:gint; y:gint; + glyphs:PPangoGlyphString); cdecl; external gdklib; +procedure gdk_draw_layout_line(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint; line:PPangoLayoutLine); cdecl; external gdklib; +procedure gdk_draw_layout(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint; layout:PPangoLayout); cdecl; external gdklib; +procedure gdk_draw_layout_line_with_colors(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint; line:PPangoLayoutLine; + foreground:PGdkColor; background:PGdkColor); cdecl; external gdklib; +procedure gdk_draw_layout_with_colors(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint; layout:PPangoLayout; + foreground:PGdkColor; background:PGdkColor); cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_draw_pixmap(drawable:PGdkDrawable; gc:PGdkGC; src:PGdkDrawable; xsrc:gint; ysrc:gint; + xdest:gint; ydest:gint; width:gint; height:gint); +procedure gdk_draw_bitmap(drawable:PGdkDrawable; gc:PGdkGC; src:PGdkDrawable; xsrc:gint; ysrc:gint; + xdest:gint; ydest:gint; width:gint; height:gint); +{$endif} +{ GDK_DISABLE_DEPRECATED } + +function gdk_drawable_get_image(drawable:PGdkDrawable; x:gint; y:gint; width:gint; height:gint):PGdkImage; cdecl; external gdklib; +function gdk_drawable_get_clip_region(drawable:PGdkDrawable):PGdkRegion; cdecl; external gdklib; +function gdk_drawable_get_visible_region(drawable:PGdkDrawable):PGdkRegion; cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_DRAWABLE : GType; +begin + GDK_TYPE_DRAWABLE:=gdk_drawable_get_type; +end; + +function GDK_DRAWABLE(anObject : Pointer) : PGdkDrawable; +begin + GDK_DRAWABLE:=PGdkDrawable(G_TYPE_CHECK_INSTANCE_CAST(anObject, + GDK_TYPE_DRAWABLE)); +end; + +function GDK_DRAWABLE_CLASS(klass : Pointer) : PGdkDrawableClass; +begin + GDK_DRAWABLE_CLASS:=PGdkDrawableClass(G_TYPE_CHECK_CLASS_CAST(klass, + GDK_TYPE_DRAWABLE)); +end; + +function GDK_IS_DRAWABLE(anObject : Pointer) : boolean; +begin + GDK_IS_DRAWABLE:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_DRAWABLE); +end; + +function GDK_IS_DRAWABLE_CLASS(klass : Pointer) : boolean; +begin + GDK_IS_DRAWABLE_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_DRAWABLE); +end; + +function GDK_DRAWABLE_GET_CLASS(obj : Pointer) : PGdkDrawableClass; +begin + GDK_DRAWABLE_GET_CLASS:=PGdkDrawableClass(G_TYPE_INSTANCE_GET_CLASS(obj, + GDK_TYPE_DRAWABLE)); +end; + +procedure gdk_draw_pixmap(drawable:PGdkDrawable; gc:PGdkGC; src:PGdkDrawable; + xsrc:gint; ysrc:gint; xdest:gint; ydest:gint; width:gint; height:gint); +begin + gdk_draw_drawable(drawable,gc,src,xsrc,ysrc,xdest,ydest,width,height); +end; + +procedure gdk_draw_bitmap(drawable:PGdkDrawable; gc:PGdkGC; src:PGdkDrawable; + xsrc:gint; ysrc:gint; xdest:gint; ydest:gint; width:gint; height:gint); +begin + gdk_draw_drawable(drawable,gc,src,xsrc,ysrc,xdest,ydest,width,height); +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkevents.inc b/packages/gtk2/src/gtk+/gdk/gdkevents.inc new file mode 100644 index 0000000000..85a8e94f23 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkevents.inc @@ -0,0 +1,478 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} + PGdkEvent = ^TGdkEvent; + + TGdkEventFunc = procedure (event:PGdkEvent; data:gpointer); cdecl; +{ Event filtering } + + PGdkXEvent = ^TGdkXEvent; + TGdkXEvent = procedure; +{ Can be cast to window system specific + even type, XEvent on X11, MSG on Win32. + } +{ Event not handled, continue processesing } +{ Translated event stored } +{ Terminate processing, removing event } + + PGdkFilterReturn = ^TGdkFilterReturn; + TGdkFilterReturn = ( + GDK_FILTER_CONTINUE, + GDK_FILTER_TRANSLATE, + GDK_FILTER_REMOVE + ); + + TGdkFilterFunc = function (xevent:PGdkXEvent; event:PGdkEvent; + data:gpointer):TGdkFilterReturn; cdecl; +{ Event types. + Nothing: No event occurred. + Delete: A window delete event was sent by the window manager. + The specified window should be deleted. + Destroy: A window has been destroyed. + Expose: Part of a window has been uncovered. + NoExpose: Same as expose, but no expose event was generated. + VisibilityNotify: A window has become fully/partially/not obscured. + MotionNotify: The mouse has moved. + ButtonPress: A mouse button was pressed. + ButtonRelease: A mouse button was release. + KeyPress: A key was pressed. + KeyRelease: A key was released. + EnterNotify: A window was entered. + LeaveNotify: A window was exited. + FocusChange: The focus window has changed. (The focus window gets + keyboard events). + Resize: A window has been resized. + Map: A window has been mapped. (It is now visible on the screen). + Unmap: A window has been unmapped. (It is no longer visible on + the screen). + Scroll: A mouse wheel was scrolled either up or down. + } + + PGdkEventType = ^TGdkEventType; + TGdkEventType = gint; + +{ Event masks. (Used to select what types of events a window + will receive). + } + + PGdkEventMask = ^TGdkEventMask; + TGdkEventMask = gint32; + + PGdkVisibilityState = ^TGdkVisibilityState; + TGdkVisibilityState = ( + GDK_VISIBILITY_UNOBSCURED, + GDK_VISIBILITY_PARTIAL, + GDK_VISIBILITY_FULLY_OBSCURED + ); + + PGdkScrollDirection = ^TGdkScrollDirection; + TGdkScrollDirection = ( + GDK_SCROLL_UP, + GDK_SCROLL_DOWN, + GDK_SCROLL_LEFT, + GDK_SCROLL_RIGHT + ); + +{ Types of enter/leave notifications. + Ancestor: + Virtual: + Inferior: + Nonlinear: + NonlinearVirtual: + Unknown: An unknown type of enter/leave event occurred. + } + + PGdkNotifyType = ^TGdkNotifyType; + TGdkNotifyType = integer; // see below for possible values + +{ Enter/leave event modes. + NotifyNormal + NotifyGrab + NotifyUngrab + } + + PGdkCrossingMode = ^TGdkCrossingMode; + TGdkCrossingMode = ( + GDK_CROSSING_NORMAL, + GDK_CROSSING_GRAB, + GDK_CROSSING_UNGRAB + ); + + PGdkPropertyState = ^TGdkPropertyState; + TGdkPropertyState = ( + GDK_PROPERTY_NEW_VALUE, + GDK_PROPERTY_STATE_DELETE // was GDK_PROPERTY_DELETE, but there is also a function + ); + + PGdkWindowState = ^TGdkWindowState; + TGdkWindowState = gint; + + + PGdkSettingAction = ^TGdkSettingAction; + TGdkSettingAction = ( + GDK_SETTING_ACTION_NEW, + GDK_SETTING_ACTION_CHANGED, + GDK_SETTING_ACTION_DELETED + ); + + PGdkEventAny = ^TGdkEventAny; + TGdkEventAny = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + end; + +{ If non-zero, how many more events follow. } + PGdkEventExpose = ^TGdkEventExpose; + TGdkEventExpose = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + area : TGdkRectangle; + region : PGdkRegion; + count : gint; + end; + +{ XXX: does anyone need the X major_code or minor_code fields? } + PGdkEventNoExpose = ^TGdkEventNoExpose; + TGdkEventNoExpose = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + end; + + PGdkEventVisibility = ^TGdkEventVisibility; + TGdkEventVisibility = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + state : TGdkVisibilityState; + end; + + PGdkEventMotion = ^TGdkEventMotion; + TGdkEventMotion = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + time : guint32; + x : gdouble; + y : gdouble; + axes : Pgdouble; + state : guint; + is_hint : gint16; + device : PGdkDevice; + x_root : gdouble; + y_root : gdouble; + end; + + PGdkEventButton = ^TGdkEventButton; + TGdkEventButton = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + time : guint32; + x : gdouble; + y : gdouble; + axes : Pgdouble; + state : guint; + button : guint; + device : PGdkDevice; + x_root : gdouble; + y_root : gdouble; + end; + + PGdkEventScroll = ^TGdkEventScroll; + TGdkEventScroll = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + time : guint32; + x : gdouble; + y : gdouble; + state : guint; + direction : TGdkScrollDirection; + device : PGdkDevice; + x_root : gdouble; + y_root : gdouble; + end; + + PGdkEventKey = ^TGdkEventKey; + TGdkEventKey = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + time : guint32; + state : guint; + keyval : guint; + length : gint; + _string : Pgchar; + hardware_keycode : guint16; + group : guint8; + end; + + PGdkEventCrossing = ^TGdkEventCrossing; + TGdkEventCrossing = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + subwindow : PGdkWindow; + time : guint32; + x : gdouble; + y : gdouble; + x_root : gdouble; + y_root : gdouble; + mode : TGdkCrossingMode; + detail : TGdkNotifyType; + focus : gboolean; + state : guint; + end; + + PGdkEventFocus = ^TGdkEventFocus; + TGdkEventFocus = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + _in : gint16; + end; + + PGdkEventConfigure = ^TGdkEventConfigure; + TGdkEventConfigure = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + x : gint; + y : gint; + width : gint; + height : gint; + end; + + PGdkEventProperty = ^TGdkEventProperty; + TGdkEventProperty = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + atom : TGdkAtom; + time : guint32; + state : guint; + end; + + PGdkEventSelection = ^TGdkEventSelection; + TGdkEventSelection = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + selection : TGdkAtom; + target : TGdkAtom; + _property : TGdkAtom; + time : guint32; + requestor : TGdkNativeWindow; + end; + +{ This event type will be used pretty rarely. It only is important + for XInput aware programs that are drawing their own cursor } + PGdkEventProximity = ^TGdkEventProximity; + TGdkEventProximity = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + time : guint32; + device : PGdkDevice; + end; + + PmatDUMMY = ^TmatDUMMY; + TmatDUMMY = record + case longint of + 0 : ( b : array[0..19] of char ); + 1 : ( s : array[0..9] of smallint ); + 2 : ( li : array[0..4] of longint ); + end; + + PGdkEventClient = ^TGdkEventClient; + TGdkEventClient = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + message_type : TGdkAtom; + data_format : gushort; + data : record + case longint of + 0 : ( b : array[0..19] of char ); + 1 : ( s : array[0..9] of smallint ); + 2 : ( l : array[0..4] of longint ); + end; + end; + + PGdkEventSetting = ^TGdkEventSetting; + TGdkEventSetting = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + action : TGdkSettingAction; + name : Pchar; + end; + + PGdkEventWindowState = ^TGdkEventWindowState; + TGdkEventWindowState = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + changed_mask : TGdkWindowState; + new_window_state : TGdkWindowState; + end; + +{ Event types for DND } + PGdkEventDND = ^TGdkEventDND; + TGdkEventDND = record + _type : TGdkEventType; + window : PGdkWindow; + send_event : gint8; + context : PGdkDragContext; + time : guint32; + x_root : gshort; + y_root : gshort; + end; + + TGdkEvent = record + case longint of + 0 : ( _type : TGdkEventType ); + 1 : ( any : TGdkEventAny ); + 2 : ( expose : TGdkEventExpose ); + 3 : ( no_expose : TGdkEventNoExpose ); + 4 : ( visibility : TGdkEventVisibility ); + 5 : ( motion : TGdkEventMotion ); + 6 : ( button : TGdkEventButton ); + 7 : ( scroll : TGdkEventScroll ); + 8 : ( key : TGdkEventKey ); + 9 : ( crossing : TGdkEventCrossing ); + 10 : ( focus_change : TGdkEventFocus ); + 11 : ( configure : TGdkEventConfigure ); + 12 : ( _property : TGdkEventProperty ); + 13 : ( selection : TGdkEventSelection ); + 14 : ( proximity : TGdkEventProximity ); + 15 : ( client : TGdkEventClient ); + 16 : ( dnd : TGdkEventDND ); + 17 : ( window_state : TGdkEventWindowState ); + 18 : ( setting : TGdkEventSetting ); + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} + +const + GDK_NOTHING = -(1); + GDK_DELETE = 0; + GDK_DESTROY = 1; + GDK_EXPOSE = 2; + GDK_MOTION_NOTIFY = 3; + GDK_BUTTON_PRESS = 4; + GDK_2BUTTON_PRESS = 5; + GDK_3BUTTON_PRESS = 6; + GDK_BUTTON_RELEASE = 7; + GDK_KEY_PRESS = 8; + GDK_KEY_RELEASE = 9; + GDK_ENTER_NOTIFY = 10; + GDK_LEAVE_NOTIFY = 11; + GDK_FOCUS_CHANGE = 12; + GDK_CONFIGURE = 13; + GDK_MAP = 14; + GDK_UNMAP = 15; + GDK_PROPERTY_NOTIFY = 16; + GDK_SELECTION_CLEAR = 17; + GDK_SELECTION_REQUEST = 18; + GDK_SELECTION_NOTIFY = 19; + GDK_PROXIMITY_IN = 20; + GDK_PROXIMITY_OUT = 21; + GDK_DRAG_ENTER = 22; + GDK_DRAG_LEAVE = 23; + GDK_DRAG_MOTION_EVENT = 24; // was GDK_DRAG_MOTION, which bites gdk_drag_motion + GDK_DRAG_STATUS_EVENT = 25; // was GDK_DRAG_STATUS, which bites gdk_drag_status + GDK_DROP_START = 26; + GDK_DROP_FINISHED = 27; + GDK_CLIENT_EVENT = 28; + GDK_VISIBILITY_NOTIFY = 29; + GDK_NO_EXPOSE = 30; + GDK_SCROLL = 31; + GDK_WINDOW_STATE = 32; + GDK_SETTING = 33; + + // values for TGdkNotifyType + GDK_NOTIFY_ANCESTOR = 0; + GDK_NOTIFY_VIRTUAL = 1; + GDK_NOTIFY_INFERIOR = 2; + GDK_NOTIFY_NONLINEAR = 3; + GDK_NOTIFY_NONLINEAR_VIRTUAL = 4; + GDK_NOTIFY_UNKNOWN = 5; + + +function GDK_TYPE_EVENT : GType; + +const + GDK_PRIORITY_EVENTS = G_PRIORITY_DEFAULT; + GDK_PRIORITY_REDRAW = G_PRIORITY_HIGH_IDLE + 20; + + GDK_EXPOSURE_MASK = 1 shl 1; + GDK_POINTER_MOTION_MASK = 1 shl 2; + GDK_POINTER_MOTION_HINT_MASK = 1 shl 3; + GDK_BUTTON_MOTION_MASK = 1 shl 4; + GDK_BUTTON1_MOTION_MASK = 1 shl 5; + GDK_BUTTON2_MOTION_MASK = 1 shl 6; + GDK_BUTTON3_MOTION_MASK = 1 shl 7; + GDK_BUTTON_PRESS_MASK = 1 shl 8; + GDK_BUTTON_RELEASE_MASK = 1 shl 9; + GDK_KEY_PRESS_MASK = 1 shl 10; + GDK_KEY_RELEASE_MASK = 1 shl 11; + GDK_ENTER_NOTIFY_MASK = 1 shl 12; + GDK_LEAVE_NOTIFY_MASK = 1 shl 13; + GDK_FOCUS_CHANGE_MASK = 1 shl 14; + GDK_STRUCTURE_MASK = 1 shl 15; + GDK_PROPERTY_CHANGE_MASK = 1 shl 16; + GDK_VISIBILITY_NOTIFY_MASK = 1 shl 17; + GDK_PROXIMITY_IN_MASK = 1 shl 18; + GDK_PROXIMITY_OUT_MASK = 1 shl 19; + GDK_SUBSTRUCTURE_MASK = 1 shl 20; + GDK_SCROLL_MASK = 1 shl 21; + GDK_ALL_EVENTS_MASK = $3FFFFE; + + GDK_WINDOW_STATE_WITHDRAWN = 1 shl 0; + GDK_WINDOW_STATE_ICONIFIED = 1 shl 1; + GDK_WINDOW_STATE_MAXIMIZED = 1 shl 2; + GDK_WINDOW_STATE_STICKY = 1 shl 3; + + +function gdk_event_get_type:GType; cdecl; external gdklib; +function gdk_events_pending:gboolean; cdecl; external gdklib; +function gdk_event_get:PGdkEvent; cdecl; external gdklib; +function gdk_event_peek:PGdkEvent; cdecl; external gdklib; +function gdk_event_get_graphics_expose(window:PGdkWindow):PGdkEvent; cdecl; external gdklib; +procedure gdk_event_put(event:PGdkEvent); cdecl; external gdklib; +function gdk_event_copy(event:PGdkEvent):PGdkEvent; cdecl; external gdklib; +procedure gdk_event_free(event:PGdkEvent); cdecl; external gdklib; +function gdk_event_get_time(event:PGdkEvent):guint32; cdecl; external gdklib; +function gdk_event_get_state(event:PGdkEvent; state:PGdkModifierType):gboolean; cdecl; external gdklib; +function gdk_event_get_coords(event:PGdkEvent; x_win:Pgdouble; y_win:Pgdouble):gboolean; cdecl; external gdklib; +function gdk_event_get_root_coords(event:PGdkEvent; x_root:Pgdouble; y_root:Pgdouble):gboolean; cdecl; external gdklib; +function gdk_event_get_axis(event:PGdkEvent; axis_use:TGdkAxisUse; value:Pgdouble):gboolean; cdecl; external gdklib; +procedure gdk_event_handler_set(func:TGdkEventFunc; data:gpointer; notify:TGDestroyNotify); cdecl; external gdklib; +procedure gdk_set_show_events(show_events:gboolean); cdecl; external gdklib; +function gdk_get_show_events:gboolean; cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +procedure gdk_add_client_message_filter(message_type:TGdkAtom; func:TGdkFilterFunc; data:gpointer); cdecl; external gdklib; +function gdk_setting_get(name:Pgchar; var value:TGValue):gboolean; cdecl; external gdklib; +{$endif} +{ GDK_MULTIHEAD_SAFE } + +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_EVENT : GType; +begin + GDK_TYPE_EVENT:=gdk_event_get_type; +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkfont.inc b/packages/gtk2/src/gtk+/gdk/gdkfont.inc new file mode 100644 index 0000000000..816716dc68 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkfont.inc @@ -0,0 +1,85 @@ +// included by gdk2.pp +{$IFDEF read_forward_definitions} +{ Types of font. + GDK_FONT_FONT: the font is an XFontStruct. + GDK_FONT_FONTSET: the font is an XFontSet used for I18N. + } + PGdkFontType = ^TGdkFontType; + TGdkFontType = ( + GDK_FONT_FONT, + GDK_FONT_FONTSET + ); + + PGdkFont = ^TGdkFont; + TGdkFont = record + _type : TGdkFontType; + ascent : gint; + descent : gint; + end; + +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function GDK_TYPE_FONT : GType; + + +function gdk_font_get_type:GType; cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_font_load(font_name:Pgchar):PGdkFont; cdecl; external gdklib; +function gdk_fontset_load(fontset_name:Pgchar):PGdkFont; cdecl; external gdklib; +function gdk_font_from_description(font_desc:PPangoFontDescription):PGdkFont; cdecl; external gdklib; +{$endif} + +function gdk_font_load_for_display(display:PGdkDisplay; font_name:Pgchar):PGdkFont; cdecl; external gdklib; +function gdk_fontset_load_for_display(display:PGdkDisplay; fontset_name:Pgchar):PGdkFont; cdecl; external gdklib; +function gdk_font_from_description_for_display(display:PGdkDisplay; font_desc:PPangoFontDescription):PGdkFont; cdecl; external gdklib; +function gdk_font_ref(font:PGdkFont):PGdkFont; cdecl; external gdklib; +procedure gdk_font_unref(font:PGdkFont); cdecl; external gdklib; +function gdk_font_id(font:PGdkFont):gint; cdecl; external gdklib; +function gdk_font_equal(fonta:PGdkFont; fontb:PGdkFont):gboolean; cdecl; external gdklib; +function gdk_string_width(font:PGdkFont; _string:Pgchar):gint; cdecl; external gdklib; +function gdk_text_width(font:PGdkFont; text:Pgchar; text_length:gint):gint; cdecl; external gdklib; +function gdk_text_width_wc(font:PGdkFont; text:PGdkWChar; text_length:gint):gint; cdecl; external gdklib; +function gdk_char_width(font:PGdkFont; character:gchar):gint; cdecl; external gdklib; +function gdk_char_width_wc(font:PGdkFont; character:TGdkWChar):gint; cdecl; external gdklib; +function gdk_string_measure(font:PGdkFont; _string:Pgchar):gint; cdecl; external gdklib; +function gdk_text_measure(font:PGdkFont; text:Pgchar; text_length:gint):gint; cdecl; external gdklib; +function gdk_char_measure(font:PGdkFont; character:gchar):gint; cdecl; external gdklib; +function gdk_string_height(font:PGdkFont; _string:Pgchar):gint; cdecl; external gdklib; +function gdk_text_height(font:PGdkFont; text:Pgchar; text_length:gint):gint; cdecl; external gdklib; +function gdk_char_height(font:PGdkFont; character:gchar):gint; cdecl; external gdklib; +procedure gdk_text_extents(font:PGdkFont; text:Pgchar; text_length:gint; lbearing:Pgint; rbearing:Pgint; + width:Pgint; ascent:Pgint; descent:Pgint); cdecl; external gdklib; +procedure gdk_text_extents_wc(font:PGdkFont; text:PGdkWChar; text_length:gint; lbearing:Pgint; rbearing:Pgint; + width:Pgint; ascent:Pgint; descent:Pgint); cdecl; external gdklib; +procedure gdk_string_extents(font:PGdkFont; _string:Pgchar; lbearing:Pgint; rbearing:Pgint; width:Pgint; + ascent:Pgint; descent:Pgint); cdecl; external gdklib; +function gdk_font_get_display(font:PGdkFont):PGdkDisplay; cdecl; external gdklib; + +{$ifdef GDK_WINDOWING_WIN32} + +{ Ditto temporary } + +function gdk_font_full_name_get(font:PGdkFont):Pgchar; cdecl; external gdklib; +procedure gdk_font_full_name_free(name:Pgchar); cdecl; external gdklib; +{$endif GDK_WINDOWING_WIN32} + +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_FONT : GType; +begin + GDK_TYPE_FONT:=gdk_font_get_type; +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkgc.inc b/packages/gtk2/src/gtk+/gdk/gdkgc.inc new file mode 100644 index 0000000000..234bbdef31 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkgc.inc @@ -0,0 +1,272 @@ +// included by gdk2.pp + +{$IFDEF read_forward_definitions} +{ GC function types. + Copy: Overwrites destination pixels with the source pixels. + Invert: Inverts the destination pixels. + Xor: Xor's the destination pixels with the source pixels. + Clear: set pixels to 0 + And: source AND destination + And Reverse: source AND (NOT destination) + And Invert: (NOT source) AND destination + Noop: destination + Or: source OR destination + Nor: (NOT source) AND (NOT destination) + Equiv: (NOT source) XOR destination + Xor Reverse: source OR (NOT destination) + Copy Inverted: NOT source + Xor Inverted: (NOT source) OR destination + Nand: (NOT source) OR (NOT destination) + Set: set pixels to 1 + } + PGdkFunction = ^TGdkFunction; + TGdkFunction = ( + GDK_COPY, + GDK_INVERT, + GDK_XOR, + GDK_CLEAR, + GDK_AND, + GDK_AND_REVERSE, + GDK_AND_INVERT, + GDK_NOOP, + GDK_OR, + GDK_EQUIV, + GDK_OR_REVERSE, + GDK_COPY_INVERT, + GDK_OR_INVERT, + GDK_NAND, + GDK_NOR, + GDK_SET + ); + +{ GC cap styles + CapNotLast: + CapButt: + CapRound: + CapProjecting: + } + PGdkCapStyle = ^TGdkCapStyle; + TGdkCapStyle = ( + GDK_CAP_NOT_LAST, + GDK_CAP_BUTT, + GDK_CAP_ROUND, + GDK_CAP_PROJECTING + ); + +{ GC fill types. + Solid: + Tiled: + Stippled: + OpaqueStippled: + } + PGdkFill = ^TGdkFill; + TGdkFill = ( + GDK_SOLID, + GDK_TILED, + GDK_STIPPLED, + GDK_OPAQUE_STIPPLED + ); + +{ GC join styles + JoinMiter: + JoinRound: + JoinBevel: + } + PGdkJoinStyle = ^TGdkJoinStyle; + TGdkJoinStyle = ( + GDK_JOIN_MITER, + GDK_JOIN_ROUND, + GDK_JOIN_BEVEL + ); + +{ GC line styles + Solid: + OnOffDash: + DoubleDash: + } + PGdkLineStyle = ^TGdkLineStyle; + TGdkLineStyle = ( + GDK_LINE_SOLID, + GDK_LINE_ON_OFF_DASH, + GDK_LINE_DOUBLE_DASH + ); + + PGdkSubwindowMode = ^TGdkSubwindowMode; + TGdkSubwindowMode = integer; // see below for possible values + + PGdkGCValuesMask = ^TGdkGCValuesMask; + TGdkGCValuesMask = longint; // see below for possible values + + PGdkGCValues = ^TGdkGCValues; + TGdkGCValues = record + foreground : TGdkColor; + background : TGdkColor; + font : PGdkFont; + _function : TGdkFunction; + fill : TGdkFill; + tile : PGdkPixmap; + stipple : PGdkPixmap; + clip_mask : PGdkPixmap; + subwindow_mode : TGdkSubwindowMode; + ts_x_origin : gint; + ts_y_origin : gint; + clip_x_origin : gint; + clip_y_origin : gint; + graphics_exposures : gint; + line_width : gint; + line_style : TGdkLineStyle; + cap_style : TGdkCapStyle; + join_style : TGdkJoinStyle; + end; + + PGdkGC = ^TGdkGC; + TGdkGC = record + parent_instance : TGObject; + clip_x_origin : gint; + clip_y_origin : gint; + ts_x_origin : gint; + ts_y_origin : gint; + colormap : PGdkColormap; + end; + +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{ Padding for future expansion } + PGdkGCClass = ^TGdkGCClass; + TGdkGCClass = record + parent_class : TGObjectClass; + get_values : procedure (gc:PGdkGC; values:PGdkGCValues); cdecl; + set_values : procedure (gc:PGdkGC; values:PGdkGCValues; mask:TGdkGCValuesMask); cdecl; + set_dashes : procedure (gc:PGdkGC; dash_offset:gint; dash_list:array of gint8; n:gint); cdecl; + _gdk_reserved1 : procedure ; cdecl; + _gdk_reserved2 : procedure ; cdecl; + _gdk_reserved3 : procedure ; cdecl; + _gdk_reserved4 : procedure ; cdecl; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +const + // values for TGdkGCValuesMask + GDK_GC_FOREGROUND = 1 shl 0; + GDK_GC_BACKGROUND = 1 shl 1; + GDK_GC_FONT = 1 shl 2; + GDK_GC_FUNCTION = 1 shl 3; + GDK_GC_FILL = 1 shl 4; + GDK_GC_TILE = 1 shl 5; + GDK_GC_STIPPLE = 1 shl 6; + GDK_GC_CLIP_MASK = 1 shl 7; + GDK_GC_SUBWINDOW = 1 shl 8; + GDK_GC_TS_X_ORIGIN = 1 shl 9; + GDK_GC_TS_Y_ORIGIN = 1 shl 10; + GDK_GC_CLIP_X_ORIGIN = 1 shl 11; + GDK_GC_CLIP_Y_ORIGIN = 1 shl 12; + GDK_GC_EXPOSURES = 1 shl 13; + GDK_GC_LINE_WIDTH = 1 shl 14; + GDK_GC_LINE_STYLE = 1 shl 15; + GDK_GC_CAP_STYLE = 1 shl 16; + GDK_GC_JOIN_STYLE = 1 shl 17; + + // values for TGdkSubwindowMode + GDK_CLIP_BY_CHILDREN = 0; + GDK_INCLUDE_INFERIORS = 1; + + +function GDK_TYPE_GC : GType; +function GDK_GC(anObject : Pointer) : PGdkGC; +function GDK_GC_CLASS(klass : Pointer) : PGdkGCClass; +function GDK_IS_GC(anObject : Pointer) : boolean; +function GDK_IS_GC_CLASS(klass : Pointer) : boolean; +function GDK_GC_GET_CLASS(obj : Pointer) : PGdkGCClass; + + +function gdk_gc_get_type:GType; cdecl; external gdklib; +function gdk_gc_new(drawable:PGdkDrawable):PGdkGC; cdecl; external gdklib; +function gdk_gc_new_with_values(drawable:PGdkDrawable; values:PGdkGCValues; values_mask:TGdkGCValuesMask):PGdkGC; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +function gdk_gc_ref(gc:PGdkGC):PGdkGC; cdecl; external gdklib; +procedure gdk_gc_unref(gc:PGdkGC); cdecl; external gdklib; +{$endif} + +procedure gdk_gc_get_values(gc:PGdkGC; values:PGdkGCValues); cdecl; external gdklib; +procedure gdk_gc_set_values(gc:PGdkGC; values:PGdkGCValues; values_mask:TGdkGCValuesMask); cdecl; external gdklib; +procedure gdk_gc_set_foreground(gc:PGdkGC; color:PGdkColor); cdecl; external gdklib; +procedure gdk_gc_set_background(gc:PGdkGC; color:PGdkColor); cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_gc_set_font(gc:PGdkGC; font:PGdkFont); cdecl; external gdklib; +{$endif} +{ GDK_DISABLE_DEPRECATED } + +procedure gdk_gc_set_function(gc:PGdkGC; _function:TGdkFunction); cdecl; external gdklib; +procedure gdk_gc_set_fill(gc:PGdkGC; fill:TGdkFill); cdecl; external gdklib; +procedure gdk_gc_set_tile(gc:PGdkGC; tile:PGdkPixmap); cdecl; external gdklib; +procedure gdk_gc_set_stipple(gc:PGdkGC; stipple:PGdkPixmap); cdecl; external gdklib; +procedure gdk_gc_set_ts_origin(gc:PGdkGC; x:gint; y:gint); cdecl; external gdklib; +procedure gdk_gc_set_clip_origin(gc:PGdkGC; x:gint; y:gint); cdecl; external gdklib; +procedure gdk_gc_set_clip_mask(gc:PGdkGC; mask:PGdkBitmap); cdecl; external gdklib; +procedure gdk_gc_set_clip_rectangle(gc:PGdkGC; rectangle:PGdkRectangle); cdecl; external gdklib; +procedure gdk_gc_set_clip_region(gc:PGdkGC; region:PGdkRegion); cdecl; external gdklib; +procedure gdk_gc_set_subwindow(gc:PGdkGC; mode:TGdkSubwindowMode); cdecl; external gdklib; +procedure gdk_gc_set_exposures(gc:PGdkGC; exposures:gboolean); cdecl; external gdklib; +procedure gdk_gc_set_line_attributes(gc:PGdkGC; line_width:gint; line_style:TGdkLineStyle; cap_style:TGdkCapStyle; join_style:TGdkJoinStyle); cdecl; external gdklib; +procedure gdk_gc_set_dashes(gc:PGdkGC; dash_offset:gint; dash_list:array of gint8; n:gint); cdecl; external gdklib; +procedure gdk_gc_offset(gc:PGdkGC; x_offset:gint; y_offset:gint); cdecl; external gdklib; +procedure gdk_gc_copy(dst_gc:PGdkGC; src_gc:PGdkGC); cdecl; external gdklib; +procedure gdk_gc_set_colormap(gc:PGdkGC; colormap:PGdkColormap); cdecl; external gdklib; +function gdk_gc_get_colormap(gc:PGdkGC):PGdkColormap; cdecl; external gdklib; +procedure gdk_gc_set_rgb_fg_color(gc:PGdkGC; color:PGdkColor); cdecl; external gdklib; +procedure gdk_gc_set_rgb_bg_color(gc:PGdkGC; color:PGdkColor); cdecl; external gdklib; +function gdk_gc_get_screen(gc:PGdkGC):PGdkScreen; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_gc_destroy(gc:PGdkGC); +{$endif} +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_GC : GType; +begin + GDK_TYPE_GC:=gdk_gc_get_type; +end; + +function GDK_GC(anObject : Pointer) : PGdkGC; +begin + GDK_GC:=PGdkGC(G_TYPE_CHECK_INSTANCE_CAST(anObject,GDK_TYPE_GC)); +end; + +function GDK_GC_CLASS(klass : Pointer) : PGdkGCClass; +begin + GDK_GC_CLASS:=PGdkGCClass(G_TYPE_CHECK_CLASS_CAST(klass,GDK_TYPE_GC)); +end; + +function GDK_IS_GC(anObject : Pointer) : boolean; +begin + GDK_IS_GC:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_GC); +end; + +function GDK_IS_GC_CLASS(klass : Pointer) : boolean; +begin + GDK_IS_GC_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_GC); +end; + +function GDK_GC_GET_CLASS(obj : Pointer) : PGdkGCClass; +begin + GDK_GC_GET_CLASS:=PGdkGCClass(G_TYPE_INSTANCE_GET_CLASS(obj,GDK_TYPE_GC)); +end; + +procedure gdk_gc_destroy(gc:PGdkGC); +begin + g_object_unref(G_OBJECT(gc)); +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdki18n.inc b/packages/gtk2/src/gtk+/gdk/gdki18n.inc new file mode 100644 index 0000000000..3a2b2a2f72 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdki18n.inc @@ -0,0 +1,112 @@ +{ Pointers to basic pascal types, inserted by h2pas conversion program.} +Type + PLongint = ^Longint; + PSmallInt = ^SmallInt; + PByte = ^Byte; + PWord = ^Word; + PDWord = ^DWord; + PDouble = ^Double; + +{$PACKRECORDS C} + +{ GDK - The GIMP Drawing Kit + Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + } +{ + Modified by the GTK+ Team and others 1997-2000. See the AUTHORS + file for a list of people on the GTK+ Team. See the ChangeLog + files for a list of changes. These files are distributed with + GTK+ at ftp://ftp.gtk.org/pub/gtk/. + } +{$ifndef __GDK_I18N_H__} +{$define __GDK_I18N_H__} +{$ifndef GDK_DISABLE_DEPRECATED} +{ GDK uses "glib". (And so does GTK). + } + +{$include <gdkconfig.inc} +{ international string support } +{$include <stdlib.inc} +{$if !defined(GDK_HAVE_BROKEN_WCTYPE) && (defined(GDK_HAVE_WCTYPE_H) || defined(GDK_HAVE_WCHAR_H)) && !defined(X_LOCALE)} +{$ifdef GDK_HAVE_WCTYPE_H} +{$include <wctype.inc} +{$else} +{$ifdef GDK_HAVE_WCHAR_H} +{$include <wchar.inc} +{$endif} +{$endif} +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function gdk_iswalnum(c : longint) : longint; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function gdk_iswspace(c : longint) : longint; + +{$else} +{$include <ctype.inc} +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function gdk_iswalnum(c : longint) : longint; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function gdk_iswspace(c : longint) : longint; + +{$endif} +{$endif} +{ GDK_DISABLE_DEPRECATED } +{$endif} +{ __GDK_I18N_H__ } +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function gdk_iswalnum(c : longint) : longint; +begin + gdk_iswalnum:=iswalnum(c); +end; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function gdk_iswspace(c : longint) : longint; +begin + gdk_iswspace:=iswspace(c); +end; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function gdk_iswalnum(c : longint) : longint; +begin + gdk_iswalnum:=(Twchar_t(c)) <= ($FF and (@(isalnum(c)))); +end; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function gdk_iswspace(c : longint) : longint; +begin + gdk_iswspace:=(Twchar_t(c)) <= ($FF and (@(isspace(c)))); +end; + + diff --git a/packages/gtk2/src/gtk+/gdk/gdkimage.inc b/packages/gtk2/src/gtk+/gdk/gdkimage.inc new file mode 100644 index 0000000000..bbb0eceaaa --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkimage.inc @@ -0,0 +1,128 @@ +// included by gdk2.pp +{$IFDEF read_forward_definitions} +{ Types of images. + Normal: Normal X image type. These are slow as they involve passing + the entire image through the X connection each time a draw + request is required. On Win32, a bitmap. + Shared: Shared memory X image type. These are fast as the X server + and the program actually use the same piece of memory. They + should be used with care though as there is the possibility + for both the X server and the program to be reading/writing + the image simultaneously and producing undesired results. + On Win32, also a bitmap. + } + PGdkImageType = ^TGdkImageType; + TGdkImageType = ( + GDK_IMAGE_NORMAL, + GDK_IMAGE_SHARED, + GDK_IMAGE_FASTEST + ); + + PGdkImage = ^TGdkImage; +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + + PGdkImageClass = ^TGdkImageClass; + TGdkImageClass = record + parent_class : TGObjectClass; + end; + +{ visual used to create the image } +{ bytes per pixel } +{ bytes per line } +{ bits per pixel } + TGdkImage = record + parent_instance : TGObject; + _type : TGdkImageType; + visual : PGdkVisual; + byte_order : TGdkByteOrder; + width : gint; + height : gint; + depth : guint16; + bpp : guint16; + bpl : guint16; + bits_per_pixel : guint16; + mem : gpointer; + colormap : PGdkColormap; + windowing_data : gpointer; + end; +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function GDK_TYPE_IMAGE : GType; +function GDK_IMAGE(anObject : Pointer) : PGdkImage; +function GDK_IMAGE_CLASS(klass : Pointer) : PGdkImageClass; +function GDK_IS_IMAGE(anObject : Pointer) : boolean; +function GDK_IS_IMAGE_CLASS(klass : Pointer) : boolean; +function GDK_IMAGE_GET_CLASS(obj : Pointer) : PGdkImageClass; + + +function gdk_image_get_type:GType; cdecl; external gdklib; +function gdk_image_new(_type:TGdkImageType; visual:PGdkVisual; width:gint; height:gint):PGdkImage; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +function gdk_image_get(drawable:PGdkDrawable; x:gint; y:gint; width:gint; height:gint):PGdkImage; cdecl; external gdklib; +function gdk_image_ref(image:PGdkImage):PGdkImage; cdecl; external gdklib; +procedure gdk_image_unref(image:PGdkImage); cdecl; external gdklib; +{$endif} + +procedure gdk_image_put_pixel(image:PGdkImage; x:gint; y:gint; pixel:guint32); cdecl; external gdklib; +function gdk_image_get_pixel(image:PGdkImage; x:gint; y:gint):guint32; cdecl; external gdklib; +procedure gdk_image_set_colormap(image:PGdkImage; colormap:PGdkColormap); cdecl; external gdklib; +function gdk_image_get_colormap(image:PGdkImage):PGdkColormap; cdecl; external gdklib; + +{$ifdef GDK_ENABLE_BROKEN} +function gdk_image_new_bitmap(visual:PGdkVisual; data:gpointer; width:gint; height:gint):PGdkImage; cdecl; external gdklib; +{$endif} +{ GDK_ENABLE_BROKEN } + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_image_destroy(image:PGdkImage); +{$endif} +{ GDK_DISABLE_DEPRECATED } +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_IMAGE : GType; +begin + GDK_TYPE_IMAGE:=gdk_image_get_type; +end; + +function GDK_IMAGE(anObject : Pointer) : PGdkImage; +begin + GDK_IMAGE:=PGdkImage(G_TYPE_CHECK_INSTANCE_CAST(anObject,GDK_TYPE_IMAGE)); +end; + +function GDK_IMAGE_CLASS(klass : Pointer) : PGdkImageClass; +begin + GDK_IMAGE_CLASS:=PGdkImageClass(G_TYPE_CHECK_CLASS_CAST(klass,GDK_TYPE_IMAGE)); +end; + +function GDK_IS_IMAGE(anObject : Pointer) : boolean; +begin + GDK_IS_IMAGE:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_IMAGE); +end; + +function GDK_IS_IMAGE_CLASS(klass : Pointer) : boolean; +begin + GDK_IS_IMAGE_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_IMAGE); +end; + +function GDK_IMAGE_GET_CLASS(obj : Pointer) : PGdkImageClass; +begin + GDK_IMAGE_GET_CLASS:=PGdkImageClass(G_TYPE_INSTANCE_GET_CLASS(obj,GDK_TYPE_IMAGE)); +end; + +procedure gdk_image_destroy(image:PGdkImage); +begin + g_object_unref(G_OBJECT(image)); +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkincludes.inc b/packages/gtk2/src/gtk+/gdk/gdkincludes.inc new file mode 100644 index 0000000000..1b67d22fac --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkincludes.inc @@ -0,0 +1,29 @@ +// included by gdk2.pp +{$include gdkcolor.inc} +{$include gdkcursor.inc} +{$include gdkdnd.inc} +{$include gdkregion-generic.inc} +{$include gdkdrawable.inc} +//-->$include gdkenumtypes.inc} // not implemented, yet +{$include gdkevents.inc} +{$include gdkfont.inc} +{$include gdkgc.inc} +//-->$include gdki18n.inc} // macros need to be implemented +{$include gdkimage.inc} +{$include gdkinput.inc} +//-->$include gdkinternals.inc} // not translated, yet +{$include gdkkeys.inc} +{$include gdkkeysyms.inc} +{$include gdkpango.inc} +{$include gdkpixbuf.inc} +{$include gdkpixmap.inc} +{$include gdkproperty.inc} +{$include gdkregion.inc} +{$include gdkrgb.inc} +{$include gdkdisplay.inc} +{$include gdkscreen.inc} +{$include gdkselection.inc} +{$include gdktypes.inc} +{$include gdkvisual.inc} +{$include gdkwindow.inc} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkinput.inc b/packages/gtk2/src/gtk+/gdk/gdkinput.inc new file mode 100644 index 0000000000..482462791d --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkinput.inc @@ -0,0 +1,154 @@ +// included by gdk2.pp + +{$IFDEF read_forward_definitions} + PGdkDevice = ^TGdkDevice; + PGdkTimeCoord = ^TGdkTimeCoord; + PPGdkTimeCoord = ^PGdkTimeCoord; +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PGdkExtensionMode = ^TGdkExtensionMode; + TGdkExtensionMode = ( + GDK_EXTENSION_EVENTS_NONE, + GDK_EXTENSION_EVENTS_ALL, + GDK_EXTENSION_EVENTS_CURSOR + ); + + PGdkInputSource = ^TGdkInputSource; + TGdkInputSource = ( + GDK_SOURCE_MOUSE, + GDK_SOURCE_PEN, + GDK_SOURCE_ERASER, + GDK_SOURCE_CURSOR + ); + + PGdkInputMode = ^TGdkInputMode; + TGdkInputMode = ( + GDK_MODE_DISABLED, + GDK_MODE_SCREEN, + GDK_MODE_WINDOW + ); + + PGdkAxisUse = ^TGdkAxisUse; + TGdkAxisUse = longint; + + PGdkDeviceKey = ^TGdkDeviceKey; + TGdkDeviceKey = record + keyval : guint; + modifiers : TGdkModifierType; + end; + + PGdkDeviceAxis = ^TGdkDeviceAxis; + TGdkDeviceAxis = record + use : TGdkAxisUse; + min : gdouble; + max : gdouble; + end; + +{ All fields are read-only } +{ TRUE if the X pointer follows device motion } + TGdkDevice = record + parent_instance : TGObject; + name : Pgchar; + source : TGdkInputSource; + mode : TGdkInputMode; + has_cursor : gboolean; + num_axes : gint; + axes : PGdkDeviceAxis; + num_keys : gint; + keys : PGdkDeviceKey; + end; + +{ We don't allocate each coordinate this big, but we use it to + be ANSI compliant and avoid accessing past the defined limits. + } + + TGdkTimeCoord = record + time : guint32; + axes : array[0..(GDK_MAX_TIMECOORD_AXES)-1] of gdouble; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +const + GDK_AXIS_IGNORE = 0; + GDK_AXIS_X = 1; + GDK_AXIS_Y = 2; + GDK_AXIS_PRESSURE = 3; + GDK_AXIS_XTILT = 4; + GDK_AXIS_YTILT = 5; + GDK_AXIS_WHEEL = 6; + GDK_AXIS_LAST = 7; + + +function GDK_TYPE_DEVICE : GType; +function GDK_DEVICE(anObject : Pointer) : PGdkDevice; +function GDK_DEVICE_CLASS(klass : Pointer) : PGdkDeviceClass; +function GDK_IS_DEVICE(anObject : Pointer) : boolean; +function GDK_IS_DEVICE_CLASS(klass : Pointer) : boolean; +function GDK_DEVICE_GET_CLASS(obj : Pointer) : PGdkDeviceClass; + + +function gdk_device_get_type:GType; cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +{ Returns a list of GdkDevice } +function gdk_devices_list:PGList; cdecl; external gdklib; +{$endif} +{ GDK_MULTIHEAD_SAFE } + + +{ Functions to configure a device } + +procedure gdk_device_set_source(device:PGdkDevice; source:TGdkInputSource); cdecl; external gdklib; +function gdk_device_set_mode(device:PGdkDevice; mode:TGdkInputMode):gboolean; cdecl; external gdklib; +procedure gdk_device_set_key(device:PGdkDevice; index:guint; keyval:guint; modifiers:TGdkModifierType); cdecl; external gdklib; +procedure gdk_device_set_axis_use(device:PGdkDevice; index:guint; use:TGdkAxisUse); cdecl; external gdklib; +procedure gdk_device_get_state(device:PGdkDevice; window:PGdkWindow; axes:Pgdouble; mask:PGdkModifierType); cdecl; external gdklib; +function gdk_device_get_history(device:PGdkDevice; window:PGdkWindow; start:guint32; stop:guint32; var events:PPGdkTimeCoord; + n_events:Pgint):gboolean; cdecl; external gdklib; +procedure gdk_device_free_history(events:PPGdkTimeCoord; n_events:gint); cdecl; external gdklib; +function gdk_device_get_axis(device:PGdkDevice; axes:Pgdouble; use:TGdkAxisUse; value:Pgdouble):gboolean; cdecl; external gdklib; +procedure gdk_input_set_extension_events(window:PGdkWindow; mask:gint; mode:TGdkExtensionMode); cdecl; external gdklib; +function gdk_device_get_core_pointer:PGdkDevice; cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_DEVICE : GType; +begin + GDK_TYPE_DEVICE:=gdk_device_get_type; +end; + +function GDK_DEVICE(anObject : Pointer) : PGdkDevice; +begin + GDK_DEVICE:=PGdkDevice(G_TYPE_CHECK_INSTANCE_CAST(anObject,GDK_TYPE_DEVICE)); +end; + +function GDK_DEVICE_CLASS(klass : Pointer) : PGdkDeviceClass; +begin + GDK_DEVICE_CLASS:=PGdkDeviceClass(G_TYPE_CHECK_CLASS_CAST(klass,GDK_TYPE_DEVICE)); +end; + +function GDK_IS_DEVICE(anObject : Pointer) : boolean; +begin + GDK_IS_DEVICE:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_DEVICE); +end; + +function GDK_IS_DEVICE_CLASS(klass : Pointer) : boolean; +begin + GDK_IS_DEVICE_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_DEVICE); +end; + +function GDK_DEVICE_GET_CLASS(obj : Pointer) : PGdkDeviceClass; +begin + GDK_DEVICE_GET_CLASS:=PGdkDeviceClass(G_TYPE_INSTANCE_GET_CLASS(obj,GDK_TYPE_DEVICE)); +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkkeys.inc b/packages/gtk2/src/gtk+/gdk/gdkkeys.inc new file mode 100644 index 0000000000..60d35b9b62 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkkeys.inc @@ -0,0 +1,105 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} +{ GdkKeymapKey is a hardware key that can be mapped to a keyval } + PGdkKeymapKey = ^TGdkKeymapKey; + TGdkKeymapKey = record + keycode : guint; + group : gint; + level : gint; + end; + + PGdkKeymap = ^TGdkKeymap; + TGdkKeymap = record + parent_instance : TGObject; + display : PGdkDisplay; + end; + + PGdkKeymapClass = ^TGdkKeymapClass; + TGdkKeymapClass = record + parent_class : TGObjectClass; + direction_changed : procedure (keymap:PGdkKeymap); cdecl; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +{ A GdkKeymap defines the translation from keyboard state + (including a hardware key, a modifier mask, and active keyboard group) + to a keyval. This translation has two phases. The first phase is + to determine the effective keyboard group and level for the keyboard + state; the second phase is to look up the keycode/group/level triplet + in the keymap and see what keyval it corresponds to. + } +function GDK_TYPE_KEYMAP : GType; +function GDK_KEYMAP(anObject : Pointer) : PGdkKeymap; +function GDK_KEYMAP_CLASS(klass : Pointer) : PGdkKeymapClass; +function GDK_IS_KEYMAP(anObject : Pointer) : boolean; +function GDK_IS_KEYMAP_CLASS(klass : Pointer) : boolean; +function GDK_KEYMAP_GET_CLASS(obj : Pointer) : PGdkKeymapClass; + + +function gdk_keymap_get_type:GType; cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_keymap_get_default:PGdkKeymap; cdecl; external gdklib; +{$endif} + +function gdk_keymap_get_for_display(display:PGdkDisplay):PGdkKeymap; cdecl; external gdklib; +function gdk_keymap_lookup_key(keymap:PGdkKeymap; key:PGdkKeymapKey):guint; cdecl; external gdklib; +function gdk_keymap_translate_keyboard_state(keymap:PGdkKeymap; hardware_keycode:guint; state:TGdkModifierType; group:gint; keyval:Pguint; + effective_group:Pgint; level:Pgint; consumed_modifiers:PGdkModifierType):gboolean; cdecl; external gdklib; +function gdk_keymap_get_entries_for_keyval(keymap:PGdkKeymap; keyval:guint; var keys:PGdkKeymapKey; n_keys:Pgint):gboolean; cdecl; external gdklib; +function gdk_keymap_get_entries_for_keycode(keymap:PGdkKeymap; hardware_keycode:guint; var keys:PGdkKeymapKey; var keyvals:Pguint; n_entries:Pgint):gboolean; cdecl; external gdklib; +function gdk_keymap_get_direction(keymap:PGdkKeymap):TPangoDirection; cdecl; external gdklib; + + +{ Key values } + +function gdk_keyval_name(keyval:guint):Pgchar; cdecl; external gdklib; +function gdk_keyval_from_name(keyval_name:Pgchar):guint; cdecl; external gdklib; +procedure gdk_keyval_convert_case(symbol:guint; lower:Pguint; upper:Pguint); cdecl; external gdklib; +function gdk_keyval_to_upper(keyval:guint):guint; cdecl; external gdklib; +function gdk_keyval_to_lower(keyval:guint):guint; cdecl; external gdklib; +function gdk_keyval_is_upper(keyval:guint):gboolean; cdecl; external gdklib; +function gdk_keyval_is_lower(keyval:guint):gboolean; cdecl; external gdklib; +function gdk_keyval_to_unicode(keyval:guint):guint32; cdecl; external gdklib; +function gdk_unicode_to_keyval(wc:guint32):guint; cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_KEYMAP : GType; +begin + GDK_TYPE_KEYMAP:=gdk_keymap_get_type; +end; + +function GDK_KEYMAP(anObject : Pointer) : PGdkKeymap; +begin + GDK_KEYMAP:=PGdkKeymap(G_TYPE_CHECK_INSTANCE_CAST(anObject,GDK_TYPE_KEYMAP)); +end; + +function GDK_KEYMAP_CLASS(klass : Pointer) : PGdkKeymapClass; +begin + GDK_KEYMAP_CLASS:=PGdkKeymapClass(G_TYPE_CHECK_CLASS_CAST(klass,GDK_TYPE_KEYMAP)); +end; + +function GDK_IS_KEYMAP(anObject : Pointer) : boolean; +begin + GDK_IS_KEYMAP:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_KEYMAP); +end; + +function GDK_IS_KEYMAP_CLASS(klass : Pointer) : boolean; +begin + GDK_IS_KEYMAP_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_KEYMAP); +end; + +function GDK_KEYMAP_GET_CLASS(obj : Pointer) : PGdkKeymapClass; +begin + GDK_KEYMAP_GET_CLASS:=PGdkKeymapClass(G_TYPE_INSTANCE_GET_CLASS(obj,GDK_TYPE_KEYMAP)); +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkkeysyms.inc b/packages/gtk2/src/gtk+/gdk/gdkkeysyms.inc new file mode 100644 index 0000000000..e63b78a5d8 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkkeysyms.inc @@ -0,0 +1,1342 @@ +// included by gdk2.pp + +{$ifdef read_interface_rest} +const + GDK_KEY_VoidSymbol = $FFFFFF; + GDK_KEY_BackSpace = $FF08; + GDK_KEY_Tab = $FF09; + GDK_KEY_Linefeed = $FF0A; + GDK_KEY_Clear = $FF0B; + GDK_KEY_Return = $FF0D; + GDK_KEY_Pause = $FF13; + GDK_KEY_Scroll_Lock = $FF14; + GDK_KEY_Sys_Req = $FF15; + GDK_KEY_Escape = $FF1B; + GDK_KEY_Delete = $FFFF; + GDK_KEY_Multi_key = $FF20; + GDK_KEY_Codeinput = $FF37; + GDK_KEY_SingleCandidate = $FF3C; + GDK_KEY_MultipleCandidate = $FF3D; + GDK_KEY_PreviousCandidate = $FF3E; + GDK_KEY_Kanji = $FF21; + GDK_KEY_Muhenkan = $FF22; + GDK_KEY_Henkan_Mode = $FF23; + GDK_KEY_Henkan = $FF23; + GDK_KEY_Romaji = $FF24; + GDK_KEY_Hiragana = $FF25; + GDK_KEY_Katakana = $FF26; + GDK_KEY_Hiragana_Katakana = $FF27; + GDK_KEY_Zenkaku = $FF28; + GDK_KEY_Hankaku = $FF29; + GDK_KEY_Zenkaku_Hankaku = $FF2A; + GDK_KEY_Touroku = $FF2B; + GDK_KEY_Massyo = $FF2C; + GDK_KEY_Kana_Lock = $FF2D; + GDK_KEY_Kana_Shift = $FF2E; + GDK_KEY_Eisu_Shift = $FF2F; + GDK_KEY_Eisu_toggle = $FF30; + GDK_KEY_Kanji_Bangou = $FF37; + GDK_KEY_Zen_Koho = $FF3D; + GDK_KEY_Mae_Koho = $FF3E; + GDK_KEY_Home = $FF50; + GDK_KEY_Left = $FF51; + GDK_KEY_Up = $FF52; + GDK_KEY_Right = $FF53; + GDK_KEY_Down = $FF54; + GDK_KEY_Prior = $FF55; + GDK_KEY_Page_Up = $FF55; + GDK_KEY_Next = $FF56; + GDK_KEY_Page_Down = $FF56; + GDK_KEY_End = $FF57; + GDK_KEY_Begin = $FF58; + GDK_KEY_Select = $FF60; + GDK_KEY_Print = $FF61; + GDK_KEY_Execute = $FF62; + GDK_KEY_Insert = $FF63; + GDK_KEY_Undo = $FF65; + GDK_KEY_Redo = $FF66; + GDK_KEY_Menu = $FF67; + GDK_KEY_Find = $FF68; + GDK_KEY_Cancel = $FF69; + GDK_KEY_Help = $FF6A; + GDK_KEY_Break = $FF6B; + GDK_KEY_Mode_switch = $FF7E; + GDK_KEY_script_switch = $FF7E; + GDK_KEY_Num_Lock = $FF7F; + GDK_KEY_KP_Space = $FF80; + GDK_KEY_KP_Tab = $FF89; + GDK_KEY_KP_Enter = $FF8D; + GDK_KEY_KP_F1 = $FF91; + GDK_KEY_KP_F2 = $FF92; + GDK_KEY_KP_F3 = $FF93; + GDK_KEY_KP_F4 = $FF94; + GDK_KEY_KP_Home = $FF95; + GDK_KEY_KP_Left = $FF96; + GDK_KEY_KP_Up = $FF97; + GDK_KEY_KP_Right = $FF98; + GDK_KEY_KP_Down = $FF99; + GDK_KEY_KP_Prior = $FF9A; + GDK_KEY_KP_Page_Up = $FF9A; + GDK_KEY_KP_Next = $FF9B; + GDK_KEY_KP_Page_Down = $FF9B; + GDK_KEY_KP_End = $FF9C; + GDK_KEY_KP_Begin = $FF9D; + GDK_KEY_KP_Insert = $FF9E; + GDK_KEY_KP_Delete = $FF9F; + GDK_KEY_KP_Equal = $FFBD; + GDK_KEY_KP_Multiply = $FFAA; + GDK_KEY_KP_Add = $FFAB; + GDK_KEY_KP_Separator = $FFAC; + GDK_KEY_KP_Subtract = $FFAD; + GDK_KEY_KP_Decimal = $FFAE; + GDK_KEY_KP_Divide = $FFAF; + GDK_KEY_KP_0 = $FFB0; + GDK_KEY_KP_1 = $FFB1; + GDK_KEY_KP_2 = $FFB2; + GDK_KEY_KP_3 = $FFB3; + GDK_KEY_KP_4 = $FFB4; + GDK_KEY_KP_5 = $FFB5; + GDK_KEY_KP_6 = $FFB6; + GDK_KEY_KP_7 = $FFB7; + GDK_KEY_KP_8 = $FFB8; + GDK_KEY_KP_9 = $FFB9; + GDK_KEY_F1 = $FFBE; + GDK_KEY_F2 = $FFBF; + GDK_KEY_F3 = $FFC0; + GDK_KEY_F4 = $FFC1; + GDK_KEY_F5 = $FFC2; + GDK_KEY_F6 = $FFC3; + GDK_KEY_F7 = $FFC4; + GDK_KEY_F8 = $FFC5; + GDK_KEY_F9 = $FFC6; + GDK_KEY_F10 = $FFC7; + GDK_KEY_F11 = $FFC8; + GDK_KEY_L1 = $FFC8; + GDK_KEY_F12 = $FFC9; + GDK_KEY_L2 = $FFC9; + GDK_KEY_F13 = $FFCA; + GDK_KEY_L3 = $FFCA; + GDK_KEY_F14 = $FFCB; + GDK_KEY_L4 = $FFCB; + GDK_KEY_F15 = $FFCC; + GDK_KEY_L5 = $FFCC; + GDK_KEY_F16 = $FFCD; + GDK_KEY_L6 = $FFCD; + GDK_KEY_F17 = $FFCE; + GDK_KEY_L7 = $FFCE; + GDK_KEY_F18 = $FFCF; + GDK_KEY_L8 = $FFCF; + GDK_KEY_F19 = $FFD0; + GDK_KEY_L9 = $FFD0; + GDK_KEY_F20 = $FFD1; + GDK_KEY_L10 = $FFD1; + GDK_KEY_F21 = $FFD2; + GDK_KEY_R1 = $FFD2; + GDK_KEY_F22 = $FFD3; + GDK_KEY_R2 = $FFD3; + GDK_KEY_F23 = $FFD4; + GDK_KEY_R3 = $FFD4; + GDK_KEY_F24 = $FFD5; + GDK_KEY_R4 = $FFD5; + GDK_KEY_F25 = $FFD6; + GDK_KEY_R5 = $FFD6; + GDK_KEY_F26 = $FFD7; + GDK_KEY_R6 = $FFD7; + GDK_KEY_F27 = $FFD8; + GDK_KEY_R7 = $FFD8; + GDK_KEY_F28 = $FFD9; + GDK_KEY_R8 = $FFD9; + GDK_KEY_F29 = $FFDA; + GDK_KEY_R9 = $FFDA; + GDK_KEY_F30 = $FFDB; + GDK_KEY_R10 = $FFDB; + GDK_KEY_F31 = $FFDC; + GDK_KEY_R11 = $FFDC; + GDK_KEY_F32 = $FFDD; + GDK_KEY_R12 = $FFDD; + GDK_KEY_F33 = $FFDE; + GDK_KEY_R13 = $FFDE; + GDK_KEY_F34 = $FFDF; + GDK_KEY_R14 = $FFDF; + GDK_KEY_F35 = $FFE0; + GDK_KEY_R15 = $FFE0; + GDK_KEY_Shift_L = $FFE1; + GDK_KEY_Shift_R = $FFE2; + GDK_KEY_Control_L = $FFE3; + GDK_KEY_Control_R = $FFE4; + GDK_KEY_Caps_Lock = $FFE5; + GDK_KEY_Shift_Lock = $FFE6; + GDK_KEY_Meta_L = $FFE7; + GDK_KEY_Meta_R = $FFE8; + GDK_KEY_Alt_L = $FFE9; + GDK_KEY_Alt_R = $FFEA; + GDK_KEY_Super_L = $FFEB; + GDK_KEY_Super_R = $FFEC; + GDK_KEY_Hyper_L = $FFED; + GDK_KEY_Hyper_R = $FFEE; + GDK_KEY_ISO_Lock = $FE01; + GDK_KEY_ISO_Level2_Latch = $FE02; + GDK_KEY_ISO_Level3_Shift = $FE03; + GDK_KEY_ISO_Level3_Latch = $FE04; + GDK_KEY_ISO_Level3_Lock = $FE05; + GDK_KEY_ISO_Group_Shift = $FF7E; + GDK_KEY_ISO_Group_Latch = $FE06; + GDK_KEY_ISO_Group_Lock = $FE07; + GDK_KEY_ISO_Next_Group = $FE08; + GDK_KEY_ISO_Next_Group_Lock = $FE09; + GDK_KEY_ISO_Prev_Group = $FE0A; + GDK_KEY_ISO_Prev_Group_Lock = $FE0B; + GDK_KEY_ISO_First_Group = $FE0C; + GDK_KEY_ISO_First_Group_Lock = $FE0D; + GDK_KEY_ISO_Last_Group = $FE0E; + GDK_KEY_ISO_Last_Group_Lock = $FE0F; + GDK_KEY_ISO_Left_Tab = $FE20; + GDK_KEY_ISO_Move_Line_Up = $FE21; + GDK_KEY_ISO_Move_Line_Down = $FE22; + GDK_KEY_ISO_Partial_Line_Up = $FE23; + GDK_KEY_ISO_Partial_Line_Down = $FE24; + GDK_KEY_ISO_Partial_Space_Left = $FE25; + GDK_KEY_ISO_Partial_Space_Right = $FE26; + GDK_KEY_ISO_Set_Margin_Left = $FE27; + GDK_KEY_ISO_Set_Margin_Right = $FE28; + GDK_KEY_ISO_Release_Margin_Left = $FE29; + GDK_KEY_ISO_Release_Margin_Right = $FE2A; + GDK_KEY_ISO_Release_Both_Margins = $FE2B; + GDK_KEY_ISO_Fast_Cursor_Left = $FE2C; + GDK_KEY_ISO_Fast_Cursor_Right = $FE2D; + GDK_KEY_ISO_Fast_Cursor_Up = $FE2E; + GDK_KEY_ISO_Fast_Cursor_Down = $FE2F; + GDK_KEY_ISO_Continuous_Underline = $FE30; + GDK_KEY_ISO_Discontinuous_Underline = $FE31; + GDK_KEY_ISO_Emphasize = $FE32; + GDK_KEY_ISO_Center_Object = $FE33; + GDK_KEY_ISO_Enter = $FE34; + GDK_KEY_dead_grave = $FE50; + GDK_KEY_dead_acute = $FE51; + GDK_KEY_dead_circumflex = $FE52; + GDK_KEY_dead_tilde = $FE53; + GDK_KEY_dead_macron = $FE54; + GDK_KEY_dead_breve = $FE55; + GDK_KEY_dead_abovedot = $FE56; + GDK_KEY_dead_diaeresis = $FE57; + GDK_KEY_dead_abovering = $FE58; + GDK_KEY_dead_doubleacute = $FE59; + GDK_KEY_dead_caron = $FE5A; + GDK_KEY_dead_cedilla = $FE5B; + GDK_KEY_dead_ogonek = $FE5C; + GDK_KEY_dead_iota = $FE5D; + GDK_KEY_dead_voiced_sound = $FE5E; + GDK_KEY_dead_semivoiced_sound = $FE5F; + GDK_KEY_dead_belowdot = $FE60; + GDK_KEY_First_Virtual_Screen = $FED0; + GDK_KEY_Prev_Virtual_Screen = $FED1; + GDK_KEY_Next_Virtual_Screen = $FED2; + GDK_KEY_Last_Virtual_Screen = $FED4; + GDK_KEY_Terminate_Server = $FED5; + GDK_KEY_AccessX_Enable = $FE70; + GDK_KEY_AccessX_Feedback_Enable = $FE71; + GDK_KEY_RepeatKeys_Enable = $FE72; + GDK_KEY_SlowKeys_Enable = $FE73; + GDK_KEY_BounceKeys_Enable = $FE74; + GDK_KEY_StickyKeys_Enable = $FE75; + GDK_KEY_MouseKeys_Enable = $FE76; + GDK_KEY_MouseKeys_Accel_Enable = $FE77; + GDK_KEY_Overlay1_Enable = $FE78; + GDK_KEY_Overlay2_Enable = $FE79; + GDK_KEY_AudibleBell_Enable = $FE7A; + GDK_KEY_Pointer_Left = $FEE0; + GDK_KEY_Pointer_Right = $FEE1; + GDK_KEY_Pointer_Up = $FEE2; + GDK_KEY_Pointer_Down = $FEE3; + GDK_KEY_Pointer_UpLeft = $FEE4; + GDK_KEY_Pointer_UpRight = $FEE5; + GDK_KEY_Pointer_DownLeft = $FEE6; + GDK_KEY_Pointer_DownRight = $FEE7; + GDK_KEY_Pointer_Button_Dflt = $FEE8; + GDK_KEY_Pointer_Button1 = $FEE9; + GDK_KEY_Pointer_Button2 = $FEEA; + GDK_KEY_Pointer_Button3 = $FEEB; + GDK_KEY_Pointer_Button4 = $FEEC; + GDK_KEY_Pointer_Button5 = $FEED; + GDK_KEY_Pointer_DblClick_Dflt = $FEEE; + GDK_KEY_Pointer_DblClick1 = $FEEF; + GDK_KEY_Pointer_DblClick2 = $FEF0; + GDK_KEY_Pointer_DblClick3 = $FEF1; + GDK_KEY_Pointer_DblClick4 = $FEF2; + GDK_KEY_Pointer_DblClick5 = $FEF3; + GDK_KEY_Pointer_Drag_Dflt = $FEF4; + GDK_KEY_Pointer_Drag1 = $FEF5; + GDK_KEY_Pointer_Drag2 = $FEF6; + GDK_KEY_Pointer_Drag3 = $FEF7; + GDK_KEY_Pointer_Drag4 = $FEF8; + GDK_KEY_Pointer_Drag5 = $FEFD; + GDK_KEY_Pointer_EnableKeys = $FEF9; + GDK_KEY_Pointer_Accelerate = $FEFA; + GDK_KEY_Pointer_DfltBtnNext = $FEFB; + GDK_KEY_Pointer_DfltBtnPrev = $FEFC; + GDK_KEY_3270_Duplicate = $FD01; + GDK_KEY_3270_FieldMark = $FD02; + GDK_KEY_3270_Right2 = $FD03; + GDK_KEY_3270_Left2 = $FD04; + GDK_KEY_3270_BackTab = $FD05; + GDK_KEY_3270_EraseEOF = $FD06; + GDK_KEY_3270_EraseInput = $FD07; + GDK_KEY_3270_Reset = $FD08; + GDK_KEY_3270_Quit = $FD09; + GDK_KEY_3270_PA1 = $FD0A; + GDK_KEY_3270_PA2 = $FD0B; + GDK_KEY_3270_PA3 = $FD0C; + GDK_KEY_3270_Test = $FD0D; + GDK_KEY_3270_Attn = $FD0E; + GDK_KEY_3270_CursorBlink = $FD0F; + GDK_KEY_3270_AltCursor = $FD10; + GDK_KEY_3270_KeyClick = $FD11; + GDK_KEY_3270_Jump = $FD12; + GDK_KEY_3270_Ident = $FD13; + GDK_KEY_3270_Rule = $FD14; + GDK_KEY_3270_Copy = $FD15; + GDK_KEY_3270_Play = $FD16; + GDK_KEY_3270_Setup = $FD17; + GDK_KEY_3270_Record = $FD18; + GDK_KEY_3270_ChangeScreen = $FD19; + GDK_KEY_3270_DeleteWord = $FD1A; + GDK_KEY_3270_ExSelect = $FD1B; + GDK_KEY_3270_CursorSelect = $FD1C; + GDK_KEY_3270_PrintScreen = $FD1D; + GDK_KEY_3270_Enter = $FD1E; + GDK_KEY_space = $020; + GDK_KEY_exclam = $021; + GDK_KEY_quotedbl = $022; + GDK_KEY_numbersign = $023; + GDK_KEY_dollar = $024; + GDK_KEY_percent = $025; + GDK_KEY_ampersand = $026; + GDK_KEY_apostrophe = $027; + GDK_KEY_quoteright = $027; + GDK_KEY_parenleft = $028; + GDK_KEY_parenright = $029; + GDK_KEY_asterisk = $02a; + GDK_KEY_plus = $02b; + GDK_KEY_comma = $02c; + GDK_KEY_minus = $02d; + GDK_KEY_period = $02e; + GDK_KEY_slash = $02f; + GDK_KEY_0 = $030; + GDK_KEY_1 = $031; + GDK_KEY_2 = $032; + GDK_KEY_3 = $033; + GDK_KEY_4 = $034; + GDK_KEY_5 = $035; + GDK_KEY_6 = $036; + GDK_KEY_7 = $037; + GDK_KEY_8 = $038; + GDK_KEY_9 = $039; + GDK_KEY_colon = $03a; + GDK_KEY_semicolon = $03b; + GDK_KEY_less = $03c; + GDK_KEY_equal = $03d; + GDK_KEY_greater = $03e; + GDK_KEY_question = $03f; + GDK_KEY_at = $040; + GDK_KEY_CAPITAL_A = $041; + GDK_KEY_CAPITAL_B = $042; + GDK_KEY_CAPITAL_C = $043; + GDK_KEY_CAPITAL_D = $044; + GDK_KEY_CAPITAL_E = $045; + GDK_KEY_CAPITAL_F = $046; + GDK_KEY_CAPITAL_G = $047; + GDK_KEY_CAPITAL_H = $048; + GDK_KEY_CAPITAL_I = $049; + GDK_KEY_CAPITAL_J = $04a; + GDK_KEY_CAPITAL_K = $04b; + GDK_KEY_CAPITAL_L = $04c; + GDK_KEY_CAPITAL_M = $04d; + GDK_KEY_CAPITAL_N = $04e; + GDK_KEY_CAPITAL_O = $04f; + GDK_KEY_CAPITAL_P = $050; + GDK_KEY_CAPITAL_Q = $051; + GDK_KEY_CAPITAL_R = $052; + GDK_KEY_CAPITAL_S = $053; + GDK_KEY_CAPITAL_T = $054; + GDK_KEY_CAPITAL_U = $055; + GDK_KEY_CAPITAL_V = $056; + GDK_KEY_CAPITAL_W = $057; + GDK_KEY_CAPITAL_X = $058; + GDK_KEY_CAPITAL_Y = $059; + GDK_KEY_CAPITAL_Z = $05a; + GDK_KEY_bracketleft = $05b; + GDK_KEY_backslash = $05c; + GDK_KEY_bracketright = $05d; + GDK_KEY_asciicircum = $05e; + GDK_KEY_underscore = $05f; + GDK_KEY_grave = $060; + GDK_KEY_quoteleft = $060; + GDK_KEY_a = $061; + GDK_KEY_b = $062; + GDK_KEY_c = $063; + GDK_KEY_d = $064; + GDK_KEY_e = $065; + GDK_KEY_f = $066; + GDK_KEY_g = $067; + GDK_KEY_h = $068; + GDK_KEY_i = $069; + GDK_KEY_j = $06a; + GDK_KEY_k = $06b; + GDK_KEY_l = $06c; + GDK_KEY_m = $06d; + GDK_KEY_n = $06e; + GDK_KEY_o = $06f; + GDK_KEY_p = $070; + GDK_KEY_q = $071; + GDK_KEY_r = $072; + GDK_KEY_s = $073; + GDK_KEY_t = $074; + GDK_KEY_u = $075; + GDK_KEY_v = $076; + GDK_KEY_w = $077; + GDK_KEY_x = $078; + GDK_KEY_y = $079; + GDK_KEY_z = $07a; + GDK_KEY_braceleft = $07b; + GDK_KEY_bar = $07c; + GDK_KEY_braceright = $07d; + GDK_KEY_asciitilde = $07e; + GDK_KEY_nobreakspace = $0a0; + GDK_KEY_exclamdown = $0a1; + GDK_KEY_cent = $0a2; + GDK_KEY_sterling = $0a3; + GDK_KEY_currency = $0a4; + GDK_KEY_yen = $0a5; + GDK_KEY_brokenbar = $0a6; + GDK_KEY_section = $0a7; + GDK_KEY_diaeresis = $0a8; + GDK_KEY_copyright = $0a9; + GDK_KEY_ordfeminine = $0aa; + GDK_KEY_guillemotleft = $0ab; + GDK_KEY_notsign = $0ac; + GDK_KEY_hyphen = $0ad; + GDK_KEY_registered = $0ae; + GDK_KEY_macron = $0af; + GDK_KEY_degree = $0b0; + GDK_KEY_plusminus = $0b1; + GDK_KEY_twosuperior = $0b2; + GDK_KEY_threesuperior = $0b3; + GDK_KEY_acute = $0b4; + GDK_KEY_mu = $0b5; + GDK_KEY_paragraph = $0b6; + GDK_KEY_periodcentered = $0b7; + GDK_KEY_cedilla = $0b8; + GDK_KEY_onesuperior = $0b9; + GDK_KEY_masculine = $0ba; + GDK_KEY_guillemotright = $0bb; + GDK_KEY_onequarter = $0bc; + GDK_KEY_onehalf = $0bd; + GDK_KEY_threequarters = $0be; + GDK_KEY_questiondown = $0bf; + GDK_KEY_CAPITAL_Agrave = $0c0; + GDK_KEY_CAPITAL_Aacute = $0c1; + GDK_KEY_CAPITAL_Acircumflex = $0c2; + GDK_KEY_CAPITAL_Atilde = $0c3; + GDK_KEY_CAPITAL_Adiaeresis = $0c4; + GDK_KEY_CAPITAL_Aring = $0c5; + GDK_KEY_CAPITAL_AE = $0c6; + GDK_KEY_CAPITAL_Ccedilla = $0c7; + GDK_KEY_CAPITAL_Egrave = $0c8; + GDK_KEY_CAPITAL_Eacute = $0c9; + GDK_KEY_CAPITAL_Ecircumflex = $0ca; + GDK_KEY_CAPITAL_Ediaeresis = $0cb; + GDK_KEY_CAPITAL_Igrave = $0cc; + GDK_KEY_CAPITAL_Iacute = $0cd; + GDK_KEY_CAPITAL_Icircumflex = $0ce; + GDK_KEY_CAPITAL_Idiaeresis = $0cf; + GDK_KEY_CAPITAL_ETH = $0d0; + GDK_KEY_CAPITAL_Ntilde = $0d1; + GDK_KEY_CAPITAL_Ograve = $0d2; + GDK_KEY_CAPITAL_Oacute = $0d3; + GDK_KEY_CAPITAL_Ocircumflex = $0d4; + GDK_KEY_CAPITAL_Otilde = $0d5; + GDK_KEY_CAPITAL_Odiaeresis = $0d6; + GDK_KEY_multiply = $0d7; + GDK_KEY_Ooblique = $0d8; + GDK_KEY_CAPITAL_Ugrave = $0d9; + GDK_KEY_CAPITAL_Uacute = $0da; + GDK_KEY_CAPITAL_Ucircumflex = $0db; + GDK_KEY_CAPITAL_Udiaeresis = $0dc; + GDK_KEY_CAPITAL_Yacute = $0dd; + GDK_KEY_CAPITAL_THORN = $0de; + GDK_KEY_ssharp = $0df; + GDK_KEY_agrave = $0e0; + GDK_KEY_aacute = $0e1; + GDK_KEY_acircumflex = $0e2; + GDK_KEY_atilde = $0e3; + GDK_KEY_adiaeresis = $0e4; + GDK_KEY_aring = $0e5; + GDK_KEY_ae = $0e6; + GDK_KEY_ccedilla = $0e7; + GDK_KEY_egrave = $0e8; + GDK_KEY_eacute = $0e9; + GDK_KEY_ecircumflex = $0ea; + GDK_KEY_ediaeresis = $0eb; + GDK_KEY_igrave = $0ec; + GDK_KEY_iacute = $0ed; + GDK_KEY_icircumflex = $0ee; + GDK_KEY_idiaeresis = $0ef; + GDK_KEY_eth = $0f0; + GDK_KEY_ntilde = $0f1; + GDK_KEY_ograve = $0f2; + GDK_KEY_oacute = $0f3; + GDK_KEY_ocircumflex = $0f4; + GDK_KEY_otilde = $0f5; + GDK_KEY_odiaeresis = $0f6; + GDK_KEY_division = $0f7; + GDK_KEY_oslash = $0f8; + GDK_KEY_ugrave = $0f9; + GDK_KEY_uacute = $0fa; + GDK_KEY_ucircumflex = $0fb; + GDK_KEY_udiaeresis = $0fc; + GDK_KEY_yacute = $0fd; + GDK_KEY_thorn = $0fe; + GDK_KEY_ydiaeresis = $0ff; + GDK_KEY_CAPITAL_Aogonek = $1a1; + GDK_KEY_breve = $1a2; + GDK_KEY_CAPITAL_Lstroke = $1a3; + GDK_KEY_CAPITAL_Lcaron = $1a5; + GDK_KEY_CAPITAL_Sacute = $1a6; + GDK_KEY_CAPITAL_Scaron = $1a9; + GDK_KEY_CAPITAL_Scedilla = $1aa; + GDK_KEY_CAPITAL_Tcaron = $1ab; + GDK_KEY_CAPITAL_Zacute = $1ac; + GDK_KEY_CAPITAL_Zcaron = $1ae; + GDK_KEY_CAPITAL_Zabovedot = $1af; + GDK_KEY_aogonek = $1b1; + GDK_KEY_ogonek = $1b2; + GDK_KEY_lstroke = $1b3; + GDK_KEY_lcaron = $1b5; + GDK_KEY_sacute = $1b6; + GDK_KEY_caron = $1b7; + GDK_KEY_scaron = $1b9; + GDK_KEY_scedilla = $1ba; + GDK_KEY_tcaron = $1bb; + GDK_KEY_zacute = $1bc; + GDK_KEY_doubleacute = $1bd; + GDK_KEY_zcaron = $1be; + GDK_KEY_zabovedot = $1bf; + GDK_KEY_CAPITAL_Racute = $1c0; + GDK_KEY_CAPITAL_Abreve = $1c3; + GDK_KEY_CAPITAL_Lacute = $1c5; + GDK_KEY_CAPITAL_Cacute = $1c6; + GDK_KEY_CAPITAL_Ccaron = $1c8; + GDK_KEY_CAPITAL_Eogonek = $1ca; + GDK_KEY_CAPITAL_Ecaron = $1cc; + GDK_KEY_CAPITAL_Dcaron = $1cf; + GDK_KEY_CAPITAL_Dstroke = $1d0; + GDK_KEY_CAPITAL_Nacute = $1d1; + GDK_KEY_CAPITAL_Ncaron = $1d2; + GDK_KEY_CAPITAL_Odoubleacute = $1d5; + GDK_KEY_CAPITAL_Rcaron = $1d8; + GDK_KEY_CAPITAL_Uring = $1d9; + GDK_KEY_CAPITAL_Udoubleacute = $1db; + GDK_KEY_CAPITAL_Tcedilla = $1de; + GDK_KEY_racute = $1e0; + GDK_KEY_abreve = $1e3; + GDK_KEY_lacute = $1e5; + GDK_KEY_cacute = $1e6; + GDK_KEY_ccaron = $1e8; + GDK_KEY_eogonek = $1ea; + GDK_KEY_ecaron = $1ec; + GDK_KEY_dcaron = $1ef; + GDK_KEY_dstroke = $1f0; + GDK_KEY_nacute = $1f1; + GDK_KEY_ncaron = $1f2; + GDK_KEY_odoubleacute = $1f5; + GDK_KEY_udoubleacute = $1fb; + GDK_KEY_rcaron = $1f8; + GDK_KEY_uring = $1f9; + GDK_KEY_tcedilla = $1fe; + GDK_KEY_abovedot = $1ff; + GDK_KEY_CAPITAL_Hstroke = $2a1; + GDK_KEY_CAPITAL_Hcircumflex = $2a6; + GDK_KEY_CAPITAL_Iabovedot = $2a9; + GDK_KEY_CAPITAL_Gbreve = $2ab; + GDK_KEY_CAPITAL_Jcircumflex = $2ac; + GDK_KEY_hstroke = $2b1; + GDK_KEY_hcircumflex = $2b6; + GDK_KEY_idotless = $2b9; + GDK_KEY_gbreve = $2bb; + GDK_KEY_jcircumflex = $2bc; + GDK_KEY_CAPITAL_Cabovedot = $2c5; + GDK_KEY_CAPITAL_Ccircumflex = $2c6; + GDK_KEY_CAPITAL_Gabovedot = $2d5; + GDK_KEY_CAPITAL_Gcircumflex = $2d8; + GDK_KEY_CAPITAL_Ubreve = $2dd; + GDK_KEY_CAPITAL_Scircumflex = $2de; + GDK_KEY_cabovedot = $2e5; + GDK_KEY_ccircumflex = $2e6; + GDK_KEY_gabovedot = $2f5; + GDK_KEY_gcircumflex = $2f8; + GDK_KEY_ubreve = $2fd; + GDK_KEY_scircumflex = $2fe; + GDK_KEY_kra = $3a2; + GDK_KEY_kappa = $3a2; + GDK_KEY_CAPITAL_Rcedilla = $3a3; + GDK_KEY_CAPITAL_Itilde = $3a5; + GDK_KEY_CAPITAL_Lcedilla = $3a6; + GDK_KEY_CAPITAL_Emacron = $3aa; + GDK_KEY_CAPITAL_Gcedilla = $3ab; + GDK_KEY_CAPITAL_Tslash = $3ac; + GDK_KEY_rcedilla = $3b3; + GDK_KEY_itilde = $3b5; + GDK_KEY_lcedilla = $3b6; + GDK_KEY_emacron = $3ba; + GDK_KEY_gcedilla = $3bb; + GDK_KEY_tslash = $3bc; + GDK_KEY_CAPITAL_ENG = $3bd; + GDK_KEY_eng = $3bf; + GDK_KEY_CAPITAL_Amacron = $3c0; + GDK_KEY_CAPITAL_Iogonek = $3c7; + GDK_KEY_CAPITAL_Eabovedot = $3cc; + GDK_KEY_CAPITAL_Imacron = $3cf; + GDK_KEY_CAPITAL_Ncedilla = $3d1; + GDK_KEY_CAPITAL_Omacron = $3d2; + GDK_KEY_CAPITAL_Kcedilla = $3d3; + GDK_KEY_CAPITAL_Uogonek = $3d9; + GDK_KEY_CAPITAL_Utilde = $3dd; + GDK_KEY_CAPITAL_Umacron = $3de; + GDK_KEY_amacron = $3e0; + GDK_KEY_iogonek = $3e7; + GDK_KEY_eabovedot = $3ec; + GDK_KEY_imacron = $3ef; + GDK_KEY_ncedilla = $3f1; + GDK_KEY_omacron = $3f2; + GDK_KEY_kcedilla = $3f3; + GDK_KEY_uogonek = $3f9; + GDK_KEY_utilde = $3fd; + GDK_KEY_umacron = $3fe; + GDK_KEY_CAPITAL_OE = $13bc; + GDK_KEY_oe = $13bd; + GDK_KEY_CAPITAL_Ydiaeresis = $13be; + GDK_KEY_overline = $47e; + GDK_KEY_kana_fullstop = $4a1; + GDK_KEY_kana_openingbracket = $4a2; + GDK_KEY_kana_closingbracket = $4a3; + GDK_KEY_kana_comma = $4a4; + GDK_KEY_kana_conjunctive = $4a5; + GDK_KEY_kana_middledot = $4a5; + GDK_KEY_kana_WO = $4a6; + GDK_KEY_kana_a = $4a7; + GDK_KEY_kana_i = $4a8; + GDK_KEY_kana_u = $4a9; + GDK_KEY_kana_e = $4aa; + GDK_KEY_kana_o = $4ab; + GDK_KEY_kana_ya = $4ac; + GDK_KEY_kana_yu = $4ad; + GDK_KEY_kana_yo = $4ae; + GDK_KEY_kana_tsu = $4af; + GDK_KEY_kana_tu = $4af; + GDK_KEY_prolongedsound = $4b0; + GDK_KEY_kana_CAPITAL_A = $4b1; + GDK_KEY_kana_CAPITAL_I = $4b2; + GDK_KEY_kana_CAPITAL_U = $4b3; + GDK_KEY_kana_CAPITAL_E = $4b4; + GDK_KEY_kana_CAPITAL_O = $4b5; + GDK_KEY_kana_KA = $4b6; + GDK_KEY_kana_KI = $4b7; + GDK_KEY_kana_KU = $4b8; + GDK_KEY_kana_KE = $4b9; + GDK_KEY_kana_KO = $4ba; + GDK_KEY_kana_SA = $4bb; + GDK_KEY_kana_SHI = $4bc; + GDK_KEY_kana_SU = $4bd; + GDK_KEY_kana_SE = $4be; + GDK_KEY_kana_SO = $4bf; + GDK_KEY_kana_TA = $4c0; + GDK_KEY_kana_CHI = $4c1; + GDK_KEY_kana_TI = $4c1; + GDK_KEY_kana_CAPITAL_TSU = $4c2; + GDK_KEY_kana_CAPITAL_TU = $4c2; + GDK_KEY_kana_TE = $4c3; + GDK_KEY_kana_TO = $4c4; + GDK_KEY_kana_NA = $4c5; + GDK_KEY_kana_NI = $4c6; + GDK_KEY_kana_NU = $4c7; + GDK_KEY_kana_NE = $4c8; + GDK_KEY_kana_NO = $4c9; + GDK_KEY_kana_HA = $4ca; + GDK_KEY_kana_HI = $4cb; + GDK_KEY_kana_FU = $4cc; + GDK_KEY_kana_HU = $4cc; + GDK_KEY_kana_HE = $4cd; + GDK_KEY_kana_HO = $4ce; + GDK_KEY_kana_MA = $4cf; + GDK_KEY_kana_MI = $4d0; + GDK_KEY_kana_MU = $4d1; + GDK_KEY_kana_ME = $4d2; + GDK_KEY_kana_MO = $4d3; + GDK_KEY_kana_CAPITAL_YA = $4d4; + GDK_KEY_kana_CAPITAL_YU = $4d5; + GDK_KEY_kana_CAPITAL_YO = $4d6; + GDK_KEY_kana_RA = $4d7; + GDK_KEY_kana_RI = $4d8; + GDK_KEY_kana_RU = $4d9; + GDK_KEY_kana_RE = $4da; + GDK_KEY_kana_RO = $4db; + GDK_KEY_kana_WA = $4dc; + GDK_KEY_kana_N = $4dd; + GDK_KEY_voicedsound = $4de; + GDK_KEY_semivoicedsound = $4df; + GDK_KEY_kana_switch = $FF7E; + GDK_KEY_Arabic_comma = $5ac; + GDK_KEY_Arabic_semicolon = $5bb; + GDK_KEY_Arabic_question_mark = $5bf; + GDK_KEY_Arabic_hamza = $5c1; + GDK_KEY_Arabic_maddaonalef = $5c2; + GDK_KEY_Arabic_hamzaonalef = $5c3; + GDK_KEY_Arabic_hamzaonwaw = $5c4; + GDK_KEY_Arabic_hamzaunderalef = $5c5; + GDK_KEY_Arabic_hamzaonyeh = $5c6; + GDK_KEY_Arabic_alef = $5c7; + GDK_KEY_Arabic_beh = $5c8; + GDK_KEY_Arabic_tehmarbuta = $5c9; + GDK_KEY_Arabic_teh = $5ca; + GDK_KEY_Arabic_theh = $5cb; + GDK_KEY_Arabic_jeem = $5cc; + GDK_KEY_Arabic_hah = $5cd; + GDK_KEY_Arabic_khah = $5ce; + GDK_KEY_Arabic_dal = $5cf; + GDK_KEY_Arabic_thal = $5d0; + GDK_KEY_Arabic_ra = $5d1; + GDK_KEY_Arabic_zain = $5d2; + GDK_KEY_Arabic_seen = $5d3; + GDK_KEY_Arabic_sheen = $5d4; + GDK_KEY_Arabic_sad = $5d5; + GDK_KEY_Arabic_dad = $5d6; + GDK_KEY_Arabic_tah = $5d7; + GDK_KEY_Arabic_zah = $5d8; + GDK_KEY_Arabic_ain = $5d9; + GDK_KEY_Arabic_ghain = $5da; + GDK_KEY_Arabic_tatweel = $5e0; + GDK_KEY_Arabic_feh = $5e1; + GDK_KEY_Arabic_qaf = $5e2; + GDK_KEY_Arabic_kaf = $5e3; + GDK_KEY_Arabic_lam = $5e4; + GDK_KEY_Arabic_meem = $5e5; + GDK_KEY_Arabic_noon = $5e6; + GDK_KEY_Arabic_ha = $5e7; + GDK_KEY_Arabic_heh = $5e7; + GDK_KEY_Arabic_waw = $5e8; + GDK_KEY_Arabic_alefmaksura = $5e9; + GDK_KEY_Arabic_yeh = $5ea; + GDK_KEY_Arabic_fathatan = $5eb; + GDK_KEY_Arabic_dammatan = $5ec; + GDK_KEY_Arabic_kasratan = $5ed; + GDK_KEY_Arabic_fatha = $5ee; + GDK_KEY_Arabic_damma = $5ef; + GDK_KEY_Arabic_kasra = $5f0; + GDK_KEY_Arabic_shadda = $5f1; + GDK_KEY_Arabic_sukun = $5f2; + GDK_KEY_Arabic_switch = $FF7E; + GDK_KEY_Serbian_dje = $6a1; + GDK_KEY_Macedonia_gje = $6a2; + GDK_KEY_Cyrillic_io = $6a3; + GDK_KEY_Ukrainian_ie = $6a4; + GDK_KEY_Ukranian_je = $6a4; + GDK_KEY_Macedonia_dse = $6a5; + GDK_KEY_Ukrainian_i = $6a6; + GDK_KEY_Ukranian_i = $6a6; + GDK_KEY_Ukrainian_yi = $6a7; + GDK_KEY_Ukranian_yi = $6a7; + GDK_KEY_Cyrillic_je = $6a8; + GDK_KEY_Serbian_je = $6a8; + GDK_KEY_Cyrillic_lje = $6a9; + GDK_KEY_Serbian_lje = $6a9; + GDK_KEY_Cyrillic_nje = $6aa; + GDK_KEY_Serbian_nje = $6aa; + GDK_KEY_Serbian_tshe = $6ab; + GDK_KEY_Macedonia_kje = $6ac; + GDK_KEY_Byelorussian_shortu = $6ae; + GDK_KEY_Cyrillic_dzhe = $6af; + GDK_KEY_Serbian_dze = $6af; + GDK_KEY_numerosign = $6b0; + GDK_KEY_Serbian_CAPITAL_DJE = $6b1; + GDK_KEY_Macedonia_CAPITAL_GJE = $6b2; + GDK_KEY_Cyrillic_CAPITAL_IO = $6b3; + GDK_KEY_Ukrainian_CAPITAL_IE = $6b4; + GDK_KEY_Ukranian_CAPITAL_JE = $6b4; + GDK_KEY_Macedonia_CAPITAL_DSE = $6b5; + GDK_KEY_Ukrainian_CAPITAL_I = $6b6; + GDK_KEY_Ukranian_CAPITAL_I = $6b6; + GDK_KEY_Ukrainian_CAPITAL_YI = $6b7; + GDK_KEY_Ukranian_CAPITAL_YI = $6b7; + GDK_KEY_Cyrillic_CAPITAL_JE = $6b8; + GDK_KEY_Serbian_CAPITAL_JE = $6b8; + GDK_KEY_Cyrillic_CAPITAL_LJE = $6b9; + GDK_KEY_Serbian_CAPITAL_LJE = $6b9; + GDK_KEY_Cyrillic_CAPITAL_NJE = $6ba; + GDK_KEY_Serbian_CAPITAL_NJE = $6ba; + GDK_KEY_Serbian_CAPITAL_TSHE = $6bb; + GDK_KEY_Macedonia_CAPITAL_KJE = $6bc; + GDK_KEY_Byelorussian_CAPITAL_SHORTU = $6be; + GDK_KEY_Cyrillic_CAPITAL_DZHE = $6bf; + GDK_KEY_Serbian_CAPITAL_DZE = $6bf; + GDK_KEY_Cyrillic_yu = $6c0; + GDK_KEY_Cyrillic_a = $6c1; + GDK_KEY_Cyrillic_be = $6c2; + GDK_KEY_Cyrillic_tse = $6c3; + GDK_KEY_Cyrillic_de = $6c4; + GDK_KEY_Cyrillic_ie = $6c5; + GDK_KEY_Cyrillic_ef = $6c6; + GDK_KEY_Cyrillic_ghe = $6c7; + GDK_KEY_Cyrillic_ha = $6c8; + GDK_KEY_Cyrillic_i = $6c9; + GDK_KEY_Cyrillic_shorti = $6ca; + GDK_KEY_Cyrillic_ka = $6cb; + GDK_KEY_Cyrillic_el = $6cc; + GDK_KEY_Cyrillic_em = $6cd; + GDK_KEY_Cyrillic_en = $6ce; + GDK_KEY_Cyrillic_o = $6cf; + GDK_KEY_Cyrillic_pe = $6d0; + GDK_KEY_Cyrillic_ya = $6d1; + GDK_KEY_Cyrillic_er = $6d2; + GDK_KEY_Cyrillic_es = $6d3; + GDK_KEY_Cyrillic_te = $6d4; + GDK_KEY_Cyrillic_u = $6d5; + GDK_KEY_Cyrillic_zhe = $6d6; + GDK_KEY_Cyrillic_ve = $6d7; + GDK_KEY_Cyrillic_softsign = $6d8; + GDK_KEY_Cyrillic_yeru = $6d9; + GDK_KEY_Cyrillic_ze = $6da; + GDK_KEY_Cyrillic_sha = $6db; + GDK_KEY_Cyrillic_e = $6dc; + GDK_KEY_Cyrillic_shcha = $6dd; + GDK_KEY_Cyrillic_che = $6de; + GDK_KEY_Cyrillic_hardsign = $6df; + GDK_KEY_Cyrillic_CAPITAL_YU = $6e0; + GDK_KEY_Cyrillic_CAPITAL_A = $6e1; + GDK_KEY_Cyrillic_CAPITAL_BE = $6e2; + GDK_KEY_Cyrillic_CAPITAL_TSE = $6e3; + GDK_KEY_Cyrillic_CAPITAL_DE = $6e4; + GDK_KEY_Cyrillic_CAPITAL_IE = $6e5; + GDK_KEY_Cyrillic_CAPITAL_EF = $6e6; + GDK_KEY_Cyrillic_CAPITAL_GHE = $6e7; + GDK_KEY_Cyrillic_CAPITAL_HA = $6e8; + GDK_KEY_Cyrillic_CAPITAL_I = $6e9; + GDK_KEY_Cyrillic_CAPITAL_SHORTI = $6ea; + GDK_KEY_Cyrillic_CAPITAL_KA = $6eb; + GDK_KEY_Cyrillic_CAPITAL_EL = $6ec; + GDK_KEY_Cyrillic_CAPITAL_EM = $6ed; + GDK_KEY_Cyrillic_CAPITAL_EN = $6ee; + GDK_KEY_Cyrillic_CAPITAL_O = $6ef; + GDK_KEY_Cyrillic_CAPITAL_PE = $6f0; + GDK_KEY_Cyrillic_CAPITAL_YA = $6f1; + GDK_KEY_Cyrillic_CAPITAL_ER = $6f2; + GDK_KEY_Cyrillic_CAPITAL_ES = $6f3; + GDK_KEY_Cyrillic_CAPITAL_TE = $6f4; + GDK_KEY_Cyrillic_CAPITAL_U = $6f5; + GDK_KEY_Cyrillic_CAPITAL_ZHE = $6f6; + GDK_KEY_Cyrillic_CAPITAL_VE = $6f7; + GDK_KEY_Cyrillic_CAPITAL_SOFTSIGN = $6f8; + GDK_KEY_Cyrillic_CAPITAL_YERU = $6f9; + GDK_KEY_Cyrillic_CAPITAL_ZE = $6fa; + GDK_KEY_Cyrillic_CAPITAL_SHA = $6fb; + GDK_KEY_Cyrillic_CAPITAL_E = $6fc; + GDK_KEY_Cyrillic_CAPITAL_SHCHA = $6fd; + GDK_KEY_Cyrillic_CAPITAL_CHE = $6fe; + GDK_KEY_Cyrillic_CAPITAL_HARDSIGN = $6ff; + GDK_KEY_Greek_CAPITAL_ALPHAaccent = $7a1; + GDK_KEY_Greek_CAPITAL_EPSILONaccent = $7a2; + GDK_KEY_Greek_CAPITAL_ETAaccent = $7a3; + GDK_KEY_Greek_CAPITAL_IOTAaccent = $7a4; + GDK_KEY_Greek_CAPITAL_IOTAdiaeresis = $7a5; + GDK_KEY_Greek_CAPITAL_OMICRONaccent = $7a7; + GDK_KEY_Greek_CAPITAL_UPSILONaccent = $7a8; + GDK_KEY_Greek_CAPITAL_UPSILONdieresis = $7a9; + GDK_KEY_Greek_CAPITAL_OMEGAaccent = $7ab; + GDK_KEY_Greek_accentdieresis = $7ae; + GDK_KEY_Greek_horizbar = $7af; + GDK_KEY_Greek_alphaaccent = $7b1; + GDK_KEY_Greek_epsilonaccent = $7b2; + GDK_KEY_Greek_etaaccent = $7b3; + GDK_KEY_Greek_iotaaccent = $7b4; + GDK_KEY_Greek_iotadieresis = $7b5; + GDK_KEY_Greek_iotaaccentdieresis = $7b6; + GDK_KEY_Greek_omicronaccent = $7b7; + GDK_KEY_Greek_upsilonaccent = $7b8; + GDK_KEY_Greek_upsilondieresis = $7b9; + GDK_KEY_Greek_upsilonaccentdieresis = $7ba; + GDK_KEY_Greek_omegaaccent = $7bb; + GDK_KEY_Greek_CAPITAL_ALPHA = $7c1; + GDK_KEY_Greek_CAPITAL_BETA = $7c2; + GDK_KEY_Greek_CAPITAL_GAMMA = $7c3; + GDK_KEY_Greek_CAPITAL_DELTA = $7c4; + GDK_KEY_Greek_CAPITAL_EPSILON = $7c5; + GDK_KEY_Greek_CAPITAL_ZETA = $7c6; + GDK_KEY_Greek_CAPITAL_ETA = $7c7; + GDK_KEY_Greek_CAPITAL_THETA = $7c8; + GDK_KEY_Greek_CAPITAL_IOTA = $7c9; + GDK_KEY_Greek_CAPITAL_KAPPA = $7ca; + GDK_KEY_Greek_CAPITAL_LAMDA = $7cb; + GDK_KEY_Greek_CAPITAL_LAMBDA = $7cb; + GDK_KEY_Greek_CAPITAL_MU = $7cc; + GDK_KEY_Greek_CAPITAL_NU = $7cd; + GDK_KEY_Greek_CAPITAL_XI = $7ce; + GDK_KEY_Greek_CAPITAL_OMICRON = $7cf; + GDK_KEY_Greek_CAPITAL_PI = $7d0; + GDK_KEY_Greek_CAPITAL_RHO = $7d1; + GDK_KEY_Greek_CAPITAL_SIGMA = $7d2; + GDK_KEY_Greek_CAPITAL_TAU = $7d4; + GDK_KEY_Greek_CAPITAL_UPSILON = $7d5; + GDK_KEY_Greek_CAPITAL_PHI = $7d6; + GDK_KEY_Greek_CAPITAL_CHI = $7d7; + GDK_KEY_Greek_CAPITAL_PSI = $7d8; + GDK_KEY_Greek_CAPITAL_OMEGA = $7d9; + GDK_KEY_Greek_alpha = $7e1; + GDK_KEY_Greek_beta = $7e2; + GDK_KEY_Greek_gamma = $7e3; + GDK_KEY_Greek_delta = $7e4; + GDK_KEY_Greek_epsilon = $7e5; + GDK_KEY_Greek_zeta = $7e6; + GDK_KEY_Greek_eta = $7e7; + GDK_KEY_Greek_theta = $7e8; + GDK_KEY_Greek_iota = $7e9; + GDK_KEY_Greek_kappa = $7ea; + GDK_KEY_Greek_lamda = $7eb; + GDK_KEY_Greek_lambda = $7eb; + GDK_KEY_Greek_mu = $7ec; + GDK_KEY_Greek_nu = $7ed; + GDK_KEY_Greek_xi = $7ee; + GDK_KEY_Greek_omicron = $7ef; + GDK_KEY_Greek_pi = $7f0; + GDK_KEY_Greek_rho = $7f1; + GDK_KEY_Greek_sigma = $7f2; + GDK_KEY_Greek_finalsmallsigma = $7f3; + GDK_KEY_Greek_tau = $7f4; + GDK_KEY_Greek_upsilon = $7f5; + GDK_KEY_Greek_phi = $7f6; + GDK_KEY_Greek_chi = $7f7; + GDK_KEY_Greek_psi = $7f8; + GDK_KEY_Greek_omega = $7f9; + GDK_KEY_Greek_switch = $FF7E; + GDK_KEY_leftradical = $8a1; + GDK_KEY_topleftradical = $8a2; + GDK_KEY_horizconnector = $8a3; + GDK_KEY_topintegral = $8a4; + GDK_KEY_botintegral = $8a5; + GDK_KEY_vertconnector = $8a6; + GDK_KEY_topleftsqbracket = $8a7; + GDK_KEY_botleftsqbracket = $8a8; + GDK_KEY_toprightsqbracket = $8a9; + GDK_KEY_botrightsqbracket = $8aa; + GDK_KEY_topleftparens = $8ab; + GDK_KEY_botleftparens = $8ac; + GDK_KEY_toprightparens = $8ad; + GDK_KEY_botrightparens = $8ae; + GDK_KEY_leftmiddlecurlybrace = $8af; + GDK_KEY_rightmiddlecurlybrace = $8b0; + GDK_KEY_topleftsummation = $8b1; + GDK_KEY_botleftsummation = $8b2; + GDK_KEY_topvertsummationconnector = $8b3; + GDK_KEY_botvertsummationconnector = $8b4; + GDK_KEY_toprightsummation = $8b5; + GDK_KEY_botrightsummation = $8b6; + GDK_KEY_rightmiddlesummation = $8b7; + GDK_KEY_lessthanequal = $8bc; + GDK_KEY_notequal = $8bd; + GDK_KEY_greaterthanequal = $8be; + GDK_KEY_integral = $8bf; + GDK_KEY_therefore = $8c0; + GDK_KEY_variation = $8c1; + GDK_KEY_infinity = $8c2; + GDK_KEY_nabla = $8c5; + GDK_KEY_approximate = $8c8; + GDK_KEY_similarequal = $8c9; + GDK_KEY_ifonlyif = $8cd; + GDK_KEY_implies = $8ce; + GDK_KEY_identical = $8cf; + GDK_KEY_radical = $8d6; + GDK_KEY_includedin = $8da; + GDK_KEY_includes = $8db; + GDK_KEY_intersection = $8dc; + GDK_KEY_union = $8dd; + GDK_KEY_logicaland = $8de; + GDK_KEY_logicalor = $8df; + GDK_KEY_partialderivative = $8ef; + GDK_KEY_function = $8f6; + GDK_KEY_leftarrow = $8fb; + GDK_KEY_uparrow = $8fc; + GDK_KEY_rightarrow = $8fd; + GDK_KEY_downarrow = $8fe; + GDK_KEY_blank = $9df; + GDK_KEY_soliddiamond = $9e0; + GDK_KEY_checkerboard = $9e1; + GDK_KEY_ht = $9e2; + GDK_KEY_ff = $9e3; + GDK_KEY_cr = $9e4; + GDK_KEY_lf = $9e5; + GDK_KEY_nl = $9e8; + GDK_KEY_vt = $9e9; + GDK_KEY_lowrightcorner = $9ea; + GDK_KEY_uprightcorner = $9eb; + GDK_KEY_upleftcorner = $9ec; + GDK_KEY_lowleftcorner = $9ed; + GDK_KEY_crossinglines = $9ee; + GDK_KEY_horizlinescan1 = $9ef; + GDK_KEY_horizlinescan3 = $9f0; + GDK_KEY_horizlinescan5 = $9f1; + GDK_KEY_horizlinescan7 = $9f2; + GDK_KEY_horizlinescan9 = $9f3; + GDK_KEY_leftt = $9f4; + GDK_KEY_rightt = $9f5; + GDK_KEY_bott = $9f6; + GDK_KEY_topt = $9f7; + GDK_KEY_vertbar = $9f8; + GDK_KEY_emspace = $aa1; + GDK_KEY_enspace = $aa2; + GDK_KEY_em3space = $aa3; + GDK_KEY_em4space = $aa4; + GDK_KEY_digitspace = $aa5; + GDK_KEY_punctspace = $aa6; + GDK_KEY_thinspace = $aa7; + GDK_KEY_hairspace = $aa8; + GDK_KEY_emdash = $aa9; + GDK_KEY_endash = $aaa; + GDK_KEY_signifblank = $aac; + GDK_KEY_ellipsis = $aae; + GDK_KEY_doubbaselinedot = $aaf; + GDK_KEY_onethird = $ab0; + GDK_KEY_twothirds = $ab1; + GDK_KEY_onefifth = $ab2; + GDK_KEY_twofifths = $ab3; + GDK_KEY_threefifths = $ab4; + GDK_KEY_fourfifths = $ab5; + GDK_KEY_onesixth = $ab6; + GDK_KEY_fivesixths = $ab7; + GDK_KEY_careof = $ab8; + GDK_KEY_figdash = $abb; + GDK_KEY_leftanglebracket = $abc; + GDK_KEY_decimalpoint = $abd; + GDK_KEY_rightanglebracket = $abe; + GDK_KEY_marker = $abf; + GDK_KEY_oneeighth = $ac3; + GDK_KEY_threeeighths = $ac4; + GDK_KEY_fiveeighths = $ac5; + GDK_KEY_seveneighths = $ac6; + GDK_KEY_trademark = $ac9; + GDK_KEY_signaturemark = $aca; + GDK_KEY_trademarkincircle = $acb; + GDK_KEY_leftopentriangle = $acc; + GDK_KEY_rightopentriangle = $acd; + GDK_KEY_emopencircle = $ace; + GDK_KEY_emopenrectangle = $acf; + GDK_KEY_leftsinglequotemark = $ad0; + GDK_KEY_rightsinglequotemark = $ad1; + GDK_KEY_leftdoublequotemark = $ad2; + GDK_KEY_rightdoublequotemark = $ad3; + GDK_KEY_prescription = $ad4; + GDK_KEY_minutes = $ad6; + GDK_KEY_seconds = $ad7; + GDK_KEY_latincross = $ad9; + GDK_KEY_hexagram = $ada; + GDK_KEY_filledrectbullet = $adb; + GDK_KEY_filledlefttribullet = $adc; + GDK_KEY_filledrighttribullet = $add; + GDK_KEY_emfilledcircle = $ade; + GDK_KEY_emfilledrect = $adf; + GDK_KEY_enopencircbullet = $ae0; + GDK_KEY_enopensquarebullet = $ae1; + GDK_KEY_openrectbullet = $ae2; + GDK_KEY_opentribulletup = $ae3; + GDK_KEY_opentribulletdown = $ae4; + GDK_KEY_openstar = $ae5; + GDK_KEY_enfilledcircbullet = $ae6; + GDK_KEY_enfilledsqbullet = $ae7; + GDK_KEY_filledtribulletup = $ae8; + GDK_KEY_filledtribulletdown = $ae9; + GDK_KEY_leftpointer = $aea; + GDK_KEY_rightpointer = $aeb; + GDK_KEY_club = $aec; + GDK_KEY_diamond = $aed; + GDK_KEY_heart = $aee; + GDK_KEY_maltesecross = $af0; + GDK_KEY_dagger = $af1; + GDK_KEY_doubledagger = $af2; + GDK_KEY_checkmark = $af3; + GDK_KEY_ballotcross = $af4; + GDK_KEY_musicalsharp = $af5; + GDK_KEY_musicalflat = $af6; + GDK_KEY_malesymbol = $af7; + GDK_KEY_femalesymbol = $af8; + GDK_KEY_telephone = $af9; + GDK_KEY_telephonerecorder = $afa; + GDK_KEY_phonographcopyright = $afb; + GDK_KEY_caret = $afc; + GDK_KEY_singlelowquotemark = $afd; + GDK_KEY_doublelowquotemark = $afe; + GDK_KEY_cursor = $aff; + GDK_KEY_leftcaret = $ba3; + GDK_KEY_rightcaret = $ba6; + GDK_KEY_downcaret = $ba8; + GDK_KEY_upcaret = $ba9; + GDK_KEY_overbar = $bc0; + GDK_KEY_downtack = $bc2; + GDK_KEY_upshoe = $bc3; + GDK_KEY_downstile = $bc4; + GDK_KEY_underbar = $bc6; + GDK_KEY_jot = $bca; + GDK_KEY_quad = $bcc; + GDK_KEY_uptack = $bce; + GDK_KEY_circle = $bcf; + GDK_KEY_upstile = $bd3; + GDK_KEY_downshoe = $bd6; + GDK_KEY_rightshoe = $bd8; + GDK_KEY_leftshoe = $bda; + GDK_KEY_lefttack = $bdc; + GDK_KEY_righttack = $bfc; + GDK_KEY_hebrew_doublelowline = $cdf; + GDK_KEY_hebrew_aleph = $ce0; + GDK_KEY_hebrew_bet = $ce1; + GDK_KEY_hebrew_beth = $ce1; + GDK_KEY_hebrew_gimel = $ce2; + GDK_KEY_hebrew_gimmel = $ce2; + GDK_KEY_hebrew_dalet = $ce3; + GDK_KEY_hebrew_daleth = $ce3; + GDK_KEY_hebrew_he = $ce4; + GDK_KEY_hebrew_waw = $ce5; + GDK_KEY_hebrew_zain = $ce6; + GDK_KEY_hebrew_zayin = $ce6; + GDK_KEY_hebrew_chet = $ce7; + GDK_KEY_hebrew_het = $ce7; + GDK_KEY_hebrew_tet = $ce8; + GDK_KEY_hebrew_teth = $ce8; + GDK_KEY_hebrew_yod = $ce9; + GDK_KEY_hebrew_finalkaph = $cea; + GDK_KEY_hebrew_kaph = $ceb; + GDK_KEY_hebrew_lamed = $cec; + GDK_KEY_hebrew_finalmem = $ced; + GDK_KEY_hebrew_mem = $cee; + GDK_KEY_hebrew_finalnun = $cef; + GDK_KEY_hebrew_nun = $cf0; + GDK_KEY_hebrew_samech = $cf1; + GDK_KEY_hebrew_samekh = $cf1; + GDK_KEY_hebrew_ayin = $cf2; + GDK_KEY_hebrew_finalpe = $cf3; + GDK_KEY_hebrew_pe = $cf4; + GDK_KEY_hebrew_finalzade = $cf5; + GDK_KEY_hebrew_finalzadi = $cf5; + GDK_KEY_hebrew_zade = $cf6; + GDK_KEY_hebrew_zadi = $cf6; + GDK_KEY_hebrew_qoph = $cf7; + GDK_KEY_hebrew_kuf = $cf7; + GDK_KEY_hebrew_resh = $cf8; + GDK_KEY_hebrew_shin = $cf9; + GDK_KEY_hebrew_taw = $cfa; + GDK_KEY_hebrew_taf = $cfa; + GDK_KEY_Hebrew_switch = $FF7E; + GDK_KEY_Thai_kokai = $da1; + GDK_KEY_Thai_khokhai = $da2; + GDK_KEY_Thai_khokhuat = $da3; + GDK_KEY_Thai_khokhwai = $da4; + GDK_KEY_Thai_khokhon = $da5; + GDK_KEY_Thai_khorakhang = $da6; + GDK_KEY_Thai_ngongu = $da7; + GDK_KEY_Thai_chochan = $da8; + GDK_KEY_Thai_choching = $da9; + GDK_KEY_Thai_chochang = $daa; + GDK_KEY_Thai_soso = $dab; + GDK_KEY_Thai_chochoe = $dac; + GDK_KEY_Thai_yoying = $dad; + GDK_KEY_Thai_dochada = $dae; + GDK_KEY_Thai_topatak = $daf; + GDK_KEY_Thai_thothan = $db0; + GDK_KEY_Thai_thonangmontho = $db1; + GDK_KEY_Thai_thophuthao = $db2; + GDK_KEY_Thai_nonen = $db3; + GDK_KEY_Thai_dodek = $db4; + GDK_KEY_Thai_totao = $db5; + GDK_KEY_Thai_thothung = $db6; + GDK_KEY_Thai_thothahan = $db7; + GDK_KEY_Thai_thothong = $db8; + GDK_KEY_Thai_nonu = $db9; + GDK_KEY_Thai_bobaimai = $dba; + GDK_KEY_Thai_popla = $dbb; + GDK_KEY_Thai_phophung = $dbc; + GDK_KEY_Thai_fofa = $dbd; + GDK_KEY_Thai_phophan = $dbe; + GDK_KEY_Thai_fofan = $dbf; + GDK_KEY_Thai_phosamphao = $dc0; + GDK_KEY_Thai_moma = $dc1; + GDK_KEY_Thai_yoyak = $dc2; + GDK_KEY_Thai_rorua = $dc3; + GDK_KEY_Thai_ru = $dc4; + GDK_KEY_Thai_loling = $dc5; + GDK_KEY_Thai_lu = $dc6; + GDK_KEY_Thai_wowaen = $dc7; + GDK_KEY_Thai_sosala = $dc8; + GDK_KEY_Thai_sorusi = $dc9; + GDK_KEY_Thai_sosua = $dca; + GDK_KEY_Thai_hohip = $dcb; + GDK_KEY_Thai_lochula = $dcc; + GDK_KEY_Thai_oang = $dcd; + GDK_KEY_Thai_honokhuk = $dce; + GDK_KEY_Thai_paiyannoi = $dcf; + GDK_KEY_Thai_saraa = $dd0; + GDK_KEY_Thai_maihanakat = $dd1; + GDK_KEY_Thai_saraaa = $dd2; + GDK_KEY_Thai_saraam = $dd3; + GDK_KEY_Thai_sarai = $dd4; + GDK_KEY_Thai_saraii = $dd5; + GDK_KEY_Thai_saraue = $dd6; + GDK_KEY_Thai_sarauee = $dd7; + GDK_KEY_Thai_sarau = $dd8; + GDK_KEY_Thai_sarauu = $dd9; + GDK_KEY_Thai_phinthu = $dda; + GDK_KEY_Thai_maihanakat_maitho = $dde; + GDK_KEY_Thai_baht = $ddf; + GDK_KEY_Thai_sarae = $de0; + GDK_KEY_Thai_saraae = $de1; + GDK_KEY_Thai_sarao = $de2; + GDK_KEY_Thai_saraaimaimuan = $de3; + GDK_KEY_Thai_saraaimaimalai = $de4; + GDK_KEY_Thai_lakkhangyao = $de5; + GDK_KEY_Thai_maiyamok = $de6; + GDK_KEY_Thai_maitaikhu = $de7; + GDK_KEY_Thai_maiek = $de8; + GDK_KEY_Thai_maitho = $de9; + GDK_KEY_Thai_maitri = $dea; + GDK_KEY_Thai_maichattawa = $deb; + GDK_KEY_Thai_thanthakhat = $dec; + GDK_KEY_Thai_nikhahit = $ded; + GDK_KEY_Thai_leksun = $df0; + GDK_KEY_Thai_leknung = $df1; + GDK_KEY_Thai_leksong = $df2; + GDK_KEY_Thai_leksam = $df3; + GDK_KEY_Thai_leksi = $df4; + GDK_KEY_Thai_lekha = $df5; + GDK_KEY_Thai_lekhok = $df6; + GDK_KEY_Thai_lekchet = $df7; + GDK_KEY_Thai_lekpaet = $df8; + GDK_KEY_Thai_lekkao = $df9; + GDK_KEY_Hangul = $ff31; + GDK_KEY_Hangul_Start = $ff32; + GDK_KEY_Hangul_End = $ff33; + GDK_KEY_Hangul_Hanja = $ff34; + GDK_KEY_Hangul_Jamo = $ff35; + GDK_KEY_Hangul_Romaja = $ff36; + GDK_KEY_Hangul_Codeinput = $ff37; + GDK_KEY_Hangul_Jeonja = $ff38; + GDK_KEY_Hangul_Banja = $ff39; + GDK_KEY_Hangul_PreHanja = $ff3a; + GDK_KEY_Hangul_PostHanja = $ff3b; + GDK_KEY_Hangul_SingleCandidate = $ff3c; + GDK_KEY_Hangul_MultipleCandidate = $ff3d; + GDK_KEY_Hangul_PreviousCandidate = $ff3e; + GDK_KEY_Hangul_Special = $ff3f; + GDK_KEY_Hangul_switch = $FF7E; + GDK_KEY_Hangul_Kiyeog = $ea1; + GDK_KEY_Hangul_SsangKiyeog = $ea2; + GDK_KEY_Hangul_KiyeogSios = $ea3; + GDK_KEY_Hangul_Nieun = $ea4; + GDK_KEY_Hangul_NieunJieuj = $ea5; + GDK_KEY_Hangul_NieunHieuh = $ea6; + GDK_KEY_Hangul_Dikeud = $ea7; + GDK_KEY_Hangul_SsangDikeud = $ea8; + GDK_KEY_Hangul_Rieul = $ea9; + GDK_KEY_Hangul_RieulKiyeog = $eaa; + GDK_KEY_Hangul_RieulMieum = $eab; + GDK_KEY_Hangul_RieulPieub = $eac; + GDK_KEY_Hangul_RieulSios = $ead; + GDK_KEY_Hangul_RieulTieut = $eae; + GDK_KEY_Hangul_RieulPhieuf = $eaf; + GDK_KEY_Hangul_RieulHieuh = $eb0; + GDK_KEY_Hangul_Mieum = $eb1; + GDK_KEY_Hangul_Pieub = $eb2; + GDK_KEY_Hangul_SsangPieub = $eb3; + GDK_KEY_Hangul_PieubSios = $eb4; + GDK_KEY_Hangul_Sios = $eb5; + GDK_KEY_Hangul_SsangSios = $eb6; + GDK_KEY_Hangul_Ieung = $eb7; + GDK_KEY_Hangul_Jieuj = $eb8; + GDK_KEY_Hangul_SsangJieuj = $eb9; + GDK_KEY_Hangul_Cieuc = $eba; + GDK_KEY_Hangul_Khieuq = $ebb; + GDK_KEY_Hangul_Tieut = $ebc; + GDK_KEY_Hangul_Phieuf = $ebd; + GDK_KEY_Hangul_Hieuh = $ebe; + GDK_KEY_Hangul_A = $ebf; + GDK_KEY_Hangul_AE = $ec0; + GDK_KEY_Hangul_YA = $ec1; + GDK_KEY_Hangul_YAE = $ec2; + GDK_KEY_Hangul_EO = $ec3; + GDK_KEY_Hangul_E = $ec4; + GDK_KEY_Hangul_YEO = $ec5; + GDK_KEY_Hangul_YE = $ec6; + GDK_KEY_Hangul_O = $ec7; + GDK_KEY_Hangul_WA = $ec8; + GDK_KEY_Hangul_WAE = $ec9; + GDK_KEY_Hangul_OE = $eca; + GDK_KEY_Hangul_YO = $ecb; + GDK_KEY_Hangul_U = $ecc; + GDK_KEY_Hangul_WEO = $ecd; + GDK_KEY_Hangul_WE = $ece; + GDK_KEY_Hangul_WI = $ecf; + GDK_KEY_Hangul_YU = $ed0; + GDK_KEY_Hangul_EU = $ed1; + GDK_KEY_Hangul_YI = $ed2; + GDK_KEY_Hangul_I = $ed3; + GDK_KEY_Hangul_J_Kiyeog = $ed4; + GDK_KEY_Hangul_J_SsangKiyeog = $ed5; + GDK_KEY_Hangul_J_KiyeogSios = $ed6; + GDK_KEY_Hangul_J_Nieun = $ed7; + GDK_KEY_Hangul_J_NieunJieuj = $ed8; + GDK_KEY_Hangul_J_NieunHieuh = $ed9; + GDK_KEY_Hangul_J_Dikeud = $eda; + GDK_KEY_Hangul_J_Rieul = $edb; + GDK_KEY_Hangul_J_RieulKiyeog = $edc; + GDK_KEY_Hangul_J_RieulMieum = $edd; + GDK_KEY_Hangul_J_RieulPieub = $ede; + GDK_KEY_Hangul_J_RieulSios = $edf; + GDK_KEY_Hangul_J_RieulTieut = $ee0; + GDK_KEY_Hangul_J_RieulPhieuf = $ee1; + GDK_KEY_Hangul_J_RieulHieuh = $ee2; + GDK_KEY_Hangul_J_Mieum = $ee3; + GDK_KEY_Hangul_J_Pieub = $ee4; + GDK_KEY_Hangul_J_PieubSios = $ee5; + GDK_KEY_Hangul_J_Sios = $ee6; + GDK_KEY_Hangul_J_SsangSios = $ee7; + GDK_KEY_Hangul_J_Ieung = $ee8; + GDK_KEY_Hangul_J_Jieuj = $ee9; + GDK_KEY_Hangul_J_Cieuc = $eea; + GDK_KEY_Hangul_J_Khieuq = $eeb; + GDK_KEY_Hangul_J_Tieut = $eec; + GDK_KEY_Hangul_J_Phieuf = $eed; + GDK_KEY_Hangul_J_Hieuh = $eee; + GDK_KEY_Hangul_RieulYeorinHieuh = $eef; + GDK_KEY_Hangul_SunkyeongeumMieum = $ef0; + GDK_KEY_Hangul_SunkyeongeumPieub = $ef1; + GDK_KEY_Hangul_PanSios = $ef2; + GDK_KEY_Hangul_KkogjiDalrinIeung = $ef3; + GDK_KEY_Hangul_SunkyeongeumPhieuf = $ef4; + GDK_KEY_Hangul_YeorinHieuh = $ef5; + GDK_KEY_Hangul_AraeA = $ef6; + GDK_KEY_Hangul_AraeAE = $ef7; + GDK_KEY_Hangul_J_PanSios = $ef8; + GDK_KEY_Hangul_J_KkogjiDalrinIeung = $ef9; + GDK_KEY_Hangul_J_YeorinHieuh = $efa; + GDK_KEY_Korean_Won = $eff; + GDK_KEY_EcuSign = $20a0; + GDK_KEY_ColonSign = $20a1; + GDK_KEY_CruzeiroSign = $20a2; + GDK_KEY_FFrancSign = $20a3; + GDK_KEY_LiraSign = $20a4; + GDK_KEY_MillSign = $20a5; + GDK_KEY_NairaSign = $20a6; + GDK_KEY_PesetaSign = $20a7; + GDK_KEY_RupeeSign = $20a8; + GDK_KEY_WonSign = $20a9; + GDK_KEY_NewSheqelSign = $20aa; + GDK_KEY_DongSign = $20ab; + GDK_KEY_EuroSign = $20ac; +{$endif} + +// included by gdk2.pp + + diff --git a/packages/gtk2/src/gtk+/gdk/gdkpango.inc b/packages/gtk2/src/gtk+/gdk/gdkpango.inc new file mode 100644 index 0000000000..5de3a0cb5b --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkpango.inc @@ -0,0 +1,49 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} +{ Attributes use to render insensitive text in GTK+. } + PGdkPangoAttrStipple = ^TGdkPangoAttrStipple; + TGdkPangoAttrStipple = record + attr : TPangoAttribute; + stipple : PGdkBitmap; + end; + + PGdkPangoAttrEmbossed = ^TGdkPangoAttrEmbossed; + TGdkPangoAttrEmbossed = record + attr : TPangoAttribute; + embossed : gboolean; + end; + + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} + +{ Pango interaction } + +function gdk_pango_context_get_for_screen(screen:PGdkScreen):PPangoContext; cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_pango_context_get:PPangoContext; cdecl; external gdklib; +{$endif} + +procedure gdk_pango_context_set_colormap(context:PPangoContext; colormap:PGdkColormap); cdecl; external gdklib; + +{ Get a clip region to draw only part of a layout or + line. index_ranges contains alternating range starts/stops. The + region is the region which contains the given ranges, i.e. if you + draw with the region as clip, only the given ranges are drawn. + } +function gdk_pango_layout_line_get_clip_region(line:PPangoLayoutLine; x_origin:gint; y_origin:gint; index_ranges:Pgint; n_ranges:gint):PGdkRegion; cdecl; external gdklib; +function gdk_pango_layout_get_clip_region(layout:PPangoLayout; x_origin:gint; y_origin:gint; index_ranges:Pgint; n_ranges:gint):PGdkRegion; cdecl; external gdklib; + +function gdk_pango_attr_stipple_new(stipple:PGdkBitmap):PPangoAttribute; cdecl; external gdklib; +function gdk_pango_attr_embossed_new(embossed:gboolean):PPangoAttribute; cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +{$ENDIF} diff --git a/packages/gtk2/src/gtk+/gdk/gdkpixbuf.inc b/packages/gtk2/src/gtk+/gdk/gdkpixbuf.inc new file mode 100644 index 0000000000..f9ab602f15 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkpixbuf.inc @@ -0,0 +1,38 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} + +{ Rendering to a drawable } + +procedure gdk_pixbuf_render_threshold_alpha(pixbuf:PGdkPixbuf; bitmap:PGdkBitmap; src_x:longint; src_y:longint; dest_x:longint; + dest_y:longint; width:longint; height:longint; alpha_threshold:longint); cdecl; external gdklib; +procedure gdk_pixbuf_render_to_drawable(pixbuf:PGdkPixbuf; drawable:PGdkDrawable; gc:PGdkGC; src_x:longint; src_y:longint; + dest_x:longint; dest_y:longint; width:longint; height:longint; dither:TGdkRgbDither; + x_dither:longint; y_dither:longint); cdecl; external gdklib; +procedure gdk_pixbuf_render_to_drawable_alpha(pixbuf:PGdkPixbuf; drawable:PGdkDrawable; src_x:longint; src_y:longint; dest_x:longint; + dest_y:longint; width:longint; height:longint; alpha_mode:TGdkPixbufAlphaMode; alpha_threshold:longint; + dither:TGdkRgbDither; x_dither:longint; y_dither:longint); cdecl; external gdklib; +procedure gdk_pixbuf_render_pixmap_and_mask_for_colormap(pixbuf:PGdkPixbuf; colormap:PGdkColormap; var pixmap_return:PGdkPixmap; var mask_return:PGdkBitmap; alpha_threshold:longint); cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +procedure gdk_pixbuf_render_pixmap_and_mask(pixbuf:PGdkPixbuf; var pixmap_return:PGdkPixmap; var mask_return:PGdkBitmap; alpha_threshold:longint); cdecl; external gdklib; +{$endif} + + +{ Fetching a region from a drawable } + +function gdk_pixbuf_get_from_drawable(dest:PGdkPixbuf; src:PGdkDrawable; cmap:PGdkColormap; src_x:longint; src_y:longint; + dest_x:longint; dest_y:longint; width:longint; height:longint):PGdkPixbuf; cdecl; external gdklib; +function gdk_pixbuf_get_from_image(dest:PGdkPixbuf; src:PGdkImage; cmap:PGdkColormap; src_x:longint; src_y:longint; + dest_x:longint; dest_y:longint; width:longint; height:longint):PGdkPixbuf; cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +{$ENDIF} diff --git a/packages/gtk2/src/gtk+/gdk/gdkpixmap.inc b/packages/gtk2/src/gtk+/gdk/gdkpixmap.inc new file mode 100644 index 0000000000..409c60855a --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkpixmap.inc @@ -0,0 +1,125 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} +{ window-system-specific delegate anObject } + PGdkPixmapObject = ^TGdkPixmapObject; + TGdkPixmapObject = record + parent_instance : TGdkDrawable; + impl : PGdkDrawable; + depth : gint; + end; + + PGdkPixmapObjectClass = ^TGdkPixmapObjectClass; + TGdkPixmapObjectClass = record + parent_class : TGdkDrawableClass; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function GDK_TYPE_PIXMAP : GType; +function GDK_PIXMAP(anObject : Pointer) : PGdkPixmap; +function GDK_PIXMAP_CLASS(klass : Pointer) : PGdkPixmapObjectClass; +function GDK_IS_PIXMAP(anObject : Pointer) : boolean; +function GDK_IS_PIXMAP_CLASS(klass : Pointer) : boolean; +function GDK_PIXMAP_GET_CLASS(obj : Pointer) : PGdkPixmapObjectClass; + +function GDK_PIXMAP_OBJECT(anObject : Pointer) : PGdkPixmapObject; + + +function gdk_pixmap_get_type:GType; cdecl; external gdklib; + + +{ Pixmaps } + +function gdk_pixmap_new(window:PGdkWindow; width:gint; height:gint; depth:gint):PGdkPixmap; cdecl; external gdklib; +function gdk_bitmap_create_from_data(window:PGdkWindow; data:Pgchar; width:gint; height:gint):PGdkBitmap; cdecl; external gdklib; +function gdk_pixmap_create_from_data(window:PGdkWindow; data:Pgchar; width:gint; height:gint; depth:gint; + fg:PGdkColor; bg:PGdkColor):PGdkPixmap; cdecl; external gdklib; +function gdk_pixmap_create_from_xpm(window:PGdkWindow; var mask:PGdkBitmap; transparent_color:PGdkColor; filename:Pgchar):PGdkPixmap; cdecl; external gdklib; +function gdk_pixmap_colormap_create_from_xpm(window:PGdkWindow; colormap:PGdkColormap; var mask:PGdkBitmap; transparent_color:PGdkColor; filename:Pgchar):PGdkPixmap; cdecl; external gdklib; +function gdk_pixmap_create_from_xpm_d(window:PGdkWindow; var mask:PGdkBitmap; transparent_color:PGdkColor; data:PPgchar):PGdkPixmap; cdecl; external gdklib; +function gdk_pixmap_colormap_create_from_xpm_d(window:PGdkWindow; colormap:PGdkColormap; var mask:PGdkBitmap; transparent_color:PGdkColor; data:PPgchar):PGdkPixmap; cdecl; external gdklib; +{ Functions to create/lookup pixmaps from their native equivalents } + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_pixmap_foreign_new(anid:TGdkNativeWindow):PGdkPixmap; cdecl; external gdklib; +function gdk_pixmap_lookup(anid:TGdkNativeWindow):PGdkPixmap; cdecl; external gdklib; +{$endif} +{ GDK_MULTIHEAD_SAFE } + +function gdk_pixmap_foreign_new_for_display(display:PGdkDisplay; anid:TGdkNativeWindow):PGdkPixmap; cdecl; external gdklib; +function gdk_pixmap_lookup_for_display(display:PGdkDisplay; anid:TGdkNativeWindow):PGdkPixmap; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +function gdk_bitmap_ref(drawable:PGdkDrawable):PGdkDrawable; +procedure gdk_bitmap_unref(drawable:PGdkDrawable); +function gdk_pixmap_ref(drawable:PGdkDrawable):PGdkDrawable; +procedure gdk_pixmap_unref(drawable:PGdkDrawable); +{$endif} +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_PIXMAP : GType; +begin + GDK_TYPE_PIXMAP:=gdk_pixmap_get_type; +end; + +function GDK_PIXMAP(anObject : Pointer) : PGdkPixmap; +begin + GDK_PIXMAP:=PGdkPixmap(G_TYPE_CHECK_INSTANCE_CAST(anObject,GDK_TYPE_PIXMAP)); +end; + +function GDK_PIXMAP_CLASS(klass : Pointer) : PGdkPixmapObjectClass; +begin + GDK_PIXMAP_CLASS:=PGdkPixmapObjectClass(G_TYPE_CHECK_CLASS_CAST(klass, + GDK_TYPE_PIXMAP)); +end; + +function GDK_IS_PIXMAP(anObject : Pointer) : boolean; +begin + GDK_IS_PIXMAP:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_PIXMAP); +end; + +function GDK_IS_PIXMAP_CLASS(klass : Pointer) : boolean; +begin + GDK_IS_PIXMAP_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_PIXMAP); +end; + +function GDK_PIXMAP_GET_CLASS(obj : Pointer) : PGdkPixmapObjectClass; +begin + GDK_PIXMAP_GET_CLASS:=PGdkPixmapObjectClass(G_TYPE_INSTANCE_GET_CLASS(obj, + GDK_TYPE_PIXMAP)); +end; + +function GDK_PIXMAP_OBJECT(anObject : Pointer) : PGdkPixmapObject; +begin + GDK_PIXMAP_OBJECT:=PGdkPixmapObject(GDK_PIXMAP(anObject)); +end; + +function gdk_bitmap_ref(drawable:PGdkDrawable):PGdkDrawable; +begin + gdk_bitmap_ref:=GDK_DRAWABLE(g_object_ref(G_OBJECT(drawable))); +end; + +procedure gdk_bitmap_unref(drawable:PGdkDrawable); +begin + g_object_unref(G_OBJECT(drawable)); +end; + +function gdk_pixmap_ref(drawable:PGdkDrawable):PGdkDrawable; +begin + gdk_pixmap_ref:=GDK_DRAWABLE(g_object_ref(G_OBJECT(drawable))); +end; + +procedure gdk_pixmap_unref(drawable:PGdkDrawable); +begin + g_object_unref(G_OBJECT(drawable)); +end; + +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkpoly-generic.inc b/packages/gtk2/src/gtk+/gdk/gdkpoly-generic.inc new file mode 100644 index 0000000000..737e9ba851 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkpoly-generic.inc @@ -0,0 +1,338 @@ +{ Pointers to basic pascal types, inserted by h2pas conversion program.} +Type + PLongint = ^Longint; + PSmallInt = ^SmallInt; + PByte = ^Byte; + PWord = ^Word; + PDWord = ^DWord; + PDouble = ^Double; + +{$PACKRECORDS C} + +{ $TOG: poly.h /main/5 1998/02/06 17:47:27 kaleb $ } +{ + +Copyright 1987, 1998 The Open Group + +All Rights Reserved. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + + } +{ + This file contains a few macros to help track + the edge of a filled anObject. The anObject is assumed + to be filled in scanline order, and thus the + algorithm used is an extension of Bresenham's line + drawing algorithm which assumes that y is always the + major axis. + Since these pieces of code are the same for any filled shape, + it is more convenient to gather the library in one + place, but since these pieces of code are also in + the inner loops of output primitives, procedure call + overhead is out of the question. + See the author for a derivation if needed. + } +{ + In scan converting polygons, we want to choose those pixels + which are inside the polygon. Thus, we add .5 to the starting + x coordinate for both left and right edges. Now we choose the + first pixel which is inside the pgon for the left edge and the + first pixel which is outside the pgon for the right edge. + Draw the left pixel, but not the right. + + How to add .5 to the starting x coordinate: + If the edge is moving to the right, then subtract dy from the + error term from the general form of the algorithm. + If the edge is moving to the left, then add dy to the error term. + + The reason for the difference between edges moving to the left + and edges moving to the right is simple: If an edge is moving + to the right, then we want the algorithm to flip immediately. + If it is moving to the left, then we don't want it to flip until + we traverse an entire pixel. + } +{#define BRESINITPGON(dy, x1, x2, xStart, d, m, m1, incr1, incr2) { \ +int dx; // local storage \ +\ +// \ +// if the edge is horizontal, then it is ignored \ +// and assumed not to be processed. Otherwise, do this stuff. \ +// \ +if ((dy) != 0) { \ + xStart = (x1); \ + dx = (x2) - xStart; \ + if (dx < 0) { \ + m = dx / (dy); \ + m1 = m - 1; \ + incr1 = -2 dx + 2 (dy) m1; \ + incr2 = -2 dx + 2 (dy) m; \ + d = 2 m (dy) - 2 dx - 2 (dy); \ + } else { \ + m = dx / (dy); \ + m1 = m + 1; \ + incr1 = 2 dx - 2 (dy) m1; \ + incr2 = 2 dx - 2 (dy) m; \ + d = -2 m (dy) + 2 dx; \ + } \ +} \ +} + } +{#define BRESINCRPGON(d, minval, m, m1, incr1, incr2) { \ + if (m1 > 0) { \ + if (d > 0) { \ + minval += m1; \ + d += incr1; \ + } \ + else { \ + minval += m; \ + d += incr2; \ + } \ + } else {\ + if (d >= 0) { \ + minval += m1; \ + d += incr1; \ + } \ + else { \ + minval += m; \ + d += incr2; \ + } \ + } \ +} + } +{ + This structure contains all of the information needed + to run the bresenham algorithm. + The variables may be hardcoded into the declarations + instead of using this structure to make use of + register declarations. + } +{ minor axis } +{ decision variable } +{ slope and slope+1 } +{ error increments } +type + + PBRESINFO = ^TBRESINFO; + TBRESINFO = record + minor_axis : longint; + d : longint; + m : longint; + m1 : longint; + incr1 : longint; + incr2 : longint; + end; +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function BRESINITPGONSTRUCT(dmaj,min1,min2,bres : longint) : longint; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function BRESINCRPGONSTRUCT(bres : longint) : longint; + +{ + These are the data structures needed to scan + convert regions. Two different scan conversion + methods are available -- the even-odd method, and + the winding number method. + The even-odd rule states that a point is inside + the polygon if a ray drawn from that point in any + direction will pass through an odd number of + path segments. + By the winding number rule, a point is decided + to be inside the polygon if a ray drawn from that + point in any direction passes through a different + number of clockwise and counter-clockwise path + segments. + + These data structures are adapted somewhat from + the algorithm in (Foley/Van Dam) for scan converting + polygons. + The basic algorithm is to start at the top (smallest y) + of the polygon, stepping down to the bottom of + the polygon by incrementing the y coordinate. We + keep a list of edges which the current scanline crosses, + sorted by x. This list is called the Active Edge Table (AET) + As we change the y-coordinate, we update each entry in + in the active edge table to reflect the edges new xcoord. + This list must be sorted at each scanline in case + two edges intersect. + We also keep a data structure known as the Edge Table (ET), + which keeps track of all the edges which the current + scanline has not yet reached. The ET is basically a + list of ScanLineList structures containing a list of + edges which are entered at a given scanline. There is one + ScanLineList per scanline at which an edge is entered. + When we enter a new edge, we move it from the ET to the AET. + + From the AET, we can implement the even-odd rule as in + (Foley/Van Dam). + The winding number rule is a little trickier. We also + keep the EdgeTableEntries in the AET linked by the + nextWETE (winding EdgeTableEntry) link. This allows + the edges to be linked just as before for updating + purposes, but only uses the edges linked by the nextWETE + link as edges representing spans of the polygon to + drawn (as with the even-odd rule). + } +{ + for the winding number rule + } + +const + CLOCKWISE = 1; + COUNTERCLOCKWISE = -(1); +{ ycoord at which we exit this edge. } +{ Bresenham info to run the edge } +{ next in the list } +{ for insertion sort } +{ for winding num rule } +{ flag for winding number rule } +type + + PEdgeTableEntry = ^TEdgeTableEntry; + TEdgeTableEntry = record + ymax : longint; + bres : TBRESINFO; + next : PEdgeTableEntry; + back : PEdgeTableEntry; + nextWETE : PEdgeTableEntry; + ClockWise : longint; + end; +{ the scanline represented } +{ header node } +{ next in the list } + + PScanLineList = ^TScanLineList; + TScanLineList = record + scanline : longint; + edgelist : PEdgeTableEntry; + next : PScanLineList; + end; +{ ymax for the polygon } +{ ymin for the polygon } +{ header node } + + PEdgeTable = ^TEdgeTable; + TEdgeTable = record + ymax : longint; + ymin : longint; + scanlines : TScanLineList; + end; +{ + Here is a struct to help with storage allocation + so we can allocate a big chunk at a time, and then take + pieces from this heap when we need to. + } + +const + SLLSPERBLOCK = 25; +type + + PScanLineListBlock = ^TScanLineListBlock; + TScanLineListBlock = record + SLLs : array[0..(SLLSPERBLOCK)-1] of TScanLineList; + next : PScanLineListBlock; + end; +{ + + a few macros for the inner loops of the fill code where + performance considerations don't allow a procedure call. + + Evaluate the given edge at the given scanline. + If the edge has expired, then we leave it and fix up + the active edge table; otherwise, we increment the + x value to be ready for the next scanline. + The winding number rule is in effect, so we must notify + the caller when the edge has been removed so he + can reorder the Winding Active Edge Table. + } +{ +#define EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET) { \ + if (pAET->ymax == y) { // leaving this edge \ + pPrevAET->next = pAET->next; \ + pAET = pPrevAET->next; \ + fixWAET = 1; \ + if (pAET) \ + pAET->back = pPrevAET; \ + } \ + else { \ + BRESINCRPGONSTRUCT(pAET->bres); \ + pPrevAET = pAET; \ + pAET = pAET->next; \ + } \ +} + } +{ + Evaluate the given edge at the given scanline. + If the edge has expired, then we leave it and fix up + the active edge table; otherwise, we increment the + x value to be ready for the next scanline. + The even-odd rule is in effect. + } +{#define EVALUATEEDGEEVENODD(pAET, pPrevAET, y) { \ + if (pAET->ymax == y) { // leaving this edge \ + pPrevAET->next = pAET->next; \ + pAET = pPrevAET->next; \ + if (pAET) \ + pAET->back = pPrevAET; \ + } \ + else { \ + BRESINCRPGONSTRUCT(pAET->bres); \ + pPrevAET = pAET; \ + pAET = pAET->next; \ + } \ +} + } +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function BRESINITPGONSTRUCT(dmaj,min1,min2,bres : longint) : longint; +begin + BRESINITPGONSTRUCT:=BRESINITPGON(dmaj,min1,min2,bres.minor_axis,bres.d,bres.m,bres.m1,bres.incr1,bres.incr2); +end; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function BRESINCRPGONSTRUCT(bres : longint) : longint; +begin + BRESINCRPGONSTRUCT:=BRESINCRPGON(bres.d,bres.minor_axis,bres.m,bres.m1,bres.incr1,bres.incr2); +end; + + diff --git a/packages/gtk2/src/gtk+/gdk/gdkprivate.inc b/packages/gtk2/src/gtk+/gdk/gdkprivate.inc new file mode 100644 index 0000000000..4e08e88fc1 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkprivate.inc @@ -0,0 +1,89 @@ +{ Pointers to basic pascal types, inserted by h2pas conversion program.} +Type + PLongint = ^Longint; + PSmallInt = ^SmallInt; + PByte = ^Byte; + PWord = ^Word; + PDWord = ^DWord; + PDouble = ^Double; + +{$PACKRECORDS C} + +{ GDK - The GIMP Drawing Kit + Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + } +{ + Modified by the GTK+ Team and others 1997-2000. See the AUTHORS + file for a list of people on the GTK+ Team. See the ChangeLog + files for a list of changes. These files are distributed with + GTK+ at ftp://ftp.gtk.org/pub/gtk/. + } +{$ifndef __GDK_PRIVATE_H__} +{$define __GDK_PRIVATE_H__} +{$include <gdk/gdktypes.inc} +{$include <gdk/gdkevents.inc} +{$include <gdk/gdkfont.inc} +{$include <gdk/gdkgc.inc} +{$include <gdk/gdkimage.inc} +{$include <gdk/gdkregion.inc} +{$include <gdk/gdkvisual.inc} +{$include <gdk/gdkwindow.inc} +function GDK_PARENT_RELATIVE_BG : PGdkPixmap; +function GDK_NO_BG : PGdkPixmap; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function GDK_WINDOW_TYPE(d : longint) : longint; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function GDK_WINDOW_DESTROYED(d : longint) : longint; + +procedure gdk_window_destroy_notify(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_synthesize_window_state(window:PGdkWindow; unset_flags:TGdkWindowState; set_flags:TGdkWindowState); cdecl; external gdklib; +{$endif} +{ __GDK_PRIVATE_H__ } +function GDK_PARENT_RELATIVE_BG : PGdkPixmap; + begin + GDK_PARENT_RELATIVE_BG:=PGdkPixmap(1); + end; + +function GDK_NO_BG : PGdkPixmap; + begin + GDK_NO_BG:=PGdkPixmap(2); + end; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function GDK_WINDOW_TYPE(d : longint) : longint; +begin + GDK_WINDOW_TYPE:=(PGdkWindowObject(GDK_WINDOW(d)))^.window_type; +end; + +{ was #define dname(params) para_def_expr } +{ argument types are unknown } +{ return type might be wrong } +function GDK_WINDOW_DESTROYED(d : longint) : longint; +begin + GDK_WINDOW_DESTROYED:=(PGdkWindowObject(GDK_WINDOW(d)))^.destroyed; +end; + + diff --git a/packages/gtk2/src/gtk+/gdk/gdkproperty.inc b/packages/gtk2/src/gtk+/gdk/gdkproperty.inc new file mode 100644 index 0000000000..5143045845 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkproperty.inc @@ -0,0 +1,47 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} + PGdkPropMode = ^TGdkPropMode; + TGdkPropMode = ( + GDK_PROP_MODE_REPLACE, + GDK_PROP_MODE_PREPEND, + GDK_PROP_MODE_APPEND + ); + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function gdk_atom_intern(atom_name:Pgchar; only_if_exists:gboolean):TGdkAtom; cdecl; external gdklib; +function gdk_atom_name(atom:TGdkAtom):Pgchar; cdecl; external gdklib; +function gdk_property_get(window:PGdkWindow; _property:TGdkAtom; _type:TGdkAtom; offset:gulong; length:gulong; + pdelete:gint; actual_property_type:PGdkAtom; actual_format:Pgint; actual_length:Pgint; data:PPguchar):gboolean; cdecl; external gdklib; +procedure gdk_property_change(window:PGdkWindow; _property:TGdkAtom; _type:TGdkAtom; format:gint; mode:TGdkPropMode; + data:Pguchar; nelements:gint); cdecl; external gdklib; +procedure gdk_property_delete(window:PGdkWindow; _property:TGdkAtom); cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_text_property_to_text_list(encoding:TGdkAtom; format:gint; text:Pguchar; length:gint; var list:PPgchar):gint; cdecl; external gdklib; +function gdk_text_property_to_utf8_list(encoding:TGdkAtom; format:gint; text:Pguchar; length:gint; var list:PPgchar):gint; cdecl; external gdklib; +function gdk_utf8_to_compound_text(str:Pgchar; encoding:PGdkAtom; format:Pgint; ctext:PPguchar; length:Pgint):gboolean; cdecl; external gdklib; +function gdk_string_to_compound_text(str:Pgchar; encoding:PGdkAtom; format:Pgint; ctext:PPguchar; length:Pgint):gint; cdecl; external gdklib; +{$endif} + +function gdk_text_property_to_text_list_for_display(display:PGdkDisplay; encoding:TGdkAtom; format:gint; text:Pguchar; length:gint; + var list:PPgchar):gint; cdecl; external gdklib; +function gdk_text_property_to_utf8_list_for_display(display:PGdkDisplay; encoding:TGdkAtom; format:gint; text:Pguchar; length:gint; + var list:PPgchar):gint; cdecl; external gdklib; +function gdk_utf8_to_string_target(str:Pgchar):Pgchar; cdecl; external gdklib; +function gdk_string_to_compound_text_for_display(display:PGdkDisplay; str:Pgchar; encoding:PGdkAtom; format:Pgint; ctext:PPguchar; + length:Pgint):gint; cdecl; external gdklib; +function gdk_utf8_to_compound_text_for_display(display:PGdkDisplay; str:Pgchar; encoding:PGdkAtom; format:Pgint; ctext:PPguchar; + length:Pgint):gboolean; cdecl; external gdklib; +procedure gdk_free_text_list(list:PPgchar); cdecl; external gdklib; +procedure gdk_free_compound_text(ctext:Pguchar); cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +{$ENDIF} diff --git a/packages/gtk2/src/gtk+/gdk/gdkregion-generic.inc b/packages/gtk2/src/gtk+/gdk/gdkregion-generic.inc new file mode 100644 index 0000000000..ca2e1138ee --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkregion-generic.inc @@ -0,0 +1,155 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} + PGdkRegionBox = ^TGdkRegionBox; + TGdkRegionBox = TGdkSegment; + +{ + clip region + } + PGdkRegion = ^TGdkRegion; + TGdkRegion = record + size : longint; + numRects : longint; + rects : PGdkRegionBox; + extents : TGdkRegionBox; + end; + +{ + used to allocate buffers for points and link + the buffers together + } + PPOINTBLOCK = ^TPOINTBLOCK; + TPOINTBLOCK = record + pts : array[0..(NUMPTSTOBUFFER)-1] of TGdkPoint; + next : PPOINTBLOCK; + end; +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +{ 1 if two BOXs overlap. + 0 if two BOXs do not overlap. + Remember, x2 and y2 are not in the region + } +function gdkregion_EXTENTCHECK(r1, r2: PGdkRegionBox): boolean; + +{ + update region extents + } +procedure gdkregion_EXTENTS(r: PGdkRegionBox; idRect: PGdkRegion); + +{ + Check to see if there is enough memory in the present region. + } +function gdkregion_MEMCHECK(reg: PGdkRegion; var ARect, firstrect: PGdkRegionBox): boolean; + +{ this routine checks to see if the previous rectangle is the same + or subsumes the new rectangle to add. + } +function gdkregion_CHECK_PREVIOUS(Reg: PGdkRegion; R: PGdkRegionBox; + Rx1,Ry1,Rx2,Ry2 : gint) : boolean; + +{ add a rectangle to the given Region } +procedure gdkregion_ADDRECT(reg: PGdkRegion; r: PGdkRegionBox; + rx1, ry1, rx2, ry2: gint); + +{ add a rectangle to the given Region } +procedure gdkregion_ADDRECTNOX(reg: PGdkRegion; r: PGdkRegionBox; rx1,ry1,rx2,ry2: gint); + +{ } +function gdkregion_EMPTY_REGION(pReg: PGdkRegion): boolean; +{pReg->numRects = 0} + +function gdkregion_REGION_NOT_EMPTY(pReg : PGdkRegion) : boolean; + +function gdkregion_INBOX(r: TGdkRegionBox; x,y : gint) : boolean; + +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function gdkregion_EXTENTCHECK(r1, r2: PGdkRegionBox): boolean; +begin + gdkregion_EXTENTCHECK:=(r1^.x2 > r2^.x1) and (r1^.x1 < r2^.x2) and (r1^.y2 > r2^.y1) + and (r1^.y1 < r2^.y2) +end; + +procedure gdkregion_EXTENTS(r: PGdkRegionBox; idRect: PGdkRegion); +begin + if (r^.x1 < idRect^.extents.x1) then idRect^.extents.x1 := r^.x1; + if r^.y1 < idRect^.extents.y1 then idRect^.extents.y1 := r^.y1; + if r^.x2 > idRect^.extents.x2 then idRect^.extents.x2 := r^.x2; +end; + +function gdkregion_MEMCHECK(reg: PGdkRegion; + var ARect, firstrect: PGdkRegionBox): boolean; +begin +{$IFNDEF KYLIX} + if reg^.numRects >= reg^.size - 1 then begin + firstrect := PGdkRegionBox(g_renew (SizeOf(TGdkRegionBox), firstrect, + 2 * reg^.size)); + reg^.size:=reg^.size*2; + Arect:=@firstrect[reg^.numRects]; + end; + Result:=true; +{$ENDIF} +end; + +function gdkregion_CHECK_PREVIOUS(Reg: PGdkRegion; R: PGdkRegionBox; + Rx1,Ry1,Rx2,Ry2 : gint) : boolean; +begin +{$IFNDEF KYLIX} + gdkregion_CHECK_PREVIOUS:= + not (((((Reg^.numRects > 0) and ((R - 1)^.y1 = Ry1)) + and ((R - 1)^.y2 = Ry2)) + and ((R - 1)^.x1 <= Rx1)) + and ((R - 1)^.x2 >= Rx2)); +{$ENDIF} +end; + +procedure gdkregion_ADDRECT(reg: PGdkRegion; r: PGdkRegionBox; + rx1, ry1, rx2, ry2: gint); +begin + if ((rx1 < rx2) and (ry1 < ry2) + and gdkregion_CHECK_PREVIOUS(reg, r, rx1, ry1, rx2, ry2)) then begin + r^.x1 := rx1; + r^.y1 := ry1; + r^.x2 := rx2; + r^.y2 := ry2; + end; + +end; + +procedure gdkregion_ADDRECTNOX(reg: PGdkRegion; r: PGdkRegionBox; + rx1,ry1,rx2,ry2: gint); +begin + if ((rx1 < rx2) and (ry1 < ry2) + and gdkregion_CHECK_PREVIOUS(reg, r, rx1, ry1, rx2, ry2)) then begin + r^.x1 := rx1; + r^.y1 := ry1; + r^.x2 := rx2; + r^.y2 := ry2; + inc(reg^.numRects); + end; + +end; + +function gdkregion_EMPTY_REGION(pReg: PGdkRegion): boolean; +begin + gdkregion_EMPTY_REGION:=pReg^.numRects=0; +end; + +function gdkregion_REGION_NOT_EMPTY(pReg : PGdkRegion) : boolean; +begin + gdkregion_REGION_NOT_EMPTY:=pReg^.numRects<>0; +end; + +function gdkregion_INBOX(r: TGdkRegionBox; x,y : gint) : boolean; +begin + gdkregion_INBOX:=(((r.x2 > x) and (r.x1 <= x)) and (r.y2 > y)) and (r.y1<= y); +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkregion.inc b/packages/gtk2/src/gtk+/gdk/gdkregion.inc new file mode 100644 index 0000000000..e0ffebd6db --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkregion.inc @@ -0,0 +1,58 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} +{ GC fill rule for polygons + EvenOddRule + WindingRule + } + PGdkFillRule = ^TGdkFillRule; + TGdkFillRule = ( + GDK_EVEN_ODD_RULE, + GDK_WINDING_RULE + ); + +{ Types of overlapping between a rectangle and a region + GDK_OVERLAP_RECTANGLE_IN: rectangle is in region + GDK_OVERLAP_RECTANGLE_OUT: rectangle in not in region + GDK_OVERLAP_RECTANGLE_PART: rectangle in partially in region + } + PGdkOverlapType = ^TGdkOverlapType; + TGdkOverlapType = ( + GDK_OVERLAP_RECTANGLE_IN, + GDK_OVERLAP_RECTANGLE_OUT, + GDK_OVERLAP_RECTANGLE_PART + ); + + TGdkSpanFunc = procedure (span:PGdkSpan; data:gpointer); cdecl; +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function gdk_region_new:PGdkRegion; cdecl; external gdklib; +function gdk_region_polygon(points:PGdkPoint; npoints:gint; fill_rule:TGdkFillRule):PGdkRegion; cdecl; external gdklib; +function gdk_region_copy(region:PGdkRegion):PGdkRegion; cdecl; external gdklib; +function gdk_region_rectangle(rectangle:PGdkRectangle):PGdkRegion; cdecl; external gdklib; +procedure gdk_region_destroy(region:PGdkRegion); cdecl; external gdklib; +procedure gdk_region_get_clipbox(region:PGdkRegion; rectangle:PGdkRectangle); cdecl; external gdklib; +procedure gdk_region_get_rectangles(region:PGdkRegion; var rectangles:PGdkRectangle; n_rectangles:Pgint); cdecl; external gdklib; +function gdk_region_empty(region:PGdkRegion):gboolean; cdecl; external gdklib; +function gdk_region_equal(region1:PGdkRegion; region2:PGdkRegion):gboolean; cdecl; external gdklib; +function gdk_region_point_in(region:PGdkRegion; x:longint; y:longint):gboolean; cdecl; external gdklib; +function gdk_region_rect_in(region:PGdkRegion; rect:PGdkRectangle):TGdkOverlapType; cdecl; external gdklib; +procedure gdk_region_offset(region:PGdkRegion; dx:gint; dy:gint); cdecl; external gdklib; +procedure gdk_region_shrink(region:PGdkRegion; dx:gint; dy:gint); cdecl; external gdklib; +procedure gdk_region_union_with_rect(region:PGdkRegion; rect:PGdkRectangle); cdecl; external gdklib; +procedure gdk_region_intersect(source1:PGdkRegion; source2:PGdkRegion); cdecl; external gdklib; +procedure gdk_region_union(source1:PGdkRegion; source2:PGdkRegion); cdecl; external gdklib; +procedure gdk_region_subtract(source1:PGdkRegion; source2:PGdkRegion); cdecl; external gdklib; +procedure gdk_region_xor(source1:PGdkRegion; source2:PGdkRegion); cdecl; external gdklib; +procedure gdk_region_spans_intersect_foreach(region:PGdkRegion; spans:PGdkSpan; n_spans:longint; sorted:gboolean; _function:TGdkSpanFunc; + data:gpointer); cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkrgb.inc b/packages/gtk2/src/gtk+/gdk/gdkrgb.inc new file mode 100644 index 0000000000..7847c3df99 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkrgb.inc @@ -0,0 +1,84 @@ +// included by gdk2.pp + +{$IFDEF read_forward_definitions} + PGdkRgbDither = ^TGdkRgbDither; + TGdkRgbDither = ( + GDK_RGB_DITHER_NONE, + GDK_RGB_DITHER_NORMAL, + GDK_RGB_DITHER_MAX + ); +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{< private > } + PGdkRgbCmap = ^TGdkRgbCmap; + TGdkRgbCmap = record + colors : array[0..255] of guint32; + n_colors : gint; + info_list : PGSList; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_rgb_init; cdecl; external gdklib; +function gdk_rgb_xpixel_from_rgb(rgb:guint32):gulong; cdecl; external gdklib; +procedure gdk_rgb_gc_set_foreground(gc:PGdkGC; rgb:guint32); cdecl; external gdklib; +procedure gdk_rgb_gc_set_background(gc:PGdkGC; rgb:guint32); cdecl; external gdklib; +{$endif} + + +{ GDK_DISABLE_DEPRECATED } + +procedure gdk_rgb_find_color(colormap:PGdkColormap; color:PGdkColor); cdecl; external gdklib; + +procedure gdk_draw_rgb_image(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint; width:gint; + height:gint; dith:TGdkRgbDither; rgb_buf:Pguchar; rowstride:gint); cdecl; external gdklib; +procedure gdk_draw_rgb_image_dithalign(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint; width:gint; + height:gint; dith:TGdkRgbDither; rgb_buf:Pguchar; rowstride:gint; xdith:gint; + ydith:gint); cdecl; external gdklib; +procedure gdk_draw_rgb_32_image(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint; width:gint; + height:gint; dith:TGdkRgbDither; buf:Pguchar; rowstride:gint); cdecl; external gdklib; +procedure gdk_draw_rgb_32_image_dithalign(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint; width:gint; + height:gint; dith:TGdkRgbDither; buf:Pguchar; rowstride:gint; xdith:gint; + ydith:gint); cdecl; external gdklib; +procedure gdk_draw_gray_image(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint; width:gint; + height:gint; dith:TGdkRgbDither; buf:Pguchar; rowstride:gint); cdecl; external gdklib; +procedure gdk_draw_indexed_image(drawable:PGdkDrawable; gc:PGdkGC; x:gint; y:gint; width:gint; + height:gint; dith:TGdkRgbDither; buf:Pguchar; rowstride:gint; cmap:PGdkRgbCmap); cdecl; external gdklib; +function gdk_rgb_cmap_new(colors:Pguint32; n_colors:gint):PGdkRgbCmap; cdecl; external gdklib; +procedure gdk_rgb_cmap_free(cmap:PGdkRgbCmap); cdecl; external gdklib; +procedure gdk_rgb_set_verbose(verbose:gboolean); cdecl; external gdklib; + + +{ experimental colormap stuff } + +procedure gdk_rgb_set_install(install:gboolean); cdecl; external gdklib; +procedure gdk_rgb_set_min_colors(min_colors:gint); cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_rgb_get_colormap:PGdkColormap; cdecl; external gdklib; +function gdk_rgb_get_visual:PGdkVisual; cdecl; external gdklib; +function gdk_rgb_ditherable:gboolean; cdecl; external gdklib; +{$ifndef GDK_DISABLE_DEPRECATED} +function gdk_rgb_get_cmap:PGdkColormap; +{$endif GDK_DISABLE_DEPRECATED} +{$endif GDK_MULTIHEAD_SAFE} + +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function gdk_rgb_get_cmap:PGdkColormap; +begin + gdk_rgb_get_cmap:=gdk_rgb_get_colormap; +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkscreen.inc b/packages/gtk2/src/gtk+/gdk/gdkscreen.inc new file mode 100644 index 0000000000..697aacbc98 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkscreen.inc @@ -0,0 +1,106 @@ +// included by gdk2.pp +{$IFDEF read_forward_definitions} + PGdkScreen = ^TGdkScreen; + TGdkScreen = record + parent_instance : TGObject; + end; + +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PGdkScreenClass = ^TGdkScreenClass; + TGdkScreenClass = record + parent_class : TGObjectClass; + get_display : function (screen:PGdkScreen):PGdkDisplay; cdecl; + get_width : function (screen:PGdkScreen):gint; cdecl; + get_height : function (screen:PGdkScreen):gint; cdecl; + get_width_mm : function (screen:PGdkScreen):gint; cdecl; + get_height_mm : function (screen:PGdkScreen):gint; cdecl; + get_root_depth : function (screen:PGdkScreen):gint; cdecl; + get_screen_num : function (screen:PGdkScreen):gint; cdecl; + get_root_window : function (screen:PGdkScreen):PGdkWindow; cdecl; + get_default_colormap : function (screen:PGdkScreen):PGdkColormap; cdecl; + set_default_colormap : procedure (screen:PGdkScreen; colormap:PGdkColormap); cdecl; + get_window_at_pointer : function (screen:PGdkScreen; win_x:Pgint; win_y:Pgint):PGdkWindow; cdecl; + get_n_monitors : function (screen:PGdkScreen):gint; cdecl; + get_monitor_geometry : procedure (screen:PGdkScreen; monitor_num:gint; dest:PGdkRectangle); cdecl; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function GDK_TYPE_SCREEN : GType; +function GDK_SCREEN(anObject : Pointer) : PGdkScreen; +function GDK_SCREEN_CLASS(klass : Pointer) : PGdkScreenClass; +function GDK_IS_SCREEN(anObject : Pointer) : boolean; +function GDK_IS_SCREEN_CLASS(klass : Pointer) : boolean; +function GDK_SCREEN_GET_CLASS(obj : Pointer) : PGdkScreenClass; + + +//function gdk_screen_get_type:GType; cdecl; external gdklib; +function gdk_screen_get_default_colormap(screen:PGdkScreen):PGdkColormap; cdecl; external gdklib; +procedure gdk_screen_set_default_colormap(screen:PGdkScreen; colormap:PGdkColormap); cdecl; external gdklib; +function gdk_screen_get_system_colormap(screen:PGdkScreen):PGdkColormap; cdecl; external gdklib; +function gdk_screen_get_system_visual(screen:PGdkScreen):PGdkVisual; cdecl; external gdklib; +function gdk_screen_get_rgb_colormap(screen:PGdkScreen):PGdkColormap; cdecl; external gdklib; +function gdk_screen_get_rgb_visual(screen:PGdkScreen):PGdkVisual; cdecl; external gdklib; +function gdk_screen_get_root_window(screen:PGdkScreen):PGdkWindow; cdecl; external gdklib; +function gdk_screen_get_display(screen:PGdkScreen):PGdkDisplay; cdecl; external gdklib; +function gdk_screen_get_number(screen:PGdkScreen):gint; cdecl; external gdklib; +function gdk_screen_get_window_at_pointer(screen:PGdkScreen; win_x:Pgint; win_y:Pgint):PGdkWindow; cdecl; external gdklib; +function gdk_screen_get_width(screen:PGdkScreen):gint; cdecl; external gdklib; +function gdk_screen_get_height(screen:PGdkScreen):gint; cdecl; external gdklib; +function gdk_screen_get_width_mm(screen:PGdkScreen):gint; cdecl; external gdklib; +function gdk_screen_get_height_mm(screen:PGdkScreen):gint; cdecl; external gdklib; +procedure gdk_screen_close(screen:PGdkScreen); cdecl; external gdklib; +function gdk_screen_list_visuals(screen:PGdkScreen):PGList; cdecl; external gdklib; +function gdk_screen_get_toplevel_windows(screen:PGdkScreen):PGList; cdecl; external gdklib; +function gdk_screen_get_n_monitors(screen:PGdkScreen):gint; cdecl; external gdklib; +procedure gdk_screen_get_monitor_geometry(screen:PGdkScreen; monitor_num:gint; dest:PGdkRectangle); cdecl; external gdklib; +function gdk_screen_get_monitor_at_point(screen:PGdkScreen; x:gint; y:gint):gint; cdecl; external gdklib; +function gdk_screen_get_monitor_at_window(screen:PGdkScreen; window:PGdkWindow):gint; cdecl; external gdklib; +procedure gdk_screen_broadcast_client_message(screen:PGdkScreen; event:PGdkEvent); cdecl; external gdklib; +function gdk_get_default_screen:PGdkScreen; cdecl; external gdklib; +function gdk_screen_get_setting(screen:PGdkScreen; name:Pgchar; value:PGValue):gboolean; cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_SCREEN : GType; +begin + GDK_TYPE_SCREEN:=0 //;gdk_screen_get_type; +end; + +function GDK_SCREEN(anObject : Pointer) : PGdkScreen; +begin + GDK_SCREEN:=PGdkScreen(G_TYPE_CHECK_INSTANCE_CAST(anObject,GDK_TYPE_SCREEN)); +end; + +function GDK_SCREEN_CLASS(klass : Pointer) : PGdkScreenClass; +begin + GDK_SCREEN_CLASS:=PGdkScreenClass(G_TYPE_CHECK_CLASS_CAST(klass, + GDK_TYPE_SCREEN)); +end; + +function GDK_IS_SCREEN(anObject : Pointer) : boolean; +begin + GDK_IS_SCREEN:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_SCREEN); +end; + +function GDK_IS_SCREEN_CLASS(klass : Pointer) : boolean; +begin + GDK_IS_SCREEN_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_SCREEN); +end; + +function GDK_SCREEN_GET_CLASS(obj : Pointer) : PGdkScreenClass; +begin + GDK_SCREEN_GET_CLASS:=PGdkScreenClass(G_TYPE_INSTANCE_GET_CLASS(obj, + GDK_TYPE_SCREEN)); +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkselection.inc b/packages/gtk2/src/gtk+/gdk/gdkselection.inc new file mode 100644 index 0000000000..3f8bef3709 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkselection.inc @@ -0,0 +1,150 @@ +// included by gdk2.pp + +{$IFDEF read_interface_types} + +{$ifndef GDK_DISABLE_DEPRECATED} + PGdkSelection = ^TGdkSelection; + TGdkSelection = TGdkAtom; + + PGdkTarget = ^TGdkTarget; + TGdkTarget = TGdkAtom; + + PGdkSelectionType = ^TGdkSelectionType; + TGdkSelectionType = TGdkAtom; +{$endif} +{ GDK_DISABLE_DEPRECATED } + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +{ Predefined atoms relating to selections. In general, one will need to use + gdk_intern_atom + } +function GDK_SELECTION_PRIMARY : TGdkAtom; +function GDK_SELECTION_SECONDARY : TGdkAtom; +function GDK_SELECTION_CLIPBOARD : TGdkAtom; +function GDK_TARGET_BITMAP : TGdkAtom; +function GDK_TARGET_COLORMAP : TGdkAtom; +function GDK_TARGET_DRAWABLE : TGdkAtom; +function GDK_TARGET_PIXMAP : TGdkAtom; +function GDK_TARGET_STRING : TGdkAtom; +function GDK_SELECTION_TYPE_ATOM : TGdkAtom; +function GDK_SELECTION_TYPE_BITMAP : TGdkAtom; +function GDK_SELECTION_TYPE_COLORMAP : TGdkAtom; +function GDK_SELECTION_TYPE_DRAWABLE : TGdkAtom; +function GDK_SELECTION_TYPE_INTEGER : TGdkAtom; +function GDK_SELECTION_TYPE_PIXMAP : TGdkAtom; +function GDK_SELECTION_TYPE_WINDOW : TGdkAtom; +function GDK_SELECTION_TYPE_STRING : TGdkAtom; + + +{ Selections } + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_selection_owner_set(owner:PGdkWindow; selection:TGdkAtom; time:guint32; send_event:gboolean):gboolean; cdecl; external gdklib; +function gdk_selection_owner_get(selection:TGdkAtom):PGdkWindow; cdecl; external gdklib; +{$endif} + + +{ GDK_MULTIHEAD_SAFE } + +function gdk_selection_owner_set_for_display(display:PGdkDisplay; owner:PGdkWindow; selection:TGdkAtom; time:guint32; send_event:gboolean):gboolean; cdecl; external gdklib; +function gdk_selection_owner_get_for_display(display:PGdkDisplay; selection:TGdkAtom):PGdkWindow; cdecl; external gdklib; +procedure gdk_selection_convert(requestor:PGdkWindow; selection:TGdkAtom; target:TGdkAtom; time:guint32); cdecl; external gdklib; +function gdk_selection_property_get(requestor:PGdkWindow; data:PPguchar; prop_type:PGdkAtom; prop_format:Pgint):gboolean; cdecl; external gdklib; +{$ifndef GDK_MULTIHEAD_SAFE} + +procedure gdk_selection_send_notify(requestor:guint32; selection:TGdkAtom; target:TGdkAtom; _property:TGdkAtom; time:guint32); cdecl; external gdklib; +{$endif} +{ GDK_MULTIHEAD_SAFE } + +procedure gdk_selection_send_notify_for_display(display:PGdkDisplay; requestor:guint32; selection:TGdkAtom; target:TGdkAtom; _property:TGdkAtom; + time:guint32); cdecl; external gdklib; +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_SELECTION_PRIMARY : TGdkAtom; +begin + GDK_SELECTION_PRIMARY:=_GDK_MAKE_ATOM(1); +end; + +function GDK_SELECTION_SECONDARY : TGdkAtom; +begin + GDK_SELECTION_SECONDARY:=_GDK_MAKE_ATOM(2); +end; + +function GDK_SELECTION_CLIPBOARD : TGdkAtom; +begin + GDK_SELECTION_CLIPBOARD:=_GDK_MAKE_ATOM(69); +end; + +function GDK_TARGET_BITMAP : TGdkAtom; +begin + GDK_TARGET_BITMAP:=_GDK_MAKE_ATOM(5); +end; + +function GDK_TARGET_COLORMAP : TGdkAtom; +begin + GDK_TARGET_COLORMAP:=_GDK_MAKE_ATOM(7); +end; + +function GDK_TARGET_DRAWABLE : TGdkAtom; +begin + GDK_TARGET_DRAWABLE:=_GDK_MAKE_ATOM(17); +end; + +function GDK_TARGET_PIXMAP : TGdkAtom; +begin + GDK_TARGET_PIXMAP:=_GDK_MAKE_ATOM(20); +end; + +function GDK_TARGET_STRING : TGdkAtom; +begin + GDK_TARGET_STRING:=_GDK_MAKE_ATOM(31); +end; + +function GDK_SELECTION_TYPE_ATOM : TGdkAtom; +begin + GDK_SELECTION_TYPE_ATOM:=_GDK_MAKE_ATOM(4); +end; + +function GDK_SELECTION_TYPE_BITMAP : TGdkAtom; +begin + GDK_SELECTION_TYPE_BITMAP:=_GDK_MAKE_ATOM(5); +end; + +function GDK_SELECTION_TYPE_COLORMAP : TGdkAtom; +begin + GDK_SELECTION_TYPE_COLORMAP:=_GDK_MAKE_ATOM(7); +end; + +function GDK_SELECTION_TYPE_DRAWABLE : TGdkAtom; +begin + GDK_SELECTION_TYPE_DRAWABLE:=_GDK_MAKE_ATOM(17); +end; + +function GDK_SELECTION_TYPE_INTEGER : TGdkAtom; +begin + GDK_SELECTION_TYPE_INTEGER:=_GDK_MAKE_ATOM(19); +end; + +function GDK_SELECTION_TYPE_PIXMAP : TGdkAtom; +begin + GDK_SELECTION_TYPE_PIXMAP:=_GDK_MAKE_ATOM(20); +end; + +function GDK_SELECTION_TYPE_WINDOW : TGdkAtom; +begin + GDK_SELECTION_TYPE_WINDOW:=_GDK_MAKE_ATOM(33); +end; + +function GDK_SELECTION_TYPE_STRING : TGdkAtom; +begin + GDK_SELECTION_TYPE_STRING:=_GDK_MAKE_ATOM(31); +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdktypes.inc b/packages/gtk2/src/gtk+/gdk/gdktypes.inc new file mode 100644 index 0000000000..f0ca74d0f5 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdktypes.inc @@ -0,0 +1,168 @@ +// included by gdk2.pp + +{$IFDEF read_forward_definitions} +{ Forward declarations of commonly used types } + PGdkInputCondition = ^TGdkInputCondition; + TGdkInputCondition = longint; // see below for possible values + + PGdkStatus = ^TGdkStatus; + TGdkStatus = longint; + + TGdkPoint = record + x : gint; + y : gint; + end; + PGdkPoint = ^TGdkPoint; + PPGdkPoint = ^PGdkPoint; + + PGdkSpan = ^TGdkSpan; + +{ Note that on some platforms the wchar_t type + is not the same as GdkWChar. For instance + on Win32, wchar_t is unsigned short. + } + PGdkWChar = ^TGdkWChar; + TGdkWChar = guint32; + + PGdkSegment = ^TGdkSegment; + TGdkSegment = record + x1 : gint; + y1 : gint; + x2 : gint; + y2 : gint; + end; + + PGdkRectangle = ^TGdkRectangle; + TGdkRectangle = record + x : gint; + y : gint; + width : gint; + height : gint; + end; + + PGdkAtom = ^TGdkAtom; + // internal type + TGdkAtom = PtrUInt; + + PGdkByteOrder = ^TGdkByteOrder; + TGdkByteOrder = ( + GDK_LSB_FIRST, + GDK_MSB_FIRST + ); + +{$ifdef GDK_NATIVE_WINDOW_POINTER} + PGdkNativeWindow = ^TGdkNativeWindow; + TGdkNativeWindow = gpointer; +{$else} + PGdkNativeWindow = ^TGdkNativeWindow; + TGdkNativeWindow = guint32; +{$endif} + +{ Types of modifiers. } +{ The next few modifiers are used by XKB, so we skip to the theEnd } + PGdkModifierType = ^TGdkModifierType; + TGdkModifierType = gint; + +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{ Type definitions for the basic structures. } + +{ We define specific numeric values for these constants, + since old application code may depend on them matching the X values + We don't actually depend on the matchup ourselves. + } + + PGdkGrabStatus = ^TGdkGrabStatus; + TGdkGrabStatus = integer; // see below for possible values + + TGdkInputFunction = procedure (data:gpointer; source:gint; + condition:TGdkInputCondition); cdecl; + + TGdkDestroyNotify = procedure (data:gpointer); cdecl; + + TGdkSpan = record + x : gint; + y : gint; + width : gint; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} + +{ some common magic values } +const + GDK_CURRENT_TIME = 0; + GDK_PARENT_RELATIVE = 1; + + GDK_OK = 0; + GDK_ERROR = -(1); + GDK_ERROR_PARAM = -(2); + GDK_ERROR_FILE = -(3); + GDK_ERROR_MEM = -(4); + + GDK_SHIFT_MASK = 1 shl 0; + GDK_LOCK_MASK = 1 shl 1; + GDK_CONTROL_MASK = 1 shl 2; + GDK_MOD1_MASK = 1 shl 3; + GDK_MOD2_MASK = 1 shl 4; + GDK_MOD3_MASK = 1 shl 5; + GDK_MOD4_MASK = 1 shl 6; + GDK_MOD5_MASK = 1 shl 7; + GDK_BUTTON1_MASK = 1 shl 8; + GDK_BUTTON2_MASK = 1 shl 9; + GDK_BUTTON3_MASK = 1 shl 10; + GDK_BUTTON4_MASK = 1 shl 11; + GDK_BUTTON5_MASK = 1 shl 12; + GDK_RELEASE_MASK = 1 shl 30; + GDK_MODIFIER_MASK = ord(GDK_RELEASE_MASK) or $1fff; + + // values for TGdkInputCondition + GDK_INPUT_READ = 1 shl 0; + GDK_INPUT_WRITE = 1 shl 1; + GDK_INPUT_EXCEPTION = 1 shl 2; + + // values for TGdkGrabStatus + GDK_GRAB_SUCCESS = 0; + GDK_GRAB_ALREADY_GRABBED = 1; + GDK_GRAB_INVALID_TIME = 2; + GDK_GRAB_NOT_VIEWABLE = 3; + GDK_GRAB_FROZEN = 4; + + +function GDK_ATOM_TO_POINTER(atom : TGdkAtom) : Pointer; +function GDK_POINTER_TO_ATOM(ptr : Pointer) : TGdkAtom; +function _GDK_MAKE_ATOM(val : guint) : TGdkAtom; +function GDK_NONE : TGdkAtom; + +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_ATOM_TO_POINTER(atom : TGdkAtom) : pointer; +begin + GDK_ATOM_TO_POINTER:=Pointer(PtrInt(atom)); +end; + +function GDK_POINTER_TO_ATOM(ptr : Pointer) : TGdkAtom; +begin + GDK_POINTER_TO_ATOM:=TGdkAtom(PtrInt(ptr)); +end; + +function _GDK_MAKE_ATOM(val : guint) : TGdkAtom; +begin + _GDK_MAKE_ATOM:=TGdkAtom(PtrInt(GUINT_TO_POINTER(val))); +end; + +function GDK_NONE : TGdkAtom; +begin + GDK_NONE:=_GDK_MAKE_ATOM(0); +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkvisual.inc b/packages/gtk2/src/gtk+/gdk/gdkvisual.inc new file mode 100644 index 0000000000..774e691a15 --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkvisual.inc @@ -0,0 +1,136 @@ +// included by gdk2.pp +{$IFDEF read_forward_definitions} +{ Types of visuals. + StaticGray: + Grayscale: + StaticColor: + PseudoColor: + TrueColor: + DirectColor: + } + PGdkVisualType = ^TGdkVisualType; + TGdkVisualType = ( + GDK_VISUAL_STATIC_GRAY, + GDK_VISUAL_GRAYSCALE, + GDK_VISUAL_STATIC_COLOR, + GDK_VISUAL_PSEUDO_COLOR, + GDK_VISUAL_TRUE_COLOR, + GDK_VISUAL_DIRECT_COLOR + ); + +{ The visual type. + "type" is the type of visual this is (PseudoColor, TrueColor, etc). + "depth" is the bit depth of this visual. + "colormap_size" is the size of a colormap for this visual. + "bits_per_rgb" is the number of significant bits per red, green and blue. + The red, green and blue masks, shifts and precisions refer + to value needed to calculate pixel values in TrueColor and DirectColor + visuals. The "mask" is the significant bits within the pixel. The + "shift" is the number of bits left we must shift a primary for it + to be in position (according to the "mask"). "prec" refers to how + much precision the pixel value contains for a particular primary. + } + PGdkVisual = ^TGdkVisual; + TGdkVisual = record + parent_instance : TGObject; + TheType : TGdkVisualType; + depth : gint; + byte_order : TGdkByteOrder; + colormap_size : gint; + bits_per_rgb : gint; + red_mask : guint32; + red_shift : gint; + red_prec : gint; + green_mask : guint32; + green_shift : gint; + green_prec : gint; + blue_mask : guint32; + blue_shift : gint; + blue_prec : gint; + screen : PGdkScreen; + end; + +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function GDK_TYPE_VISUAL : GType; +function GDK_VISUAL(anObject : Pointer) : PGdkVisual; +function GDK_VISUAL_CLASS(klass : Pointer) : PGdkVisualClass; +function GDK_IS_VISUAL(anObject : Pointer) : boolean; +function GDK_IS_VISUAL_CLASS(klass : Pointer) : boolean; +function GDK_VISUAL_GET_CLASS(obj : Pointer) : PGdkVisualClass; + +function gdk_visual_get_type:GType; cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_visual_get_best_depth:gint; cdecl; external gdklib; +function gdk_visual_get_best_type:TGdkVisualType; cdecl; external gdklib; +function gdk_visual_get_system:PGdkVisual; cdecl; external gdklib; +function gdk_visual_get_best:PGdkVisual; cdecl; external gdklib; +function gdk_visual_get_best_with_depth(depth:gint):PGdkVisual; cdecl; external gdklib; +function gdk_visual_get_best_with_type(visual_type:TGdkVisualType):PGdkVisual; cdecl; external gdklib; +function gdk_visual_get_best_with_both(depth:gint; visual_type:TGdkVisualType):PGdkVisual; cdecl; external gdklib; +procedure gdk_query_depths(var depths:Pgint; count:Pgint); cdecl; external gdklib; +procedure gdk_query_visual_types(var visual_types:PGdkVisualType; count:Pgint); cdecl; external gdklib; +function gdk_list_visuals:PGList; cdecl; external gdklib; +{$endif} + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_visual_ref(v : PGdkVisual); +procedure gdk_visual_unref(v : PGdkVisual); +{$endif} +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_VISUAL : GType; +begin + GDK_TYPE_VISUAL:=gdk_visual_get_type; +end; + +function GDK_VISUAL(anObject : Pointer) : PGdkVisual; +begin + GDK_VISUAL:=PGdkVisual(G_TYPE_CHECK_INSTANCE_CAST(anObject,GDK_TYPE_VISUAL)); +end; + +function GDK_VISUAL_CLASS(klass : Pointer) : PGdkVisualClass; +begin + GDK_VISUAL_CLASS:=PGdkVisualClass(G_TYPE_CHECK_CLASS_CAST(klass, + GDK_TYPE_VISUAL)); +end; + +function GDK_IS_VISUAL(anObject : Pointer) : boolean; +begin + GDK_IS_VISUAL:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_VISUAL); +end; + +function GDK_IS_VISUAL_CLASS(klass : Pointer) : boolean; +begin + GDK_IS_VISUAL_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_VISUAL); +end; + +function GDK_VISUAL_GET_CLASS(obj : Pointer) : PGdkVisualClass; +begin + GDK_VISUAL_GET_CLASS:=PGdkVisualClass(G_TYPE_INSTANCE_GET_CLASS(obj, + GDK_TYPE_VISUAL)); +end; + +procedure gdk_visual_ref(v : PGdkVisual); +begin + g_object_ref(v); +end; + +procedure gdk_visual_unref(v : PGdkVisual); +begin + g_object_unref(v); +end; +{$ENDIF} + diff --git a/packages/gtk2/src/gtk+/gdk/gdkwindow.inc b/packages/gtk2/src/gtk+/gdk/gdkwindow.inc new file mode 100644 index 0000000000..64f75a82da --- /dev/null +++ b/packages/gtk2/src/gtk+/gdk/gdkwindow.inc @@ -0,0 +1,610 @@ +// included by gdk2.pp +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{ Classes of windows. + InputOutput: Almost every window should be of this type. Such windows + receive events and are also displayed on screen. + InputOnly: Used only in special circumstances when events need to be + stolen from another window or windows. Input only windows + have no visible output, so they are handy for placing over + top of a group of windows in order to grab the events (or + filter the events) from those windows. + } + PGdkWindowClass = ^TGdkWindowClass; + TGdkWindowClass = ( + GDK_INPUT_OUTPUT, + GDK_INPUT_ONLY + ); + +{ Types of windows. + Root: There is only 1 root window and it is initialized + at startup. Creating a window of type GDK_WINDOW_ROOT + is an error. + Toplevel: Windows which interact with the window manager. + Child: Windows which are children of some other type of window. + (Any other type of window). Most windows are child windows. + Dialog: A special kind of toplevel window which interacts with + the window manager slightly differently than a regular + toplevel window. Dialog windows should be used for any + transient window. + Foreign: A window that actually belongs to another application + } + PGdkWindowType = ^TGdkWindowType; + TGdkWindowType = ( + GDK_WINDOW_ROOT, + GDK_WINDOW_TOPLEVEL, + GDK_WINDOW_CHILD, + GDK_WINDOW_DIALOG, + GDK_WINDOW_TEMP, + GDK_WINDOW_FOREIGN + ); + +{ Window attribute mask values. + GDK_WA_TITLE: The "title" field is valid. + GDK_WA_X: The "x" field is valid. + GDK_WA_Y: The "y" field is valid. + GDK_WA_CURSOR: The "cursor" field is valid. + GDK_WA_COLORMAP: The "colormap" field is valid. + GDK_WA_VISUAL: The "visual" field is valid. + } + PGdkWindowAttributesType = ^TGdkWindowAttributesType; + TGdkWindowAttributesType = longint; // see below for possible values + +{ Size restriction enumeration. } + + PGdkWindowHints = ^TGdkWindowHints; + TGdkWindowHints = longint; // see below for possible values + +{ Window type hints. + These are hints for the window manager that indicate + what type of function the window has. The window manager + can use this when determining decoration and behaviour + of the window. The hint must be set before mapping the + window. + + Normal: Normal toplevel window + Dialog: Dialog window + Menu: Window used to implement a menu. + Toolbar: Window used to implement toolbars. + } + PGdkWindowTypeHint = ^TGdkWindowTypeHint; + TGdkWindowTypeHint = ( + GDK_WINDOW_TYPE_HINT_NORMAL, + GDK_WINDOW_TYPE_HINT_DIALOG, + GDK_WINDOW_TYPE_HINT_MENU, + GDK_WINDOW_TYPE_HINT_TOOLBAR + ); + +{ The next two enumeration values current match the + Motif constants. If this is changed, the implementation + of gdk_window_set_decorations/gdk_window_set_functions + will need to change as well. + } + + PGdkWMDecoration = ^TGdkWMDecoration; + TGdkWMDecoration = longint; // see below for possible values + + PGdkWMFunction = ^TGdkWMFunction; + TGdkWMFunction = longint; // see below for possible values + +{ Currently, these are the same values numerically as in the + X protocol. If you change that, gdkwindow-x11.c/gdk_window_set_geometry_hints() + will need fixing. + } + PGdkGravity = ^TGdkGravity; + TGdkGravity = integer; // see below for possible values + + PGdkWindowEdge = ^TGdkWindowEdge; + TGdkWindowEdge = ( + GDK_WINDOW_EDGE_NORTH_WEST, + GDK_WINDOW_EDGE_NORTH, + GDK_WINDOW_EDGE_NORTH_EAST, + GDK_WINDOW_EDGE_WEST, + GDK_WINDOW_EDGE_EAST, + GDK_WINDOW_EDGE_SOUTH_WEST, + GDK_WINDOW_EDGE_SOUTH, + GDK_WINDOW_EDGE_SOUTH_EAST + ); + + PGdkWindowAttr = ^TGdkWindowAttr; + TGdkWindowAttr = record + title : Pgchar; + event_mask : gint; + x : gint; + y : gint; + width : gint; + height : gint; + wclass : TGdkWindowClass; + visual : PGdkVisual; + colormap : PGdkColormap; + window_type : TGdkWindowType; + cursor : PGdkCursor; + wmclass_name : Pgchar; + wmclass_class : Pgchar; + override_redirect : gboolean; + end; + + PGdkGeometry = ^TGdkGeometry; + TGdkGeometry = record + min_width : gint; + min_height : gint; + max_width : gint; + max_height : gint; + base_width : gint; + base_height : gint; + width_inc : gint; + height_inc : gint; + min_aspect : gdouble; + max_aspect : gdouble; + win_gravity : TGdkGravity; + end; + +{ unused for now } + PGdkPointerHooks = ^TGdkPointerHooks; + TGdkPointerHooks = record + get_pointer : function (window:PGdkWindow; x:Pgint; y:Pgint; mask:PGdkModifierType):PGdkWindow; cdecl; + window_at_pointer : function (screen:PGdkScreen; win_x:Pgint; win_y:Pgint):PGdkWindow; cdecl; + end; + +{ window-system-specific delegate anObject } + PGdkWindowObject = ^TGdkWindowObject; + TGdkWindowObject = record + parent_instance : TGdkDrawable; + impl : PGdkDrawable; + parent : PGdkWindowObject; + user_data : gpointer; + x : gint; + y : gint; + extension_events : gint; + filters : PGList; + children : PGList; + bg_color : TGdkColor; + bg_pixmap : PGdkPixmap; + paint_stack : PGSList; + update_area : PGdkRegion; + update_freeze_count : guint; + window_type : guint8; + depth : guint8; + resize_count : guint8; + state : TGdkWindowState; + flag0 : word; { this is a bit combined flag, combining the following: + guint guffaw_gravity : 1; + guint input_only : 1; + guint modal_hint : 1; + guint destroyed : 2; + use the following functions to access them: + GdkWindowObject_guffaw_gravity + GdkWindowObject_set_guffaw_gravity + GdkWindowObject_input_only + GdkWindowObject_set_input_only + GdkWindowObject_modal_hint + GdkWindowObject_set_modal_hint + GdkWindowObject_destroyed + GdkWindowObject_set_destroyed + } + event_mask : TGdkEventMask; + end; + + PGdkWindowObjectClass = ^TGdkWindowObjectClass; + TGdkWindowObjectClass = record + parent_class : TGdkDrawableClass; + end; + + gdk_window_invalidate_maybe_recurse_child_func = + function (para1:PGdkWindow; para2:gpointer):gboolean; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +const + // values for TGdkWindowAttributesType + GDK_WA_TITLE = 1 shl 1; + GDK_WA_X = 1 shl 2; + GDK_WA_Y = 1 shl 3; + GDK_WA_CURSOR = 1 shl 4; + GDK_WA_COLORMAP = 1 shl 5; + GDK_WA_VISUAL = 1 shl 6; + GDK_WA_WMCLASS = 1 shl 7; + GDK_WA_NOREDIR = 1 shl 8; + + // values for TGdkWindowHints + GDK_HINT_POS = 1 shl 0; + GDK_HINT_MIN_SIZE = 1 shl 1; + GDK_HINT_MAX_SIZE = 1 shl 2; + GDK_HINT_BASE_SIZE = 1 shl 3; + GDK_HINT_ASPECT = 1 shl 4; + GDK_HINT_RESIZE_INC = 1 shl 5; + GDK_HINT_WIN_GRAVITY = 1 shl 6; + GDK_HINT_USER_POS = 1 shl 7; + GDK_HINT_USER_SIZE = 1 shl 8; + + // values for TGdkWMDecoration + GDK_DECOR_ALL = 1 shl 0; + GDK_DECOR_BORDER = 1 shl 1; + GDK_DECOR_RESIZEH = 1 shl 2; + GDK_DECOR_TITLE = 1 shl 3; + GDK_DECOR_MENU = 1 shl 4; + GDK_DECOR_MINIMIZE = 1 shl 5; + GDK_DECOR_MAXIMIZE = 1 shl 6; + + // values for TGdkWMFunction + GDK_FUNC_ALL = 1 shl 0; + GDK_FUNC_RESIZE = 1 shl 1; + GDK_FUNC_MOVE = 1 shl 2; + GDK_FUNC_MINIMIZE = 1 shl 3; + GDK_FUNC_MAXIMIZE = 1 shl 4; + GDK_FUNC_CLOSE = 1 shl 5; + + // values for TGdkGravity + GDK_GRAVITY_NORTH_WEST = 1; + GDK_GRAVITY_NORTH = 2; + GDK_GRAVITY_NORTH_EAST = 3; + GDK_GRAVITY_WEST = 4; + GDK_GRAVITY_CENTER = 5; + GDK_GRAVITY_EAST = 6; + GDK_GRAVITY_SOUTH_WEST = 7; + GDK_GRAVITY_SOUTH = 8; + GDK_GRAVITY_SOUTH_EAST = 9; + GDK_GRAVITY_STATIC = 10; + + +function GDK_TYPE_WINDOW : GType; +function GDK_WINDOW(anObject : Pointer) : PGdkWindow; +function GDK_WINDOW_CLASS(klass : Pointer) : PGdkWindowObjectClass; +function GDK_IS_WINDOW(anObject : Pointer) : boolean; +function GDK_IS_WINDOW_CLASS(klass : Pointer) : boolean; +function GDK_WINDOW_GET_CLASS(obj : Pointer) : PGdkWindowObjectClass; + +function GDK_WINDOW_OBJECT(anObject : Pointer) : PGdkWindowObject; + + +// constants and functions to access the bits in a TGdkWindowObject +const + bm_TGdkWindowObject_guffaw_gravity = $1; + bp_TGdkWindowObject_guffaw_gravity = 0; + bm_TGdkWindowObject_input_only = $2; + bp_TGdkWindowObject_input_only = 1; + bm_TGdkWindowObject_modal_hint = $4; + bp_TGdkWindowObject_modal_hint = 2; + bm_TGdkWindowObject_destroyed = $18; + bp_TGdkWindowObject_destroyed = 3; + +function GdkWindowObject_guffaw_gravity(var a : TGdkWindowObject) : guint; +procedure GdkWindowObject_set_guffaw_gravity(var a : TGdkWindowObject; __guffaw_gravity : guint); +function GdkWindowObject_input_only(var a : TGdkWindowObject) : guint; +procedure GdkWindowObject_set_input_only(var a : TGdkWindowObject; __input_only : guint); +function GdkWindowObject_modal_hint(var a : TGdkWindowObject) : guint; +procedure GdkWindowObject_set_modal_hint(var a : TGdkWindowObject; __modal_hint : guint); +function GdkWindowObject_destroyed(var a : TGdkWindowObject) : guint; +procedure GdkWindowObject_set_destroyed(var a : TGdkWindowObject; __destroyed : guint); + + +{ Windows } + +function gdk_window_object_get_type:GType; cdecl; external gdklib; +function gdk_window_new(parent:PGdkWindow; attributes:PGdkWindowAttr; attributes_mask:gint):PGdkWindow; cdecl; external gdklib; +procedure gdk_window_destroy(window:PGdkWindow); cdecl; external gdklib; +function gdk_window_get_window_type(window:PGdkWindow):TGdkWindowType; cdecl; external gdklib; +function gdk_window_at_pointer(win_x:Pgint; win_y:Pgint):PGdkWindow; cdecl; external gdklib; +procedure gdk_window_show(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_hide(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_withdraw(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_show_unraised(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_move(window:PGdkWindow; x:gint; y:gint); cdecl; external gdklib; +procedure gdk_window_resize(window:PGdkWindow; width:gint; height:gint); cdecl; external gdklib; +procedure gdk_window_move_resize(window:PGdkWindow; x:gint; y:gint; width:gint; height:gint); cdecl; external gdklib; +procedure gdk_window_reparent(window:PGdkWindow; new_parent:PGdkWindow; x:gint; y:gint); cdecl; external gdklib; +procedure gdk_window_clear(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_clear_area(window:PGdkWindow; x:gint; y:gint; width:gint; height:gint); cdecl; external gdklib; +procedure gdk_window_clear_area_e(window:PGdkWindow; x:gint; y:gint; width:gint; height:gint); cdecl; external gdklib; +procedure gdk_window_raise(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_lower(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_focus(window:PGdkWindow; timestamp:guint32); cdecl; external gdklib; +procedure gdk_window_set_user_data(window:PGdkWindow; user_data:gpointer); cdecl; external gdklib; +procedure gdk_window_set_override_redirect(window:PGdkWindow; override_redirect:gboolean); cdecl; external gdklib; +procedure gdk_window_add_filter(window:PGdkWindow; _function:TGdkFilterFunc; data:gpointer); cdecl; external gdklib; +procedure gdk_window_remove_filter(window:PGdkWindow; _function:TGdkFilterFunc; data:gpointer); cdecl; external gdklib; +procedure gdk_window_scroll(window:PGdkWindow; dx:gint; dy:gint); cdecl; external gdklib; + +{ + This allows for making shaped (partially transparent) windows + - cool feature, needed for Drag and Drag for example. + The shape_mask can be the mask + from gdk_pixmap_create_from_xpm. Stefan Wille + } +procedure gdk_window_shape_combine_mask(window:PGdkWindow; mask:PGdkBitmap; x:gint; y:gint); cdecl; external gdklib; +procedure gdk_window_shape_combine_region(window:PGdkWindow; shape_region:PGdkRegion; offset_x:gint; offset_y:gint); cdecl; external gdklib; + +{ + This routine allows you to quickly take the shapes of all the child windows + of a window and use their shapes as the shape mask for this window - useful + for container windows that dont want to look like a big box + + - Raster + } +procedure gdk_window_set_child_shapes(window:PGdkWindow); cdecl; external gdklib; + +{ + This routine allows you to merge (ie ADD) child shapes to your + own window's shape keeping its current shape and ADDING the child + shapes to it. + + - Raster + } +procedure gdk_window_merge_child_shapes(window:PGdkWindow); cdecl; external gdklib; + +{ + Check if a window has been shown, and whether all its + parents up to a toplevel have been shown, respectively. + Note that a window that is_viewable below is not necessarily + viewable in the X sense. + } +function gdk_window_is_visible(window:PGdkWindow):gboolean; cdecl; external gdklib; +function gdk_window_is_viewable(window:PGdkWindow):gboolean; cdecl; external gdklib; +function gdk_window_get_state(window:PGdkWindow):TGdkWindowState; cdecl; external gdklib; + +{ Set static bit gravity on the parent, and static + window gravity on all children. + } +function gdk_window_set_static_gravities(window:PGdkWindow; use_static:gboolean):gboolean; cdecl; external gdklib; + + +{ Functions to create/lookup windows from their native equivalents } + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_window_foreign_new(anid:TGdkNativeWindow):PGdkWindow; cdecl; external gdklib; +function gdk_window_lookup(anid:TGdkNativeWindow):PGdkWindow; cdecl; external gdklib; +{$endif} + +function gdk_window_foreign_new_for_display(display:PGdkDisplay; anid:TGdkNativeWindow):PGdkWindow; cdecl; external gdklib; +function gdk_window_lookup_for_display(display:PGdkDisplay; anid:TGdkNativeWindow):PGdkWindow; cdecl; external gdklib; + + +{ GdkWindow } + +{$ifndef GDK_DISABLE_DEPRECATED} +procedure gdk_window_set_hints(window:PGdkWindow; x:gint; y:gint; min_width:gint; min_height:gint; + max_width:gint; max_height:gint; flags:gint); cdecl; external gdklib; +{$endif} +procedure gdk_window_set_type_hint(window:PGdkWindow; hint:TGdkWindowTypeHint); cdecl; external gdklib; +procedure gdk_window_set_modal_hint(window:PGdkWindow; modal:gboolean); cdecl; external gdklib; +procedure gdk_window_set_geometry_hints(window:PGdkWindow; geometry:PGdkGeometry; geom_mask:TGdkWindowHints); cdecl; external gdklib; +procedure gdk_set_sm_client_id(sm_client_id:Pgchar); cdecl; external gdklib; +procedure gdk_window_begin_paint_rect(window:PGdkWindow; rectangle:PGdkRectangle); cdecl; external gdklib; +procedure gdk_window_begin_paint_region(window:PGdkWindow; region:PGdkRegion); cdecl; external gdklib; +procedure gdk_window_end_paint(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_set_title(window:PGdkWindow; title:Pgchar); cdecl; external gdklib; +procedure gdk_window_set_role(window:PGdkWindow; role:Pgchar); cdecl; external gdklib; +procedure gdk_window_set_transient_for(window:PGdkWindow; parent:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_set_background(window:PGdkWindow; color:PGdkColor); cdecl; external gdklib; +procedure gdk_window_set_back_pixmap(window:PGdkWindow; pixmap:PGdkPixmap; parent_relative:gboolean); cdecl; external gdklib; +procedure gdk_window_set_cursor(window:PGdkWindow; cursor:PGdkCursor); cdecl; external gdklib; +procedure gdk_window_get_user_data(window:PGdkWindow; data:gpointer); cdecl; external gdklib; +procedure gdk_window_get_geometry(window:PGdkWindow; x:Pgint; y:Pgint; width:Pgint; height:Pgint; + depth:Pgint); cdecl; external gdklib; +procedure gdk_window_get_position(window:PGdkWindow; x:Pgint; y:Pgint); cdecl; external gdklib; +function gdk_window_get_origin(window:PGdkWindow; x:Pgint; y:Pgint):gint; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +function gdk_window_get_deskrelative_origin(window:PGdkWindow; x:Pgint; y:Pgint):gboolean; cdecl; external gdklib; +{$endif} + +procedure gdk_window_get_root_origin(window:PGdkWindow; x:Pgint; y:Pgint); cdecl; external gdklib; +procedure gdk_window_get_frame_extents(window:PGdkWindow; rect:PGdkRectangle); cdecl; external gdklib; +function gdk_window_get_pointer(window:PGdkWindow; x:Pgint; y:Pgint; mask:PGdkModifierType):PGdkWindow; cdecl; external gdklib; +function gdk_window_get_parent(window:PGdkWindow):PGdkWindow; cdecl; external gdklib; +function gdk_window_get_toplevel(window:PGdkWindow):PGdkWindow; cdecl; external gdklib; +function gdk_window_get_children(window:PGdkWindow):PGList; cdecl; external gdklib; +function gdk_window_peek_children(window:PGdkWindow):PGList; cdecl; external gdklib; +function gdk_window_get_events(window:PGdkWindow):TGdkEventMask; cdecl; external gdklib; +procedure gdk_window_set_events(window:PGdkWindow; event_mask:TGdkEventMask); cdecl; external gdklib; +procedure gdk_window_set_icon_list(window:PGdkWindow; pixbufs:PGList); cdecl; external gdklib; +procedure gdk_window_set_icon(window:PGdkWindow; icon_window:PGdkWindow; pixmap:PGdkPixmap; mask:PGdkBitmap); cdecl; external gdklib; +procedure gdk_window_set_icon_name(window:PGdkWindow; name:Pgchar); cdecl; external gdklib; +procedure gdk_window_set_group(window:PGdkWindow; leader:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_set_decorations(window:PGdkWindow; decorations:TGdkWMDecoration); cdecl; external gdklib; +function gdk_window_get_decorations(window:PGdkWindow; decorations:PGdkWMDecoration):gboolean; cdecl; external gdklib; +procedure gdk_window_set_functions(window:PGdkWindow; functions:TGdkWMFunction); cdecl; external gdklib; + +{$ifndef GDK_MULTIHEAD_SAFE} +function gdk_window_get_toplevels:PGList; cdecl; external gdklib; +// Already defined: procedure gdk_set_sm_client_id(sm_client_id:Pgchar); cdecl; external gdklib; +{$endif} + +procedure gdk_window_iconify(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_deiconify(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_stick(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_unstick(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_maximize(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_unmaximize(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_register_dnd(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_begin_resize_drag(window:PGdkWindow; edge:TGdkWindowEdge; button:gint; root_x:gint; root_y:gint; + timestamp:guint32); cdecl; external gdklib; +procedure gdk_window_begin_move_drag(window:PGdkWindow; button:gint; root_x:gint; root_y:gint; timestamp:guint32); cdecl; external gdklib; + + +{ Interface for dirty-region queueing } + +procedure gdk_window_invalidate_rect(window:PGdkWindow; rect:PGdkRectangle; invalidate_children:gboolean); cdecl; external gdklib; +procedure gdk_window_invalidate_region(window:PGdkWindow; region:PGdkRegion; invalidate_children:gboolean); cdecl; external gdklib; +procedure gdk_window_invalidate_maybe_recurse(window:PGdkWindow; region:PGdkRegion; child_func:gdk_window_invalidate_maybe_recurse_child_func; user_data:gpointer); cdecl; external gdklib; +function gdk_window_get_update_area(window:PGdkWindow):PGdkRegion; cdecl; external gdklib; +procedure gdk_window_freeze_updates(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_thaw_updates(window:PGdkWindow); cdecl; external gdklib; +procedure gdk_window_process_all_updates; cdecl; external gdklib; +procedure gdk_window_process_updates(window:PGdkWindow; update_children:gboolean); cdecl; external gdklib; + + +{ Enable/disable flicker, so you can tell if your code is inefficient. } + +procedure gdk_window_set_debug_updates(setting:gboolean); cdecl; external gdklib; +procedure gdk_window_constrain_size(geometry:PGdkGeometry; flags:guint; width:gint; height:gint; new_width:Pgint; + new_height:Pgint); cdecl; external gdklib; +procedure gdk_window_get_internal_paint_info(window:PGdkWindow; var real_drawable:PGdkDrawable; x_offset:Pgint; y_offset:Pgint); cdecl; external gdklib; +function gdk_set_pointer_hooks(new_hooks:PGdkPointerHooks):PGdkPointerHooks; cdecl; external gdklib; +function gdk_get_default_root_window:PGdkWindow; cdecl; external gdklib; + +{$ifndef GDK_DISABLE_DEPRECATED} +function GDK_ROOT_PARENT : PGdkWindow; + +procedure gdk_window_get_size(drawable:PGdkDrawable; width:Pgint; height:Pgint); +function gdk_window_get_type(window:PGdkWindow):TGdkWindowType; +function gdk_window_get_colormap(drawable:PGdkDrawable):PGdkColormap; +procedure gdk_window_set_colormap(drawable:PGdkDrawable; colormap:PGdkColormap); +function gdk_window_get_visual(drawable:PGdkDrawable):PGdkVisual; +function gdk_window_ref(drawable:PGdkDrawable):PGdkDrawable; +procedure gdk_window_unref(drawable:PGdkDrawable); + +procedure gdk_window_copy_area(drawable:PGdkDrawable; gc:PGdkGC; + x,y: gint; source_drawable:PGdkDrawable; source_x,source_y: gint; + width,height : gint); +{$endif} +{ GDK_DISABLE_DEPRECATED } + +{$endif read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function GDK_TYPE_WINDOW : GType; +begin + GDK_TYPE_WINDOW:=gdk_window_object_get_type; +end; + +function GDK_WINDOW(anObject : Pointer) : PGdkWindow; +begin + GDK_WINDOW:=PGdkWindow(G_TYPE_CHECK_INSTANCE_CAST(anObject,GDK_TYPE_WINDOW)); +end; + +function GDK_WINDOW_CLASS(klass : Pointer) : PGdkWindowObjectClass; +begin + GDK_WINDOW_CLASS:=PGdkWindowObjectClass(G_TYPE_CHECK_CLASS_CAST(klass, + GDK_TYPE_WINDOW)); +end; + +function GDK_IS_WINDOW(anObject : Pointer) : boolean; +begin + GDK_IS_WINDOW:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,GDK_TYPE_WINDOW); +end; + +function GDK_IS_WINDOW_CLASS(klass : Pointer) : boolean; +begin + GDK_IS_WINDOW_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,GDK_TYPE_WINDOW); +end; + +function GDK_WINDOW_GET_CLASS(obj : Pointer) : PGdkWindowObjectClass; +begin + GDK_WINDOW_GET_CLASS:=PGdkWindowObjectClass(G_TYPE_INSTANCE_GET_CLASS(obj, + GDK_TYPE_WINDOW)); +end; + +function GDK_WINDOW_OBJECT(anObject : Pointer) : PGdkWindowObject; +begin + GDK_WINDOW_OBJECT:=PGdkWindowObject(GDK_WINDOW(anObject)); +end; + +function GdkWindowObject_guffaw_gravity(var a : TGdkWindowObject) : guint; +begin + GdkWindowObject_guffaw_gravity:= + (a.flag0 and bm_TGdkWindowObject_guffaw_gravity) + shr bp_TGdkWindowObject_guffaw_gravity; +end; + +procedure GdkWindowObject_set_guffaw_gravity(var a : TGdkWindowObject; __guffaw_gravity : guint); +begin + a.flag0:= + a.flag0 or ((__guffaw_gravity shl bp_TGdkWindowObject_guffaw_gravity) + and bm_TGdkWindowObject_guffaw_gravity); +end; + +function GdkWindowObject_input_only(var a : TGdkWindowObject) : guint; +begin + GdkWindowObject_input_only:= + (a.flag0 and bm_TGdkWindowObject_input_only) shr bp_TGdkWindowObject_input_only; +end; + +procedure GdkWindowObject_set_input_only(var a : TGdkWindowObject; __input_only : guint); +begin + a.flag0:=a.flag0 or ((__input_only shl bp_TGdkWindowObject_input_only) + and bm_TGdkWindowObject_input_only); +end; + +function GdkWindowObject_modal_hint(var a : TGdkWindowObject) : guint; +begin + GdkWindowObject_modal_hint:=(a.flag0 and bm_TGdkWindowObject_modal_hint) + shr bp_TGdkWindowObject_modal_hint; +end; + +procedure GdkWindowObject_set_modal_hint(var a : TGdkWindowObject; __modal_hint : guint); +begin + a.flag0:=a.flag0 or ((__modal_hint shl bp_TGdkWindowObject_modal_hint) + and bm_TGdkWindowObject_modal_hint); +end; + +function GdkWindowObject_destroyed(var a : TGdkWindowObject) : guint; +begin + GdkWindowObject_destroyed:=(a.flag0 and bm_TGdkWindowObject_destroyed) + shr bp_TGdkWindowObject_destroyed; +end; + +procedure GdkWindowObject_set_destroyed(var a : TGdkWindowObject; __destroyed : guint); +begin + a.flag0:=a.flag0 or ((__destroyed shl bp_TGdkWindowObject_destroyed) + and bm_TGdkWindowObject_destroyed); +end; + +function GDK_ROOT_PARENT : PGdkWindow; +begin + GDK_ROOT_PARENT:=gdk_get_default_root_window; +end; + +procedure gdk_window_get_size(drawable:PGdkDrawable; width:Pgint; height:Pgint); +begin + gdk_drawable_get_size(drawable,width,height); +end; + +function gdk_window_get_type(window:PGdkWindow):TGdkWindowType; +begin + gdk_window_get_type:=gdk_window_get_window_type(window); +end; + +function gdk_window_get_colormap(drawable:PGdkDrawable):PGdkColormap; +begin + gdk_window_get_colormap:=gdk_drawable_get_colormap(drawable); +end; + +procedure gdk_window_set_colormap(drawable:PGdkDrawable; colormap:PGdkColormap); +begin + gdk_drawable_set_colormap(drawable,colormap); +end; + +function gdk_window_get_visual(drawable:PGdkDrawable):PGdkVisual; +begin + gdk_window_get_visual:=gdk_drawable_get_visual(drawable); +end; + +function gdk_window_ref(drawable:PGdkDrawable):PGdkDrawable; +begin + gdk_window_ref:=GDK_DRAWABLE(g_object_ref(G_OBJECT(drawable))); +end; + +procedure gdk_window_unref(drawable:PGdkDrawable); +begin + g_object_unref(G_OBJECT(drawable)); +end; + +procedure gdk_window_copy_area(drawable:PGdkDrawable; gc:PGdkGC; + x,y: gint; source_drawable:PGdkDrawable; source_x,source_y: gint; + width,height : gint); +begin + gdk_draw_pixmap(drawable,gc,source_drawable,source_x,source_y, + x,y,width,height); +end; +{$ENDIF} + |