diff --git a/samples/minwin_gtk/CMakeLists.txt b/samples/minwin_gtk/CMakeLists.txt new file mode 100644 index 0000000..23cffae --- /dev/null +++ b/samples/minwin_gtk/CMakeLists.txt @@ -0,0 +1,58 @@ +################################# +# Preamble +############## + +# where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ +# is checked +set(CMAKE_MODULE_PATH + ${CMAKE_SOURCE_DIR}/cmake/Modules +) + +# Using Tango +set(CMAKE_D_USE_PHOBOS True) + +# check for DDoc usage +include(UseDDoc) + +################################# +# Project +############## + +SET(CMAKE_FIND_LIBRARY_PREFIXES "") +SET(CMAKE_FIND_LIBRARY_SUFFIXES ".so") + +PROJECT (minwin_gtk D) + +FIND_PACKAGE (GTK2) + +IF (GTK2_FOUND) + + INCLUDE_DIRECTORIES ( + ${CMAKE_SOURCE_DIR} + ${GTK2_INCLUDE_DIRS} + ) + + + SET (SRCS + minwin/all.d minwin/font.d minwin/layout.d minwin/peerimpl.d + minwin/app.d minwin/geometry.d minwin/listbox.d minwin/scroll.d + minwin/button.d minwin/group.d minwin/logging.d minwin/text.d + minwin/canvas.d minwin/gtk.d minwin/menu.d minwin/unittest.d + minwin/combo.d minwin/gtk_peers.d minwin/window.d + minwin/component.d minwin/icon.d minwin/multidg.d + minwin/dialog.d minwin/image.d minwin/paint.d + minwin/event.d minwin/label.d minwin/peer.d ) + + IF(CMAKE_COMPILER_IS_GDC) + ADD_DEFINITIONS (-fversion=GTK ${GTK2_DEFINITIONS}) + ELSE(CMAKE_COMPILER_IS_DMD) + ADD_DEFINITIONS (-version=GTK ${GTK2_DEFINITIONS}) + ENDIF(CMAKE_COMPILER_IS_GDC) + + ADD_LIBRARY (minwin_gtk ${SRCS}) + + TARGET_LINK_LIBRARIES (minwin_gtk ${GTK2_LIBRARIES}) + + ADD_SUBDIRECTORY (minwin/samples) + +ENDIF (GTK2_FOUND) diff --git a/samples/minwin_gtk/README.minwin b/samples/minwin_gtk/README.minwin new file mode 100644 index 0000000..fe755b8 --- /dev/null +++ b/samples/minwin_gtk/README.minwin @@ -0,0 +1,5 @@ +minwin/docs +----------- +not included because of not installed sample +if you want to look, see http://minwin.dsource.org + diff --git a/samples/minwin_gtk/cmake/Modules b/samples/minwin_gtk/cmake/Modules new file mode 120000 index 0000000..4506e23 --- /dev/null +++ b/samples/minwin_gtk/cmake/Modules @@ -0,0 +1 @@ +../../../cmaked/ \ No newline at end of file diff --git a/samples/minwin_gtk/minwin/all.d b/samples/minwin_gtk/minwin/all.d new file mode 100644 index 0000000..cfeeed2 --- /dev/null +++ b/samples/minwin_gtk/minwin/all.d @@ -0,0 +1,36 @@ +/* MinWin global import + * + * MinWin is the Minimal Window Toolkit. The goal is to provide + * basic cross-platform capabilities while still giving complete + * access to native peers and platform-specific features. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.all; + +public { + import minwin.app; + import minwin.component; + import minwin.window; + import minwin.dialog; + import minwin.geometry; + import minwin.paint; + import minwin.font; + import minwin.button; + import minwin.label; + import minwin.text; + import minwin.multidg; + import minwin.layout; + import minwin.menu; + import minwin.group; + import minwin.event; + import minwin.icon; + import minwin.image; + import minwin.combo; + import minwin.listbox; + import minwin.canvas; + import minwin.scroll; +} diff --git a/samples/minwin_gtk/minwin/app.d b/samples/minwin_gtk/minwin/app.d new file mode 100644 index 0000000..d7ffd01 --- /dev/null +++ b/samples/minwin_gtk/minwin/app.d @@ -0,0 +1,244 @@ +/* MinWin Application structure + * + * An Application encapsulates the global state provided by + * the OS when starting the application and it manages the event queue. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.app; + +private { + import minwin.logging; + import minwin.multidg; + import minwin.event; + import std.string; +} + +version(MinWin32) { + private import minwin.mswindows; +} + +extern (C) void gc_init(); +extern (C) void gc_term(); +extern (C) void _minit(); +extern (C) void _moduleCtor(); +extern (C) void _moduleUnitTests(); +extern (C) int MinWinMain(Application* app); + +const int NO_ID = -1; +class MinWinException : Exception { + int id = NO_ID; + this(char[] msg) { + super(msg); + } + this(char[] msg, int id) { + this.id = id; + if (id == NO_ID) + super(msg); + else + super(format("%s (error code %x)",msg,id)); + } +} + +// Assert a condition is true and if not throw an exception. +void sysAssert(bool passed, char[] msg, int id = 0) { + if (!passed) { + version (MinWin32) { + if (GetVersion() < 0x80_00_00_00 || id != 0) { + throw new MinWinException(msg,id); + } else { + throw new MinWinException(msg,GetLastError()); + } + } else { + throw new MinWinException(msg,id); + } + } +} + +Application gApp; + +version (MinWin32) { + + extern (Windows) + void MinWinIdleProc(HWND hWnd, uint msg, uint id, DWORD time) { + gApp.idleDelegate(); + } + + struct Application { + + char[] rsrc(char[] id, char[] group = "strings") { + wchar[] wres; + char[] cres; + if (useWfuncs) + wres.length = 64; + else + cres.length = 64; + int len; + for (;;) { + if (useWfuncs) { + len = cast(int)LoadStringW(gApp.hInstance,toUTF16z(id),wres.ptr,wres.length); + if (len < wres.length) break; + else wres.length = 2*wres.length; + } + else { + len = cast(int)LoadStringA(gApp.hInstance,toMBSz(id),cres.ptr,cres.length); + if (len < cres.length) break; + else cres.length = 2*cres.length; + } + } + if (useWfuncs) + return toUTF8(wres[0..len]); + else { + return fromMBSz(cres[0..len].ptr); + } + } + + char[][] cmdLineArgs(){ + // TODO: parse cmd line args + return parsedCmdLineArgs; + } + + MultiDelegate!() idleDelegate; + + private uint fTimerID; + private uint fIdleTime; + uint idleTime() { + return fIdleTime; + } + void idleTime(uint t) { // time 0 means stop + fIdleTime = t; + if (fTimerID) { + BOOL ok = KillTimer(null,fTimerID); + sysAssert(ok != false, "Failed to kill existing timer"); + } + if (t) { + fTimerID = SetTimer(null,0,t,&MinWinIdleProc); + sysAssert(fTimerID != 0, "Failed to set timer"); + } + } + + int enterEventLoop() { + while (nextEvent(&event)) { + // TODO: check IsDialogMessage + dispatchEvent(&event); + } + return 1; + } + + void exitEventLoop() { + PostQuitMessage(0); + } + + HINSTANCE hInstance; + HINSTANCE hPrevInstance; + LPSTR lpCmdLine; + char[][] parsedCmdLineArgs; + int nCmdShow; + Event event; + } + + extern (Windows) + int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { + int result; + gc_init(); // initialize garbage collector + _minit(); // initialize module constructor table + + try + { + _moduleCtor(); // call module constructors + _moduleUnitTests(); // run unit tests (optional) + + gApp.hInstance = hInstance; + gApp.hPrevInstance = hPrevInstance; + gApp.nCmdShow = nCmdShow; + version (LOG) log.writefln("about to enter MinWinMain"); + result = MinWinMain(&gApp); + version (LOG) log.writefln("done with MinWinMain"); + } + + catch (Object o) // catch any uncaught exceptions + { + MessageBoxX(null, o.toString(), "Error",MB_OK | MB_ICONEXCLAMATION); + result = 0; // failed + } + version(LOG) log.close(); + if (gApp.fTimerID) { + BOOL ok = KillTimer(null,gApp.fTimerID); + sysAssert(ok != false, "Failed to kill existing timer at exit"); + } + gc_term(); // run finalizers; terminate garbage collector + return result; + } + +} else version (GTK) { + + private { + import minwin.gtk; + import std.string; + import std.file; + } + + extern (C) + gboolean MinWinIdleProc(gpointer data) { + gApp.idleDelegate(); + return true; + } + + struct Application { + + char[][] cmdLineArgs; + + char[] rsrc(char[] id, char[] group = "strings") { + // TODO + return ""; + } + + char[] resourcePath; + + int enterEventLoop() { + gtk_main(); + return 1; + } + + void exitEventLoop() { + gtk_main_quit(); + } + + MultiDelegate!() idleDelegate; + uint fIdleTime; + uint idleTime() { + return fIdleTime; + } + + guint fTimerID; + + static + void idleTime(uint t) { + gApp.fIdleTime = t; + if (gApp.fTimerID) + g_source_remove(gApp.fTimerID); + if (t) + gApp.fTimerID = g_timeout_add(t,&MinWinIdleProc,null); + } + } + + int main(char[][] args) { + gApp.cmdLineArgs = args; + + char*[] argv; + argv.length = args.length; + foreach (int n, char[] str; args) { + argv[n] = toStringz(str); + } + int argc = args.length; + char**argvp = argv.ptr; + gtk_init(&argc,&argvp); + + int res = MinWinMain(&gApp); + version(LOG) log.close(); + return res; + } +} diff --git a/samples/minwin_gtk/minwin/button.d b/samples/minwin_gtk/minwin/button.d new file mode 100644 index 0000000..73313d1 --- /dev/null +++ b/samples/minwin_gtk/minwin/button.d @@ -0,0 +1,376 @@ +/* MinWin Button classes + * + * Various button classes like PushButtons + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.button; + +public import minwin.component; + +private { + import minwin.icon; + import minwin.app; + import minwin.window; + import minwin.peerimpl; + import minwin.logging; + import std.string; + import minwin.peer; +} + +abstract class AbstractButton : WindowChild { + int cmd; + Icon icon(); + void icon(Icon c); + char[] text(); + void text(char[] c); + + MultiDelegate!(Component) actionDelegate; + + void doCommand(int cmd) { + // only command is action command + version(LOG) log.writefln("calling action delegate"); + if (cmd == ButtonClickedCommand) { + actionDelegate(cast(Component)this); + if (this.cmd != 0) { + super.doCommand(this.cmd); + } + } + } +} + +abstract class AbstractToggleButton : AbstractButton { + bool selected(); + void selected(bool x); +} +version (MinWin32) { + version = SimpleToggleGroup; +} +version (SimpleToggleGroup) { + private import minwin.dialog; + // manages selected state between several ToggleButtons + class ToggleGroup { + AbstractToggleButton[] buttons; + void addButton(AbstractToggleButton[] btns ...) { + buttons ~= btns; + foreach(b; btns) { + b.actionDelegate ~= &select; + } + } + void select(Component c) { + version (LOG) log.writefln("selecting component ", c); + foreach(AbstractToggleButton b; buttons) { + b.selected = (b is c); + } + } + void select(int index) { + foreach(int n, AbstractToggleButton b; buttons) { + b.selected = n == index; + } + } + int selected() { + foreach(int n, AbstractToggleButton b; buttons) { + version(LOG)log.printf("testing button %d %x\n",n,b); + if (b && b.selected) + return n; + } + version(LOG)log.printf(" no button selected??\n"); + return 0; + } + } +} + +version (MinWin32) { + private import minwin.mswindows; + + const int ButtonClickedCommand = BN_CLICKED; + + template PreferredSizeImpl() { + const int paddingX; + const int paddingY; + Point preferredSize() { + int width,height; + HDC dc = GetDC(peer); + sysAssert(dc !is null, "Failed to get button DC in preferredSize"); + SIZE s; + try { + Font f = standardFont(StandardFont.Gui); + HFONT oldfont = SelectObject(dc,f.peer); + sysAssert(oldfont !is null, "Failed to get Button font in preferredSize"); + BOOL status = GetTextExtentPoint32X(dc,text_data,text_data.length,&s); + SelectObject(dc,oldfont); + sysAssert(status != false, "Failed to get font extents in preferredSize"); + } finally { + ReleaseDC(peer,dc); + } + width = s.cx > 75-paddingX ? s.cx+paddingX*2 : 75; + height = s.cy > 23-paddingY ? s.cy+paddingY*2 : 23; + if (userPreferredWidth_data > 0) + width = userPreferredWidth_data; + if (userPreferredHeight_data > 0) + height = userPreferredHeight_data; + return XY(width,height); + // Requires WinXP + // SIZE sz; + // SendMessageA(peer,BCM_GETIDEALSIZE,0,cast(int)&sz); + // width = sz.cx; + // height = sz.cy; + } + } + + template SelectedImpl() { + bool selected() { + version(LOG)log.printf("sending message..."); + bool res = SendMessageA(peer,BM_GETCHECK,0,0) == BST_CHECKED; + version(LOG)log.printf(" got %d\n",res); + return res; + } + void selected(bool x) { + SendMessageA(peer,BM_SETCHECK,x,0); + } + } + + template IconTextImpl() { + Icon icon_data; + Icon icon() { return icon_data; } + void icon(Icon c) { + icon_data = c; + SendMessageA(peer,BM_SETIMAGE,cast(WPARAM)c.peer,0); + } + + char[] text_data; + char[] text() { return text_data; } + void text(char[] c) { + text_data = c; + SendMessageX(peer,WM_SETTEXT,0,c); + } + } + + class Button : AbstractButton { + this(Component parent, char[] intext, char[] name = "") { + paddingX = GetSystemMetrics(SM_CXFIXEDFRAME)*2; + paddingY = GetSystemMetrics(SM_CXFIXEDFRAME)*2; + PeerForAdd parentp = parent.getPeerForAdd(); + text_data = intext; + peer = CreateWindowX("BUTTON",intext, + BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,gApp.hInstance,null); + sysAssert(peer !is null, "Failed to create peer Button"); + finish_button_setup(this,parent,name,peer); + } + mixin WindowChildImpl!(); + mixin IconTextImpl!(); + mixin PreferredSizeImpl!(); + } + class CheckBox : AbstractToggleButton { + this(Component parent, char[] intext, char[] name = "") { + paddingX = GetSystemMetrics(SM_CXMENUCHECK); + paddingY = GetSystemMetrics(SM_CYFIXEDFRAME)*2; + PeerForAdd parentp = parent.getPeerForAdd(); + text_data = intext; + peer = CreateWindowX("BUTTON",intext, + BS_AUTOCHECKBOX | WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,gApp.hInstance,null); + sysAssert(peer !is null, "Failed to create peer CheckBox"); + finish_button_setup(this,parent,name,peer); + } + mixin WindowChildImpl!(); + mixin SelectedImpl!(); + mixin IconTextImpl!(); + mixin PreferredSizeImpl!(); + } + class RadioButton : AbstractToggleButton { + this(Component parent, char[] intext, char[] name = "") { + paddingX = GetSystemMetrics(SM_CXMENUCHECK); + paddingY = GetSystemMetrics(SM_CYFIXEDFRAME)*2; + PeerForAdd parentp = parent.getPeerForAdd(); + text_data = intext; + peer = CreateWindowX("BUTTON",intext, + BS_RADIOBUTTON | WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,gApp.hInstance,null); + sysAssert(peer !is null, "Failed to create peer RadioButton"); + finish_button_setup(this,parent,name,peer); + } + mixin WindowChildImpl!(); + mixin SelectedImpl!(); + mixin IconTextImpl!(); + mixin PreferredSizeImpl!(); + } + class ToggleButton : AbstractToggleButton { + this(Component parent, char[] intext, char[] name = "") { + paddingX = GetSystemMetrics(SM_CXFIXEDFRAME)*2; + paddingY = GetSystemMetrics(SM_CYFIXEDFRAME)*2; + PeerForAdd parentp = parent.getPeerForAdd(); + text_data = intext; + peer = CreateWindowX("BUTTON",intext, + BS_PUSHLIKE | BS_AUTOCHECKBOX | WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,gApp.hInstance,null); + sysAssert(peer !is null, "Failed to create peer ToggleButton"); + finish_button_setup(this,parent,name,peer); + } + mixin WindowChildImpl!(); + mixin SelectedImpl!(); + mixin IconTextImpl!(); + mixin PreferredSizeImpl!(); + } + + private void finish_button_setup(AbstractButton b,Component parent, + char[] name, WindowChildPeer peer) { + setWindowChildPeer(b,peer,OWNS_PEER); + b.name = name; + Font f = standardFont(StandardFont.Gui); + SendMessageA(peer,WM_SETFONT,cast(WPARAM)f.peer,0); + parent.addChild(b); + } + +} else version (GTK) { + + private import minwin.gtk; + private import std.c.string; + + const int ButtonClickedCommand = 1; + + abstract class HeavyAbstractToggleButton : AbstractToggleButton { + mixin WindowChildImpl!(); + } + + // manages selected state between several ToggleButtons + class ToggleGroup { + HeavyAbstractToggleButton[] buttons; + void addButton(HeavyAbstractToggleButton[] btns ...) { + buttons ~= btns; + foreach(b; btns) { + RadioButton rb = cast(RadioButton)b; + if (rb is null) { + b.actionDelegate ~= &select; + } else { + // set the RadioButton group to its sibling, if any + if (buttons.length != 0) { + GtkRadioButton* rbpeer1 = cast(GtkRadioButton*)buttons[0].peer; + GtkRadioButton* rbpeer = cast(GtkRadioButton*)rb.peer; + GSList* group = gtk_radio_button_get_group(rbpeer1); + gtk_radio_button_set_group(rbpeer,group); + } + } + } + } + void select(Component c) { + version (LOG) log.writefln("selecting component ", c); + foreach(HeavyAbstractToggleButton b; buttons) { + b.selected = (b is c); + } + } + void select(int index) { + foreach(int n, HeavyAbstractToggleButton b; buttons) { + b.selected = n == index; + } + } + int selected() { + foreach(int n, HeavyAbstractToggleButton b; buttons) { + if (b.selected) + return n; + } + } + } + + template SelectedImpl() { + bool selected() { + return gtk_toggle_button_get_active(cast(GtkToggleButton*)peer) != 0; + } + void selected(bool x) { + gtk_toggle_button_set_active(cast(GtkToggleButton*)peer,x); + } + } + + template IconTextImpl() { + Icon icon_data; + Icon icon() { return icon_data; } + void icon(Icon c) { + icon_data = c; + // SendMessageA(peer,BM_SETIMAGE,cast(WPARAM)c.peer,0); + } + char[] text() { + char* str = gtk_button_get_label(cast(GtkButton*)peer); + if (str is null) + return ""; + else + return str[0..strlen(str)].dup; + } + void text(char[] c) { + gtk_button_set_label(cast(GtkButton*)peer,toStringz(c)); + } + } + + class Button : AbstractButton { + this(Component parent, char[] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + char* str = toStringz(text); + peer = gtk_button_new_with_label(str); + finish_button_setup(this,peer,parentp,parent); + } + mixin WindowChildImpl!(); + mixin IconTextImpl!(); + } + class CheckBox : HeavyAbstractToggleButton { + this(Component parent, char[] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + char* str = toStringz(text); + peer = gtk_check_button_new_with_label(str); + finish_button_setup(this,peer,parentp,parent); + } + mixin SelectedImpl!(); + mixin IconTextImpl!(); + } + class RadioButton : HeavyAbstractToggleButton { + this(Component parent, char[] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + char* str = toStringz(text); + peer = gtk_radio_button_new_with_label(null,str); + finish_button_setup(this,peer,parentp,parent); + } + mixin SelectedImpl!(); + mixin IconTextImpl!(); + } + class ToggleButton : HeavyAbstractToggleButton { + this(Component parent, char[] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + char* str = toStringz(text); + peer = gtk_toggle_button_new_with_label(str); + finish_button_setup(this,peer,parentp,parent); + } + mixin SelectedImpl!(); + mixin IconTextImpl!(); + } + private void finish_button_setup(AbstractButton b, + WindowChildPeer peer, + PeerForAdd parentp, + Component parent) { + gtk_widget_set_sensitive(peer,true); + gtk_container_add(cast(GtkContainer*)parentp,peer); + g_signal_connect_data(peer,"clicked", + cast(GCallback)&mw_buttonclick_callback, + cast(gpointer)b, + null,cast(GConnectFlags)0); + setWindowChildPeer(b,peer,OWNS_PEER); + parent.addChild(b); + gtk_widget_realize(peer); + b.visible = true; + } + extern (C) void mw_buttonclick_callback(GtkButton *but, gpointer ud) { + Component c = cast(Component) ud; + if (c) { + c.doCommand(ButtonClickedCommand); + } + } +} diff --git a/samples/minwin_gtk/minwin/canvas.d b/samples/minwin_gtk/minwin/canvas.d new file mode 100644 index 0000000..4a6f5dd --- /dev/null +++ b/samples/minwin_gtk/minwin/canvas.d @@ -0,0 +1,273 @@ +/* MinWin Canvas class + * + * A Canvas is a component that fires key and mouse events and has no + * other builtin capabilities + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.canvas; + +private { + import minwin.component; + import minwin.event; + import minwin.app; + import minwin.paint; + import minwin.logging; + import minwin.window; + import minwin.peerimpl; + import minwin.image; + import std.string; +} + +template SharedCanvasImpl() { + // events + MultiDelegate!(Component,KeyEvent*) keyDelegate; + MultiDelegate!(Component,MouseEvent*) mouseDelegate; + MultiDelegate!(Component,GContext) paintDelegate; +} + +version (MinWin32) { + + private import minwin.mswindows; + + // generic heavyweight window child + class Canvas : WindowChild { + this(Component parent, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + peer = CreateWindowA("MinWinCanvas","", + WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,gApp.hInstance,null); + sysAssert(peer !is null, "Failed to create peer Canvas"); + this.name = name; + version(LOG)log.printf("canvas ctor %x peer %x\n",this,peer); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + } + + mixin SharedCanvasImpl!(); + mixin WindowChildImpl!(); + Point preferredSize(){ + int width = 60; + int height = 60; + if (userPreferredWidth > 0) + width = userPreferredWidth; + if (userPreferredHeight > 0) + height = userPreferredHeight; + return XY(width,height); + } + void backgroundColor(Color c) { + // TODO + } + + mixin CommonEventSourceImpl!(); + + int WindowProc(HWND hWnd, uint uMsg, WPARAM wParam, LPARAM lParam) { + version (LOG) log.printf(" in canvas windowproc msg %d\n",uMsg); + bool doDefault = true; + if (uMsg <= WM_KEYLAST && uMsg >= WM_KEYFIRST) { + version(LOG) log.writefln("got canvas key event %d %d",uMsg,wParam); + keyDelegate(this, cast(KeyEvent*)&gApp.event); + } else if (uMsg <= WM_MOUSELAST && uMsg >= WM_MOUSEFIRST) { + MouseEvent ev; + mouseDelegate(this, cast(MouseEvent*)&gApp.event); + } else { + switch (uMsg) { + case WM_PAINT: + version (LOG) log.writefln(" got canvas paint"); + repaintNow(); + break; + case WM_DESTROY: + version (LOG) log.writefln(" got canvas destroy"); + hasPeer = NO_PEER; + default: + version (LOG) log.writefln(" got canvas default"); + break; + } + } + return doDefault; + } + } + extern(Windows) int MinWinCanvasProc(HWND hWnd, uint uMsg, WPARAM wParam, LPARAM lParam) { + version(LOG) log.printf("in minwin canvas proc hwnd %p\n",hWnd); + bool doDefault = true; + Canvas canvas = cast(Canvas)peerToWindowChild(hWnd); + version(LOG) log.printf("in minwin canvas proc canvas %p\n",canvas); + if (canvas !is null) + doDefault = canvas.WindowProc(hWnd,uMsg,wParam,lParam) != 0; + if (doDefault) + return DefWindowProcA(hWnd, uMsg, wParam, lParam); + else + return 0; + } + static this() { + HINSTANCE hInst = GetModuleHandleA(null); + WNDCLASSA wc; + wc.lpszClassName = "MinWinCanvas"; + wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW; + wc.lpfnWndProc = &MinWinCanvasProc; + wc.hInstance = hInst; + wc.hCursor = LoadCursorA(cast(HINSTANCE) null, IDC_ARROW); + wc.hbrBackground = null; + // wc.hbrBackground = cast(HBRUSH) (COLOR_WINDOW + 1); // not +1 for default + wc.lpszMenuName = null; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + RegisterClassA(&wc); + } + +} else version (GTK) { + + private import minwin.gtk; + + class Canvas : WindowChild { + this(Component parent, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + peer = gtk_drawing_area_new(); + gtk_widget_add_events(peer,GdkEventMask.GDK_KEY_PRESS_MASK | + GdkEventMask.GDK_KEY_RELEASE_MASK | + GdkEventMask.GDK_EXPOSURE_MASK | + GdkEventMask.GDK_POINTER_MOTION_MASK | + GdkEventMask.GDK_BUTTON_PRESS_MASK | + GdkEventMask.GDK_BUTTON_RELEASE_MASK); + g_signal_connect_data(peer,"expose-event", + cast(GCallback)&mw_canvas_expose_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + g_signal_connect_data(peer,"key-press-event", + cast(GCallback)&mw_canvas_key_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + g_signal_connect_data(peer,"key-release-event", + cast(GCallback)&mw_canvas_key_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + g_signal_connect_data(peer,"motion-notify-event", + cast(GCallback)&mw_can_mouse_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + g_signal_connect_data(peer,"button-press-event", + cast(GCallback)&mw_can_button_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + g_signal_connect_data(peer,"button-release-event", + cast(GCallback)&mw_can_button_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + GtkObject* obj = cast(GtkObject*)peer; + obj.flags |= GtkWidgetFlags.GTK_CAN_FOCUS; + gtk_container_add(cast(GtkContainer*)parentp,peer); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + gtk_widget_realize(peer); + visible = true; + } + + mixin CommonEventSourceImpl!(); + + void backgroundColor(Color c) { + GdkWindow* win = (cast(GtkWidget*)peer).window; + GdkColor nc; + // look up GdkColor for rgb values in c using rgb colormap + gdk_window_set_background(win,&nc); + } + + GContext getGContext(Event* paintEvent) { + GContext gc = newGContext(); + // GtkWidget* widget = cast(GtkWidget*)peer; + GdkWindow* gwin = peer.window; + sysAssert(gwin !is null,"Canvas peer has no window",0); + // version(LOG) log.printf(" CANVAS DRAWABLE is %x\n",gwin); + gc.drawable = cast(GdkDrawable*)gwin; + gc.layout = gtk_widget_create_pango_layout(peer,""); + gc.peer = gdk_gc_new(gc.drawable); + gc.hasPeer = OWNS_PEER; + gc.paintEvent = cast(GdkEventExpose*)paintEvent; + return gc; + } + + // share with Window modulo peer vs content + Image getCompatibleImage(int width, int height) { + GtkWidget* widget = peer; + GdkDrawable* gwin = cast(GdkDrawable*)widget.window; + // ImagePeer bm = gdk_pixbuf_new(GdkColorspace.GDK_COLORSPACE_RGB, + // false,8,width,height); + int depth = gdk_drawable_get_depth(gwin); + ImagePeer bm = gdk_pixmap_new(gwin,width,height,depth); + version(LOG) log.writefln("create bitmap %x",cast(int)bm); + Image res = new Image(bm); + res.width = width; + res.height = height; + res.hasPeer = OWNS_PEER; + return res; + } + // share with Window modulo peer vs content + Image loadCompatibleImage(char[] imageKey, char[] fmt = "bmp") { + GtkWidget* widget = peer; + GdkDrawable* gwin = cast(GdkDrawable*)widget.window; + GError* err; + char[] fname = imageKey; + if (gApp.resourcePath.length > 0) { + fname = gApp.resourcePath ~ "/" ~ fname; + } + fname = fname ~ "." ~ fmt; + GdkPixbuf* pbuf = gdk_pixbuf_new_from_file(toStringz(fname),&err); + int width = gdk_pixbuf_get_width(pbuf); + int height = gdk_pixbuf_get_height(pbuf); + int depth = gdk_drawable_get_depth(gwin); + GdkColormap* cmap = gdk_drawable_get_colormap(gwin); + ImagePeer bm = gdk_pixmap_new(gwin,width,height,depth); + gdk_pixbuf_render_pixmap_and_mask_for_colormap(pbuf,cmap,&bm,null,0); + Image res = new Image(bm); + res.width = width; + res.height = height; + res.hasPeer = OWNS_PEER; + return res; + } + mixin SharedCanvasImpl!(); + mixin WindowChildImpl!(); + } + extern (C) gboolean mw_canvas_expose_callback(GtkWidget* w, + GdkEventExpose* event, + gpointer ud) { + Canvas c = cast(Canvas) ud; + if (c) { + c.repaintNow(cast(Event*)event); + } + return false; + } + extern (C) gboolean mw_canvas_key_callback(GtkWidget* w, + GdkEventKey* event, + gpointer ud) { + Canvas c = cast(Canvas) ud; + if (c && !c.keyDelegate.isEmpty) { + c.keyDelegate(c,cast(KeyEvent*)event); + } + return false; + } + + extern (C) gboolean mw_can_mouse_callback(GtkWidget* w, + GdkEventMotion* event, + gpointer ud) { + Canvas c = cast(Canvas) ud; + if (c && !c.mouseDelegate.isEmpty) { + // TODO this should be made into a GdkEventButton + c.mouseDelegate(c,cast(MouseEvent*)event); + } + return false; + } + extern (C) gboolean mw_can_button_callback(GtkWidget* w, + GdkEventButton* event, + gpointer ud) { + Canvas c = cast(Canvas) ud; + if (c && !c.mouseDelegate.isEmpty) { + // TODO this should be made into a GdkEventButton + c.mouseDelegate(c,cast(MouseEvent*)event); + } + return false; + } +} diff --git a/samples/minwin_gtk/minwin/combo.d b/samples/minwin_gtk/minwin/combo.d new file mode 100644 index 0000000..9940a3d --- /dev/null +++ b/samples/minwin_gtk/minwin/combo.d @@ -0,0 +1,165 @@ +/* MinWin ComboBox class + * + * Drop-down list of items to choose from. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.combo; + +private { + import minwin.component; + import minwin.app; + import minwin.window; + import minwin.peerimpl; + import std.string; + import minwin.logging; +} + +version (MinWin32) { + + // bug: clicking on the drop down button doesn't show the list + + private import minwin.mswindows; + + class ComboBox : WindowChild { + + bool editable_data; + bool editable() { return editable_data; } // read-only + + this(Component parent, char[][] text, bool editable = true, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + editable_data = editable; + int style = editable?(CBS_DROPDOWN|CBS_AUTOHSCROLL):CBS_DROPDOWN; + peer = CreateWindowX("COMBOBOX","", + style | WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,gApp.hInstance,null); + sysAssert(peer !is null, "Failed to create peer ComboBox"); + setWindowChildPeer(this,peer,OWNS_PEER); + foreach (char[] s; text) { + SendMessageX(peer,CB_ADDSTRING,0,s); + } + this.name = name; + Font f = standardFont(StandardFont.Gui); + SendMessageA(peer,WM_SETFONT,cast(WPARAM)f.peer,0); + parent.addChild(this); + } + mixin WindowChildImpl!(); + Point preferredSize(){ + // width = SendMessageA(peer,CB_GETDROPPEDWIDTH,0,0); + // height = SendMessageA(peer,CB_GETITEMHEIGHT,cast(WPARAM)-1,0); + int width = 75; + int height = 63; + return XY(width,height); + } + // -1 for custom text + int selection() { + return SendMessageA(peer,CB_GETCURSEL,0,0); + } + void selection(int n) { + SendMessageA(peer,CB_SETCURSEL,n,0); + version (LOG) log.writefln("number of item is %d", + SendMessageA(peer,CB_GETCOUNT,0,0)); + } + } + /* + extern(Windows) int MinWinComboBoxProc(HWND hWnd, uint uMsg, + WPARAM wParam, LPARAM lParam) { + if (uMsg == + return DefWindowProcA(hWnd, uMsg, wParam, lParam); + } + static this() { + HINSTANCE hInst = GetModuleHandleA(null); + WNDCLASSA wc; + wc.lpszClassName = "MinWinComboBox"; + wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW; + wc.lpfnWndProc = &MinWinComboBoxProc; + wc.hInstance = hInst; + wc.hCursor = LoadCursorA(cast(HINSTANCE) null, IDC_ARROW); + wc.hbrBackground = cast(HBRUSH) (COLOR_WINDOW + 1); // not +1 for default + wc.lpszMenuName = null; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + RegisterClassA(&wc); + } + */ +} else version (GTK) { + + private import minwin.gtk; + private import std.c.string; + + class ComboBox : WindowChild { + + bool editable_data; + bool editable() { return editable_data; } // read-only + + this(Component parent, char[][] text, bool editable = true, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + editable_data = editable; + if (editable_data) { + peer = gtk_combo_box_entry_new_text(); + } else { + peer = gtk_combo_box_new_text(); + } + GtkComboBox* box = cast(GtkComboBox*)peer; + foreach (char[] s; text) + gtk_combo_box_append_text(box,toStringz(s)); + gtk_container_add(cast(GtkContainer*)parentp,peer); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + gtk_widget_realize(peer); + visible = true; + } + + // -1 for custom text + int selection() { + GtkComboBox* box = cast(GtkComboBox*)peer; + return gtk_combo_box_get_active(box); + } + void selection(int n) { + GtkComboBox* box = cast(GtkComboBox*)peer; + gtk_combo_box_set_active(box,n); + } + + char[] text() { + char* str; + if (!editable) { + GtkComboBox* box = cast(GtkComboBox*)peer; + GtkTreeModel* model = gtk_combo_box_get_model(box); + GtkTreeIter iter; + if (gtk_tree_model_get_iter_first(model,&iter)) { + int n = selection(); + GValue* val; + while (n--) { + gtk_tree_model_iter_next(model,&iter); + } + gtk_tree_model_get_value(model,&iter,0,val); + str = *(cast(char**)val); + g_value_unset(val); + } + } else { + GtkEntry* box = cast(GtkEntry*)((cast(GtkBin*)peer).child); + str = gtk_entry_get_text(box); + } + if (str is null) + return ""; + else + return str[0..strlen(str)].dup; + } + + void text(char[] s) { + if (editable) { + GtkEntry* box = cast(GtkEntry*)((cast(GtkBin*)peer).child); + char* str = toStringz(s); + gtk_entry_set_text(box,str); + } + } + + mixin WindowChildImpl!(); + } +} diff --git a/samples/minwin_gtk/minwin/component.d b/samples/minwin_gtk/minwin/component.d new file mode 100644 index 0000000..a0cc4ad --- /dev/null +++ b/samples/minwin_gtk/minwin/component.d @@ -0,0 +1,279 @@ +/* MinWin Component class + * + * A Component is the root of the widget inheritance tree. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.component; + +public { + import minwin.multidg; + import minwin.geometry; + import minwin.peer; +} +private { + import minwin.event; + import minwin.layout; + import minwin.logging; +} + +abstract class Component { + + // Peer management + mixin PeerMixin!(); + + // disposePeer will dipose of the system resource associated + // with this object if it owns the peer and the object does + // not have any parent. It is assumed that an object with a + // parent will have its peer disposed when the parent is disposed. + void disposePeer(); + + PeerForAdd getPeerForAdd() { return null; } + + void getPeerOffset(inout int x, inout int y) { + x = 0; + y = 0; + } + + void dispose() { + Component ch = child; + while (ch !is null) { + ch.dispose(); + ch = ch.next; + } + disposePeer(); + } + + // Name property used for resource lookup on X and debugging + char[] name; + + // Application data associative array for user data + void*[char[]] userdata; + + void doCommand(int cmd) { + if (parent) + parent.doCommand(cmd); + } + + void requestFocus() {} + + // size management + void getMinimumSize(inout int width, inout int height) { + //todo: ask layout + width = 0; + height = 0; + } + void getMaximumSize(inout int width, inout int height) { + //todo: ask layout + width = int.max; + height = int.max; + } + abstract void getBounds(inout Rect r); + abstract void setBounds(inout Rect r); + Rect bounds() { + Rect r; + getBounds(r); + return r; + } + void bounds(Rect r) { + setBounds(r); + } + void getLayoutBounds(inout Rect r) { + Point s = size; + version(LOG)log.writefln("getLayoutBounds got size %d %d",s.x,s.y); + r.LTWH(0,0,s.x,s.y); + } + void size(Point s); + Point size() { + Rect bounds; + getBounds(bounds); + version(LOG)log.writefln("size function got width,height %d %d",bounds.width,bounds.height); + Point res; + res.x = bounds.width; + res.y = bounds.height; + return res; + } + int width() { + Rect bounds; + getBounds(bounds); + return bounds.width; + } + int height() { + Rect bounds; + getBounds(bounds); + return bounds.height; + } + + // property to request a particular width no matter what layout + int userPreferredWidth_data; + final int userPreferredWidth() { return userPreferredWidth_data; } + void userPreferredWidth(int width) { + userPreferredWidth_data = width; + // childLayoutDirty = true; + // repaint(); + } + + // property to request a particular height no matter what layout + int userPreferredHeight_data; + final int userPreferredHeight() { return userPreferredHeight_data; } + void userPreferredHeight(int height) { + userPreferredHeight_data = height; + // childLayoutDirty = true; + // repaint(); + } + + void userPreferredSize(int width, int height) { + userPreferredHeight = height; + userPreferredWidth = width; + } + + Point preferredSize(){ + Point p; + if (layoutMgr) { + p = layoutMgr.preferredSize(this); + } + if (userPreferredWidth() > 0) + p.x = userPreferredWidth(); + if (userPreferredHeight() > 0) + p.y = userPreferredHeight(); + return p; + } + + // visible property + void visible(bool vis); + bool visible(); + + // enabled property + void enabled(bool ena); + bool enabled(); + + Component getRootAncestor() { + Component top = this; + while (top.parent !is null) { + top = top.parent; + } + return top; + } + + // hierarchy management + Component parent; + Component child; + Component next; + Component prev; + + Component last() { + return child ? child.prev : null; + } + + // loop over children + int opApply(int delegate(inout Component c) dg) { + int res = 0; + Component c = child; + if (c) { + do { + res = dg(c); + c = c.next; + } while(!res && c !is child); + } + return res; + } + + // link two component as siblings. + // should an api be exposed to re-arrange without getting the peer? + void link(Component left, Component right) { + left.next = right; + right.prev = left; + } + + void opCatAssign(Component x) { + addChild(x); + } + + void addChild(Component x) { + x.parent = this; + if (!child) { + child = x; + x.prev = x.next = x; + } else { + link(last,x); + link(x,child); + } + } + + void removeChild(Component x) { + Component old = last; + if (x is child) { + if (child is last) + child = null; + else + child = child.next; + } + link(x.prev,x.next); + x.prev = null; + x.next = null; + x.parent = null; + } + + // layout management. TODO: invalidate and repaint on change + LayoutManager layoutMgr; + bool childLayoutDirty = true; + + bool parentOwnsLayout_data = true; + bool parentOwnsLayout() { return parentOwnsLayout_data; } + void parentOwnsLayout(bool x) { + parentOwnsLayout_data = x; + if (parent) { + parent.childLayoutDirty = true; + parent.repaint(); + } + } + + bool parentOwnsVisibility = true; + + void layout(bool validateParent) { + if (parent && validateParent) + parent.layout(true); + if (childLayoutDirty) { + if (layoutMgr) + layoutMgr.layout(this); + childLayoutDirty = false; + } + foreach( Component ch; this) { + ch.layout(false); + } + } + + void pack() { + int width,height; + Point s; + if (layoutMgr) { + s = layoutMgr.preferredSize(this); + version(LOG) log.writefln("preferred size %d %d",s.x,s.y); + size = s; + childLayoutDirty = true; + version(LOG) log.printf("in pack about to repaint %x\n",this); + repaint(); + version(LOG) log.printf("in pack done repaint about to layout %x\n",this); + layout(false); + version(LOG) log.printf("in pack done layout %x\n",this); + } + } + + // painting and graphics context management + void repaint() { + version(LOG) log.printf("in component.repaint for %x\n",this); + foreach ( Component c; this) { + version(LOG) log.printf(" repaint for child %x of %x\n",c,this); + c.repaint(); + } + } + bool clearBackgroundOnPaint = true; + void repaint(inout Rect r) {} +} + +class WindowChild : Component { + WindowChildPeer getPeer() { return null; } +} diff --git a/samples/minwin_gtk/minwin/dialog.d b/samples/minwin_gtk/minwin/dialog.d new file mode 100644 index 0000000..bef21fb --- /dev/null +++ b/samples/minwin_gtk/minwin/dialog.d @@ -0,0 +1,468 @@ +/* MinWin Dialog class + * + * A general dialog class and utility helper dialogs + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.dialog; + +private { + import std.string; + import std.c.string; + import minwin.peerimpl; + import minwin.font; + import minwin.event; + import minwin.component; + import minwin.menu; + import minwin.app; + import minwin.logging; + import minwin.icon; + import minwin.image; +} + +version (MinWin32) { + + private import minwin.mswindows; + + class Dialog : AbstractWindow { + AbstractWindow owner; + bool modal_data; + bool visible_data; + + this(AbstractWindow owner, char[] title = "", bool modal = true, char[] name = "") { + Rect r; + owner.getBounds(r); + DWORD style = WS_TABSTOP | WS_POPUP | DS_MODALFRAME | WS_CAPTION | WS_SYSMENU; + peer = CreateWindowX("MinWinDialog", title, + style & ~WS_MAXIMIZEBOX & ~WS_MINIMIZEBOX, + r.left, r.top, + DefaultWindowWidth, DefaultWindowHeight, + owner.peer, + cast(HMENU) null, gApp.hInstance, null); + sysAssert(peer !is null, "Failed to create peer Dialog"); + setWindowPeer(this,peer,OWNS_PEER); + backgroundPeer = CreateSolidBrush(systemBackgroundColor().native); + this.name = name; + this.owner = owner; + modal_data = modal; + WindowList[this] = this; // prevent garbage collection + } + + this(WindowPeer peer) { + setWindowPeer(this,peer,FOREIGN_PEER); + WindowList[this] = this; // prevent garbage collection + } + + AbstractWindow[] originalWindows; + int[] originalEnabledState; + + void visible(bool vis) { + if (modal_data && !vis && visible_data) { + // make sure original states are restored before hiding + foreach(int n, AbstractWindow w; originalWindows) { + if (IsWindow(w.peer)) { + EnableWindow(w.peer,originalEnabledState[n]); + } + } + originalWindows = null; + originalEnabledState = null; + } + version (LOG) log.writefln("setting dialog visible %d",cast(int)vis); + super.visible(vis); + version (LOG) log.writefln("done with super vis"); + visible_data = vis; + if (modal_data && vis) { + cancelCloseDelegate ~= delegate bool(Component c) { + Dialog dlg = cast(Dialog)c; + if (!dlg || !dlg.owner) return false; + EnableWindow(dlg.owner.peer,1); + return false; + }; + version (LOG) log.writefln("disabling windows dialog"); + originalWindows = WindowList.values; + originalEnabledState.length = originalWindows.length; + foreach(int n, AbstractWindow w; originalWindows) { + originalEnabledState[n] = IsWindowEnabled(w.peer) != 0; + version (LOG) log.writefln("disable %d %p for dialog",n,w); + if (originalEnabledState[n] != 0 && (w !is this)) { + EnableWindow(w.peer,0); + } + } + while (visible_data && IsWindow(peer)) { + version (LOG) log.writefln("in modal loop for %p",this); + if (!GetMessageA(&gApp.event.native, cast(HWND) null, 0, 0)) { + PostQuitMessage(0); // quit out of next event loop + break; + } + if (!IsDialogMessageA(peer, &gApp.event.native)) { + TranslateMessage(&gApp.event.native); + DispatchMessageA(&gApp.event.native); + } + } + visible_data = false; + foreach(int n, AbstractWindow w; originalWindows) { + if (IsWindow(w.peer)) { + EnableWindow(w.peer,originalEnabledState[n]); + } + } + } + } + + int WindowProc(HWND hWnd, uint uMsg, WPARAM wParam, LPARAM lParam) { + bool doDefault = true; + if (uMsg <= WM_KEYLAST && uMsg >= WM_KEYFIRST) { + keyDelegate(this,cast(KeyEvent*)&gApp.event); + } else if (uMsg <= WM_MOUSELAST && uMsg >= WM_MOUSEFIRST) { + mouseDelegate(this,cast(MouseEvent*)&gApp.event); + } else { + doDefault = super.WindowProc(hWnd,uMsg,wParam,lParam) != 0; + } + return doDefault; + } + // also handle tab key by calling GetNextDlgTabItem + } + static this() { + if (DefaultWindowIcon is null) { + IconPeer ip = LoadIconA(cast(HINSTANCE) null, IDI_APPLICATION); + DefaultWindowIcon = DefaultWindowSmallIcon = new Icon(ip); + } + HINSTANCE hInst = GetModuleHandleA(null); + WNDCLASSA wc; + wc.lpszClassName = "MinWinDialog"; + wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW; + wc.lpfnWndProc = &MinWinWindowProc; + wc.hInstance = hInst; + wc.hIcon = DefaultWindowIcon.peer; + wc.hCursor = LoadCursorA(cast(HINSTANCE) null, IDC_ARROW); + wc.hbrBackground = null; + // wc.hbrBackground = cast(HBRUSH) (COLOR_WINDOW); // not +1 for default + wc.lpszMenuName = null; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + RegisterClassA(&wc); + } + +} else version (GTK) { + + private import minwin.gtk; + private import minwin.gtk_peers; + + class Dialog : AbstractWindow { + AbstractWindow owner; + + this(AbstractWindow owner, char[] title = "", bool modal = true, char[] name = "") { + char* str = toStringz(title); + this.owner = owner; + // TODO: application name vs window name?? + peer = cast(GtkWindow*)gtk_window_new(GtkWindowType.GTK_WINDOW_TOPLEVEL); + if (modal) { + gtk_window_set_modal(peer,modal); + gtk_window_set_transient_for(peer,owner.peer); + } + gtk_window_set_title(peer,str); + gtk_window_set_resizable(peer,0); + gtk_window_set_default_size(peer,DefaultWindowWidth,DefaultWindowHeight); + this.name = name; + g_signal_connect_data(peer,"destroy", + cast(GCallback)&mw_destroy_callback, + cast(gpointer)this, + null,cast(GConnectFlags)0); + g_signal_connect_data(peer,"delete-event", + cast(GCallback)&mw_dialog_close_callback, + cast(gpointer)this, + null,cast(GConnectFlags)0); + setWindowPeer(this,peer,OWNS_PEER); + WindowList[this] = this; // prevent garbage collection + + content = cast(MinWinGtkPeer*)MinWinGtkPeer_new(); + GtkWidget* wcontent = cast(GtkWidget*)content; + gtk_widget_set_sensitive(wcontent,true); + content.sizeRequest = >kRequest; + content.sizeAllocate = >kAllocate; + gtk_container_add(cast(GtkContainer*)peer,wcontent); + g_signal_connect_data(peer,"expose-event", + cast(GCallback)&mw_expose_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + gtk_widget_realize(wcontent); + gtk_widget_show(wcontent); + } + + this(AbstractWindow owner, WindowPeer peer) { + setWindowPeer(this,peer,FOREIGN_PEER); + this.owner = owner; + WindowList[this] = this; // prevent garbage collection + } + + GMainLoop* loop; + + void visible(bool vis) { + version(LOG)log.writefln("calling super.visible %d",vis); + version(LOG)log.flush(); + super.visible(vis); + version(LOG)log.writefln("done calling super.visible %d",vis); + version(LOG)log.flush(); + if (!gtk_window_get_modal(peer)) return; + if (vis) { + version(LOG)log.writefln("making event loop"); + version(LOG)log.flush(); + loop = g_main_loop_new(null, false); + g_main_loop_run(loop); + g_main_loop_unref(loop); + version(LOG)log.writefln("exiting event loop"); + version(LOG)log.flush(); + // that's it? + } else { + if (g_main_loop_is_running(loop)) + g_main_loop_quit(loop); + version(LOG)log.writefln("visible off quit loop event loop"); + version(LOG)log.flush(); + } + } + } + extern (C) void mw_dialog_close_callback(GtkWidget* w, GdkEvent* ev, gpointer ud) { + AbstractWindow win = cast(AbstractWindow) ud; + version(LOG)log.printf("mw_dialog_close_callback\n"); + if (win) { + win.visible = false; + // win.close(); // destroys dialog so dont do this + } + } +} + + +/*************************************** + Helper dialogs +***************************************/ + +// used in open and save file dialogs for filtering +struct FileFilter { + char[] description; + char[][] extensions; +} +version (GTK) { + version = SharedFileDialogData; +} + +version (SharedFileDialogData) { + struct FileDialogData { + char[] title; + FileFilter[] filter; + char[] initialDir; + char[] initialFile; + char[] result; + int filterIndex; + int done; + + // can get the requested buffer length... + bool isBufferTooShort() { + return false; // TODO + } + } +} + +version (MinWin32) { + private { + import minwin.mswindows; + import std.c.stdlib; + } + + void informationDialog(AbstractWindow owner, char[] text, char[] title) { + //version(LOG) log.writefln("info dialog peer is %x",cast(uint)owner.peer); + MessageBoxX(owner.peer, text, title, MB_OK | MB_ICONINFORMATION); + } + void warningDialog(AbstractWindow owner, char[] text, char[] title) { + MessageBoxX(owner.peer, text, title, MB_OK | MB_ICONWARNING); + } + void errorDialog(AbstractWindow owner, char[] text, char[] title) { + MessageBoxX(owner.peer, text, title, MB_OK | MB_ICONERROR); + } + void messageDialog(AbstractWindow owner, char[] text, char[] title,...) { + MessageBoxX(owner.peer, text, title, MB_OK | MB_ICONINFORMATION); + } + + alias OPENFILENAMEA FileDialogNative; + struct FileDialogData { + FileDialogNative native; + + void title(char[] title) { + native.lpstrTitle = toStringz(title); + } + char[] title() { + return native.lpstrTitle[0 .. strlen(native.lpstrTitle)]; + } + + void filter(FileFilter[] filters) { + char[] total; + foreach (FileFilter f; filters) { + total ~= f.description; + total ~= 0; + if (f.extensions.length > 0) { + foreach (char[] ext; f.extensions) { + total ~= "*."; + total ~= ext; + total ~= ";"; + } + total.length = total.length - 1; // remove last ; + } + total ~= 0; + } + total ~= 0; + total ~= 0; + native.lpstrFilter = total.ptr; + } + + void initialDir(char[] initialDir) { + native.lpstrInitialDir = toStringz(initialDir); + } + + void initialFile(char[] f) { + if (native.lpstrFile is null) { + native.lpstrFile = (new char[MAX_PATH]).ptr; + native.nMaxFile = MAX_PATH; + } + int len = f.length < native.nMaxFile-1 ? f.length : native.nMaxFile-1; + native.lpstrFile[0 .. len] = f[0 .. len]; + native.lpstrFile[len] = 0; + } + + char[] result() { + return native.lpstrFile[0 .. strlen(native.lpstrFile)]; + } + + // can get the requested buffer length... + bool isBufferTooShort() { + // bool res = CommDlgExtendedError() == FNERR_BUFFERTOOSMALL; + return false; + } + + int filterIndex() { + return native.nFilterIndex; + } + + } + + bool openFileDialog(AbstractWindow owner, inout FileDialogData data) { + data.native.hwndOwner = owner.peer; + data.native.lStructSize = OPENFILENAMEA.sizeof; + // data.flags = OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST; + data.native.Flags = OFN_PATHMUSTEXIST; + if (data.native.lpstrFile is null) { + data.native.lpstrFile = (new char[MAX_PATH]).ptr; + data.native.nMaxFile = MAX_PATH; + data.native.lpstrFile[0] = 0; + } + bool res = GetOpenFileNameA(&data.native) != 0; + /* if (!res) + check if the name was too long for the buffer + */ + return res; + } + + bool saveFileDialog(AbstractWindow owner, inout FileDialogData data) { + data.native.hwndOwner = owner.peer; + data.native.lStructSize = OPENFILENAMEA.sizeof; + data.native.Flags = OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST; + if (data.native.lpstrFile is null) { + data.native.lpstrFile = (new char[MAX_PATH]).ptr; + data.native.nMaxFile = MAX_PATH; + data.native.lpstrFile[0] = 0; + } + bool res = GetSaveFileNameA(&data.native) != 0; + /* if (!res) + check if the name was too long for the buffer + */ + return res; + } + +} else version(GTK) { + + private import minwin.gtk; + private import minwin.window; + + void informationDialog(AbstractWindow owner, char* text, char[] +title) { + msgDialog(owner,text,title,GtkMessageType.GTK_MESSAGE_INFO, + GtkButtonsType.GTK_BUTTONS_OK); + } + void warningDialog(AbstractWindow owner, char* text, char[] title) { + msgDialog(owner,text,title,GtkMessageType.GTK_MESSAGE_WARNING, + GtkButtonsType.GTK_BUTTONS_OK); + } + void errorDialog(AbstractWindow owner, char* text, char[] title) { + msgDialog(owner,text,title,GtkMessageType.GTK_MESSAGE_ERROR, + GtkButtonsType.GTK_BUTTONS_OK); + } + alias informationDialog messageDialog; + void msgDialog(AbstractWindow owner, char* text, char[] title, + GtkMessageType type, GtkButtonsType buttons) { + // TODO: title? + GtkWidget* d = gtk_message_dialog_new(owner.peer, + GtkDialogFlags.GTK_DIALOG_DESTROY_WITH_PARENT, + type,buttons,text); + gtk_dialog_run(cast(GtkDialog*)d); + gtk_widget_destroy(d); + } + + bool openFileDialog(AbstractWindow owner, inout FileDialogData data) { + bool result; + GtkWidget* peer = + gtk_file_chooser_dialog_new(toStringz(data.title),owner.peer, + GtkFileChooserAction.GTK_FILE_CHOOSER_ACTION_OPEN, + cast(char*)"gtk-cancel", cast(uint)GtkResponseType.GTK_RESPONSE_CANCEL, + cast(char*)"gtk-open", cast(uint)GtkResponseType.GTK_RESPONSE_ACCEPT, + null); + GtkFileChooser* fc = cast(GtkFileChooser*)peer; + return opensaveFileDialog(data,peer,fc); + } + + bool saveFileDialog(AbstractWindow owner, inout FileDialogData data) { + GtkWidget* peer = + gtk_file_chooser_dialog_new(toStringz(data.title),owner.peer, + GtkFileChooserAction.GTK_FILE_CHOOSER_ACTION_SAVE, + cast(char*)"gtk-cancel", cast(uint)GtkResponseType.GTK_RESPONSE_CANCEL, + cast(char*)"gtk-save", cast(uint)GtkResponseType.GTK_RESPONSE_ACCEPT, + null); + GtkFileChooser* fc = cast(GtkFileChooser*)peer; + if (data.initialFile.length > 0) + gtk_file_chooser_set_current_name(fc,toStringz(data.initialFile)); + return opensaveFileDialog(data,peer,fc); + } + bool opensaveFileDialog(inout FileDialogData data, + GtkWidget* peer, + GtkFileChooser* fc) { + bool result; + if (data.initialDir.length > 0) + gtk_file_chooser_set_current_folder(fc,toStringz(data.initialDir)); + foreach( FileFilter filt ; data.filter) { + GtkFileFilter* f = gtk_file_filter_new(); + gtk_file_filter_set_name(f,toStringz(filt.description)); + foreach( char[] ext; filt.extensions) { + gtk_file_filter_add_pattern(f,cast(char*)("*."~ext)); + } + gtk_file_chooser_add_filter(fc,f); + } + // TODO: assertion local_full_path[0] = / + result = gtk_dialog_run(cast(GtkDialog*)peer) == GtkResponseType.GTK_RESPONSE_ACCEPT; + if (result) { + char* name = gtk_file_chooser_get_filename(fc); + int len = strlen(name); + data.result = name[0..len].dup; + g_free(name); + } + gtk_widget_destroy(peer); + return result; + } +} + +// utility dialogs: +// query dialog +// file chooser dialog + +// color chooser? +// print dialog? + + diff --git a/samples/minwin_gtk/minwin/event.d b/samples/minwin_gtk/minwin/event.d new file mode 100644 index 0000000..7bb4d5f --- /dev/null +++ b/samples/minwin_gtk/minwin/event.d @@ -0,0 +1,219 @@ +/* MinWin Event classes + * + * Various event classes for key, mouse, focus events, etc + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.event; + +private import minwin.geometry; + +enum Modifier { + Shift = 1, + Alt = 2, + Ctrl = 4, + Command = 8, + Meta = 16 +} + +version (MinWin32) { + private import minwin.mswindows; + + alias MSG EventNative; + + template EventBaseImpl() { + int modifiers() { + int mod = 0; + if ((GetKeyState(VK_LSHIFT) | GetKeyState(VK_RSHIFT)) & 0x8000) + mod |= Modifier.Shift; + if ((GetKeyState(VK_LCONTROL) | GetKeyState(VK_RCONTROL)) & 0x8000) + mod |= Modifier.Ctrl; + if ((GetKeyState(VK_LMENU) | GetKeyState(VK_RMENU)) & 0x8000) + mod |= Modifier.Alt; + return mod; + } + + int id() { return native.message; } + } + + struct Event { + EventNative native; + mixin EventBaseImpl!(); + } + + Event toEvent(EventNative nat) { + Event res; + res.native = nat; + return res; + } + + alias MSG KeyEventNative; + struct KeyEvent { + KeyEventNative native; + // UTF-32 character typed + dchar keyChar() { return cast(dchar)native.wParam; } + // key code + int keyCode() { return native.wParam; } + int keyRepeat() { return native.lParam & 0x0F; } + mixin EventBaseImpl!(); + } + alias WM_CHAR KeyPressedEvent; + alias WM_KEYDOWN KeyDownEvent; + alias WM_KEYUP KeyUpEvent; + + + alias WM_MOUSEMOVE MouseMoveEvent; + alias WM_LBUTTONDOWN MouseDownEvent; + alias WM_LBUTTONUP MouseUpEvent; + alias WM_RBUTTONDOWN MouseAlt1DownEvent; + alias WM_RBUTTONUP MouseAlt1UpEvent; + alias WM_MBUTTONDOWN MouseAlt2DownEvent; + alias WM_MBUTTONUP MouseAlt2UpEvent; + + alias MSG MouseEventNative; + struct MouseEvent { + MouseEventNative native; + Point point() { + return XY(LOWORD(native.lParam),HIWORD(native.lParam)); + } + mixin EventBaseImpl!(); + } + + // alias WM_ACTIVATE WindowActivateEvent; + // also focus event, destory event + alias WM_SIZE WindowSizeEvent; + alias WM_SIZING WindowSizingEvent; + alias WM_MOVE WindowMoveEvent; + alias WM_MOVING WindowMovingEvent; + + alias MSG WindowEventNative; + struct WindowEvent { + WindowEventNative native; + mixin EventBaseImpl!(); + } + + // TODO: add event filter api + + bool nextEvent(Event* event) { + return GetMessageA(&event.native,cast(HWND)null,0,0) != 0; + } + + bool peekEvent(Event* event) { + return PeekMessageA(&event.native,cast(HWND)null,0,0,PM_REMOVE) != 0; + } + + void dispatchEvent(Event* event) { + TranslateMessage(&event.native); + DispatchMessageA(&event.native); + } + + // alias void* KeyEventPeer; + // alias void* MouseEventPeer; + // alias void* MotionEventPeer; +} else version (GTK) { + + private import minwin.gtk; + + alias GdkEvent EventNative; + + template EventBaseImpl() { + int modifiers() { + int mod; + int state; + if (native.type == GdkEventType.GDK_KEY_PRESS || native.type == GdkEventType.GDK_KEY_RELEASE) { + GdkEventKey* ke = cast(GdkEventKey*)(&native); + state = ke.state; + } else { + // return event.message; + } + return mod; + } + + GdkEventType id() { return native.type; } + } + + struct Event { + EventNative native; + mixin EventBaseImpl!(); + } + + Event toEvent(EventNative nat) { + Event res; + res.native = nat; + return res; + } + + alias GdkEventType.GDK_KEY_PRESS KeyPressedEvent; + alias GdkEventType.GDK_KEY_PRESS KeyDownEvent; + alias GdkEventType.GDK_KEY_RELEASE KeyUpEvent; + + alias GdkEventKey KeyEventNative; + struct KeyEvent { + KeyEventNative native; + // UTF-32 character typed + dchar keyChar() { return cast(dchar)native.keyval; } + + // key code + int keyCode() { return native.keyval; } + + int keyRepeat() { return 0; } + mixin EventBaseImpl!(); + } + + + alias GdkEventType.GDK_MOTION_NOTIFY MouseMoveEvent; + alias GdkEventType.GDK_BUTTON_PRESS MouseDownEvent; + alias GdkEventType.GDK_BUTTON_RELEASE MouseUpEvent; + alias GdkEventType.GDK_2BUTTON_PRESS MouseAlt1DownEvent; + alias GdkEventType.GDK_BUTTON_RELEASE MouseAlt1UpEvent; + alias GdkEventType.GDK_3BUTTON_PRESS MouseAlt2DownEvent; + alias GdkEventType.GDK_BUTTON_RELEASE MouseAlt2UpEvent; + + alias GdkEventButton MouseEventNative; + alias GdkEventButton MotionEventNative; + struct MouseEvent { + MouseEventNative native; + Point point() { + return XY(cast(int)native.x,cast(int)native.y); + } + mixin EventBaseImpl!(); + } + + // alias WM_ACTIVATE WindowActivateEvent; + alias GdkEventType.GDK_CONFIGURE WindowSizeEvent; + alias GdkEventType.GDK_CONFIGURE WindowSizingEvent; + alias GdkEventType.GDK_CONFIGURE WindowMoveEvent; + alias GdkEventType.GDK_CONFIGURE WindowMovingEvent; + + alias GdkEventConfigure WindowEventNative; + struct WindowEvent { + WindowEventNative native; + mixin EventBaseImpl!(); + } + + // TODO: add event filter api + + bool nextEvent(Event* event) { + assert(false); + while (gtk_events_pending() == 0) {} // busy wait - icky + peekEvent(event); + return true; // how does one check if a Quit is pending? + } + + bool peekEvent(Event* event) { + Event* e = cast(Event*)gdk_event_get(); + if (e) { + *event = *e; + gdk_event_free(cast(GdkEvent*)e); + } + return e !is null; + } + + void dispatchEvent(Event* event) { + gtk_main_do_event(&event.native); + } + +} diff --git a/samples/minwin_gtk/minwin/font.d b/samples/minwin_gtk/minwin/font.d new file mode 100644 index 0000000..bcbacae --- /dev/null +++ b/samples/minwin_gtk/minwin/font.d @@ -0,0 +1,192 @@ +/* MinWin Font class + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.font; + +private { + import minwin.app; + import minwin.component; + import minwin.peerimpl; + import std.string; + import std.c.string; +} + +enum FontWeight { + Any = 0, + Thin = 100, + ExtraLight = 200, + Light = 300, + Normal = 400, + Medium = 500, + SemiBold = 600, + Bold = 700, + ExtraBold = 800, + Heavy = 900 +} + +enum StandardFont { + Gui, Fixed, Variable +} + +version (GTK) version = GenericFontDataStruct; +version (GenericFontDataStruct) { + struct FontData { + int size; + FontWeight weight; + bool italic; + char[] name; + } +} + +version (MinWin32) { + private import minwin.mswindows; + + alias HFONT FontPeer; + + alias LOGFONTA FontDataNative; + struct FontData { + FontDataNative native; + void size(int size) { native.lfHeight = size; } + int size() { return native.lfHeight; } + void weight(FontWeight w) { native.lfWeight = w; } + FontWeight weight() { return cast(FontWeight)native.lfWeight; } + void italic(bool i) { native.lfItalic = i; } + bool italic() { return native.lfItalic != 0; } + char[] name() { + char* s = native.lfFaceName.ptr; + return s[0..strlen(s)]; + } + void name(char[] n) { + native.lfFaceName[0 .. n.length] = n[]; + } + } + + + alias TEXTMETRICA FontMetricsNative; + struct FontMetrics { + FontMetricsNative native; + int size() { return native.tmHeight; } + int ascent() { return native.tmAscent; } + int descent() { return native.tmDescent; } + int leading() { return native.tmExternalLeading; } + int maxWidth() { return native.tmMaxCharWidth; } + } + + class Font { + FontPeer peer; + + this(inout FontData d) { + d.native.lfCharSet = DEFAULT_CHARSET; + peer = CreateFontIndirectA(&d.native); + sysAssert(peer !is null, "Failed to create peer Font"); + hasPeer = OWNS_PEER; + } + + // mixin CommonFontCtor!(); + this(FontPeer p) { + peer = p; + hasPeer = FOREIGN_PEER; + } + + this(char[] name, int size = 0, FontWeight weight = FontWeight.Normal) { + FontData fd; + if (size > 0) + fd.size = size; + if (weight > 0) + fd.weight = weight; + if (name.length > 0) + fd.name = name; + this(fd); + } + + mixin SimplePeerMixin!(); + + } + + Font standardFont(StandardFont id) { + static Font[5] fonts; + if (fonts[0] is null && id == StandardFont.Gui) { + fonts[0] = new Font(GetStockObject(DEFAULT_GUI_FONT)); + } else if (fonts[1] is null && id == StandardFont.Fixed) { + fonts[1] = new Font(GetStockObject(ANSI_FIXED_FONT)); + } else if (fonts[2] is null && id == StandardFont.Variable) { + fonts[2] = new Font(GetStockObject(ANSI_VAR_FONT)); + } + return fonts[id]; + } + +} else version (GTK) { + + private import minwin.app; + private import minwin.gtk; + private import std.string; + + alias PangoFontDescription* FontPeer; + + struct FontMetrics { + int size; + int ascent; + int descent; + int leading; + int maxWidth; + } + + class Font { + FontPeer peer; + + this(inout FontData d) { + peer = pango_font_description_new(); + if (d.name.length > 0) + pango_font_description_set_family(peer,toStringz(d.name)); + if (d.size > 0) + pango_font_description_set_size(peer,d.size*PANGO_SCALE); + if (d.weight > 0) + pango_font_description_set_weight(peer,cast(PangoWeight)d.weight); + hasPeer = OWNS_PEER; + } + + // mixin CommonFontCtor!(); + this(FontPeer p) { + peer = p; + hasPeer = FOREIGN_PEER; + } + + this(char[] name, int size = 0, FontWeight weight = FontWeight.Normal) { + FontData fd; + if (size > 0) + fd.size = size; + if (weight > 0) + fd.weight = weight; + if (name.length > 0) + fd.name = name; + this(fd); + } + + mixin PeerMixin!(); + void dispose() { disposePeer(); } + void disposePeer() { + if (hasPeer == OWNS_PEER) + pango_font_description_free(peer); + hasPeer = NO_PEER; + } + } + + // TODO: what are the standard GTK fonts?? + Font standardFont(StandardFont id) { + static Font[5] fonts; + FontData d; + if (fonts[0] is null && id == StandardFont.Gui) { + fonts[0] = new Font("variable"); + } else if (fonts[1] is null && id == StandardFont.Fixed) { + fonts[1] = new Font("fixed"); + } else if (fonts[2] is null && id == StandardFont.Variable) { + fonts[2] = new Font("variable"); + } + return fonts[id]; + } + +} diff --git a/samples/minwin_gtk/minwin/geometry.d b/samples/minwin_gtk/minwin/geometry.d new file mode 100644 index 0000000..ea622e7 --- /dev/null +++ b/samples/minwin_gtk/minwin/geometry.d @@ -0,0 +1,521 @@ +/* MinWin geometry types + * + * Defines Point, Rect, Region and Color and associated functions. + * These are structs with a single field called "native" that stores + * the native type or, in the case of color on Unix system, an + * int with the RGB triple. A Region is a class wrapping a system + * region resource. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.geometry; + +private { + import minwin.peer; + import minwin.app; + import minwin.logging; + import std.string; +} + +enum FillRule { + EvenOdd, Winding +} + +template CommonPointImpl() { + PointNative native; + void x(int v) { native.x = v; } + int x() { return native.x; } + void y(int v) { native.y = v; } + int y() { return native.y; } + void XY(int x, int y) { + native.x = x; + native.y = y; + } + Point opAdd(Point b) { + Point res; + res.x = x+b.x; + res.y = y+b.y; + return res; + } + Point opSub(Point b) { + Point res; + res.x = x-b.x; + res.y = y-b.y; + return res; + } + char[] toString() { + return format("[Point x:%.3d y:%.3d]",x(),y()); + } +} + +template CommonRectImpl() { + RectNative native; + void translate(Point p) { + left = left + p.x; + top = top + p.y; + right = right + p.x; + bottom = bottom + p.y; + } + char[] toString() { + return format("[Rect l:%.3d t:%.3d w:%.3d h:%.3d]",left(),top(),width(),height()); + } + bool contains(Point p) { + return (p.x >= left) && (p.x <= right) && (p.y >= top) && (p.y <= bottom); + } +} + +template CommonColorImpl() { + ColorNative native; + char[] toString() { + return format("[Color r:%.3d g:%.3d b:%.3d]",red,green,blue); + } + +} + +version(GTK) + version = WidthHeightRect; + +version(WidthHeightRect) { + template WidthHeightRectImpl() { + void LTWH(int left, int top, int width, int height) { + native.x = left; + native.y = top; + native.width = width; + native.height = height; + } + void LTRB(int left, int top, int right, int bottom) { + native.x = left; + native.y = top; + native.width = right-left; + native.height = bottom-top; + } + int left() { return native.x; } + int top() { return native.y; } + int right() { return native.x + native.width; } + int bottom() { return native.y + native.height; } + int width() { return native.width; } + int height() { return native.height; } + void left(int v) { native.x = v; } + void top(int v) { native.y = v; } + void right(int v) { native.width = v - native.x; } + void bottom(int v) { native.height = v - native.y; } + void width(int v) { native.width = v; } + void height(int v) { native.height = v; } + } +} +version(GTK) + version = CommonUnixColor; + +// should check x display? RGB masks says red FF0000, blue FF +version(CommonUnixColor) { + alias uint ColorNative; + struct Color { + ColorNative native; + void RGB(ubyte r, ubyte g, ubyte b) { + native = ((cast(uint)r)<<16) | ((cast(uint)g)<<8) | (cast(uint)b); + } + ubyte red(){ return cast(ubyte)((native & 0x0FF0000)>>16); } + ubyte green(){ return cast(ubyte)((native & 0x0FF00)>>8); } + ubyte blue(){ return cast(ubyte)(native & 0x0FF); } + void red(ubyte r) { native |= ((cast(uint)r)<<16);} + void green(ubyte g) { native |= ((cast(uint)g)<<8);} + void blue(ubyte b) { native |= b; } + package static int rescale(int v, int s1, int s2) { + double x = 1.0*s2/s1; + return cast(int)(x*v); + } + } +} + +version (MinWin32) { + private import minwin.mswindows; + private import std.c.stdlib; + + alias POINT PointNative; + struct Point { + mixin CommonPointImpl!(); + } + + alias RECT RectNative; + struct Rect { + mixin CommonRectImpl!(); + void LTWH(int left, int top, int width, int height) { + native.left = left; + native.top = top; + native.right = left+width; + native.bottom = top+height; + } + void LTRB(int left, int top, int right, int bottom) { + native.left = left; + native.top = top; + native.right = right; + native.bottom = bottom; + } + int left() { return native.left; } + int top() { return native.top; } + int right() { return native.right; } + int bottom() { return native.bottom; } + int width() { return native.right - native.left; } + int height() { return native.bottom - native.top; } + void left(int v) { native.left = v; } + void top(int v) { native.top = v; } + void right(int v) { native.right = v; } + void bottom(int v) { native.bottom = v; } + void width(int v) { native.right = native.left + v; } + void height(int v) { native.bottom = native.top + v; } + } + + alias COLORREF ColorNative; + struct Color { + mixin CommonColorImpl!(); + void RGB(ubyte r, ubyte g, ubyte b) { + native = std.c.windows.windows.RGB(r,g,b); + } + ubyte red(){ return cast(ubyte)(native & 0x0FF); } + ubyte green(){ return cast(ubyte)((native & 0x0FF00)>>8); } + ubyte blue(){ return cast(ubyte)((native & 0x0FF0000)>>16); } + void red(ubyte r) { native |= r; } + void green(ubyte g) { native |= ((cast(uint)g)<<8);} + void blue(ubyte b) { native |= ((cast(uint)b)<<16);} + } + + Color systemBackgroundColor() { + return toColor(GetSysColor(COLOR_MENU)); + } + + alias HRGN RegionPeer; + class Region { + RegionPeer peer; + mixin SimplePeerMixin!(); + + this(inout Rect r) { + peer = CreateRectRgnIndirect(&r.native); + sysAssert(peer !is null, "Failed to create peer Region"); + hasPeer = OWNS_PEER; + } + this(Point[] pts, FillRule rule = FillRule.Winding) { + peer = CreatePolygonRgn(cast(POINT*)pts.ptr, pts.length, rule); + sysAssert(peer !is null, "Failed to create peer polygon Region"); + hasPeer = OWNS_PEER; + } + + this(RegionPeer rgn) { + peer = rgn; + hasPeer = FOREIGN_PEER; + } + int opEquals(Object o) { + Region r = cast(Region)o; + return r && EqualRgn(peer,r.peer); + } + Region unionRgn(Region r) { + int ok = CombineRgn(peer,peer,r.peer,RGN_OR); + sysAssert(ok != false, "Failed to combine regions",0); + return this; + } + Region unionRect(inout Rect r) { + Region rectRgn = new Region(r); + int ok = CombineRgn(peer,peer,rectRgn.peer,RGN_OR); + sysAssert(ok != false, "Failed to union regions",0); + return this; + } + Region intersectRgn(Region r) { + int ok = CombineRgn(peer,peer,r.peer,RGN_AND); + sysAssert(ok != false, "Failed to intersect regions",0); + return this; + } + bool contains(Point p) { + return PtInRegion(peer,p.x,p.y) != 0; + } + Region dup() { + RGNDATA* data; + DWORD siz = GetRegionData(peer,0,null); + sysAssert(siz != 0, "Failed to get region data size",0); + data = cast(RGNDATA*)malloc(RGNDATAHEADER.sizeof+siz); + sysAssert(data !is null, "Failed to malloc region data",0); + Region r; + try { + siz = GetRegionData(peer,siz,data); + sysAssert(siz != 0, "Failed to get region data",0); + HRGN p = ExtCreateRegion(null,siz,data); + sysAssert(p !is null, "Failed to duplicate region",0); + r = new Region(p); + } finally { + free(data); + } + return r; + } + } + +} else version (GTK) { + + private import minwin.gtk; + + alias GdkPoint PointNative; + struct Point { + mixin CommonPointImpl!(); + } + alias GdkRectangle RectNative; + struct Rect { + mixin CommonRectImpl!(); + mixin WidthHeightRectImpl!(); + } + + GdkColor* toNativeColor(Color c) { + GdkColor* r = new GdkColor; + r.red = Color.rescale(c.red,ubyte.max,ushort.max); + r.green = Color.rescale(c.green,ubyte.max,ushort.max); + r.blue = Color.rescale(c.blue,ubyte.max,ushort.max); + version(LOG)log.writefln("rescaled color %x %x %x to %x %x %x", + cast(int)c.red,cast(int)c.green,cast(int)c.blue, + cast(int)r.red,cast(int)r.green,cast(int)r.blue); + return r; + } + + Color systemBackgroundColor() { + GtkStyle* style = gtk_widget_get_default_style(); + GdkColor* c = &style.bg[GtkStateType.GTK_STATE_NORMAL]; + ubyte r = Color.rescale(c.red,ushort.max,ubyte.max); + ubyte g = Color.rescale(c.green,ushort.max,ubyte.max); + ubyte b = Color.rescale(c.blue,ushort.max,ubyte.max); + Color c2; + c2.RGB(r,g,b); + return c2; + } + + alias GdkRegion* RegionPeer; + + class Region { + RegionPeer peer; + + mixin PeerMixin!(); + void dispose() { disposePeer(); } + void disposePeer() { + if (hasPeer == OWNS_PEER) { + gdk_region_destroy(peer); + } + hasPeer = NO_PEER; + } + + this(inout Rect r) { + peer = gdk_region_new(); + gdk_region_union_with_rect(peer,&r.native); + hasPeer = OWNS_PEER; + } + + this(Point[] pts, FillRule rule = FillRule.Winding) { + peer = gdk_region_polygon(cast(GdkPoint*)pts.ptr, pts.length, + cast(GdkFillRule)rule); + hasPeer = OWNS_PEER; + } + + this(RegionPeer rgn) { + peer = rgn; + hasPeer = FOREIGN_PEER; + } + + int opEquals(Object o) { + Region r = cast(Region)o; + return r && gdk_region_equal(peer,r.peer); + } + Region unionRgn(Region r) { + gdk_region_union(peer,r.peer); + return this; + } + Region unionRect(inout Rect r) { + gdk_region_union_with_rect(peer,&r.native); + return this; + } + Region intersectRgn(Region r) { + gdk_region_intersect(peer,r.peer); + return this; + } + bool contains(Point p) { + return gdk_region_point_in(peer,p.x,p.y) != 0; + } + Region dup() { + GdkRegion* r = gdk_region_new(); + gdk_region_union(r,peer); + Region mwr = new Region(r); + mwr.hasPeer = OWNS_PEER; + return mwr; + } + } +} + +Point toPoint(PointNative nat) { + Point r; + r.native = nat; + return r; +} +Point XY(int x, int y) { + Point p; + p.XY(x,y); + return p; +} + +Rect toRect(RectNative nat) { + Rect r; + r.native = nat; + return r; +} + +Rect LTWH(int left, int top, int width, int height) { + Rect r; + r.LTWH(left,top,width,height); + return r; +} + +Rect LTRB(int left, int top, int right, int bottom) { + Rect r; + r.LTRB(left,top,right,bottom); + return r; +} + +Color toColor(ColorNative nat) { + Color r; + r.native = nat; + return r; +} +Color RGB(ubyte r, ubyte g, ubyte b) { + Color res; + res.RGB(r,g,b); + return res; +} + + +private { + final int max(int a,int b){ return a>b?a:b; } + final int min(int a,int b){ return ar || t>b) { + res.LTRB(0,0,0,0); + } else { + res.LTRB(l,t,r,b); + } +} +void unionRect(inout Rect res, inout Rect r1, inout Rect r2) { + int l,t,r,b; + l = min(r1.left,r2.left); + t = min(r1.top,r2.top); + r = max(r1.right,r2.right); + b = max(r1.bottom,r2.bottom); + res.LTRB(l,t,r,b); +} +void offsetRect(inout Rect res, int x, int y) { + res.LTWH(res.left+x,res.top+y,res.width,res.height); +} + +// Region unittests +unittest { + Rect r = LTWH(10,10,100,100); + Region rgn = new Region(r); + assert(rgn.contains(XY(50,50))); + assert(!rgn.contains(XY(0,50))); + + Rect r2 = LTWH(-10,10,40,60); + rgn.unionRect(r2); + assert(rgn.contains(XY(0,50))); + + Region rgn2 = rgn.dup; + assert(rgn == rgn2); + assert(rgn !is rgn2); + + Point[] x; + x.length = 5; + x[0].XY(0,-10); + x[1].XY(100,100); + x[2].XY(0,200); + x[3].XY(-100,100); + x[4].XY(0,-10); + rgn2.intersectRgn(new Region(x)); + assert(rgn2.contains(XY(0,50))); +} + +// Color unittests +unittest { + Color c = RGB(30,40,60); + assert(c.red == 30); + assert(c.green == 40); + assert(c.blue == 60); +} + +// Rect unittests +unittest { + Rect r1 = LTWH(10,20,100,200); + assert(r1.left == 10); + assert(r1.top == 20); + assert(r1.width == 100); + assert(r1.height == 200); + assert(r1.right == 110); + assert(r1.bottom == 220); + r1.LTWH(-10,-20,10,20); + assert(r1.right == 0); + assert(r1.bottom == 0); + r1.LTRB(-10,-20,10,20); + assert(r1.right == 10); + assert(r1.bottom == 20); + assert(r1.width == 20); + assert(r1.height == 40); + Rect r5; + r5.left = -10; + r5.top = -20; + r5.width = 30; + r5.height = 50; + assert(r5.left == -10); + assert(r5.top == -20); + assert(r5.right == 20); + assert(r5.bottom == 30); + + Rect r2 = LTRB(-10,-20,10,20); + assert(r1 == r2); + + Rect r3; + r2.LTWH(0,5,20,20); + intersectRect(r3,r1,r2); + assert(r3 == LTRB(0,5,10,20)); + Rect r4 = LTWH(-100,-100,300,300); + intersectRect(r3,r1,r4); + assert(r3 == r1); + intersectRect(r3,r4,r1); + assert(r3 == r1); + + r4.LTWH(0,0,100,10); + unionRect(r3,r4,r1); + assert(r3 == LTRB(-10,-20,100,20)); + + offsetRect(r4,10,20); + assert(r4 == LTWH(10,20,100,10)); +} + +// Point unittests +unittest { + Point p = XY(100,200); + assert(p.x == 100); + assert(p.y == 200); + p.XY(300,-400); + assert(p.x == 300); + assert(p.y == -400); + // try platform-specific properties that happen to work + assert(p.native.x == 300); + assert(p.native.y == -400); + + assert(p == XY(300,-400)); + + Rect r = LTWH(10,20,300,400); + assert(r.contains(XY(200,300))); + assert(r.contains(XY(10,200))); + assert(r.contains(XY(10,420))); + assert(!r.contains(XY(0,200))); + assert(!r.contains(XY(200,1000))); +} + diff --git a/samples/minwin_gtk/minwin/group.d b/samples/minwin_gtk/minwin/group.d new file mode 100644 index 0000000..ec72eac --- /dev/null +++ b/samples/minwin_gtk/minwin/group.d @@ -0,0 +1,265 @@ +/* MinWin Group class + * + * A Group is a lightweight component (meaning it has + * no peer) that contains and lays out other components. + * + * A GroupBox is a potentially heavyweight component that + * puts a box and label around other components. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.group; + +private { + import minwin.component; + import minwin.window; + import minwin.peerimpl; + import minwin.logging; + import std.string; +} + +// lightweight group of other children - no peer +class Group : Component { + Rect bounds; + this(Component parent, char[] name = "") { + hasPeer = NO_PEER; + this.name = name; + if (parent) + parent.addChild(this); + } + void disposePeer(){} + PeerForAdd getPeerForAdd() { + return parent.getPeerForAdd(); + } + void getPeerOffset(inout int x, inout int y) { + int px, py; + if (parent) + parent.getPeerOffset(px,py); + x = bounds.left+px; + y = bounds.top+py; + } + void getBounds(inout Rect r) { + r = bounds; + } + void setBounds(inout Rect r) { + bounds = r; + version(LOG) log.writefln("setting group bounds to %d %d %d %d", + r.left,r.top,r.width,r.height); + childLayoutDirty = true; + repaint(); + } + void size(Point s) { + bounds.LTWH(bounds.left,bounds.top,s.x,s.y); + childLayoutDirty = true; + repaint(); + } + void visible(bool vis) { + foreach(Component ch; this) { + ch.visible = vis; + } + childLayoutDirty = true; + layout(false); + } + bool visible() { + bool vis = false; + foreach(Component ch; this) { + vis = vis || ch.visible(); + } + return vis; + } + void enabled(bool b) { + foreach(Component ch; this) { + ch.enabled = b; + } + } + bool enabled() { + bool b = false; + foreach(Component ch; this) { + b = b || ch.enabled; + } + return b; + } +} +private import minwin.layout; +unittest { + Group g = new Group(null); + g.layoutMgr = new FlowLayout; + Group g2 = new Group(g); + g2.layoutMgr = new FlowLayout; + g2.userPreferredSize(40,50); + Group g3 = new Group(g); + g3.layoutMgr = new FlowLayout; + Group g4 = new Group(g3); + g4.userPreferredSize(50,10); + Group g5 = new Group(g3); + g5.userPreferredSize(60,20); + Group g6 = new Group(g3); + g6.userPreferredSize(70,30); + g.pack(); + Rect r2; + g.getBounds(r2); + assert( r2 == LTWH(0,0,70,110) ); + + g6.getBounds(r2); + assert( r2 == LTWH(0,30,70,30) ); + g5.getBounds(r2); + assert( r2 == LTWH(5,10,60,20) ); + g4.getBounds(r2); + assert( r2 == LTWH(10,0,50,10) ); + + int x,y; + g6.getPeerOffset(x,y); + assert( x == 0 ); + assert( y == 80 ); +} + +version (MinWin32) { + + private { + import minwin.app; + import minwin.mswindows; + import std.utf; + } + + class GroupBox : WindowChild { + int labelHeight; + + char[] text_data; + char[] text() { return text_data; } + void text(char[] c) { + text_data = c; + SendMessageX(peer,WM_SETTEXT,0,c); + } + + this(Component parent, char[] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + text_data = text; + peer = CreateWindowX("BUTTON",text, + BS_GROUPBOX | WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,gApp.hInstance,null); + sysAssert(peer !is null, "Failed to create peer Button"); + setWindowChildPeer(this,peer,OWNS_PEER); + this.name = name; + Font f = standardFont(StandardFont.Gui); + SendMessageA(peer,WM_SETFONT,cast(WPARAM)f.peer,0); + HDC dc = GetDC(peer); + HFONT oldFont = SelectObject(dc,f.peer); + TEXTMETRICA metrics; + GetTextMetricsA(dc,&metrics); + labelHeight = metrics.tmHeight; + SelectObject(dc,oldFont); + ReleaseDC(peer,dc); + parent.addChild(this); + } + + + void getLayoutBounds(inout Rect r) { + super.getLayoutBounds(r); + r.LTWH(r.left+2, r.top+labelHeight+2, r.width-4, r.height-labelHeight-4); + } + + Point preferredSize() { + Point s; + if (layoutMgr) { + s = layoutMgr.preferredSize(this); + } + s.y = s.y + labelHeight+4; + s.x = s.x + 4; + if (userPreferredWidth() > 0) + s.x = userPreferredWidth(); + if (userPreferredHeight() > 0) + s.y = userPreferredHeight(); + return s; + } + mixin WindowChildImpl!(); + } + +} else version (GTK) { + + private import minwin.gtk; + private import minwin.gtk_peers; + private import std.c.string; + + class GroupBox : WindowChild { + + MinWinGtkPeer* content; + + char[] text() { + char* str = gtk_frame_get_label(cast(GtkFrame*)peer); + if (str is null) + return ""; + else + return str[0..strlen(str)].dup; + } + void text(char[] c) { + gtk_frame_set_label(cast(GtkFrame*)peer,g_strdup(c.ptr)); + } + + this(Component parent, char[] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + char* str = toStringz(text); + peer = gtk_frame_new(str); + gtk_container_add(cast(GtkContainer*)parentp,peer); + + // add our peer to hook into GTK size allocation algorithm + GtkWidget* wcontent = MinWinGtkPeer_new(); + content = cast(MinWinGtkPeer*)wcontent; + gtk_widget_set_sensitive(wcontent,true); + content.sizeRequest = >kRequest; + content.sizeAllocate = >kAllocate; + gtk_container_add(cast(GtkContainer*)peer,wcontent); + + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + + gtk_widget_realize(wcontent); + gtk_widget_show(wcontent); + gtk_widget_realize(peer); + visible = true; + } + + mixin WindowChildImpl!(); + + PeerForAdd getPeerForAdd() { + return cast(GtkWidget*)content; + } + + // callback from the GTK peer asking for preferred size + private void gtkRequest(GtkWidget *w, GtkRequisition* req) { + version(LOG)log.writefln("gtkRequest for groupbox"); + Point s; + if (layoutMgr) { + s = layoutMgr.preferredSize(this); + req.width = s.x; + req.height = s.y; + } else { + req.width = 0; + req.height = 0; + } + version(LOG)log.writefln("done gtkRequest for groupbox"); + } + + // callback from GTK peer telling us our position + private void gtkAllocate(GtkWidget *w, GtkAllocation* req) { + version(LOG)log.writefln("gtkAllocate for groupbox"); + if (layoutMgr) { + layoutMgr.layout(this); + } + childLayoutDirty = false; + version(LOG)log.writefln("done gtkAllocate for groupbox"); + } + + void getLayoutBounds(inout Rect r) { + GtkWidget* w = cast(GtkWidget*)content; + r = toRect(w.allocation); + } + + } + +} + diff --git a/samples/minwin_gtk/minwin/gtk.brf b/samples/minwin_gtk/minwin/gtk.brf new file mode 100644 index 0000000..d7d1eff --- /dev/null +++ b/samples/minwin_gtk/minwin/gtk.brf @@ -0,0 +1,7 @@ +all.d +-allobj +-Tlibminwin_gtk +-I.. +-fversion=GTK +-lib +-g diff --git a/samples/minwin_gtk/minwin/gtk.d b/samples/minwin_gtk/minwin/gtk.d new file mode 100644 index 0000000..4509bc4 --- /dev/null +++ b/samples/minwin_gtk/minwin/gtk.d @@ -0,0 +1,26930 @@ +/* +* Full GTK, GDK, Pango, ect... bindings +* +* Tedious work done by John Demme (me@teqdruid.com) +* h2d used as well. +* +* LGPL License from original header files probably applies. +* +* Known issue: +* Crashes at gtk_main if linked in. I'm not sure why. Solution: + Use as header file. Do not compile, and do not link into program. +*/ + +module minwin.gtk; + +version(build) pragma(nolink); + +// Included as part of MinWin since the LGPL says the use of header +// files is unrestricted. The LGPL does not apply to any other part of +// MinWin except for this file (and even there John isn't sure if it +// applies since it is a port of header files). The original gtk.d is +// available from www.dsource.org + +extern (C) { + + alias int ptrdiff_t; + alias uint size_t; + alias int wchar_t; + + alias byte gint8; + alias ubyte guint8; + alias short gint16; + alias ushort guint16; + + alias int gint32; + alias uint guint32; + + alias long gint64; + alias ulong guint64; + alias int gssize; + alias uint gsize; + alias _GStaticMutex GStaticMutex; + alias void _GMutex; + + struct _GStaticMutex { + _GMutex *runtime_mutex; + union static_mutex_union { + char pad[24]; + double dummy_double; + void *dummy_pointer; + int dummy_long; + } + static_mutex_union static_mutex; + } + alias _GSystemThread GSystemThread; + + union _GSystemThread { + char data[4]; + double dummy_double; + void *dummy_pointer; + int dummy_long; + } + alias int GPid; + + alias char gchar; + alias short gshort; + alias int glong; + alias int gint; + alias gint gboolean; + + alias ubyte guchar; + alias ushort gushort; + alias uint gulong; + alias uint guint; + + alias float gfloat; + alias double gdouble; + alias void* gpointer; + alias void *gconstpointer; + + alias gint (*GCompareFunc) (gpointer a, + gpointer b); + alias gint (*GCompareDataFunc) (gpointer a, + gpointer b, + gpointer user_data); + alias gboolean (*GEqualFunc) (gpointer a, + gpointer b); + alias void (*GDestroyNotify) (gpointer data); + alias void (*GFunc) (gpointer data, + gpointer user_data); + alias guint (*GHashFunc) (gpointer key); + alias void (*GHFunc) (gpointer key, + gpointer value, + gpointer user_data); + alias void (*GFreeFunc) (gpointer data); + + alias _GDoubleIEEE754 GDoubleIEEE754; + + alias _GFloatIEEE754 GFloatIEEE754; + + union _GFloatIEEE754 { + gfloat v_float; + struct mpn_struct { + guint mantissa; + guint biased_exponent; + guint sign; + } + } + union _GDoubleIEEE754 { + gdouble v_double; + struct mpn_struct { + guint mantissa_low; + guint mantissa_high; + guint biased_exponent; + guint sign; + } + } + alias _GTimeVal GTimeVal; + + + struct _GTimeVal { + glong tv_sec; + glong tv_usec; + } + + alias _GArray GArray; + + alias _GByteArray GByteArray; + + alias _GPtrArray GPtrArray; + + + struct _GArray { + gchar *data; + guint len; + } + + struct _GByteArray { + guint8 *data; + guint len; + } + + struct _GPtrArray { + gpointer *pdata; + guint len; + } + GArray* g_array_new (gboolean zero_terminated, + gboolean clear_, + guint element_size); + GArray* g_array_sized_new (gboolean zero_terminated, + gboolean clear_, + guint element_size, + guint reserved_size); + gchar* g_array_free (GArray *array, + gboolean free_segment); + GArray* g_array_append_vals (GArray *array, + gpointer data, + guint len); + GArray* g_array_prepend_vals (GArray *array, + gpointer data, + guint len); + GArray* g_array_insert_vals (GArray *array, + guint index_, + gpointer data, + guint len); + GArray* g_array_set_size (GArray *array, + guint length); + GArray* g_array_remove_index (GArray *array, + guint index_); + GArray* g_array_remove_index_fast (GArray *array, + guint index_); + GArray* g_array_remove_range (GArray *array, + guint index_, + guint length); + void g_array_sort (GArray *array, + GCompareFunc compare_func); + void g_array_sort_with_data (GArray *array, + GCompareDataFunc compare_func, + gpointer user_data); + + + + + + + GPtrArray* g_ptr_array_new (); + GPtrArray* g_ptr_array_sized_new (guint reserved_size); + gpointer* g_ptr_array_free (GPtrArray *array, + gboolean free_seg); + void g_ptr_array_set_size (GPtrArray *array, + gint length); + gpointer g_ptr_array_remove_index (GPtrArray *array, + guint index_); + gpointer g_ptr_array_remove_index_fast (GPtrArray *array, + guint index_); + gboolean g_ptr_array_remove (GPtrArray *array, + gpointer data); + gboolean g_ptr_array_remove_fast (GPtrArray *array, + gpointer data); + void g_ptr_array_remove_range (GPtrArray *array, + guint index_, + guint length); + void g_ptr_array_add (GPtrArray *array, + gpointer data); + void g_ptr_array_sort (GPtrArray *array, + GCompareFunc compare_func); + void g_ptr_array_sort_with_data (GPtrArray *array, + GCompareDataFunc compare_func, + gpointer user_data); + void g_ptr_array_foreach (GPtrArray *array, + GFunc func, + gpointer user_data); + + + + + + + GByteArray* g_byte_array_new (); + GByteArray* g_byte_array_sized_new (guint reserved_size); + guint8* g_byte_array_free (GByteArray *array, + gboolean free_segment); + GByteArray* g_byte_array_append (GByteArray *array, + guint8 *data, + guint len); + GByteArray* g_byte_array_prepend (GByteArray *array, + guint8 *data, + guint len); + GByteArray* g_byte_array_set_size (GByteArray *array, + guint length); + GByteArray* g_byte_array_remove_index (GByteArray *array, + guint index_); + GByteArray* g_byte_array_remove_index_fast (GByteArray *array, + guint index_); + GByteArray* g_byte_array_remove_range (GByteArray *array, + guint index_, + guint length); + void g_byte_array_sort (GByteArray *array, + GCompareFunc compare_func); + void g_byte_array_sort_with_data (GByteArray *array, + GCompareDataFunc compare_func, + gpointer user_data); + + alias guint32 GQuark; + + GQuark g_quark_try_string ( gchar *string); + GQuark g_quark_from_static_string ( gchar *string); + GQuark g_quark_from_string ( gchar *string); + gchar* g_quark_to_string (GQuark quark) ; + + alias _GError GError; + + struct _GError { + GQuark domain; + gint code; + gchar *message; + } + + GError* g_error_new (GQuark domain, + gint code, + gchar *format, + ...) ; + + GError* g_error_new_literal (GQuark domain, + gint code, + gchar *message); + + void g_error_free (GError *error); + GError* g_error_copy ( GError *error); + + gboolean g_error_matches ( GError *error, + GQuark domain, + gint code); + + + + + void g_set_error (GError **err, + GQuark domain, + gint code, + gchar *format, + ...) ; + + + + void g_propagate_error (GError **dest, + GError *src); + + + void g_clear_error (GError **err); + + + + + + + gint g_atomic_int_exchange_and_add (gint *atomic, + gint val); + void g_atomic_int_add (gint *atomic, + gint val); + gboolean g_atomic_int_compare_and_exchange (gint *atomic, + gint oldval, + gint newval); + gboolean g_atomic_pointer_compare_and_exchange (gpointer *atomic, + gpointer oldval, + gpointer newval); + + + + + + + + GQuark g_thread_error_quark (); + + + enum GThreadError { + G_THREAD_ERROR_AGAIN + }; + + + alias gpointer (*GThreadFunc) (gpointer data); + + enum GThreadPriority { + G_THREAD_PRIORITY_LOW, + G_THREAD_PRIORITY_NORMAL, + G_THREAD_PRIORITY_HIGH, + G_THREAD_PRIORITY_URGENT + }; + + + alias _GThread GThread; + + struct _GThread { + + GThreadFunc func; + gpointer data; + gboolean joinable; + GThreadPriority priority; + } + + alias _GMutex GMutex; + + alias _GCond GCond; + alias void _GCond; + + alias _GPrivate GPrivate; + alias void _GPrivate; + + alias _GStaticPrivate GStaticPrivate; + + + alias _GThreadFunctions GThreadFunctions; + + struct _GThreadFunctions { + GMutex* (*mutex_new) (); + void (*mutex_lock) (GMutex *mutex); + gboolean (*mutex_trylock) (GMutex *mutex); + void (*mutex_unlock) (GMutex *mutex); + void (*mutex_free) (GMutex *mutex); + GCond* (*cond_new) (); + void (*cond_signal) (GCond *cond); + void (*cond_broadcast) (GCond *cond); + void (*cond_wait) (GCond *cond, + GMutex *mutex); + gboolean (*cond_timed_wait) (GCond *cond, + GMutex *mutex, + GTimeVal *end_time); + void (*cond_free) (GCond *cond); + gpointer (*private_get) (GPrivate *private_key); + void (*private_set) (GPrivate *private_key, + gpointer data); + void (*thread_create) (GThreadFunc func, + gpointer data, + gulong stack_size, + gboolean joinable, + gboolean bound, + GThreadPriority priority, + gpointer thread, + GError **error); + void (*thread_yield) (); + void (*thread_join) (gpointer thread); + void (*thread_exit) (); + void (*thread_set_priority)(gpointer thread, + GThreadPriority priority); + void (*thread_self) (gpointer thread); + gboolean (*thread_equal) (gpointer thread1, + gpointer thread2); + } + + GThreadFunctions g_thread_functions_for_glib_use; + gboolean g_thread_use_default_impl; + gboolean g_threads_got_initialized; + + + + + + void g_thread_init (GThreadFunctions *vtable); + void g_thread_init_with_errorcheck_mutexes (GThreadFunctions* vtable); + GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex); + GThread* g_thread_create_full (GThreadFunc func, + gpointer data, + gulong stack_size, + gboolean joinable, + gboolean bound, + GThreadPriority priority, + GError **error); + GThread* g_thread_self (); + void g_thread_exit (gpointer retval); + gpointer g_thread_join (GThread *thread); + + void g_thread_set_priority (GThread *thread, + GThreadPriority priority); + void g_static_mutex_init (GStaticMutex *mutex); + void g_static_mutex_free (GStaticMutex *mutex); + + struct _GStaticPrivate { + + guint index; + } + + void g_static_private_init (GStaticPrivate *private_key); + gpointer g_static_private_get (GStaticPrivate *private_key); + void g_static_private_set (GStaticPrivate *private_key, + gpointer data, + GDestroyNotify notify); + void g_static_private_free (GStaticPrivate *private_key); + + alias _GStaticRecMutex GStaticRecMutex; + + struct _GStaticRecMutex { + + GStaticMutex mutex; + guint depth; + GSystemThread owner; + } + + + void g_static_rec_mutex_init (GStaticRecMutex *mutex); + void g_static_rec_mutex_lock (GStaticRecMutex *mutex); + gboolean g_static_rec_mutex_trylock (GStaticRecMutex *mutex); + void g_static_rec_mutex_unlock (GStaticRecMutex *mutex); + void g_static_rec_mutex_lock_full (GStaticRecMutex *mutex, + guint depth); + guint g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex); + void g_static_rec_mutex_free (GStaticRecMutex *mutex); + + alias _GStaticRWLock GStaticRWLock; + + struct _GStaticRWLock { + + GStaticMutex mutex; + GCond *read_cond; + GCond *write_cond; + guint read_counter; + gboolean have_writer; + guint want_to_read; + guint want_to_write; + } + + + + void g_static_rw_lock_init (GStaticRWLock* lock); + void g_static_rw_lock_reader_lock (GStaticRWLock* lock); + gboolean g_static_rw_lock_reader_trylock (GStaticRWLock* lock); + void g_static_rw_lock_reader_unlock (GStaticRWLock* lock); + void g_static_rw_lock_writer_lock (GStaticRWLock* lock); + gboolean g_static_rw_lock_writer_trylock (GStaticRWLock* lock); + void g_static_rw_lock_writer_unlock (GStaticRWLock* lock); + void g_static_rw_lock_free (GStaticRWLock* lock); + + enum GOnceStatus { + G_ONCE_STATUS_NOTCALLED, + G_ONCE_STATUS_PROGRESS, + G_ONCE_STATUS_READY + }; + + + alias _GOnce GOnce; + + struct _GOnce { + GOnceStatus status; + gpointer retval; + } + + + + gpointer g_once_impl (GOnce *once, GThreadFunc func, gpointer arg); + void glib_dummy_decl (); + + + + + alias _GAsyncQueue GAsyncQueue; + alias void _GAsyncQueue; + + + + + GAsyncQueue* g_async_queue_new (); + + + + + + void g_async_queue_lock (GAsyncQueue *queue); + void g_async_queue_unlock (GAsyncQueue *queue); + + + void g_async_queue_ref (GAsyncQueue *queue); + void g_async_queue_unref (GAsyncQueue *queue); + + + void g_async_queue_ref_unlocked (GAsyncQueue *queue); + void g_async_queue_unref_and_unlock (GAsyncQueue *queue); + + + + void g_async_queue_push (GAsyncQueue *queue, + gpointer data); + void g_async_queue_push_unlocked (GAsyncQueue *queue, + gpointer data); + + + + gpointer g_async_queue_pop (GAsyncQueue *queue); + gpointer g_async_queue_pop_unlocked (GAsyncQueue *queue); + + + gpointer g_async_queue_try_pop (GAsyncQueue *queue); + gpointer g_async_queue_try_pop_unlocked (GAsyncQueue *queue); + + + + gpointer g_async_queue_timed_pop (GAsyncQueue *queue, + GTimeVal *end_time); + gpointer g_async_queue_timed_pop_unlocked (GAsyncQueue *queue, + GTimeVal *end_time); + + + + + + + + gint g_async_queue_length (GAsyncQueue *queue); + gint g_async_queue_length_unlocked (GAsyncQueue *queue); + + + + + void g_on_error_query ( gchar *prg_name); + void g_on_error_stack_trace ( gchar *prg_name); + + + + alias _GAllocator GAllocator; + alias void _GAllocator; + + alias _GMemChunk GMemChunk; + alias void _GMemChunk; + + alias _GMemVTable GMemVTable; + + gpointer g_malloc (gulong n_bytes); + gpointer g_malloc0 (gulong n_bytes); + gpointer g_realloc (gpointer mem, + gulong n_bytes); + void g_free (gpointer mem); + gpointer g_try_malloc (gulong n_bytes); + gpointer g_try_realloc (gpointer mem, + gulong n_bytes); + struct _GMemVTable { + gpointer (*malloc) (gsize n_bytes); + gpointer (*realloc) (gpointer mem, + gsize n_bytes); + void (*free) (gpointer mem); + + gpointer (*calloc) (gsize n_blocks, + gsize n_block_bytes); + gpointer (*try_malloc) (gsize n_bytes); + gpointer (*try_realloc) (gpointer mem, + gsize n_bytes); + } + void g_mem_set_vtable (GMemVTable *vtable); + gboolean g_mem_is_system_malloc (); + + + + GMemVTable *glib_mem_profiler_table; + void g_mem_profile (); + GMemChunk* g_mem_chunk_new ( gchar *name, + gint atom_size, + gulong area_size, + gint type); + void g_mem_chunk_destroy (GMemChunk *mem_chunk); + gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk); + gpointer g_mem_chunk_alloc0 (GMemChunk *mem_chunk); + void g_mem_chunk_free (GMemChunk *mem_chunk, + gpointer mem); + void g_mem_chunk_clean (GMemChunk *mem_chunk); + void g_mem_chunk_reset (GMemChunk *mem_chunk); + void g_mem_chunk_print (GMemChunk *mem_chunk); + void g_mem_chunk_info (); + void g_blow_chunks (); + + + + + GAllocator* g_allocator_new ( gchar *name, + guint n_preallocs); + void g_allocator_free (GAllocator *allocator); + + + + + + + + + + + + alias _GList GList; + + + struct _GList { + gpointer data; + GList *next; + GList *prev; + } + + + + void g_list_push_allocator (GAllocator *allocator); + void g_list_pop_allocator (); + GList* g_list_alloc (); + void g_list_free (GList *list); + void g_list_free_1 (GList *list); + GList* g_list_append (GList *list, + gpointer data); + GList* g_list_prepend (GList *list, + gpointer data); + GList* g_list_insert (GList *list, + gpointer data, + gint position); + GList* g_list_insert_sorted (GList *list, + gpointer data, + GCompareFunc func); + GList* g_list_insert_before (GList *list, + GList *sibling, + gpointer data); + GList* g_list_concat (GList *list1, + GList *list2); + GList* g_list_remove (GList *list, + gpointer data); + GList* g_list_remove_all (GList *list, + gpointer data); + GList* g_list_remove_link (GList *list, + GList *llink); + GList* g_list_delete_link (GList *list, + GList *link_); + GList* g_list_reverse (GList *list); + GList* g_list_copy (GList *list); + GList* g_list_nth (GList *list, + guint n); + GList* g_list_nth_prev (GList *list, + guint n); + GList* g_list_find (GList *list, + gpointer data); + GList* g_list_find_custom (GList *list, + gpointer data, + GCompareFunc func); + gint g_list_position (GList *list, + GList *llink); + gint g_list_index (GList *list, + gpointer data); + GList* g_list_last (GList *list); + GList* g_list_first (GList *list); + guint g_list_length (GList *list); + void g_list_foreach (GList *list, + GFunc func, + gpointer user_data); + GList* g_list_sort (GList *list, + GCompareFunc compare_func); + GList* g_list_sort_with_data (GList *list, + GCompareDataFunc compare_func, + gpointer user_data); + gpointer g_list_nth_data (GList *list, + guint n); + + + + + + + + + alias _GCache GCache; + alias void _GCache; + + + alias gpointer (*GCacheNewFunc) (gpointer key); + alias gpointer (*GCacheDupFunc) (gpointer value); + alias void (*GCacheDestroyFunc) (gpointer value); + + + + GCache* g_cache_new (GCacheNewFunc value_new_func, + GCacheDestroyFunc value_destroy_func, + GCacheDupFunc key_dup_func, + GCacheDestroyFunc key_destroy_func, + GHashFunc hash_key_func, + GHashFunc hash_value_func, + GEqualFunc key_equal_func); + void g_cache_destroy (GCache *cache); + gpointer g_cache_insert (GCache *cache, + gpointer key); + void g_cache_remove (GCache *cache, + gpointer value); + void g_cache_key_foreach (GCache *cache, + GHFunc func, + gpointer user_data); + void g_cache_value_foreach (GCache *cache, + GHFunc func, + gpointer user_data); + + + + + alias _GCompletion GCompletion; + + + alias gchar* (*GCompletionFunc) (gpointer); + + + + + alias gint (*GCompletionStrncmpFunc) (gchar *s1, + gchar *s2, + gsize n); + + struct _GCompletion { + GList* items; + GCompletionFunc func; + + gchar* prefix; + GList* cache; + GCompletionStrncmpFunc strncmp_func; + } + + GCompletion* g_completion_new (GCompletionFunc func); + void g_completion_add_items (GCompletion* cmp, + GList* items); + void g_completion_remove_items (GCompletion* cmp, + GList* items); + void g_completion_clear_items (GCompletion* cmp); + GList* g_completion_complete (GCompletion* cmp, + gchar* prefix, + gchar** new_prefix); + GList* g_completion_complete_utf8 (GCompletion *cmp, + gchar* prefix, + gchar** new_prefix); + void g_completion_set_compare (GCompletion *cmp, + GCompletionStrncmpFunc strncmp_func); + void g_completion_free (GCompletion* cmp); + + + + + + + enum GConvertError { + G_CONVERT_ERROR_NO_CONVERSION, + G_CONVERT_ERROR_ILLEGAL_SEQUENCE, + G_CONVERT_ERROR_FAILED, + G_CONVERT_ERROR_PARTIAL_INPUT, + G_CONVERT_ERROR_BAD_URI, + G_CONVERT_ERROR_NOT_ABSOLUTE_PATH + }; + + + + GQuark g_convert_error_quark (); + + + + alias _GIConv *GIConv; + alias void _GIConv; + + + GIConv g_iconv_open ( gchar *to_codeset, + gchar *from_codeset); + size_t g_iconv (GIConv converter, + gchar **inbuf, + gsize *inbytes_left, + gchar **outbuf, + gsize *outbytes_left); + gint g_iconv_close (GIConv converter); + + + gchar* g_convert ( gchar *str, + gssize len, + gchar *to_codeset, + gchar *from_codeset, + gsize *bytes_read, + gsize *bytes_written, + GError **error); + gchar* g_convert_with_iconv ( gchar *str, + gssize len, + GIConv converter, + gsize *bytes_read, + gsize *bytes_written, + GError **error); + gchar* g_convert_with_fallback ( gchar *str, + gssize len, + gchar *to_codeset, + gchar *from_codeset, + gchar *fallback, + gsize *bytes_read, + gsize *bytes_written, + GError **error); + + + + + gchar* g_locale_to_utf8 ( gchar *opsysstring, + gssize len, + gsize *bytes_read, + gsize *bytes_written, + GError **error); + gchar* g_locale_from_utf8 ( gchar *utf8string, + gssize len, + gsize *bytes_read, + gsize *bytes_written, + GError **error); + + + + + gchar* g_filename_to_utf8 ( gchar *opsysstring, + gssize len, + gsize *bytes_read, + gsize *bytes_written, + GError **error); + gchar* g_filename_from_utf8 ( gchar *utf8string, + gssize len, + gsize *bytes_read, + gsize *bytes_written, + GError **error); + + gchar *g_filename_from_uri ( gchar *uri, + gchar **hostname, + GError **error); + + gchar *g_filename_to_uri ( gchar *filename, + gchar *hostname, + GError **error); + + + + + + alias _GData GData; + alias void _GData; + + + alias void (*GDataForeachFunc) (GQuark key_id, + gpointer data, + gpointer user_data); + + + + void g_datalist_init (GData **datalist); + void g_datalist_clear (GData **datalist); + gpointer g_datalist_id_get_data (GData **datalist, + GQuark key_id); + void g_datalist_id_set_data_full (GData **datalist, + GQuark key_id, + gpointer data, + GDestroyNotify destroy_func); + gpointer g_datalist_id_remove_no_notify (GData **datalist, + GQuark key_id); + void g_datalist_foreach (GData **datalist, + GDataForeachFunc func, + gpointer user_data); + void g_dataset_destroy (gpointer dataset_location); + gpointer g_dataset_id_get_data (gpointer dataset_location, + GQuark key_id); + void g_dataset_id_set_data_full (gpointer dataset_location, + GQuark key_id, + gpointer data, + GDestroyNotify destroy_func); + gpointer g_dataset_id_remove_no_notify (gpointer dataset_location, + GQuark key_id); + void g_dataset_foreach (gpointer dataset_location, + GDataForeachFunc func, + gpointer user_data); + + + alias gint32 GTime; + alias guint16 GDateYear; + alias guint8 GDateDay; + alias _GDate GDate; + + + + + enum GDateDMY { + G_DATE_DAY = 0, + G_DATE_MONTH = 1, + G_DATE_YEAR = 2 + }; + + + + enum GDateWeekday { + G_DATE_BAD_WEEKDAY = 0, + G_DATE_MONDAY = 1, + G_DATE_TUESDAY = 2, + G_DATE_WEDNESDAY = 3, + G_DATE_THURSDAY = 4, + G_DATE_FRIDAY = 5, + G_DATE_SATURDAY = 6, + G_DATE_SUNDAY = 7 + }; + + enum GDateMonth { + G_DATE_BAD_MONTH = 0, + G_DATE_JANUARY = 1, + G_DATE_FEBRUARY = 2, + G_DATE_MARCH = 3, + G_DATE_APRIL = 4, + G_DATE_MAY = 5, + G_DATE_JUNE = 6, + G_DATE_JULY = 7, + G_DATE_AUGUST = 8, + G_DATE_SEPTEMBER = 9, + G_DATE_OCTOBER = 10, + G_DATE_NOVEMBER = 11, + G_DATE_DECEMBER = 12 + }; + + struct _GDate { + guint julian_days; + + + + + + guint julian; + guint dmy; + + + guint day; + guint month; + guint year; + } + + + + + + GDate* g_date_new (); + GDate* g_date_new_dmy (GDateDay day, + GDateMonth month, + GDateYear year); + GDate* g_date_new_julian (guint32 julian_day); + void g_date_free (GDate *date); + + + + + + + gboolean g_date_valid ( GDate *date); + gboolean g_date_valid_day (GDateDay day) ; + gboolean g_date_valid_month (GDateMonth month) ; + gboolean g_date_valid_year (GDateYear year) ; + gboolean g_date_valid_weekday (GDateWeekday weekday) ; + gboolean g_date_valid_julian (guint32 julian_date) ; + gboolean g_date_valid_dmy (GDateDay day, + GDateMonth month, + GDateYear year) ; + + GDateWeekday g_date_get_weekday ( GDate *date); + GDateMonth g_date_get_month ( GDate *date); + GDateYear g_date_get_year ( GDate *date); + GDateDay g_date_get_day ( GDate *date); + guint32 g_date_get_julian ( GDate *date); + guint g_date_get_day_of_year ( GDate *date); + + + + + + + guint g_date_get_monday_week_of_year ( GDate *date); + guint g_date_get_sunday_week_of_year ( GDate *date); + + + + + + void g_date_clear (GDate *date, + guint n_dates); + + + + + + void g_date_set_parse (GDate *date, + gchar *str); + void g_date_set_time (GDate *date, + GTime time_); + void g_date_set_month (GDate *date, + GDateMonth month); + void g_date_set_day (GDate *date, + GDateDay day); + void g_date_set_year (GDate *date, + GDateYear year); + void g_date_set_dmy (GDate *date, + GDateDay day, + GDateMonth month, + GDateYear y); + void g_date_set_julian (GDate *date, + guint32 julian_date); + gboolean g_date_is_first_of_month ( GDate *date); + gboolean g_date_is_last_of_month ( GDate *date); + + + void g_date_add_days (GDate *date, + guint n_days); + void g_date_subtract_days (GDate *date, + guint n_days); + + + void g_date_add_months (GDate *date, + guint n_months); + void g_date_subtract_months (GDate *date, + guint n_months); + + + void g_date_add_years (GDate *date, + guint n_years); + void g_date_subtract_years (GDate *date, + guint n_years); + gboolean g_date_is_leap_year (GDateYear year) ; + guint8 g_date_get_days_in_month (GDateMonth month, + GDateYear year) ; + guint8 g_date_get_monday_weeks_in_year (GDateYear year) ; + guint8 g_date_get_sunday_weeks_in_year (GDateYear year) ; + + + + gint g_date_days_between ( GDate *date1, + GDate *date2); + + + gint g_date_compare ( GDate *lhs, + GDate *rhs); + void g_date_to_struct_tm ( GDate *date, + void* tm); + + void g_date_clamp (GDate *date, + GDate *min_date, + GDate *max_date); + + + void g_date_order (GDate *date1, GDate *date2); + + + + + gsize g_date_strftime (gchar *s, + gsize slen, + gchar *format, + GDate *date); + + + + alias _GDir GDir; + alias void _GDir; + + + GDir * g_dir_open ( gchar *path, + guint flags, + GError **error); + gchar *g_dir_read_name (GDir *dir); + void g_dir_rewind (GDir *dir); + void g_dir_close (GDir *dir); + + + + + + + + enum GFileError { + G_FILE_ERROR_EXIST, + G_FILE_ERROR_ISDIR, + G_FILE_ERROR_ACCES, + G_FILE_ERROR_NAMETOOLONG, + G_FILE_ERROR_NOENT, + G_FILE_ERROR_NOTDIR, + G_FILE_ERROR_NXIO, + G_FILE_ERROR_NODEV, + G_FILE_ERROR_ROFS, + G_FILE_ERROR_TXTBSY, + G_FILE_ERROR_FAULT, + G_FILE_ERROR_LOOP, + G_FILE_ERROR_NOSPC, + G_FILE_ERROR_NOMEM, + G_FILE_ERROR_MFILE, + G_FILE_ERROR_NFILE, + G_FILE_ERROR_BADF, + G_FILE_ERROR_INVAL, + G_FILE_ERROR_PIPE, + G_FILE_ERROR_AGAIN, + G_FILE_ERROR_INTR, + G_FILE_ERROR_IO, + G_FILE_ERROR_PERM, + G_FILE_ERROR_FAILED + }; + + + + + + + enum GFileTest { + G_FILE_TEST_IS_REGULAR = 1 << 0, + G_FILE_TEST_IS_SYMLINK = 1 << 1, + G_FILE_TEST_IS_DIR = 1 << 2, + G_FILE_TEST_IS_EXECUTABLE = 1 << 3, + G_FILE_TEST_EXISTS = 1 << 4 + }; + + + GQuark g_file_error_quark (); + + GFileError g_file_error_from_errno (gint err_no); + + gboolean g_file_test ( gchar *filename, + GFileTest test); + gboolean g_file_get_contents ( gchar *filename, + gchar **contents, + gsize *length, + GError **error); + gchar *g_file_read_link ( gchar *filename, + GError **error); + + + gint g_mkstemp (gchar *tmpl); + + + gint g_file_open_tmp ( gchar *tmpl, + gchar **name_used, + GError **error); + + gchar *g_build_path ( gchar *separator, + gchar *first_element, + ...); + gchar *g_build_filename ( gchar *first_element, + ...); + + + + + alias _GHashTable GHashTable; + alias void _GHashTable; + + + alias gboolean (*GHRFunc) (gpointer key, + gpointer value, + gpointer user_data); + + + + GHashTable* g_hash_table_new (GHashFunc hash_func, + GEqualFunc key_equal_func); + GHashTable* g_hash_table_new_full (GHashFunc hash_func, + GEqualFunc key_equal_func, + GDestroyNotify key_destroy_func, + GDestroyNotify value_destroy_func); + void g_hash_table_destroy (GHashTable *hash_table); + void g_hash_table_insert (GHashTable *hash_table, + gpointer key, + gpointer value); + void g_hash_table_replace (GHashTable *hash_table, + gpointer key, + gpointer value); + gboolean g_hash_table_remove (GHashTable *hash_table, + gpointer key); + gboolean g_hash_table_steal (GHashTable *hash_table, + gpointer key); + gpointer g_hash_table_lookup (GHashTable *hash_table, + gpointer key); + gboolean g_hash_table_lookup_extended (GHashTable *hash_table, + gpointer lookup_key, + gpointer *orig_key, + gpointer *value); + void g_hash_table_foreach (GHashTable *hash_table, + GHFunc func, + gpointer user_data); + gpointer g_hash_table_find (GHashTable *hash_table, + GHRFunc predicate, + gpointer user_data); + guint g_hash_table_foreach_remove (GHashTable *hash_table, + GHRFunc func, + gpointer user_data); + guint g_hash_table_foreach_steal (GHashTable *hash_table, + GHRFunc func, + gpointer user_data); + guint g_hash_table_size (GHashTable *hash_table); + gboolean g_str_equal (gpointer v, + gpointer v2); + guint g_str_hash (gpointer v); + + gboolean g_int_equal (gpointer v, + gpointer v2); + guint g_int_hash (gpointer v); + + + + + + + + guint g_direct_hash (gpointer v) ; + gboolean g_direct_equal (gpointer v, + gpointer v2) ; + + + + + + + alias _GHook GHook; + + alias _GHookList GHookList; + + + alias gint (*GHookCompareFunc) (GHook *new_hook, + GHook *sibling); + alias gboolean (*GHookFindFunc) (GHook *hook, + gpointer data); + alias void (*GHookMarshaller) (GHook *hook, + gpointer marshal_data); + alias gboolean (*GHookCheckMarshaller) (GHook *hook, + gpointer marshal_data); + alias void (*GHookFunc) (gpointer data); + alias gboolean (*GHookCheckFunc) (gpointer data); + alias void (*GHookFinalizeFunc) (GHookList *hook_list, + GHook *hook); + enum GHookFlagMask { + G_HOOK_FLAG_ACTIVE = 1 << 0, + G_HOOK_FLAG_IN_CALL = 1 << 1, + G_HOOK_FLAG_MASK = 0x0f + }; + + + + + + struct _GHookList { + gulong seq_id; + guint hook_size; + guint is_setup; + GHook *hooks; + GMemChunk *hook_memchunk; + GHookFinalizeFunc finalize_hook; + gpointer dummy[2]; + } + struct _GHook { + gpointer data; + GHook *next; + GHook *prev; + guint ref_count; + gulong hook_id; + guint flags; + gpointer func; + GDestroyNotify destroy; + } + void g_hook_list_init (GHookList *hook_list, + guint hook_size); + void g_hook_list_clear (GHookList *hook_list); + GHook* g_hook_alloc (GHookList *hook_list); + void g_hook_free (GHookList *hook_list, + GHook *hook); + void g_hook_ref (GHookList *hook_list, + GHook *hook); + void g_hook_unref (GHookList *hook_list, + GHook *hook); + gboolean g_hook_destroy (GHookList *hook_list, + gulong hook_id); + void g_hook_destroy_link (GHookList *hook_list, + GHook *hook); + void g_hook_prepend (GHookList *hook_list, + GHook *hook); + void g_hook_insert_before (GHookList *hook_list, + GHook *sibling, + GHook *hook); + void g_hook_insert_sorted (GHookList *hook_list, + GHook *hook, + GHookCompareFunc func); + GHook* g_hook_get (GHookList *hook_list, + gulong hook_id); + GHook* g_hook_find (GHookList *hook_list, + gboolean need_valids, + GHookFindFunc func, + gpointer data); + GHook* g_hook_find_data (GHookList *hook_list, + gboolean need_valids, + gpointer data); + GHook* g_hook_find_func (GHookList *hook_list, + gboolean need_valids, + gpointer func); + GHook* g_hook_find_func_data (GHookList *hook_list, + gboolean need_valids, + gpointer func, + gpointer data); + + GHook* g_hook_first_valid (GHookList *hook_list, + gboolean may_be_in_call); + + + + GHook* g_hook_next_valid (GHookList *hook_list, + GHook *hook, + gboolean may_be_in_call); + + gint g_hook_compare_ids (GHook *new_hook, + GHook *sibling); + + + + + + void g_hook_list_invoke (GHookList *hook_list, + gboolean may_recurse); + + + + void g_hook_list_invoke_check (GHookList *hook_list, + gboolean may_recurse); + + + void g_hook_list_marshal (GHookList *hook_list, + gboolean may_recurse, + GHookMarshaller marshaller, + gpointer marshal_data); + void g_hook_list_marshal_check (GHookList *hook_list, + gboolean may_recurse, + GHookCheckMarshaller marshaller, + gpointer marshal_data); + + + + + alias _GSList GSList; + + + struct _GSList { + gpointer data; + GSList *next; + } + + + + void g_slist_push_allocator (GAllocator *allocator); + void g_slist_pop_allocator (); + GSList* g_slist_alloc (); + void g_slist_free (GSList *list); + void g_slist_free_1 (GSList *list); + GSList* g_slist_append (GSList *list, + gpointer data); + GSList* g_slist_prepend (GSList *list, + gpointer data); + GSList* g_slist_insert (GSList *list, + gpointer data, + gint position); + GSList* g_slist_insert_sorted (GSList *list, + gpointer data, + GCompareFunc func); + GSList* g_slist_insert_before (GSList *slist, + GSList *sibling, + gpointer data); + GSList* g_slist_concat (GSList *list1, + GSList *list2); + GSList* g_slist_remove (GSList *list, + gpointer data); + GSList* g_slist_remove_all (GSList *list, + gpointer data); + GSList* g_slist_remove_link (GSList *list, + GSList *link_); + GSList* g_slist_delete_link (GSList *list, + GSList *link_); + GSList* g_slist_reverse (GSList *list); + GSList* g_slist_copy (GSList *list); + GSList* g_slist_nth (GSList *list, + guint n); + GSList* g_slist_find (GSList *list, + gpointer data); + GSList* g_slist_find_custom (GSList *list, + gpointer data, + GCompareFunc func); + gint g_slist_position (GSList *list, + GSList *llink); + gint g_slist_index (GSList *list, + gpointer data); + GSList* g_slist_last (GSList *list); + guint g_slist_length (GSList *list); + void g_slist_foreach (GSList *list, + GFunc func, + gpointer user_data); + GSList* g_slist_sort (GSList *list, + GCompareFunc compare_func); + GSList* g_slist_sort_with_data (GSList *list, + GCompareDataFunc compare_func, + gpointer user_data); + gpointer g_slist_nth_data (GSList *list, + guint n); + + + + + + + + alias _GMainContext GMainContext; + alias void _GMainContext; + + alias _GMainLoop GMainLoop; + alias void _GMainLoop; + + alias _GSource GSource; + + alias _GSourceCallbackFuncs GSourceCallbackFuncs; + + alias _GSourceFuncs GSourceFuncs; + + + alias gboolean (*GSourceFunc) (gpointer data); + alias void (*GChildWatchFunc) (GPid pid, + gint status, + gpointer data); + struct _GSource { + + gpointer callback_data; + GSourceCallbackFuncs *callback_funcs; + + GSourceFuncs *source_funcs; + guint ref_count; + + GMainContext *context; + + gint priority; + guint flags; + guint source_id; + + GSList *poll_fds; + + GSource *prev; + GSource *next; + + gpointer reserved1; + gpointer reserved2; + } + + struct _GSourceCallbackFuncs { + void (*ref) (gpointer cb_data); + void (*unref) (gpointer cb_data); + void (*get) (gpointer cb_data, + GSource *source, + GSourceFunc *func, + gpointer *data); + } + + alias void (*GSourceDummyMarshal) (); + + struct _GSourceFuncs { + gboolean (*prepare) (GSource *source, + gint *timeout_); + gboolean (*check) (GSource *source); + gboolean (*dispatch) (GSource *source, + GSourceFunc callback, + gpointer user_data); + void (*finalize) (GSource *source); + + + GSourceFunc closure_callback; + GSourceDummyMarshal closure_marshal; + } + alias _GPollFD GPollFD; + + alias gint (*GPollFunc) (GPollFD *ufds, + guint nfsd, + gint timeout_); + + struct _GPollFD { + gint fd; + gushort events; + gushort revents; + } + GMainContext *g_main_context_new (); + void g_main_context_ref (GMainContext *context); + void g_main_context_unref (GMainContext *context); + GMainContext *g_main_context_default (); + + gboolean g_main_context_iteration (GMainContext *context, + gboolean may_block); + gboolean g_main_context_pending (GMainContext *context); + + + + GSource *g_main_context_find_source_by_id (GMainContext *context, + guint source_id); + GSource *g_main_context_find_source_by_user_data (GMainContext *context, + gpointer user_data); + GSource *g_main_context_find_source_by_funcs_user_data (GMainContext *context, + GSourceFuncs *funcs, + gpointer user_data); + + + + void g_main_context_wakeup (GMainContext *context); + gboolean g_main_context_acquire (GMainContext *context); + void g_main_context_release (GMainContext *context); + gboolean g_main_context_wait (GMainContext *context, + GCond *cond, + GMutex *mutex); + + gboolean g_main_context_prepare (GMainContext *context, + gint *priority); + gint g_main_context_query (GMainContext *context, + gint max_priority, + gint *timeout_, + GPollFD *fds, + gint n_fds); + gint g_main_context_check (GMainContext *context, + gint max_priority, + GPollFD *fds, + gint n_fds); + void g_main_context_dispatch (GMainContext *context); + + void g_main_context_set_poll_func (GMainContext *context, + GPollFunc func); + GPollFunc g_main_context_get_poll_func (GMainContext *context); + + + + void g_main_context_add_poll (GMainContext *context, + GPollFD *fd, + gint priority); + void g_main_context_remove_poll (GMainContext *context, + GPollFD *fd); + + int g_main_depth (); + + + + GMainLoop *g_main_loop_new (GMainContext *context, + gboolean is_running); + void g_main_loop_run (GMainLoop *loop); + void g_main_loop_quit (GMainLoop *loop); + GMainLoop *g_main_loop_ref (GMainLoop *loop); + void g_main_loop_unref (GMainLoop *loop); + gboolean g_main_loop_is_running (GMainLoop *loop); + GMainContext *g_main_loop_get_context (GMainLoop *loop); + + + + GSource *g_source_new (GSourceFuncs *source_funcs); + GSource *g_source_ref (GSource *source); + void g_source_unref (GSource *source); + + guint g_source_attach (GSource *source, + GMainContext *context); + void g_source_destroy (GSource *source); + + void g_source_set_priority (GSource *source, + gint priority); + gint g_source_get_priority (GSource *source); + void g_source_set_can_recurse (GSource *source, + gboolean can_recurse); + gboolean g_source_get_can_recurse (GSource *source); + guint g_source_get_id (GSource *source); + + GMainContext *g_source_get_context (GSource *source); + + void g_source_set_callback (GSource *source, + GSourceFunc func, + gpointer data, + GDestroyNotify notify); + + + + void g_source_set_callback_indirect (GSource *source, + gpointer callback_data, + GSourceCallbackFuncs *callback_funcs); + + void g_source_add_poll (GSource *source, + GPollFD *fd); + void g_source_remove_poll (GSource *source, + GPollFD *fd); + + void g_source_get_current_time (GSource *source, + GTimeVal *timeval); + + + + + + + + GSource *g_idle_source_new (); + GSource *g_child_watch_source_new (GPid pid); + GSource *g_timeout_source_new (guint interval); + + + + void g_get_current_time (GTimeVal *result); + gboolean g_source_remove (guint tag); + gboolean g_source_remove_by_user_data (gpointer user_data); + gboolean g_source_remove_by_funcs_user_data (GSourceFuncs *funcs, + gpointer user_data); + + + guint g_timeout_add_full (gint priority, + guint interval, + GSourceFunc Function, + gpointer data, + GDestroyNotify notify); + guint g_timeout_add (guint interval, + GSourceFunc Function, + gpointer data); + guint g_child_watch_add_full (gint priority, + GPid pid, + GChildWatchFunc Function, + gpointer data, + GDestroyNotify notify); + guint g_child_watch_add (GPid pid, + GChildWatchFunc Function, + gpointer data); + guint g_idle_add (GSourceFunc Function, + gpointer data); + guint g_idle_add_full (gint priority, + GSourceFunc Function, + gpointer data, + GDestroyNotify notify); + gboolean g_idle_remove_by_data (gpointer data); + + + GSourceFuncs g_timeout_funcs; + GSourceFuncs g_child_watch_funcs; + GSourceFuncs g_idle_funcs; + + + + + alias guint32 gunichar; + alias guint16 gunichar2; + + + + + enum GUnicodeType { + G_UNICODE_CONTROL, + G_UNICODE_FORMAT, + G_UNICODE_UNASSIGNED, + G_UNICODE_PRIVATE_USE, + G_UNICODE_SURROGATE, + G_UNICODE_LOWERCASE_LETTER, + G_UNICODE_MODIFIER_LETTER, + G_UNICODE_OTHER_LETTER, + G_UNICODE_TITLECASE_LETTER, + G_UNICODE_UPPERCASE_LETTER, + G_UNICODE_COMBINING_MARK, + G_UNICODE_ENCLOSING_MARK, + G_UNICODE_NON_SPACING_MARK, + G_UNICODE_DECIMAL_NUMBER, + G_UNICODE_LETTER_NUMBER, + G_UNICODE_OTHER_NUMBER, + G_UNICODE_CONNECT_PUNCTUATION, + G_UNICODE_DASH_PUNCTUATION, + G_UNICODE_CLOSE_PUNCTUATION, + G_UNICODE_FINAL_PUNCTUATION, + G_UNICODE_INITIAL_PUNCTUATION, + G_UNICODE_OTHER_PUNCTUATION, + G_UNICODE_OPEN_PUNCTUATION, + G_UNICODE_CURRENCY_SYMBOL, + G_UNICODE_MODIFIER_SYMBOL, + G_UNICODE_MATH_SYMBOL, + G_UNICODE_OTHER_SYMBOL, + G_UNICODE_LINE_SEPARATOR, + G_UNICODE_PARAGRAPH_SEPARATOR, + G_UNICODE_SPACE_SEPARATOR + }; + + + + + + enum GUnicodeBreakType { + G_UNICODE_BREAK_MANDATORY, + G_UNICODE_BREAK_CARRIAGE_RETURN, + G_UNICODE_BREAK_LINE_FEED, + G_UNICODE_BREAK_COMBINING_MARK, + G_UNICODE_BREAK_SURROGATE, + G_UNICODE_BREAK_ZERO_WIDTH_SPACE, + G_UNICODE_BREAK_INSEPARABLE, + G_UNICODE_BREAK_NON_BREAKING_GLUE, + G_UNICODE_BREAK_CONTINGENT, + G_UNICODE_BREAK_SPACE, + G_UNICODE_BREAK_AFTER, + G_UNICODE_BREAK_BEFORE, + G_UNICODE_BREAK_BEFORE_AND_AFTER, + G_UNICODE_BREAK_HYPHEN, + G_UNICODE_BREAK_NON_STARTER, + G_UNICODE_BREAK_OPEN_PUNCTUATION, + G_UNICODE_BREAK_CLOSE_PUNCTUATION, + G_UNICODE_BREAK_QUOTATION, + G_UNICODE_BREAK_EXCLAMATION, + G_UNICODE_BREAK_IDEOGRAPHIC, + G_UNICODE_BREAK_NUMERIC, + G_UNICODE_BREAK_INFIX_SEPARATOR, + G_UNICODE_BREAK_SYMBOL, + G_UNICODE_BREAK_ALPHABETIC, + G_UNICODE_BREAK_PREFIX, + G_UNICODE_BREAK_POSTFIX, + G_UNICODE_BREAK_COMPLEX_CONTEXT, + G_UNICODE_BREAK_AMBIGUOUS, + G_UNICODE_BREAK_UNKNOWN, + G_UNICODE_BREAK_NEXT_LINE, + G_UNICODE_BREAK_WORD_JOINER + }; + + + + + + + + + gboolean g_get_charset ( char **charset); + + + + gboolean g_unichar_isalnum (gunichar c) ; + gboolean g_unichar_isalpha (gunichar c) ; + gboolean g_unichar_iscntrl (gunichar c) ; + gboolean g_unichar_isdigit (gunichar c) ; + gboolean g_unichar_isgraph (gunichar c) ; + gboolean g_unichar_islower (gunichar c) ; + gboolean g_unichar_isprint (gunichar c) ; + gboolean g_unichar_ispunct (gunichar c) ; + gboolean g_unichar_isspace (gunichar c) ; + gboolean g_unichar_isupper (gunichar c) ; + gboolean g_unichar_isxdigit (gunichar c) ; + gboolean g_unichar_istitle (gunichar c) ; + gboolean g_unichar_isdefined (gunichar c) ; + gboolean g_unichar_iswide (gunichar c) ; + + + + gunichar g_unichar_toupper (gunichar c) ; + gunichar g_unichar_tolower (gunichar c) ; + gunichar g_unichar_totitle (gunichar c) ; + + + + gint g_unichar_digit_value (gunichar c) ; + + gint g_unichar_xdigit_value (gunichar c) ; + + + GUnicodeType g_unichar_type (gunichar c) ; + + + GUnicodeBreakType g_unichar_break_type (gunichar c) ; + + + + + + void g_unicode_canonical_ordering (gunichar *string, + gsize len); + + + + + gunichar *g_unicode_canonical_decomposition (gunichar ch, + gsize *result_len); + + + + gchar * g_utf8_skip; + + + + gunichar g_utf8_get_char ( gchar *p); + gunichar g_utf8_get_char_validated ( gchar *p, + gssize max_len); + + gchar* g_utf8_offset_to_pointer ( gchar *str, + glong offset); + glong g_utf8_pointer_to_offset ( gchar *str, + gchar *pos); + gchar* g_utf8_prev_char ( gchar *p); + gchar* g_utf8_find_next_char ( gchar *p, + gchar *end); + gchar* g_utf8_find_prev_char ( gchar *str, + gchar *p); + + glong g_utf8_strlen ( gchar *p, + gssize max); + + + gchar* g_utf8_strncpy (gchar *dest, + gchar *src, + gsize n); + + + + gchar* g_utf8_strchr ( gchar *p, + gssize len, + gunichar c); + gchar* g_utf8_strrchr ( gchar *p, + gssize len, + gunichar c); + gchar* g_utf8_strreverse ( gchar *str, + gssize len); + + gunichar2 *g_utf8_to_utf16 ( gchar *str, + glong len, + glong *items_read, + glong *items_written, + GError **error); + gunichar * g_utf8_to_ucs4 ( gchar *str, + glong len, + glong *items_read, + glong *items_written, + GError **error); + gunichar * g_utf8_to_ucs4_fast ( gchar *str, + glong len, + glong *items_written); + gunichar * g_utf16_to_ucs4 ( gunichar2 *str, + glong len, + glong *items_read, + glong *items_written, + GError **error); + gchar* g_utf16_to_utf8 ( gunichar2 *str, + glong len, + glong *items_read, + glong *items_written, + GError **error); + gunichar2 *g_ucs4_to_utf16 ( gunichar *str, + glong len, + glong *items_read, + glong *items_written, + GError **error); + gchar* g_ucs4_to_utf8 ( gunichar *str, + glong len, + glong *items_read, + glong *items_written, + GError **error); + + + + + + gint g_unichar_to_utf8 (gunichar c, + gchar *outbuf); + + + + + + gboolean g_utf8_validate ( gchar *str, + gssize max_len, + gchar **end); + + + gboolean g_unichar_validate (gunichar ch); + + gchar *g_utf8_strup ( gchar *str, + gssize len); + gchar *g_utf8_strdown ( gchar *str, + gssize len); + gchar *g_utf8_casefold ( gchar *str, + gssize len); + + enum GNormalizeMode { + G_NORMALIZE_DEFAULT, + G_NORMALIZE_NFD = G_NORMALIZE_DEFAULT, + G_NORMALIZE_DEFAULT_COMPOSE, + G_NORMALIZE_NFC = G_NORMALIZE_DEFAULT_COMPOSE, + G_NORMALIZE_ALL, + G_NORMALIZE_NFKD = G_NORMALIZE_ALL, + G_NORMALIZE_ALL_COMPOSE, + G_NORMALIZE_NFKC = G_NORMALIZE_ALL_COMPOSE + }; + + + gchar *g_utf8_normalize ( gchar *str, + gssize len, + GNormalizeMode mode); + + gint g_utf8_collate ( gchar *str1, + gchar *str2); + gchar *g_utf8_collate_key ( gchar *str, + gssize len); + + gboolean g_unichar_get_mirror_char (gunichar ch, + gunichar *mirrored_ch); + + + //alias __builtin_va_list __gnuc_va_list; + alias void* va_list; + + + gchar* g_get_user_name (); + gchar* g_get_real_name (); + gchar* g_get_home_dir (); + gchar* g_get_tmp_dir (); + gchar* g_get_prgname (); + void g_set_prgname ( gchar *prgname); + gchar* g_get_application_name (); + void g_set_application_name ( gchar *application_name); + + + alias _GDebugKey GDebugKey; + + struct _GDebugKey { + gchar *key; + guint value; + } + + + + guint g_parse_debug_string ( gchar *string, + GDebugKey *keys, + guint nkeys); + + gint g_snprintf (gchar *string, + gulong n, + gchar *format, + ...) ; + gint g_vsnprintf (gchar *string, + gulong n, + gchar *format, + va_list args); + + + gboolean g_path_is_absolute ( gchar *file_name); + + + gchar* g_path_skip_root ( gchar *file_name); + + + + + + + + gchar* g_basename ( gchar *file_name); + + + + + + gchar* g_get_current_dir (); + gchar* g_path_get_basename ( gchar *file_name); + gchar* g_path_get_dirname ( gchar *file_name); + + + + void g_nullify_pointer (gpointer *nullify_location); + + + + gchar* g_getenv ( gchar *variable); + gboolean g_setenv ( gchar *variable, + gchar *value, + gboolean overwrite); + void g_unsetenv ( gchar *variable); + + + + + + + alias void (*GVoidFunc) (); + void g_atexit (GVoidFunc func); + + + gchar* g_find_program_in_path ( gchar *program); + + + + gint g_bit_nth_lsf (gulong mask, + gint nth_bit); + gint g_bit_nth_msf (gulong mask, + gint nth_bit); + guint g_bit_storage (gulong number); + + + + + alias _GTrashStack GTrashStack; + + struct _GTrashStack { + GTrashStack *next; + } + + void g_trash_stack_push (GTrashStack **stack_p, + gpointer data_p); + gpointer g_trash_stack_pop (GTrashStack **stack_p); + gpointer g_trash_stack_peek (GTrashStack **stack_p); + guint g_trash_stack_height (GTrashStack **stack_p); + guint glib_major_version; + guint glib_minor_version; + guint glib_micro_version; + guint glib_interface_age; + guint glib_binary_age; + + + + + + + + + + + + alias _GString GString; + + alias _GStringChunk GStringChunk; + alias void _GStringChunk; + + struct _GString { + gchar *str; + gsize len; + gsize allocated_len; + } + + + + GStringChunk* g_string_chunk_new (gsize size); + void g_string_chunk_free (GStringChunk *chunk); + gchar* g_string_chunk_insert (GStringChunk *chunk, + gchar *string); + gchar* g_string_chunk_insert_len (GStringChunk *chunk, + gchar *string, + gssize len); + gchar* g_string_chunk_insert_ (GStringChunk *chunk, + gchar *string); + + + + + GString* g_string_new ( gchar *init); + GString* g_string_new_len ( gchar *init, + gssize len); + GString* g_string_sized_new (gsize dfl_size); + gchar* g_string_free (GString *string, + gboolean free_segment); + gboolean g_string_equal ( GString *v, + GString *v2); + guint g_string_hash ( GString *str); + GString* g_string_assign (GString *string, + gchar *rval); + GString* g_string_truncate (GString *string, + gsize len); + GString* g_string_set_size (GString *string, + gsize len); + GString* g_string_insert_len (GString *string, + gssize pos, + gchar *val, + gssize len); + GString* g_string_append (GString *string, + gchar *val); + GString* g_string_append_len (GString *string, + gchar *val, + gssize len); + GString* g_string_append_c (GString *string, + gchar c); + GString* g_string_append_unichar (GString *string, + gunichar wc); + GString* g_string_prepend (GString *string, + gchar *val); + GString* g_string_prepend_c (GString *string, + gchar c); + GString* g_string_prepend_unichar (GString *string, + gunichar wc); + GString* g_string_prepend_len (GString *string, + gchar *val, + gssize len); + GString* g_string_insert (GString *string, + gssize pos, + gchar *val); + GString* g_string_insert_c (GString *string, + gssize pos, + gchar c); + GString* g_string_insert_unichar (GString *string, + gssize pos, + gunichar wc); + GString* g_string_erase (GString *string, + gssize pos, + gssize len); + GString* g_string_ascii_down (GString *string); + GString* g_string_ascii_up (GString *string); + void g_string_printf (GString *string, + gchar *format, + ...) ; + void g_string_append_printf (GString *string, + gchar *format, + ...) ; + GString* g_string_down (GString *string); + GString* g_string_up (GString *string); + + + + + + + + + + + + + + + alias _GIOChannel GIOChannel; + + alias _GIOFuncs GIOFuncs; + + + enum GIOError { + G_IO_ERROR_NONE, + G_IO_ERROR_AGAIN, + G_IO_ERROR_INVAL, + G_IO_ERROR_UNKNOWN + }; + + + + + enum GIOChannelError { + + G_IO_CHANNEL_ERROR_FBIG, + G_IO_CHANNEL_ERROR_INVAL, + G_IO_CHANNEL_ERROR_IO, + G_IO_CHANNEL_ERROR_ISDIR, + G_IO_CHANNEL_ERROR_NOSPC, + G_IO_CHANNEL_ERROR_NXIO, + G_IO_CHANNEL_ERROR_OVERFLOW, + G_IO_CHANNEL_ERROR_PIPE, + + G_IO_CHANNEL_ERROR_FAILED + }; + + + enum GIOStatus { + G_IO_STATUS_ERROR, + G_IO_STATUS_NORMAL, + G_IO_STATUS_EOF, + G_IO_STATUS_AGAIN + }; + + + enum GSeekType { + G_SEEK_CUR, + G_SEEK_SET, + G_SEEK_END + }; + + + enum GIOCondition { + G_IO_IN =1, + G_IO_OUT =4, + G_IO_PRI =2, + G_IO_ERR =8, + G_IO_HUP =16, + G_IO_NVAL =32 + }; + + + enum GIOFlags { + G_IO_FLAG_APPEND = 1 << 0, + G_IO_FLAG_NONBLOCK = 1 << 1, + G_IO_FLAG_IS_READABLE = 1 << 2, + G_IO_FLAG_IS_WRITEABLE = 1 << 3, + G_IO_FLAG_IS_SEEKABLE = 1 << 4, + G_IO_FLAG_MASK = (1 << 5) - 1, + G_IO_FLAG_GET_MASK = G_IO_FLAG_MASK, + G_IO_FLAG_SET_MASK = G_IO_FLAG_APPEND | G_IO_FLAG_NONBLOCK + }; + + + struct _GIOChannel { + + guint ref_count; + GIOFuncs *funcs; + + gchar *encoding; + GIConv read_cd; + GIConv write_cd; + gchar *line_term; + guint line_term_len; + + gsize buf_size; + GString *read_buf; + GString *encoded_read_buf; + GString *write_buf; + gchar partial_write_buf[6]; + + + + guint use_buffer; + guint do_encode; + guint close_on_unref; + guint is_readable; + guint is_writeable; + guint is_seekable; + + gpointer reserved1; + gpointer reserved2; + } + + alias gboolean (*GIOFunc) (GIOChannel *source, + GIOCondition condition, + gpointer data); + struct _GIOFuncs { + GIOStatus (*io_read) (GIOChannel *channel, + gchar *buf, + gsize count, + gsize *bytes_read, + GError **err); + GIOStatus (*io_write) (GIOChannel *channel, + gchar *buf, + gsize count, + gsize *bytes_written, + GError **err); + GIOStatus (*io_seek) (GIOChannel *channel, + gint64 offset, + GSeekType type, + GError **err); + GIOStatus (*io_close) (GIOChannel *channel, + GError **err); + GSource* (*io_create_watch) (GIOChannel *channel, + GIOCondition condition); + void (*io_free) (GIOChannel *channel); + GIOStatus (*io_set_flags) (GIOChannel *channel, + GIOFlags flags, + GError **err); + GIOFlags (*io_get_flags) (GIOChannel *channel); + } + + void g_io_channel_init (GIOChannel *channel); + void g_io_channel_ref (GIOChannel *channel); + void g_io_channel_unref (GIOChannel *channel); + + + GIOError g_io_channel_read (GIOChannel *channel, + gchar *buf, + gsize count, + gsize *bytes_read); + GIOError g_io_channel_write (GIOChannel *channel, + gchar *buf, + gsize count, + gsize *bytes_written); + GIOError g_io_channel_seek (GIOChannel *channel, + gint64 offset, + GSeekType type); + void g_io_channel_close (GIOChannel *channel); + + + GIOStatus g_io_channel_shutdown (GIOChannel *channel, + gboolean flush, + GError **err); + guint g_io_add_watch_full (GIOChannel *channel, + gint priority, + GIOCondition condition, + GIOFunc func, + gpointer user_data, + GDestroyNotify notify); + GSource * g_io_create_watch (GIOChannel *channel, + GIOCondition condition); + guint g_io_add_watch (GIOChannel *channel, + GIOCondition condition, + GIOFunc func, + gpointer user_data); + + + + + void g_io_channel_set_buffer_size (GIOChannel *channel, + gsize size); + gsize g_io_channel_get_buffer_size (GIOChannel *channel); + GIOCondition g_io_channel_get_buffer_condition (GIOChannel *channel); + GIOStatus g_io_channel_set_flags (GIOChannel *channel, + GIOFlags flags, + GError **error); + GIOFlags g_io_channel_get_flags (GIOChannel *channel); + void g_io_channel_set_line_term (GIOChannel *channel, + gchar *line_term, + gint length); + gchar* g_io_channel_get_line_term (GIOChannel *channel, + gint *length); + void g_io_channel_set_buffered (GIOChannel *channel, + gboolean buffered); + gboolean g_io_channel_get_buffered (GIOChannel *channel); + GIOStatus g_io_channel_set_encoding (GIOChannel *channel, + gchar *encoding, + GError **error); + gchar* g_io_channel_get_encoding (GIOChannel *channel); + void g_io_channel_set_close_on_unref (GIOChannel *channel, + gboolean do_close); + gboolean g_io_channel_get_close_on_unref (GIOChannel *channel); + + + GIOStatus g_io_channel_flush (GIOChannel *channel, + GError **error); + GIOStatus g_io_channel_read_line (GIOChannel *channel, + gchar **str_return, + gsize *length, + gsize *terminator_pos, + GError **error); + GIOStatus g_io_channel_read_line_string (GIOChannel *channel, + GString *buffer, + gsize *terminator_pos, + GError **error); + GIOStatus g_io_channel_read_to_end (GIOChannel *channel, + gchar **str_return, + gsize *length, + GError **error); + GIOStatus g_io_channel_read_chars (GIOChannel *channel, + gchar *buf, + gsize count, + gsize *bytes_read, + GError **error); + GIOStatus g_io_channel_read_unichar (GIOChannel *channel, + gunichar *thechar, + GError **error); + GIOStatus g_io_channel_write_chars (GIOChannel *channel, + gchar *buf, + gssize count, + gsize *bytes_written, + GError **error); + GIOStatus g_io_channel_write_unichar (GIOChannel *channel, + gunichar thechar, + GError **error); + GIOStatus g_io_channel_seek_position (GIOChannel *channel, + gint64 offset, + GSeekType type, + GError **error); + GIOChannel* g_io_channel_new_file ( gchar *filename, + gchar *mode, + GError **error); + + + + GQuark g_io_channel_error_quark (); + GIOChannelError g_io_channel_error_from_errno (gint en); + GIOChannel* g_io_channel_unix_new (int fd); + gint g_io_channel_unix_get_fd (GIOChannel *channel); + + + + GSourceFuncs g_io_watch_funcs; + + + + + + + enum GMarkupError { + G_MARKUP_ERROR_BAD_UTF8, + G_MARKUP_ERROR_EMPTY, + G_MARKUP_ERROR_PARSE, + + + + G_MARKUP_ERROR_UNKNOWN_ELEMENT, + G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, + G_MARKUP_ERROR_INVALID_CONTENT + }; + + + + + GQuark g_markup_error_quark (); + + enum GMarkupParseFlags { + + G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1 << 0 + + }; + + + alias _GMarkupParseContext GMarkupParseContext; + alias void _GMarkupParseContext; + + alias _GMarkupParser GMarkupParser; + + + struct _GMarkupParser { + + void (*start_element) (GMarkupParseContext *context, + gchar *element_name, + gchar **attribute_names, + gchar **attribute_values, + gpointer user_data, + GError **error); + + + void (*end_element) (GMarkupParseContext *context, + gchar *element_name, + gpointer user_data, + GError **error); + + + + void (*text) (GMarkupParseContext *context, + gchar *text, + gsize text_len, + gpointer user_data, + GError **error); + + + + + + + void (*passthrough) (GMarkupParseContext *context, + gchar *passthrough_text, + gsize text_len, + gpointer user_data, + GError **error); + + + + + void (*error) (GMarkupParseContext *context, + GError *error, + gpointer user_data); + } + + GMarkupParseContext *g_markup_parse_context_new ( GMarkupParser *parser, + GMarkupParseFlags flags, + gpointer user_data, + GDestroyNotify user_data_dnotify); + void g_markup_parse_context_free (GMarkupParseContext *context); + gboolean g_markup_parse_context_parse (GMarkupParseContext *context, + gchar *text, + gssize text_len, + GError **error); + + gboolean g_markup_parse_context_end_parse (GMarkupParseContext *context, + GError **error); + gchar *g_markup_parse_context_get_element (GMarkupParseContext *context); + + + void g_markup_parse_context_get_position (GMarkupParseContext *context, + gint *line_number, + gint *char_number); + + + gchar* g_markup_escape_text ( gchar *text, + gssize length); + + gchar *g_markup_printf_escaped ( char *format, + ...) ; + gchar *g_markup_vprintf_escaped ( char *format, + va_list args); + + + + + + + + + + + gsize g_printf_string_upper_bound ( gchar* format, + va_list args); + enum GLogLevelFlags { + + G_LOG_FLAG_RECURSION = 1 << 0, + G_LOG_FLAG_FATAL = 1 << 1, + + + G_LOG_LEVEL_ERROR = 1 << 2, + G_LOG_LEVEL_CRITICAL = 1 << 3, + G_LOG_LEVEL_WARNING = 1 << 4, + G_LOG_LEVEL_MESSAGE = 1 << 5, + G_LOG_LEVEL_INFO = 1 << 6, + G_LOG_LEVEL_DEBUG = 1 << 7, + + G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL) + }; + + + + + + alias void (*GLogFunc) (gchar *log_domain, + GLogLevelFlags log_level, + gchar *message, + gpointer user_data); + + + + guint g_log_set_handler ( gchar *log_domain, + GLogLevelFlags log_levels, + GLogFunc log_func, + gpointer user_data); + void g_log_remove_handler ( gchar *log_domain, + guint handler_id); + void g_log_default_handler ( gchar *log_domain, + GLogLevelFlags log_level, + gchar *message, + gpointer unused_data); + void g_log ( gchar *log_domain, + GLogLevelFlags log_level, + gchar *format, + ...) ; + void g_logv ( gchar *log_domain, + GLogLevelFlags log_level, + gchar *format, + va_list args); + GLogLevelFlags g_log_set_fatal_mask ( gchar *log_domain, + GLogLevelFlags fatal_mask); + GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask); + + + void _g_log_fallback_handler ( gchar *log_domain, + GLogLevelFlags log_level, + gchar *message, + gpointer unused_data); + alias void (*GPrintFunc) (gchar *string); + void g_print ( gchar *format, + ...) ; + GPrintFunc g_set_print_handler (GPrintFunc func); + void g_printerr ( gchar *format, + ...) ; + GPrintFunc g_set_printerr_handler (GPrintFunc func); + + + + alias _GNode GNode; + + + + enum GTraverseFlags { + G_TRAVERSE_LEAFS = 1 << 0, + G_TRAVERSE_NON_LEAFS = 1 << 1, + G_TRAVERSE_ALL = G_TRAVERSE_LEAFS | G_TRAVERSE_NON_LEAFS, + G_TRAVERSE_MASK = 0x03 + }; + + + + enum GTraverseType { + G_IN_ORDER, + G_PRE_ORDER, + G_POST_ORDER, + G_LEVEL_ORDER + }; + + + alias gboolean (*GNodeTraverseFunc) (GNode *node, + gpointer data); + alias void (*GNodeForeachFunc) (GNode *node, + gpointer data); + alias gpointer (*GCopyFunc) (gpointer src, + gpointer data); + + + + struct _GNode { + gpointer data; + GNode *next; + GNode *prev; + GNode *parent; + GNode *children; + } + + + + + + + void g_node_push_allocator (GAllocator *allocator); + void g_node_pop_allocator (); + GNode* g_node_new (gpointer data); + void g_node_destroy (GNode *root); + void g_node_unlink (GNode *node); + GNode* g_node_copy_deep (GNode *node, + GCopyFunc copy_func, + gpointer data); + GNode* g_node_copy (GNode *node); + GNode* g_node_insert (GNode *parent, + gint position, + GNode *node); + GNode* g_node_insert_before (GNode *parent, + GNode *sibling, + GNode *node); + GNode* g_node_insert_after (GNode *parent, + GNode *sibling, + GNode *node); + GNode* g_node_prepend (GNode *parent, + GNode *node); + guint g_node_n_nodes (GNode *root, + GTraverseFlags flags); + GNode* g_node_get_root (GNode *node); + gboolean g_node_is_ancestor (GNode *node, + GNode *descendant); + guint g_node_depth (GNode *node); + GNode* g_node_find (GNode *root, + GTraverseType order, + GTraverseFlags flags, + gpointer data); + void g_node_traverse (GNode *root, + GTraverseType order, + GTraverseFlags flags, + gint max_depth, + GNodeTraverseFunc func, + gpointer data); + + + + + + + guint g_node_max_height (GNode *root); + + void g_node_children_foreach (GNode *node, + GTraverseFlags flags, + GNodeForeachFunc func, + gpointer data); + void g_node_reverse_children (GNode *node); + guint g_node_n_children (GNode *node); + GNode* g_node_nth_child (GNode *node, + guint n); + GNode* g_node_last_child (GNode *node); + GNode* g_node_find_child (GNode *node, + GTraverseFlags flags, + gpointer data); + gint g_node_child_position (GNode *node, + GNode *child); + gint g_node_child_index (GNode *node, + gpointer data); + + GNode* g_node_first_sibling (GNode *node); + GNode* g_node_last_sibling (GNode *node); + + + + + alias _GPatternSpec GPatternSpec; + alias void _GPatternSpec; + + + GPatternSpec* g_pattern_spec_new ( gchar *pattern); + void g_pattern_spec_free (GPatternSpec *pspec); + gboolean g_pattern_spec_equal (GPatternSpec *pspec1, + GPatternSpec *pspec2); + gboolean g_pattern_match (GPatternSpec *pspec, + guint string_length, + gchar *string, + gchar *string_reversed); + gboolean g_pattern_match_string (GPatternSpec *pspec, + gchar *string); + gboolean g_pattern_match_simple ( gchar *pattern, + gchar *string); + + + + guint g_spaced_primes_closest (guint num) ; + + + + + void g_qsort_with_data (gpointer pbase, + gint total_elems, + gsize size, + GCompareDataFunc compare_func, + gpointer user_data); + + + + + + alias _GQueue GQueue; + + + struct _GQueue { + GList *head; + GList *tail; + guint length; + } + + + + GQueue* g_queue_new (); + void g_queue_free (GQueue *queue); + gboolean g_queue_is_empty (GQueue *queue); + guint g_queue_get_length (GQueue *queue); + void g_queue_reverse (GQueue *queue); + GQueue * g_queue_copy (GQueue *queue); + void g_queue_foreach (GQueue *queue, + GFunc func, + gpointer user_data); + GList * g_queue_find (GQueue *queue, + gpointer data); + GList * g_queue_find_custom (GQueue *queue, + gpointer data, + GCompareFunc func); + void g_queue_sort (GQueue *queue, + GCompareDataFunc compare_func, + gpointer user_data); + + void g_queue_push_head (GQueue *queue, + gpointer data); + void g_queue_push_tail (GQueue *queue, + gpointer data); + void g_queue_push_nth (GQueue *queue, + gpointer data, + gint n); + gpointer g_queue_pop_head (GQueue *queue); + gpointer g_queue_pop_tail (GQueue *queue); + gpointer g_queue_pop_nth (GQueue *queue, + guint n); + gpointer g_queue_peek_head (GQueue *queue); + gpointer g_queue_peek_tail (GQueue *queue); + gpointer g_queue_peek_nth (GQueue *queue, + guint n); + gint g_queue_index (GQueue *queue, + gpointer data); + void g_queue_remove (GQueue *queue, + gpointer data); + void g_queue_remove_all (GQueue *queue, + gpointer data); + void g_queue_insert_before (GQueue *queue, + GList *sibling, + gpointer data); + void g_queue_insert_after (GQueue *queue, + GList *sibling, + gpointer data); + void g_queue_insert_sorted (GQueue *queue, + gpointer data, + GCompareDataFunc func, + gpointer user_data); + + void g_queue_push_head_link (GQueue *queue, + GList *link_); + void g_queue_push_tail_link (GQueue *queue, + GList *link_); + void g_queue_push_nth_link (GQueue *queue, + gint n, + GList *link_); + GList* g_queue_pop_head_link (GQueue *queue); + GList* g_queue_pop_tail_link (GQueue *queue); + GList* g_queue_pop_nth_link (GQueue *queue, + guint n); + GList* g_queue_peek_head_link (GQueue *queue); + GList* g_queue_peek_tail_link (GQueue *queue); + GList* g_queue_peek_nth_link (GQueue *queue, + guint n); + gint g_queue_link_index (GQueue *queue, + GList *link_); + void g_queue_unlink (GQueue *queue, + GList *link_); + void g_queue_delete_link (GQueue *queue, + GList *link_); + + + + + alias _GRand GRand; + alias void _GRand; + + GRand* g_rand_new_with_seed (guint32 seed); + GRand* g_rand_new_with_seed_array ( guint32 *seed, + guint seed_length); + GRand* g_rand_new (); + void g_rand_free (GRand *rand_); + GRand* g_rand_copy (GRand *rand_); + void g_rand_set_seed (GRand *rand_, + guint32 seed); + void g_rand_set_seed_array (GRand *rand_, + guint32 *seed, + guint seed_length); + + + + guint32 g_rand_int (GRand *rand_); + gint32 g_rand_int_range (GRand *rand_, + gint32 begin, + gint32 end); + gdouble g_rand_double (GRand *rand_); + gdouble g_rand_double_range (GRand *rand_, + gdouble begin, + gdouble end); + void g_random_set_seed (guint32 seed); + + + + guint32 g_random_int (); + gint32 g_random_int_range (gint32 begin, + gint32 end); + gdouble g_random_double (); + gdouble g_random_double_range (gdouble begin, + gdouble end); + + + + + + alias _GRelation GRelation; + alias void _GRelation; + + alias _GTuples GTuples; + + + struct _GTuples { + guint len; + } + GRelation* g_relation_new (gint fields); + void g_relation_destroy (GRelation *relation); + void g_relation_index (GRelation *relation, + gint field, + GHashFunc hash_func, + GEqualFunc key_equal_func); + void g_relation_insert (GRelation *relation, + ...); + gint g_relation_delete (GRelation *relation, + gpointer key, + gint field); + GTuples* g_relation_select (GRelation *relation, + gpointer key, + gint field); + gint g_relation_count (GRelation *relation, + gpointer key, + gint field); + gboolean g_relation_exists (GRelation *relation, + ...); + void g_relation_print (GRelation *relation); + + void g_tuples_destroy (GTuples *tuples); + gpointer g_tuples_index (GTuples *tuples, + gint index_, + gint field); + + + + + alias _GScanner GScanner; + + alias _GScannerConfig GScannerConfig; + + alias _GTokenValue GTokenValue; + + + alias void (*GScannerMsgFunc) (GScanner *scanner, + gchar *message, + gboolean error); + enum GErrorType { + G_ERR_UNKNOWN, + G_ERR_UNEXP_EOF, + G_ERR_UNEXP_EOF_IN_STRING, + G_ERR_UNEXP_EOF_IN_COMMENT, + G_ERR_NON_DIGIT_IN_CONST, + G_ERR_DIGIT_RADIX, + G_ERR_FLOAT_RADIX, + G_ERR_FLOAT_MALFORMED + }; + + + + enum GTokenType + { + G_TOKEN_EOF = 0, + + G_TOKEN_LEFT_PAREN = '(', + G_TOKEN_RIGHT_PAREN = ')', + G_TOKEN_LEFT_CURLY = '{', + G_TOKEN_RIGHT_CURLY = '}', + G_TOKEN_LEFT_BRACE = '[', + G_TOKEN_RIGHT_BRACE = ']', + G_TOKEN_EQUAL_SIGN = '=', + G_TOKEN_COMMA = ',', + + G_TOKEN_NONE = 256, + + G_TOKEN_ERROR, + + G_TOKEN_CHAR, + G_TOKEN_BINARY, + G_TOKEN_OCTAL, + G_TOKEN_INT, + G_TOKEN_HEX, + G_TOKEN_FLOAT, + G_TOKEN_STRING, + + G_TOKEN_SYMBOL, + G_TOKEN_IDENTIFIER, + G_TOKEN_IDENTIFIER_NULL, + + G_TOKEN_COMMENT_SINGLE, + G_TOKEN_COMMENT_MULTI, + G_TOKEN_LAST + } + + union _GTokenValue { + gpointer v_symbol; + gchar *v_identifier; + gulong v_binary; + gulong v_octal; + gulong v_int; + guint64 v_int64; + gdouble v_float; + gulong v_hex; + gchar *v_string; + gchar *v_comment; + guchar v_char; + guint v_error; + } + + struct _GScannerConfig { + + + gchar *cset_skip_characters; + gchar *cset_identifier_first; + gchar *cset_identifier_nth; + gchar *cpair_comment_single; + + + + guint case_sensitive; + + + + + guint skip_comment_multi; + guint skip_comment_single; + guint scan_comment_multi; + guint scan_identifier; + guint scan_identifier_1char; + guint scan_identifier_NULL; + guint scan_symbols; + guint scan_binary; + guint scan_octal; + guint scan_float; + guint scan_hex; + guint scan_hex_dollar; + guint scan_string_sq; + guint scan_string_dq; + guint numbers_2_int; + guint int_2_float; + guint identifier_2_string; + guint char_2_token; + guint symbol_2_token; + guint scope_0_fallback; + guint store_int64; + guint padding_dummy; + } + + struct _GScanner { + + gpointer user_data; + guint max_parse_errors; + + + guint parse_errors; + + + gchar *input_name; + + + GData *qdata; + + + GScannerConfig *config; + + + GTokenType token; + GTokenValue value; + guint line; + guint position; + + + GTokenType next_token; + GTokenValue next_value; + guint next_line; + guint next_position; + + + GHashTable *symbol_table; + gint input_fd; + gchar *text; + gchar *text_end; + gchar *buffer; + guint scope_id; + + + GScannerMsgFunc msg_handler; + } + + GScanner* g_scanner_new ( GScannerConfig *config_templ); + void g_scanner_destroy (GScanner *scanner); + void g_scanner_input_file (GScanner *scanner, + gint input_fd); + void g_scanner_sync_file_offset (GScanner *scanner); + void g_scanner_input_text (GScanner *scanner, + gchar *text, + guint text_len); + GTokenType g_scanner_get_next_token (GScanner *scanner); + GTokenType g_scanner_peek_next_token (GScanner *scanner); + GTokenType g_scanner_cur_token (GScanner *scanner); + GTokenValue g_scanner_cur_value (GScanner *scanner); + guint g_scanner_cur_line (GScanner *scanner); + guint g_scanner_cur_position (GScanner *scanner); + gboolean g_scanner_eof (GScanner *scanner); + guint g_scanner_set_scope (GScanner *scanner, + guint scope_id); + void g_scanner_scope_add_symbol (GScanner *scanner, + guint scope_id, + gchar *symbol, + gpointer value); + void g_scanner_scope_remove_symbol (GScanner *scanner, + guint scope_id, + gchar *symbol); + gpointer g_scanner_scope_lookup_symbol (GScanner *scanner, + guint scope_id, + gchar *symbol); + void g_scanner_scope_foreach_symbol (GScanner *scanner, + guint scope_id, + GHFunc func, + gpointer user_data); + gpointer g_scanner_lookup_symbol (GScanner *scanner, + gchar *symbol); + void g_scanner_unexp_token (GScanner *scanner, + GTokenType expected_token, + gchar *identifier_spec, + gchar *symbol_spec, + gchar *symbol_name, + gchar *message, + gint is_error); + void g_scanner_error (GScanner *scanner, + gchar *format, + ...) ; + void g_scanner_warn (GScanner *scanner, + gchar *format, + ...) ; + + + + + + enum GShellError { + + G_SHELL_ERROR_BAD_QUOTING, + + G_SHELL_ERROR_EMPTY_STRING, + G_SHELL_ERROR_FAILED + }; + + + GQuark g_shell_error_quark (); + + gchar* g_shell_quote ( gchar *unquoted_string); + gchar* g_shell_unquote ( gchar *quoted_string, + GError **error); + gboolean g_shell_parse_argv ( gchar *command_line, + gint *argcp, + gchar ***argvp, + GError **error); + + + + + + + + + enum GSpawnError { + G_SPAWN_ERROR_FORK, + G_SPAWN_ERROR_READ, + G_SPAWN_ERROR_CHDIR, + G_SPAWN_ERROR_ACCES, + G_SPAWN_ERROR_PERM, + G_SPAWN_ERROR_2BIG, + G_SPAWN_ERROR_NOEXEC, + G_SPAWN_ERROR_NAMETOOLONG, + G_SPAWN_ERROR_NOENT, + G_SPAWN_ERROR_NOMEM, + G_SPAWN_ERROR_NOTDIR, + G_SPAWN_ERROR_LOOP, + G_SPAWN_ERROR_TXTBUSY, + G_SPAWN_ERROR_IO, + G_SPAWN_ERROR_NFILE, + G_SPAWN_ERROR_MFILE, + G_SPAWN_ERROR_INVAL, + G_SPAWN_ERROR_ISDIR, + G_SPAWN_ERROR_LIBBAD, + G_SPAWN_ERROR_FAILED + + + }; + + + alias void (* GSpawnChildSetupFunc) (gpointer user_data); + + enum GSpawnFlags { + G_SPAWN_LEAVE_DESCRIPTORS_OPEN = 1 << 0, + G_SPAWN_DO_NOT_REAP_CHILD = 1 << 1, + + G_SPAWN_SEARCH_PATH = 1 << 2, + + G_SPAWN_STDOUT_TO_DEV_NULL = 1 << 3, + G_SPAWN_STDERR_TO_DEV_NULL = 1 << 4, + G_SPAWN_CHILD_INHERITS_STDIN = 1 << 5, + G_SPAWN_FILE_AND_ARGV_ZERO = 1 << 6 + }; + + + GQuark g_spawn_error_quark (); + + gboolean g_spawn_async ( gchar *working_directory, + gchar **argv, + gchar **envp, + GSpawnFlags flags, + GSpawnChildSetupFunc child_setup, + gpointer user_data, + GPid *child_pid, + GError **error); + + + + + + gboolean g_spawn_async_with_pipes ( gchar *working_directory, + gchar **argv, + gchar **envp, + GSpawnFlags flags, + GSpawnChildSetupFunc child_setup, + gpointer user_data, + GPid *child_pid, + gint *standard_input, + gint *standard_output, + gint *standard_error, + GError **error); + + + + + + + gboolean g_spawn_sync ( gchar *working_directory, + gchar **argv, + gchar **envp, + GSpawnFlags flags, + GSpawnChildSetupFunc child_setup, + gpointer user_data, + gchar **standard_output, + gchar **standard_error, + gint *exit_status, + GError **error); + + gboolean g_spawn_command_line_sync ( gchar *command_line, + gchar **standard_output, + gchar **standard_error, + gint *exit_status, + GError **error); + gboolean g_spawn_command_line_async ( gchar *command_line, + GError **error); + + void g_spawn_close_pid (GPid pid); + + + + + + + enum GAsciiType { + G_ASCII_ALNUM = 1 << 0, + G_ASCII_ALPHA = 1 << 1, + G_ASCII_CNTRL = 1 << 2, + G_ASCII_DIGIT = 1 << 3, + G_ASCII_GRAPH = 1 << 4, + G_ASCII_LOWER = 1 << 5, + G_ASCII_PRINT = 1 << 6, + G_ASCII_PUNCT = 1 << 7, + G_ASCII_SPACE = 1 << 8, + G_ASCII_UPPER = 1 << 9, + G_ASCII_XDIGIT = 1 << 10 + }; + + + guint16 * g_ascii_table; + gchar g_ascii_tolower (gchar c) ; + gchar g_ascii_toupper (gchar c) ; + + gint g_ascii_digit_value (gchar c) ; + gint g_ascii_xdigit_value (gchar c) ; + + + + + + gchar* g_strdelimit (gchar *string, + gchar *delimiters, + gchar new_delimiter); + gchar* g_strcanon (gchar *string, + gchar *valid_chars, + gchar substitutor); + gchar* g_strerror (gint errnum) ; + gchar* g_strsignal (gint signum) ; + gchar* g_strreverse (gchar *string); + gsize g_strlcpy (gchar *dest, + gchar *src, + gsize dest_size); + gsize g_strlcat (gchar *dest, + gchar *src, + gsize dest_size); + gchar * g_strstr_len ( gchar *haystack, + gssize haystack_len, + gchar *needle); + gchar * g_strrstr ( gchar *haystack, + gchar *needle); + gchar * g_strrstr_len ( gchar *haystack, + gssize haystack_len, + gchar *needle); + + gboolean g_str_has_suffix ( gchar *str, + gchar *suffix); + gboolean g_str_has_prefix ( gchar *str, + gchar *prefix); + + + + gdouble g_strtod ( gchar *nptr, + gchar **endptr); + gdouble g_ascii_strtod ( gchar *nptr, + gchar **endptr); + guint64 g_ascii_strtoull ( gchar *nptr, + gchar **endptr, + guint base); + + + + + gchar * g_ascii_dtostr (gchar *buffer, + gint buf_len, + gdouble d); + gchar * g_ascii_formatd (gchar *buffer, + gint buf_len, + gchar *format, + gdouble d); + + + gchar* g_strchug (gchar *string); + + gchar* g_strchomp (gchar *string); + + + + gint g_ascii_strcasecmp ( gchar *s1, + gchar *s2); + gint g_ascii_strncasecmp ( gchar *s1, + gchar *s2, + gsize n); + gchar* g_ascii_strdown ( gchar *str, + gssize len); + gchar* g_ascii_strup ( gchar *str, + gssize len); + gint g_strcasecmp ( gchar *s1, + gchar *s2); + gint g_strncasecmp ( gchar *s1, + gchar *s2, + guint n); + gchar* g_strdown (gchar *string); + gchar* g_strup (gchar *string); + + + + + + + gchar* g_strdup ( gchar *str); + gchar* g_strdup_printf ( gchar *format, + ...) ; + gchar* g_strdup_vprintf ( gchar *format, + va_list args); + gchar* g_strndup ( gchar *str, + gsize n); + gchar* g_strnfill (gsize length, + gchar fill_char); + gchar* g_strconcat ( gchar *string1, + ...); + gchar* g_strjoin ( gchar *separator, + ...); + + + + + gchar* g_strcompress ( gchar *source); + gchar* g_strescape ( gchar *source, + gchar *exceptions); + + gpointer g_memdup (gpointer mem, + guint byte_size); + gchar** g_strsplit ( gchar *string, + gchar *delimiter, + gint max_tokens); + gchar ** g_strsplit_set ( gchar *string, + gchar *delimiters, + gint max_tokens); + gchar* g_strjoinv ( gchar *separator, + gchar **str_array); + void g_strfreev (gchar **str_array); + gchar** g_strdupv (gchar **str_array); + + gchar* g_stpcpy (gchar *dest, + char *src); + + gchar *g_strip_context ( gchar *msgid, + gchar *msgval); + + + + + + + alias _GThreadPool GThreadPool; + + + + + + + + struct _GThreadPool { + GFunc func; + gpointer user_data; + gboolean exclusive; + } + + + + + + + GThreadPool* g_thread_pool_new (GFunc func, + gpointer user_data, + gint max_threads, + gboolean exclusive, + GError **error); + + + + + + void g_thread_pool_push (GThreadPool *pool, + gpointer data, + GError **error); + + + + + void g_thread_pool_set_max_threads (GThreadPool *pool, + gint max_threads, + GError **error); + gint g_thread_pool_get_max_threads (GThreadPool *pool); + + + + guint g_thread_pool_get_num_threads (GThreadPool *pool); + + + guint g_thread_pool_unprocessed (GThreadPool *pool); + + + + + + void g_thread_pool_free (GThreadPool *pool, + gboolean immediate, + gboolean wait); + + + + void g_thread_pool_set_max_unused_threads (gint max_threads); + gint g_thread_pool_get_max_unused_threads (); + guint g_thread_pool_get_num_unused_threads (); + + + void g_thread_pool_stop_unused_threads (); + + alias _GTimer GTimer; + alias void _GTimer; + + GTimer* g_timer_new (); + void g_timer_destroy (GTimer *timer); + void g_timer_start (GTimer *timer); + void g_timer_stop (GTimer *timer); + void g_timer_reset (GTimer *timer); + void g_timer_continue (GTimer *timer); + gdouble g_timer_elapsed (GTimer *timer, + gulong *microseconds); + + void g_usleep (gulong microseconds); + + void g_time_val_add (GTimeVal *time_, + glong microseconds); + + + + + alias _GTree GTree; + alias void _GTree; + + + alias gboolean (*GTraverseFunc) (gpointer key, + gpointer value, + gpointer data); + + + + GTree* g_tree_new (GCompareFunc key_compare_func); + GTree* g_tree_new_with_data (GCompareDataFunc key_compare_func, + gpointer key_compare_data); + GTree* g_tree_new_full (GCompareDataFunc key_compare_func, + gpointer key_compare_data, + GDestroyNotify key_destroy_func, + GDestroyNotify value_destroy_func); + void g_tree_destroy (GTree *tree); + void g_tree_insert (GTree *tree, + gpointer key, + gpointer value); + void g_tree_replace (GTree *tree, + gpointer key, + gpointer value); + void g_tree_remove (GTree *tree, + gpointer key); + void g_tree_steal (GTree *tree, + gpointer key); + gpointer g_tree_lookup (GTree *tree, + gpointer key); + gboolean g_tree_lookup_extended (GTree *tree, + gpointer lookup_key, + gpointer *orig_key, + gpointer *value); + void g_tree_foreach (GTree *tree, + GTraverseFunc func, + gpointer user_data); + + + void g_tree_traverse (GTree *tree, + GTraverseFunc traverse_func, + GTraverseType traverse_type, + gpointer user_data); + + + gpointer g_tree_search (GTree *tree, + GCompareFunc search_func, + gpointer user_data); + gint g_tree_height (GTree *tree); + gint g_tree_nnodes (GTree *tree); + + + + + + + alias _PangoCoverage PangoCoverage; + alias void _PangoCoverage; + + + enum PangoCoverageLevel { + PANGO_COVERAGE_NONE, + PANGO_COVERAGE_FALLBACK, + PANGO_COVERAGE_APPROXIMATE, + PANGO_COVERAGE_EXACT + }; + + + PangoCoverage * pango_coverage_new (); + PangoCoverage * pango_coverage_ref (PangoCoverage *coverage); + void pango_coverage_unref (PangoCoverage *coverage); + PangoCoverage * pango_coverage_copy (PangoCoverage *coverage); + PangoCoverageLevel pango_coverage_get (PangoCoverage *coverage, + int index_); + void pango_coverage_set (PangoCoverage *coverage, + int index_, + PangoCoverageLevel level); + void pango_coverage_max (PangoCoverage *coverage, + PangoCoverage *other); + + void pango_coverage_to_bytes (PangoCoverage *coverage, + guchar **bytes, + int *n_bytes); + PangoCoverage *pango_coverage_from_bytes (guchar *bytes, + int n_bytes); + + + + alias gulong GType; + + + + alias _GValue GValue; + + union _GTypeCValue ; + alias _GTypeCValue GTypeCValue; + + alias _GTypePlugin GTypePlugin; + alias void _GTypePlugin; + + alias _GTypeClass GTypeClass; + + alias _GTypeInterface GTypeInterface; + + alias _GTypeInstance GTypeInstance; + + alias _GTypeInfo GTypeInfo; + + alias _GTypeFundamentalInfo GTypeFundamentalInfo; + + alias _GInterfaceInfo GInterfaceInfo; + + alias _GTypeValueTable GTypeValueTable; + + alias _GTypeQuery GTypeQuery; + + + + + + struct _GTypeClass { + + GType g_type; + } + struct _GTypeInstance { + + GTypeClass *g_class; + } + struct _GTypeInterface { + + GType g_type; + GType g_instance_type; + } + struct _GTypeQuery { + GType type; + gchar *type_name; + guint class_size; + guint instance_size; + } + enum GTypeDebugFlags { + G_TYPE_DEBUG_NONE = 0, + G_TYPE_DEBUG_OBJECTS = 1 << 0, + G_TYPE_DEBUG_SIGNALS = 1 << 1, + G_TYPE_DEBUG_MASK = 0x03 + }; + + + + + void g_type_init (); + void g_type_init_with_debug_flags (GTypeDebugFlags debug_flags); + gchar* g_type_name (GType type); + GQuark g_type_qname (GType type); + GType g_type_from_name ( gchar *name); + GType g_type_parent (GType type); + guint g_type_depth (GType type); + GType g_type_next_base (GType leaf_type, + GType root_type); + gboolean g_type_is_a (GType type, + GType is_a_type); + gpointer g_type_class_ref (GType type); + gpointer g_type_class_peek (GType type); + gpointer g_type_class_peek_static (GType type); + void g_type_class_unref (gpointer g_class); + gpointer g_type_class_peek_parent (gpointer g_class); + gpointer g_type_interface_peek (gpointer instanc_class, + GType iface_type); + gpointer g_type_interface_peek_parent (gpointer g_iface); + + gpointer g_type_default_interface_ref (GType g_type); + gpointer g_type_default_interface_peek (GType g_type); + void g_type_default_interface_unref (gpointer g_iface); + + + GType* g_type_children (GType type, + guint *n_children); + GType* g_type_interfaces (GType type, + guint *n_interfaces); + + + void g_type_set_qdata (GType type, + GQuark quark, + gpointer data); + gpointer g_type_get_qdata (GType type, + GQuark quark); + void g_type_query (GType type, + GTypeQuery *query); + + + + alias void (*GBaseInitFunc) (gpointer g_class); + alias void (*GBaseFinalizeFunc) (gpointer g_class); + alias void (*GClassInitFunc) (gpointer g_class, + gpointer class_data); + alias void (*GClassFinalizeFunc) (gpointer g_class, + gpointer class_data); + alias void (*GInstanceInitFunc) (GTypeInstance *instanc, + gpointer g_class); + alias void (*GInterfaceInitFunc) (gpointer g_iface, + gpointer iface_data); + alias void (*GInterfaceFinalizeFunc) (gpointer g_iface, + gpointer iface_data); + alias gboolean (*GTypeClassCacheFunc) (gpointer cache_data, + GTypeClass *g_class); + alias void (*GTypeInterfaceCheckFunc) (gpointer func_data, + gpointer g_iface); + enum GTypeFundamentalFlags { + G_TYPE_FLAG_CLASSED = (1 << 0), + G_TYPE_FLAG_INSTANTIATABLE = (1 << 1), + G_TYPE_FLAG_DERIVABLE = (1 << 2), + G_TYPE_FLAG_DEEP_DERIVABLE = (1 << 3) + }; + + enum GTypeFlags { + G_TYPE_FLAG_ABSTRACT = (1 << 4), + G_TYPE_FLAG_VALUE_ABSTRACT = (1 << 5) + }; + + struct _GTypeInfo { + + guint16 class_size; + + GBaseInitFunc base_init; + GBaseFinalizeFunc base_finalize; + + + GClassInitFunc class_init; + GClassFinalizeFunc class_finalize; + gpointer class_data; + + + guint16 instance_size; + guint16 n_preallocs; + GInstanceInitFunc instance_init; + + + GTypeValueTable *value_table; + } + struct _GTypeFundamentalInfo { + GTypeFundamentalFlags type_flags; + } + struct _GInterfaceInfo { + GInterfaceInitFunc interface_init; + GInterfaceFinalizeFunc interface_finalize; + gpointer interface_data; + } + struct _GTypeValueTable { + void (*value_init) (GValue *value); + void (*value_free) (GValue *value); + void (*value_copy) (GValue *src_value, + GValue *dest_value); + + gpointer (*value_peek_pointer) (GValue *value); + gchar *collect_format; + gchar* (*collect_value) (GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags); + gchar *lcopy_format; + gchar* (*lcopy_value) (GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags); + } + GType g_type_register_static (GType parent_type, + gchar *type_name, + GTypeInfo *info, + GTypeFlags flags); + GType g_type_register_dynamic (GType parent_type, + gchar *type_name, + GTypePlugin *plugin, + GTypeFlags flags); + GType g_type_register_fundamental (GType type_id, + gchar *type_name, + GTypeInfo *info, + GTypeFundamentalInfo *finfo, + GTypeFlags flags); + void g_type_add_interface_static (GType instance_type, + GType interface_type, + GInterfaceInfo *info); + void g_type_add_interface_dynamic (GType instance_type, + GType interface_type, + GTypePlugin *plugin); + void g_type_interface_add_prerequisite (GType interface_type, + GType prerequisite_type); + GType*g_type_interface_prerequisites (GType interface_type, + guint *n_prerequisites); + void g_type_class_add_private (gpointer g_class, + gsize private_size); + gpointer g_type_instance_get_private (GTypeInstance *insance, + GType private_type); + GTypePlugin* g_type_get_plugin (GType type); + GTypePlugin* g_type_interface_get_plugin (GType instance_type, + GType interface_type); + GType g_type_fundamental_next (); + GType g_type_fundamental (GType type_id); + GTypeInstance* g_type_create_instance (GType type); + void g_type_free_instance (GTypeInstance *insance); + + void g_type_add_class_cache_func (gpointer cache_data, + GTypeClassCacheFunc cache_func); + void g_type_remove_class_cache_func (gpointer cache_data, + GTypeClassCacheFunc cache_func); + void g_type_class_unref_uncached (gpointer g_class); + + void g_type_add_interface_check (gpointer check_data, + GTypeInterfaceCheckFunc check_func); + void g_type_remove_interface_check (gpointer check_data, + GTypeInterfaceCheckFunc chec_func); + + GTypeValueTable* g_type_value_table_peek (GType type); + + + + gboolean g_type_check_instance (GTypeInstance *instanc); + GTypeInstance* g_type_check_instance_cast (GTypeInstance *instanc, + GType iface_type); + gboolean g_type_check_instance_is_a (GTypeInstance *instanc, + GType iface_type); + GTypeClass* g_type_check_class_cast (GTypeClass *g_class, + GType is_a_type); + gboolean g_type_check_class_is_a (GTypeClass *g_class, + GType is_a_type); + gboolean g_type_check_is_value_type (GType type); + gboolean g_type_check_value (GValue *value); + gboolean g_type_check_value_holds (GValue *value, + GType type); + gboolean g_type_test_flags (GType type, + guint flags); + + + + gchar* g_type_name_from_instance (GTypeInstance *instanc); + gchar* g_type_name_from_class (GTypeClass *g_class); + GTypeDebugFlags _g_type_debug_flags; + + + + + + + + + + + + alias gpointer (*GBoxedCopyFunc) (gpointer boxed); + alias void (*GBoxedFreeFunc) (gpointer boxed); + + + + gpointer g_boxed_copy (GType boxed_type, + gpointer src_boxed); + void g_boxed_free (GType boxed_type, + gpointer boxed); + void g_value_set_boxed (GValue *value, + gpointer v_boxed); + void g_value_set_static_boxed (GValue *value, + gpointer v_boxed); + gpointer g_value_get_boxed ( GValue *value); + gpointer g_value_dup_boxed ( GValue *value); + + + + GType g_boxed_type_register_static ( gchar *name, + GBoxedCopyFunc boxed_copy, + GBoxedFreeFunc boxed_free); + void g_value_take_boxed (GValue *value, + gpointer v_boxed); + + void g_value_set_boxed_take_ownership (GValue *value, + gpointer v_boxed); + + GType g_closure_get_type () ; + GType g_value_get_type () ; + GType g_value_array_get_type () ; + GType g_strv_get_type () ; + GType g_gstring_get_type () ; + + alias gchar** GStrv; + + + + + alias _GEnumClass GEnumClass; + + alias _GFlagsClass GFlagsClass; + + alias _GEnumValue GEnumValue; + + alias _GFlagsValue GFlagsValue; + + struct _GEnumClass { + GTypeClass g_type_class; + + + gint minimum; + gint maximum; + guint n_values; + GEnumValue *values; + } + struct _GFlagsClass { + GTypeClass g_type_class; + + + guint mask; + guint n_values; + GFlagsValue *values; + } + struct _GEnumValue { + gint value; + gchar *value_name; + gchar *value_nick; + } + struct _GFlagsValue { + guint value; + gchar *value_name; + gchar *value_nick; + } + + + + GEnumValue* g_enum_get_value (GEnumClass *enum_class, + gint value); + GEnumValue* g_enum_get_value_by_name (GEnumClass *enum_class, + gchar *name); + GEnumValue* g_enum_get_value_by_nick (GEnumClass *enum_class, + gchar *nick); + GFlagsValue* g_flags_get_first_value (GFlagsClass *flags_class, + guint value); + GFlagsValue* g_flags_get_value_by_name (GFlagsClass *flags_class, + gchar *name); + GFlagsValue* g_flags_get_value_by_nick (GFlagsClass *flags_class, + gchar *nick); + void g_value_set_enum (GValue *value, + gint v_enum); + gint g_value_get_enum ( GValue *value); + void g_value_set_flags (GValue *value, + guint v_flags); + guint g_value_get_flags ( GValue *value); + + + + + + + + GType g_enum_register_static ( gchar *name, + GEnumValue *_static_values); + GType g_flags_register_static ( gchar *name, + GFlagsValue *_static_values); + + + + void g_enum_complete_type_info (GType g_enum_type, + GTypeInfo *info, + GEnumValue *_values); + void g_flags_complete_type_info (GType g_flags_type, + GTypeInfo *info, + GFlagsValue *_values); + + + + + alias void (*GValueTransform) ( GValue *src_value, + GValue *dest_value); + struct _GValue { + + GType g_type; + + + union data_union { + gint v_int; + guint v_uint; + glong v_long; + gulong v_ulong; + gint64 v_int64; + guint64 v_uint64; + gfloat v_float; + gdouble v_double; + gpointer v_pointer; + } + data_union data[2]; + } + + + + GValue* g_value_init (GValue *value, + GType g_type); + void g_value_copy ( GValue *src_value, + GValue *dest_value); + GValue* g_value_reset (GValue *value); + void g_value_unset (GValue *value); + void g_value_set_instance (GValue *value, + gpointer instanc); + + + + gboolean g_value_fits_pointer ( GValue *value); + gpointer g_value_peek_pointer ( GValue *value); + + + + gboolean g_value_type_compatible (GType src_type, + GType dest_type); + gboolean g_value_type_transformable (GType src_type, + GType dest_type); + gboolean g_value_transform ( GValue *src_value, + GValue *dest_value); + void g_value_register_transform_func (GType src_type, + GType dest_type, + GValueTransform transform_func); + + + + + + + enum GParamFlags { + G_PARAM_READABLE = 1 << 0, + G_PARAM_WRITABLE = 1 << 1, + G_PARAM_CONSTRUCT = 1 << 2, + G_PARAM_CONSTRUCT_ONLY = 1 << 3, + G_PARAM_LAX_VALIDATION = 1 << 4, + G_PARAM_PRIVATE = 1 << 5 + }; + + + + + + + + + alias _GParamSpec GParamSpec; + + alias _GParamSpecClass GParamSpecClass; + + alias _GParameter GParameter; + + alias _GParamSpecPool GParamSpecPool; + alias void _GParamSpecPool; + + struct _GParamSpec { + GTypeInstance g_type_instance; + + gchar *name; + GParamFlags flags; + GType value_type; + GType owner_type; + + + gchar *_nick; + gchar *_blurb; + GData *qdata; + guint ref_count; + guint param_id; + } + struct _GParamSpecClass { + GTypeClass g_type_class; + + GType value_type; + + void (*finalize) (GParamSpec *pspec); + + + void (*value_set_default) (GParamSpec *pspec, + GValue *value); + gboolean (*value_validate) (GParamSpec *pspec, + GValue *value); + gint (*values_cmp) (GParamSpec *pspec, + GValue *value1, + GValue *value2); + + gpointer dummy[4]; + } + struct _GParameter { + gchar *name; + GValue value; + } + + + + GParamSpec* g_param_spec_ref (GParamSpec *pspec); + void g_param_spec_unref (GParamSpec *pspec); + void g_param_spec_sink (GParamSpec *pspec); + gpointer g_param_spec_get_qdata (GParamSpec *pspec, + GQuark quark); + void g_param_spec_set_qdata (GParamSpec *pspec, + GQuark quark, + gpointer data); + void g_param_spec_set_qdata_full (GParamSpec *pspec, + GQuark quark, + gpointer data, + GDestroyNotify destroy); + gpointer g_param_spec_steal_qdata (GParamSpec *pspec, + GQuark quark); + GParamSpec* g_param_spec_get_redirect_target (GParamSpec *pspec); + + void g_param_value_set_default (GParamSpec *pspec, + GValue *value); + gboolean g_param_value_defaults (GParamSpec *pspec, + GValue *value); + gboolean g_param_value_validate (GParamSpec *pspec, + GValue *value); + gboolean g_param_value_convert (GParamSpec *pspec, + GValue *src_value, + GValue *dest_value, + gboolean strict_validation); + gint g_param_values_cmp (GParamSpec *pspec, + GValue *value1, + GValue *value2); + gchar* g_param_spec_get_name (GParamSpec *pspec); + gchar* g_param_spec_get_nick (GParamSpec *pspec); + gchar* g_param_spec_get_blurb (GParamSpec *pspec); + void g_value_set_param (GValue *value, + GParamSpec *param); + GParamSpec* g_value_get_param ( GValue *value); + GParamSpec* g_value_dup_param ( GValue *value); + + + void g_value_take_param (GValue *value, + GParamSpec *param); + + void g_value_set_param_take_ownership (GValue *value, + GParamSpec *param); + + + + alias _GParamSpecTypeInfo GParamSpecTypeInfo; + + struct _GParamSpecTypeInfo { + + guint16 instance_size; + guint16 n_preallocs; + void (*instanc_init) (GParamSpec *pspec); + + + GType value_type; + void (*finalize) (GParamSpec *pspec); + void (*value_set_default) (GParamSpec *pspec, + GValue *value); + gboolean (*value_validate) (GParamSpec *pspec, + GValue *value); + gint (*values_cmp) (GParamSpec *pspec, + GValue *value1, + GValue *value2); + } + GType g_param_type_register_static ( gchar *name, + GParamSpecTypeInfo *pspec_info); + + + GType _g_param_type_register_static_ant ( gchar *name, + GParamSpecTypeInfo *pspec_info, + GType opt_type); + + + + gpointer g_param_spec_internal (GType param_type, + gchar *name, + gchar *nick, + gchar *blurb, + GParamFlags flags); + GParamSpecPool* g_param_spec_pool_new (gboolean type_prefixing); + void g_param_spec_pool_insert (GParamSpecPool *pool, + GParamSpec *pspec, + GType owner_type); + void g_param_spec_pool_remove (GParamSpecPool *pool, + GParamSpec *pspec); + GParamSpec* g_param_spec_pool_lookup (GParamSpecPool *pool, + gchar *param_name, + GType owner_type, + gboolean walk_ancestors); + GList* g_param_spec_pool_list_owned (GParamSpecPool *pool, + GType owner_type); + GParamSpec** g_param_spec_pool_list (GParamSpecPool *pool, + GType owner_type, + guint *n_pspecs_p); + + + + alias _GClosure GClosure; + + alias _GClosureNotifyData GClosureNotifyData; + + alias void (*GCallback) (); + alias void (*GClosureNotify) (gpointer data, + GClosure *closure); + alias void (*GClosureMarshal) (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + alias _GCClosure GCClosure; + + + + + struct _GClosureNotifyData { + gpointer data; + GClosureNotify notify; + } + struct _GClosure { + guint ref_count; + guint meta_marshal; + guint n_guards; + guint n_fnotifiers; + guint n_inotifiers; + guint in_inotify; + guint floating; + guint derivative_flag; + guint in_marshal; + guint is_invalid; + + void (*marshal) (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + gpointer data; + + GClosureNotifyData *notifiers; + } + + + struct _GCClosure { + GClosure closure; + gpointer callback; + } + + + + GClosure* g_cclosure_new (GCallback callback_func, + gpointer user_data, + GClosureNotify destroy_data); + GClosure* g_cclosure_new_swap (GCallback callback_func, + gpointer user_data, + GClosureNotify destroy_data); + GClosure* g_signal_type_cclosure_new (GType itype); + + + + GClosure* g_closure_ref (GClosure *closure); + void g_closure_sink (GClosure *closure); + void g_closure_unref (GClosure *closure); + + GClosure* g_closure_new_simple (guint sizeof_closure, + gpointer data); + void g_closure_add_finalize_notifier (GClosure *closure, + gpointer notify_data, + GClosureNotify notify_func); + void g_closure_remove_finalize_notifier (GClosure *closure, + gpointer notify_data, + GClosureNotify notify_func); + void g_closure_add_invalidate_notifier (GClosure *closure, + gpointer notify_data, + GClosureNotify notify_func); + void g_closure_remove_invalidate_notifier (GClosure *closure, + gpointer notify_data, + GClosureNotify notify_func); + void g_closure_add_marshal_guards (GClosure *closure, + gpointer pre_marshal_data, + GClosureNotify pre_marshal_notify, + gpointer post_marshal_data, + GClosureNotify post_marshal_notify); + void g_closure_set_marshal (GClosure *closure, + GClosureMarshal marshal); + void g_closure_set_meta_marshal (GClosure *closure, + gpointer marshal_data, + GClosureMarshal meta_marshal); + void g_closure_invalidate (GClosure *closure); + void g_closure_invoke (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint); + + + + + + + + void g_cclosure_marshal_VOID__VOID (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__BOOLEAN (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__CHAR (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__UCHAR (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__UINT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__LONG (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__ULONG (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__ENUM (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__FLAGS (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__FLOAT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__DOUBLE (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__PARAM (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__BOXED (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__OBJECT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_VOID__UINT_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void g_cclosure_marshal_BOOLEAN__FLAGS (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + + + + alias _GSignalQuery GSignalQuery; + + alias _GSignalInvocationHint GSignalInvocationHint; + + alias GClosureMarshal GSignalCMarshaller; + alias gboolean (*GSignalEmissionHook) (GSignalInvocationHint *ihint, + guint n_param_values, + GValue *param_values, + gpointer data); + alias gboolean (*GSignalAccumulator) (GSignalInvocationHint *ihint, + GValue *return_accu, + GValue *handler_return, + gpointer data); + + + + enum GSignalFlags { + G_SIGNAL_RUN_FIRST = 1 << 0, + G_SIGNAL_RUN_LAST = 1 << 1, + G_SIGNAL_RUN_CLEANUP = 1 << 2, + G_SIGNAL_NO_RECURSE = 1 << 3, + G_SIGNAL_DETAILED = 1 << 4, + G_SIGNAL_ACTION = 1 << 5, + G_SIGNAL_NO_HOOKS = 1 << 6 + }; + + + enum GConnectFlags { + G_CONNECT_AFTER = 1 << 0, + G_CONNECT_SWAPPED = 1 << 1 + }; + + enum GSignalMatchType { + G_SIGNAL_MATCH_ID = 1 << 0, + G_SIGNAL_MATCH_DETAIL = 1 << 1, + G_SIGNAL_MATCH_CLOSURE = 1 << 2, + G_SIGNAL_MATCH_FUNC = 1 << 3, + G_SIGNAL_MATCH_DATA = 1 << 4, + G_SIGNAL_MATCH_UNBLOCKED = 1 << 5 + }; + + + + + + + struct _GSignalInvocationHint { + guint signal_id; + GQuark detail; + GSignalFlags run_type; + } + struct _GSignalQuery { + guint signal_id; + gchar *signal_name; + GType itype; + GSignalFlags signal_flags; + GType return_type; + guint n_params; + GType *param_types; + } + + + + guint g_signal_newv ( gchar *signal_name, + GType itype, + GSignalFlags signal_flags, + GClosure *class_closure, + GSignalAccumulator accumulator, + gpointer accu_data, + GSignalCMarshaller c_marshaller, + GType return_type, + guint n_params, + GType *param_types); + guint g_signal_new_valist ( gchar *signal_name, + GType itype, + GSignalFlags signal_flags, + GClosure *class_closure, + GSignalAccumulator accumulator, + gpointer accu_data, + GSignalCMarshaller c_marshaller, + GType return_type, + guint n_params, + va_list args); + guint g_signal_new ( gchar *signal_name, + GType itype, + GSignalFlags signal_flags, + guint class_offset, + GSignalAccumulator accumulator, + gpointer accu_data, + GSignalCMarshaller c_marshaller, + GType return_type, + guint n_params, + ...); + void g_signal_emitv ( GValue *instanc_and_params, + guint signal_id, + GQuark detail, + GValue *return_value); + void g_signal_emit_valist (gpointer instanc, + guint signal_id, + GQuark detail, + va_list var_args); + void g_signal_emit (gpointer instanc, + guint signal_id, + GQuark detail, + ...); + void g_signal_emit_by_name (gpointer instanc, + gchar *detailed_signal, + ...); + guint g_signal_lookup ( gchar *name, + GType itype); + gchar* g_signal_name (guint signal_id); + void g_signal_query (guint signal_id, + GSignalQuery *query); + guint* g_signal_list_ids (GType itype, + guint *n_ids); + gboolean g_signal_parse_name ( gchar *detailed_signal, + GType itype, + guint *signal_id_p, + GQuark *detail_p, + gboolean force_detail_quark); + GSignalInvocationHint* g_signal_get_invocation_hint (gpointer instanc); + + + + void g_signal_stop_emission (gpointer instanc, + guint signal_id, + GQuark detail); + void g_signal_stop_emission_by_name (gpointer instanc, + gchar *detailed_signal); + gulong g_signal_add_emission_hook (guint signal_id, + GQuark detail, + GSignalEmissionHook hook_func, + gpointer hook_data, + GDestroyNotify data_destroy); + void g_signal_remove_emission_hook (guint signal_id, + gulong hook_id); + + + + gboolean g_signal_has_handler_pending (gpointer instanc, + guint signal_id, + GQuark detail, + gboolean may_be_blocked); + gulong g_signal_connect_closure_by_id (gpointer instanc, + guint signal_id, + GQuark detail, + GClosure *closure, + gboolean after); + gulong g_signal_connect_closure (gpointer instanc, + gchar *detailed_signal, + GClosure *closure, + gboolean after); + gulong g_signal_connect_data (gpointer instanc, + gchar *detailed_signal, + GCallback c_handler, + gpointer data, + GClosureNotify destroy_data, + GConnectFlags connect_flags); + void g_signal_handler_block (gpointer instanc, + gulong handler_id); + void g_signal_handler_unblock (gpointer instanc, + gulong handler_id); + void g_signal_handler_disconnect (gpointer instanc, + gulong handler_id); + gboolean g_signal_handler_is_connected (gpointer instanc, + gulong handler_id); + gulong g_signal_handler_find (gpointer instanc, + GSignalMatchType mask, + guint signal_id, + GQuark detail, + GClosure *closure, + gpointer func, + gpointer data); + guint g_signal_handlers_block_matched (gpointer instanc, + GSignalMatchType mask, + guint signal_id, + GQuark detail, + GClosure *closure, + gpointer func, + gpointer data); + guint g_signal_handlers_unblock_matched (gpointer instanc, + GSignalMatchType mask, + guint signal_id, + GQuark detail, + GClosure *closure, + gpointer func, + gpointer data); + guint g_signal_handlers_disconnect_matched (gpointer instanc, + GSignalMatchType mask, + guint signal_id, + GQuark detail, + GClosure *closure, + gpointer func, + gpointer data); + + + + void g_signal_override_class_closure (guint signal_id, + GType instance_type, + GClosure *class_closure); + void g_signal_chain_from_overridden ( GValue *instanc_and_params, + GValue *return_value); + gboolean g_signal_accumulator_true_handled (GSignalInvocationHint *ihint, + GValue *return_accu, + GValue *handler_return, + gpointer dummy); + + + void g_signal_handlers_destroy (gpointer instanc); + void _g_signals_destroy (GType itype); + + + + + alias _GObject GObject; + + alias _GObjectClass GObjectClass; + + + alias void (*GObjectGetPropertyFunc) (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + alias void (*GObjectSetPropertyFunc) (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + alias void (*GObjectFinalizeFunc) (GObject *object); + alias void (*GWeakNotify) (gpointer data, + GObject *where_the_object_was); + struct _GObject { + GTypeInstance g_type_instance; + + + guint ref_count; + GData *qdata; + } + struct _GObjectClass { + GTypeClass g_type_class; + + + GSList *construct_properties; // BVH + + + + GObject* (*constructor) (GType type, + guint n_ruct_properties); + void (*set_property) (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + void (*get_property) (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + void (*dispose) (GObject *object); + void (*finalize) (GObject *object); + + + void (*dispatch_properties_changed) (GObject *object, + guint n_pspecs, + GParamSpec **pspecs); + + + void (*notify) (GObject *object, + GParamSpec *pspec); + + + gpointer pdummy[8]; + } + struct _GObjectConstructParam { + GParamSpec *pspec; + GValue *value; + } + + + + void g_object_class_install_property (GObjectClass *oclass, + guint property_id, + GParamSpec *pspec); + GParamSpec* g_object_class_find_property (GObjectClass *oclass, + gchar *property_name); + GParamSpec**g_object_class_list_properties (GObjectClass *oclass, + guint *n_properties); + void g_object_class_override_property (GObjectClass *oclass, + guint property_id, + gchar *name); + + void g_object_interface_install_property (gpointer g_iface, + GParamSpec *pspec); + GParamSpec* g_object_interface_find_property (gpointer g_iface, + gchar *property_name); + GParamSpec**g_object_interface_list_properties (gpointer g_iface, + guint *n_properties_p); + + gpointer g_object_new (GType object_type, + gchar *first_property_name, + ...); + gpointer g_object_newv (GType object_type, + guint n_parameters, + GParameter *parameters); + GObject* g_object_new_valist (GType object_type, + gchar *first_property_name, + va_list var_args); + void g_object_set (gpointer object, + gchar *first_property_name, + ...); + void g_object_get (gpointer object, + gchar *first_property_name, + ...); + gpointer g_object_connect (gpointer object, + gchar *signal_spec, + ...); + void g_object_disconnect (gpointer object, + gchar *signal_spec, + ...); + void g_object_set_valist (GObject *object, + gchar *first_property_name, + va_list var_args); + void g_object_get_valist (GObject *object, + gchar *first_property_name, + va_list var_args); + void g_object_set_property (GObject *object, + gchar *property_name, + GValue *value); + void g_object_get_property (GObject *object, + gchar *property_name, + GValue *value); + void g_object_freeze_notify (GObject *object); + void g_object_notify (GObject *object, + gchar *property_name); + void g_object_thaw_notify (GObject *object); + gpointer g_object_ref (gpointer object); + void g_object_unref (gpointer object); + void g_object_weak_ref (GObject *object, + GWeakNotify notify, + gpointer data); + void g_object_weak_unref (GObject *object, + GWeakNotify notify, + gpointer data); + void g_object_add_weak_pointer (GObject *object, + gpointer *weak_pointer_location); + void g_object_remove_weak_pointer (GObject *object, + gpointer *weak_pointer_location); + gpointer g_object_get_qdata (GObject *object, + GQuark quark); + void g_object_set_qdata (GObject *object, + GQuark quark, + gpointer data); + void g_object_set_qdata_full (GObject *object, + GQuark quark, + gpointer data, + GDestroyNotify destroy); + gpointer g_object_steal_qdata (GObject *object, + GQuark quark); + gpointer g_object_get_data (GObject *object, + gchar *key); + void g_object_set_data (GObject *object, + gchar *key, + gpointer data); + void g_object_set_data_full (GObject *object, + gchar *key, + gpointer data, + GDestroyNotify destroy); + gpointer g_object_steal_data (GObject *object, + gchar *key); + void g_object_watch_closure (GObject *object, + GClosure *closure); + GClosure* g_cclosure_new_object (GCallback callback_func, + GObject *object); + GClosure* g_cclosure_new_object_swap (GCallback callback_func, + GObject *object); + GClosure* g_closure_new_object (guint sizeof_closure, + GObject *object); + void g_value_set_object (GValue *value, + gpointer v_object); + gpointer g_value_get_object ( GValue *value); + GObject* g_value_dup_object ( GValue *value); + gulong g_signal_connect_object (gpointer instanc, + gchar *detailed_signal, + GCallback c_handler, + gpointer gobject, + GConnectFlags connect_flags); + + + + void g_object_run_dispose (GObject *object); + + + void g_value_take_object (GValue *value, + gpointer v_object); + + void g_value_set_object_take_ownership (GValue *value, + gpointer v_object); + + + + alias _GParamSpecChar GParamSpecChar; + + alias _GParamSpecUChar GParamSpecUChar; + + alias _GParamSpecBoolean GParamSpecBoolean; + + alias _GParamSpecInt GParamSpecInt; + + alias _GParamSpecUInt GParamSpecUInt; + + alias _GParamSpecLong GParamSpecLong; + + alias _GParamSpecULong GParamSpecULong; + + alias _GParamSpecInt64 GParamSpecInt64; + + alias _GParamSpecUInt64 GParamSpecUInt64; + + alias _GParamSpecUnichar GParamSpecUnichar; + + alias _GParamSpecEnum GParamSpecEnum; + + alias _GParamSpecFlags GParamSpecFlags; + + alias _GParamSpecFloat GParamSpecFloat; + + alias _GParamSpecDouble GParamSpecDouble; + + alias _GParamSpecString GParamSpecString; + + alias _GParamSpecParam GParamSpecParam; + + alias _GParamSpecBoxed GParamSpecBoxed; + + alias _GParamSpecPointer GParamSpecPointer; + + alias _GParamSpecValueArray GParamSpecValueArray; + + alias _GParamSpecObject GParamSpecObject; + + alias _GParamSpecOverride GParamSpecOverride; + + + struct _GParamSpecChar { + GParamSpec parent_instance; + + gint8 minimum; + gint8 maximum; + gint8 default_value; + } + struct _GParamSpecUChar { + GParamSpec parent_instance; + + guint8 minimum; + guint8 maximum; + guint8 default_value; + } + struct _GParamSpecBoolean { + GParamSpec parent_instance; + + gboolean default_value; + } + struct _GParamSpecInt { + GParamSpec parent_instance; + + gint minimum; + gint maximum; + gint default_value; + } + struct _GParamSpecUInt { + GParamSpec parent_instance; + + guint minimum; + guint maximum; + guint default_value; + } + struct _GParamSpecLong { + GParamSpec parent_instance; + + glong minimum; + glong maximum; + glong default_value; + } + struct _GParamSpecULong { + GParamSpec parent_instance; + + gulong minimum; + gulong maximum; + gulong default_value; + } + struct _GParamSpecInt64 { + GParamSpec parent_instance; + + gint64 minimum; + gint64 maximum; + gint64 default_value; + } + struct _GParamSpecUInt64 { + GParamSpec parent_instance; + + guint64 minimum; + guint64 maximum; + guint64 default_value; + } + struct _GParamSpecUnichar { + GParamSpec parent_instance; + + gunichar default_value; + } + struct _GParamSpecEnum { + GParamSpec parent_instance; + + GEnumClass *enum_class; + gint default_value; + } + struct _GParamSpecFlags { + GParamSpec parent_instance; + + GFlagsClass *flags_class; + guint default_value; + } + struct _GParamSpecFloat { + GParamSpec parent_instance; + + gfloat minimum; + gfloat maximum; + gfloat default_value; + gfloat epsilon; + } + struct _GParamSpecDouble { + GParamSpec parent_instance; + + gdouble minimum; + gdouble maximum; + gdouble default_value; + gdouble epsilon; + } + struct _GParamSpecString { + GParamSpec parent_instance; + + gchar *default_value; + gchar *cset_first; + gchar *cset_nth; + gchar substitutor; + guint null_fold_if_empty; + guint ensure_non_null; + } + struct _GParamSpecParam { + GParamSpec parent_instance; + } + struct _GParamSpecBoxed { + GParamSpec parent_instance; + } + struct _GParamSpecPointer { + GParamSpec parent_instance; + } + struct _GParamSpecValueArray { + GParamSpec parent_instance; + GParamSpec *element_spec; + guint fixed_n_elements; + } + struct _GParamSpecObject { + GParamSpec parent_instance; + } + struct _GParamSpecOverride { + + GParamSpec parent_instance; + GParamSpec *overridden; + } + + + GParamSpec* g_param_spec_char ( gchar *name, + gchar *nick, + gchar *blurb, + gint8 minimum, + gint8 maximum, + gint8 default_value, + GParamFlags flags); + GParamSpec* g_param_spec_uchar ( gchar *name, + gchar *nick, + gchar *blurb, + guint8 minimum, + guint8 maximum, + guint8 default_value, + GParamFlags flags); + GParamSpec* g_param_spec_boolean ( gchar *name, + gchar *nick, + gchar *blurb, + gboolean default_value, + GParamFlags flags); + GParamSpec* g_param_spec_int ( gchar *name, + gchar *nick, + gchar *blurb, + gint minimum, + gint maximum, + gint default_value, + GParamFlags flags); + GParamSpec* g_param_spec_uint ( gchar *name, + gchar *nick, + gchar *blurb, + guint minimum, + guint maximum, + guint default_value, + GParamFlags flags); + GParamSpec* g_param_spec_long ( gchar *name, + gchar *nick, + gchar *blurb, + glong minimum, + glong maximum, + glong default_value, + GParamFlags flags); + GParamSpec* g_param_spec_ulong ( gchar *name, + gchar *nick, + gchar *blurb, + gulong minimum, + gulong maximum, + gulong default_value, + GParamFlags flags); + GParamSpec* g_param_spec_int64 ( gchar *name, + gchar *nick, + gchar *blurb, + gint64 minimum, + gint64 maximum, + gint64 default_value, + GParamFlags flags); + GParamSpec* g_param_spec_uint64 ( gchar *name, + gchar *nick, + gchar *blurb, + guint64 minimum, + guint64 maximum, + guint64 default_value, + GParamFlags flags); + GParamSpec* g_param_spec_unichar ( gchar *name, + gchar *nick, + gchar *blurb, + gunichar default_value, + GParamFlags flags); + GParamSpec* g_param_spec_enum ( gchar *name, + gchar *nick, + gchar *blurb, + GType enum_type, + gint default_value, + GParamFlags flags); + GParamSpec* g_param_spec_flags ( gchar *name, + gchar *nick, + gchar *blurb, + GType flags_type, + guint default_value, + GParamFlags flags); + GParamSpec* g_param_spec_float ( gchar *name, + gchar *nick, + gchar *blurb, + gfloat minimum, + gfloat maximum, + gfloat default_value, + GParamFlags flags); + GParamSpec* g_param_spec_double ( gchar *name, + gchar *nick, + gchar *blurb, + gdouble minimum, + gdouble maximum, + gdouble default_value, + GParamFlags flags); + GParamSpec* g_param_spec_string ( gchar *name, + gchar *nick, + gchar *blurb, + gchar *default_value, + GParamFlags flags); + GParamSpec* g_param_spec_param ( gchar *name, + gchar *nick, + gchar *blurb, + GType param_type, + GParamFlags flags); + GParamSpec* g_param_spec_boxed ( gchar *name, + gchar *nick, + gchar *blurb, + GType boxed_type, + GParamFlags flags); + GParamSpec* g_param_spec_pointer ( gchar *name, + gchar *nick, + gchar *blurb, + GParamFlags flags); + GParamSpec* g_param_spec_value_array ( gchar *name, + gchar *nick, + gchar *blurb, + GParamSpec *element_spec, + GParamFlags flags); + GParamSpec* g_param_spec_object ( gchar *name, + gchar *nick, + gchar *blurb, + GType object_type, + GParamFlags flags); + + GParamSpec* g_param_spec_override ( gchar *name, + GParamSpec *overridden); + GType *g_param_spec_types; + + + + + + void g_source_set_closure (GSource *source, + GClosure *closure); + + GType g_io_channel_get_type (); + GType g_io_condition_get_type (); + + + + + + + + + alias _GTypeModule GTypeModule; + + alias _GTypeModuleClass GTypeModuleClass; + + struct _GTypeModule { + GObject parent_instance; + + guint use_count; + GSList *type_infos; + GSList *interface_infos; + + + gchar *name; + } + + struct _GTypeModuleClass { + GObjectClass parent_class; + + + gboolean (* load) (GTypeModule *modle); + void (* unload) (GTypeModule *modle); + + + + void (*reserved1) (); + void (*reserved2) (); + void (*reserved3) (); + void (*reserved4) (); + } + + GType g_type_module_get_type (); + gboolean g_type_module_use (GTypeModule *modle); + void g_type_module_unuse (GTypeModule *modle); + void g_type_module_set_name (GTypeModule *modle, + gchar *name); + GType g_type_module_register_type (GTypeModule *modle, + GType parent_type, + gchar *type_name, + GTypeInfo *type_info, + GTypeFlags flags); + void g_type_module_add_interface (GTypeModule *modle, + GType instance_type, + GType interface_type, + GInterfaceInfo *interface_info); + + + + + alias _GTypePluginClass GTypePluginClass; + + alias void (*GTypePluginUse) (GTypePlugin *plugin); + alias void (*GTypePluginUnuse) (GTypePlugin *plugin); + alias void (*GTypePluginCompleteTypeInfo) (GTypePlugin *plugin, + GType g_type, + GTypeInfo *info, + GTypeValueTable *value_table); + alias void (*GTypePluginCompleteInterfaceInfo) (GTypePlugin *plugin, + GType instance_type, + GType interface_type, + GInterfaceInfo *info); + struct _GTypePluginClass { + + GTypeInterface base_iface; + + + GTypePluginUse use_plugin; + GTypePluginUnuse unuse_plugin; + GTypePluginCompleteTypeInfo complete_type_info; + GTypePluginCompleteInterfaceInfo complete_interface_info; + } + + + + GType g_type_plugin_get_type () ; + void g_type_plugin_use (GTypePlugin *plugin); + void g_type_plugin_unuse (GTypePlugin *plugin); + void g_type_plugin_complete_type_info (GTypePlugin *plugin, + GType g_type, + GTypeInfo *info, + GTypeValueTable *value_table); + void g_type_plugin_complete_interface_info (GTypePlugin *plugin, + GType instance_type, + GType interface_type, + GInterfaceInfo *info); + + + alias _GValueArray GValueArray; + + struct _GValueArray { + guint n_values; + GValue *values; + + + guint n_prealloced; + } + + + + GValue* g_value_array_get_nth (GValueArray *value_array, + guint index_); + GValueArray* g_value_array_new (guint n_prealloced); + void g_value_array_free (GValueArray *value_array); + GValueArray* g_value_array_copy ( GValueArray *value_array); + GValueArray* g_value_array_prepend (GValueArray *value_array, + GValue *value); + GValueArray* g_value_array_append (GValueArray *value_array, + GValue *value); + GValueArray* g_value_array_insert (GValueArray *value_array, + guint index_, + GValue *value); + GValueArray* g_value_array_remove (GValueArray *value_array, + guint index_); + GValueArray* g_value_array_sort (GValueArray *value_array, + GCompareFunc compare_func); + GValueArray* g_value_array_sort_with_data (GValueArray *value_array, + GCompareDataFunc compare_func, + gpointer user_data); + + + void g_value_set_char (GValue *value, + gchar v_char); + gchar g_value_get_char ( GValue *value); + void g_value_set_uchar (GValue *value, + guchar v_uchar); + guchar g_value_get_uchar ( GValue *value); + void g_value_set_boolean (GValue *value, + gboolean v_boolean); + gboolean g_value_get_boolean ( GValue *value); + void g_value_set_int (GValue *value, + gint v_int); + gint g_value_get_int ( GValue *value); + void g_value_set_uint (GValue *value, + guint v_uint); + guint g_value_get_uint ( GValue *value); + void g_value_set_long (GValue *value, + glong v_long); + glong g_value_get_long ( GValue *value); + void g_value_set_ulong (GValue *value, + gulong v_ulong); + gulong g_value_get_ulong ( GValue *value); + void g_value_set_int64 (GValue *value, + gint64 v_int64); + gint64 g_value_get_int64 ( GValue *value); + void g_value_set_uint64 (GValue *value, + guint64 v_uint64); + guint64 g_value_get_uint64 ( GValue *value); + void g_value_set_float (GValue *value, + gfloat v_float); + gfloat g_value_get_float ( GValue *value); + void g_value_set_double (GValue *value, + gdouble v_double); + gdouble g_value_get_double ( GValue *value); + void g_value_set_string (GValue *value, + gchar *v_string); + void g_value_set_static_string (GValue *value, + gchar *v_string); + gchar* g_value_get_string ( GValue *value); + gchar* g_value_dup_string ( GValue *value); + void g_value_set_pointer (GValue *value, + gpointer v_pointer); + gpointer g_value_get_pointer ( GValue *value); + + + + GType g_pointer_type_register_static ( gchar *name); + + + gchar* g_strdup_value_contents ( GValue *value); + + + void g_value_take_string (GValue *value, + gchar *v_string); + + void g_value_set_string_take_ownership (GValue *value, + gchar *v_string); + + + + + alias gchar* gchararray; + + + + + + + alias _PangoLogAttr PangoLogAttr; + + + alias _PangoEngineLang PangoEngineLang; + alias void _PangoEngineLang; + + alias _PangoEngineShape PangoEngineShape; + alias void _PangoEngineShape; + + + alias _PangoFont PangoFont; + alias void _PangoFont; + + + alias _PangoMatrix PangoMatrix; + + alias _PangoRectangle PangoRectangle; + + + + alias _PangoLanguage PangoLanguage; + alias void _PangoLanguage; + + + + + alias guint32 PangoGlyph; + + + + + struct _PangoRectangle { + int x; + int y; + int width; + int height; + } + struct _PangoMatrix { + double xx; + double xy; + double yx; + double yy; + double x0; + double y0; + } + GType pango_matrix_get_type (); + + PangoMatrix *pango_matrix_copy ( PangoMatrix *matrix); + void pango_matrix_free (PangoMatrix *matrix); + + void pango_matrix_translate (PangoMatrix *matrix, + double tx, + double ty); + void pango_matrix_scale (PangoMatrix *matrix, + double scale_x, + double scale_y); + void pango_matrix_rotate (PangoMatrix *matrix, + double degrees); + void pango_matrix_concat (PangoMatrix *matrix, + PangoMatrix *new_matrix); + enum PangoDirection { + PANGO_DIRECTION_LTR, + PANGO_DIRECTION_RTL, + PANGO_DIRECTION_TTB_LTR, + PANGO_DIRECTION_TTB_RTL, + PANGO_DIRECTION_WEAK_LTR, + PANGO_DIRECTION_WEAK_RTL, + PANGO_DIRECTION_NEUTRAL + }; + + + + + GType pango_language_get_type (); + PangoLanguage *pango_language_from_string ( char *language); + + + gboolean pango_language_matches (PangoLanguage *language, + char *range_list); + + + gboolean pango_get_mirror_char (gunichar ch, + gunichar *mirrored_ch); + + + + PangoDirection pango_unichar_direction (gunichar ch); + PangoDirection pango_find_base_dir ( gchar *text, + gint length); + + + + + + + + alias _PangoFontDescription PangoFontDescription; + alias void _PangoFontDescription; + + alias _PangoFontMetrics PangoFontMetrics; + alias void _PangoFontMetrics; + + enum PangoStyle { + PANGO_STYLE_NORMAL, + PANGO_STYLE_OBLIQUE, + PANGO_STYLE_ITALIC + }; + + + enum PangoVariant { + PANGO_VARIANT_NORMAL, + PANGO_VARIANT_SMALL_CAPS + }; + + + enum PangoWeight { + PANGO_WEIGHT_ULTRALIGHT = 200, + PANGO_WEIGHT_LIGHT = 300, + PANGO_WEIGHT_NORMAL = 400, + PANGO_WEIGHT_BOLD = 700, + PANGO_WEIGHT_ULTRABOLD = 800, + PANGO_WEIGHT_HEAVY = 900 + }; + + + enum PangoStretch { + PANGO_STRETCH_ULTRA_CONDENSED, + PANGO_STRETCH_EXTRA_CONDENSED, + PANGO_STRETCH_CONDENSED, + PANGO_STRETCH_SEMI_CONDENSED, + PANGO_STRETCH_NORMAL, + PANGO_STRETCH_SEMI_EXPANDED, + PANGO_STRETCH_EXPANDED, + PANGO_STRETCH_EXTRA_EXPANDED, + PANGO_STRETCH_ULTRA_EXPANDED + }; + + + enum PangoFontMask { + PANGO_FONT_MASK_FAMILY = 1 << 0, + PANGO_FONT_MASK_STYLE = 1 << 1, + PANGO_FONT_MASK_VARIANT = 1 << 2, + PANGO_FONT_MASK_WEIGHT = 1 << 3, + PANGO_FONT_MASK_STRETCH = 1 << 4, + PANGO_FONT_MASK_SIZE = 1 << 5 + }; + + GType pango_font_description_get_type (); + PangoFontDescription *pango_font_description_new (); + PangoFontDescription *pango_font_description_copy ( PangoFontDescription *desc); + PangoFontDescription *pango_font_description_copy_static ( PangoFontDescription *desc); + guint pango_font_description_hash ( PangoFontDescription *desc); + gboolean pango_font_description_equal ( PangoFontDescription *desc1, + PangoFontDescription *desc2); + void pango_font_description_free (PangoFontDescription *desc); + void pango_font_descriptions_free (PangoFontDescription **descs, + int n_descs); + + void pango_font_description_set_family (PangoFontDescription *desc, + char *family); + void pango_font_description_set_family_static (PangoFontDescription *desc, + char *family); + char *pango_font_description_get_family ( PangoFontDescription *desc); + void pango_font_description_set_style (PangoFontDescription *desc, + PangoStyle style); + PangoStyle pango_font_description_get_style ( PangoFontDescription *desc); + void pango_font_description_set_variant (PangoFontDescription *desc, + PangoVariant variant); + PangoVariant pango_font_description_get_variant ( PangoFontDescription *desc); + void pango_font_description_set_weight (PangoFontDescription *desc, + PangoWeight weight); + PangoWeight pango_font_description_get_weight ( PangoFontDescription *desc); + void pango_font_description_set_stretch (PangoFontDescription *desc, + PangoStretch stretch); + PangoStretch pango_font_description_get_stretch ( PangoFontDescription *desc); + void pango_font_description_set_size (PangoFontDescription *desc, + gint size); + gint pango_font_description_get_size ( PangoFontDescription *desc); + + PangoFontMask pango_font_description_get_set_fields ( PangoFontDescription *desc); + void pango_font_description_unset_fields (PangoFontDescription *desc, + PangoFontMask to_unset); + + void pango_font_description_merge (PangoFontDescription *desc, + PangoFontDescription *desc_to_merge, + gboolean replace_existing); + void pango_font_description_merge_static (PangoFontDescription *desc, + PangoFontDescription *desc_to_merge, + gboolean replace_existing); + + gboolean pango_font_description_better_match ( PangoFontDescription *desc, + PangoFontDescription *old_match, + PangoFontDescription *new_match); + + PangoFontDescription *pango_font_description_from_string ( char *str); + char * pango_font_description_to_string ( PangoFontDescription *desc); + char * pango_font_description_to_filename ( PangoFontDescription *desc); + + + + + + + GType pango_font_metrics_get_type (); + PangoFontMetrics *pango_font_metrics_ref (PangoFontMetrics *metrics); + void pango_font_metrics_unref (PangoFontMetrics *metrics); + int pango_font_metrics_get_ascent (PangoFontMetrics *metrics); + int pango_font_metrics_get_descent (PangoFontMetrics *metrics); + int pango_font_metrics_get_approximate_char_width (PangoFontMetrics *metrics); + int pango_font_metrics_get_approximate_digit_width (PangoFontMetrics *metrics); + int pango_font_metrics_get_underline_position (PangoFontMetrics *metrics); + int pango_font_metrics_get_underline_thickness (PangoFontMetrics *metrics); + int pango_font_metrics_get_strikethrough_position (PangoFontMetrics *metrics); + int pango_font_metrics_get_strikethrough_thickness (PangoFontMetrics *metrics); + alias _PangoFontFamily PangoFontFamily; + alias void _PangoFontFamily; + + alias _PangoFontFace PangoFontFace; + alias void _PangoFontFace; + + + GType pango_font_family_get_type () ; + + void pango_font_family_list_faces (PangoFontFamily *family, + PangoFontFace ***faces, + int *n_faces); + char *pango_font_family_get_name (PangoFontFamily *family); + gboolean pango_font_family_is_monospace (PangoFontFamily *family); + GType pango_font_face_get_type () ; + + PangoFontDescription *pango_font_face_describe (PangoFontFace *face); + char *pango_font_face_get_face_name (PangoFontFace *face); + void pango_font_face_list_sizes (PangoFontFace *face, + int **sizes, + int *n_sizes); + GType pango_font_get_type () ; + + PangoFontDescription *pango_font_describe (PangoFont *font); + PangoCoverage * pango_font_get_coverage (PangoFont *font, + PangoLanguage *language); + PangoEngineShape * pango_font_find_shaper (PangoFont *font, + PangoLanguage *language, + guint32 ch); + PangoFontMetrics * pango_font_get_metrics (PangoFont *font, + PangoLanguage *language); + void pango_font_get_glyph_extents (PangoFont *font, + PangoGlyph glyph, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + + + + + + + + alias _PangoColor PangoColor; + + + struct _PangoColor { + guint16 red; + guint16 green; + guint16 blue; + } + + + GType pango_color_get_type () ; + + PangoColor *pango_color_copy ( PangoColor *src); + void pango_color_free (PangoColor *color); + gboolean pango_color_parse (PangoColor *color, + char *spec); + + + + alias _PangoAttribute PangoAttribute; + + alias _PangoAttrClass PangoAttrClass; + + + alias _PangoAttrString PangoAttrString; + + alias _PangoAttrLanguage PangoAttrLanguage; + + alias _PangoAttrInt PangoAttrInt; + + alias _PangoAttrFloat PangoAttrFloat; + + alias _PangoAttrColor PangoAttrColor; + + alias _PangoAttrFontDesc PangoAttrFontDesc; + + alias _PangoAttrShape PangoAttrShape; + + + + alias _PangoAttrList PangoAttrList; + alias void _PangoAttrList; + + alias _PangoAttrIterator PangoAttrIterator; + alias void _PangoAttrIterator; + + + enum PangoAttrType { + PANGO_ATTR_INVALID, + PANGO_ATTR_LANGUAGE, + PANGO_ATTR_FAMILY, + PANGO_ATTR_STYLE, + PANGO_ATTR_WEIGHT, + PANGO_ATTR_VARIANT, + PANGO_ATTR_STRETCH, + PANGO_ATTR_SIZE, + PANGO_ATTR_FONT_DESC, + PANGO_ATTR_FOREGROUND, + PANGO_ATTR_BACKGROUND, + PANGO_ATTR_UNDERLINE, + PANGO_ATTR_STRIKETHROUGH, + PANGO_ATTR_RISE, + PANGO_ATTR_SHAPE, + PANGO_ATTR_SCALE, + PANGO_ATTR_FALLBACK, + PANGO_ATTR_LETTER_SPACING + }; + + + enum PangoUnderline { + PANGO_UNDERLINE_NONE, + PANGO_UNDERLINE_SINGLE, + PANGO_UNDERLINE_DOUBLE, + PANGO_UNDERLINE_LOW, + PANGO_UNDERLINE_ERROR + }; + + + struct _PangoAttribute { + PangoAttrClass *klass; + guint start_index; + guint end_index; + } + + alias gboolean (*PangoAttrFilterFunc) (PangoAttribute *attribute, + gpointer data); + + struct _PangoAttrClass { + + PangoAttrType type; + PangoAttribute * (*copy) ( PangoAttribute *attr); + void (*destroy) (PangoAttribute *attr); + gboolean (*equal) ( PangoAttribute *attr1, PangoAttribute *attr2); + } + + struct _PangoAttrString { + PangoAttribute attr; + char *value; + } + + struct _PangoAttrLanguage { + PangoAttribute attr; + PangoLanguage *value; + } + + struct _PangoAttrInt { + PangoAttribute attr; + int value; + } + + struct _PangoAttrFloat { + PangoAttribute attr; + double value; + } + + struct _PangoAttrColor { + PangoAttribute attr; + PangoColor color; + } + + struct _PangoAttrShape { + PangoAttribute attr; + PangoRectangle ink_rect; + PangoRectangle logical_rect; + } + + struct _PangoAttrFontDesc { + PangoAttribute attr; + PangoFontDescription *desc; + } + + PangoAttrType pango_attr_type_register ( gchar *name); + + PangoAttribute * pango_attribute_copy ( PangoAttribute *attr); + void pango_attribute_destroy (PangoAttribute *attr); + gboolean pango_attribute_equal ( PangoAttribute *attr1, + PangoAttribute *attr2); + + PangoAttribute *pango_attr_language_new (PangoLanguage *language); + PangoAttribute *pango_attr_family_new ( char *family); + PangoAttribute *pango_attr_foreground_new (guint16 red, + guint16 green, + guint16 blue); + PangoAttribute *pango_attr_background_new (guint16 red, + guint16 green, + guint16 blue); + PangoAttribute *pango_attr_size_new (int size); + PangoAttribute *pango_attr_style_new (PangoStyle style); + PangoAttribute *pango_attr_weight_new (PangoWeight weight); + PangoAttribute *pango_attr_variant_new (PangoVariant variant); + PangoAttribute *pango_attr_stretch_new (PangoStretch stretch); + PangoAttribute *pango_attr_font_desc_new ( PangoFontDescription *desc); + PangoAttribute *pango_attr_underline_new (PangoUnderline underline); + PangoAttribute *pango_attr_strikethrough_new (gboolean strikethrough); + PangoAttribute *pango_attr_rise_new (int rise); + PangoAttribute *pango_attr_shape_new ( PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + PangoAttribute *pango_attr_scale_new (double scale_factor); + PangoAttribute *pango_attr_fallback_new (gboolean enable_fallback); + PangoAttribute *pango_attr_letter_spacing_new (int letter_spacing); + + GType pango_attr_list_get_type () ; + PangoAttrList * pango_attr_list_new (); + void pango_attr_list_ref (PangoAttrList *list); + void pango_attr_list_unref (PangoAttrList *list); + PangoAttrList * pango_attr_list_copy (PangoAttrList *list); + void pango_attr_list_insert (PangoAttrList *list, + PangoAttribute *attr); + void pango_attr_list_insert_before (PangoAttrList *list, + PangoAttribute *attr); + void pango_attr_list_change (PangoAttrList *list, + PangoAttribute *attr); + void pango_attr_list_splice (PangoAttrList *list, + PangoAttrList *other, + gint pos, + gint len); + + PangoAttrList *pango_attr_list_filter (PangoAttrList *list, + PangoAttrFilterFunc func, + gpointer data); + + PangoAttrIterator *pango_attr_list_get_iterator (PangoAttrList *list); + + void pango_attr_iterator_range (PangoAttrIterator *iterator, + gint *start, + gint *end); + gboolean pango_attr_iterator_next (PangoAttrIterator *iterator); + PangoAttrIterator *pango_attr_iterator_copy (PangoAttrIterator *iterator); + void pango_attr_iterator_destroy (PangoAttrIterator *iterator); + PangoAttribute * pango_attr_iterator_get (PangoAttrIterator *iterator, + PangoAttrType type); + void pango_attr_iterator_get_font (PangoAttrIterator *iterator, + PangoFontDescription *desc, + PangoLanguage **language, + GSList **extra_attrs); + GSList * pango_attr_iterator_get_attrs (PangoAttrIterator *iterator); + + + gboolean pango_parse_markup ( char *markup_text, + int length, + gunichar accel_marker, + PangoAttrList **attr_list, + char **text, + gunichar *accel_char, + GError **error); + + + + + + + alias _PangoAnalysis PangoAnalysis; + + alias _PangoItem PangoItem; + + + struct _PangoAnalysis { + PangoEngineShape *shape_engine; + PangoEngineLang *lang_engine; + PangoFont *font; + guint8 level; + PangoLanguage *language; + GSList *extra_attrs; + } + + struct _PangoItem { + gint offset; + gint length; + gint num_chars; + PangoAnalysis analysis; + } + + PangoItem *pango_item_new (); + PangoItem *pango_item_copy (PangoItem *item); + void pango_item_free (PangoItem *item); + PangoItem *pango_item_split (PangoItem *orig, + int split_index, + int split_offset); + + + + + + struct _PangoLogAttr { + guint is_line_break; + + guint is_mandatory_break; + + guint is_char_break; + + guint is_white; + + + + + guint is_cursor_position; + + + + + + + guint is_word_start; + guint is_word_end; + guint is_sentence_boundary; + guint is_sentence_start; + guint is_sentence_end; + + + + + guint backspace_deletes_character; + } + + + + + void pango_break ( gchar *text, + int length, + PangoAnalysis *analysis, + PangoLogAttr *attrs, + int attrs_len); + + void pango_find_paragraph_boundary ( gchar *text, + gint length, + gint *paragraph_delimiter_index, + gint *next_paragraph_start); + + void pango_get_log_attrs ( char *text, + int length, + int level, + PangoLanguage *language, + PangoLogAttr *log_attrs, + int attrs_len); + + + GType pango_fontset_get_type () ; + + alias _PangoFontset PangoFontset; + alias void _PangoFontset; + + alias gboolean (*PangoFontsetForeachFunc) (PangoFontset *fontset, + PangoFont *font, + gpointer data); + + PangoFont * pango_fontset_get_font (PangoFontset *fontset, + guint wc); + PangoFontMetrics *pango_fontset_get_metrics (PangoFontset *fontset); + void pango_fontset_foreach (PangoFontset *fontset, + PangoFontsetForeachFunc func, + gpointer data); + + + + + + + + + alias _PangoContext PangoContext; + alias void _PangoContext; + + alias _PangoFontMap PangoFontMap; + alias void _PangoFontMap; + + + GType pango_font_map_get_type () ; + PangoFont * pango_font_map_load_font (PangoFontMap *fontmap, + PangoContext *context, + PangoFontDescription *desc); + PangoFontset *pango_font_map_load_fontset (PangoFontMap *fontmap, + PangoContext *context, + PangoFontDescription *desc, + PangoLanguage *language); + void pango_font_map_list_families (PangoFontMap *fontmap, + PangoFontFamily ***families, + int *n_families); + + + + + + + + + + + alias _PangoContextClass PangoContextClass; + alias void _PangoContextClass; + + GType pango_context_get_type () ; + + + + + + + PangoFontMap *pango_context_get_font_map (PangoContext *context); + + void pango_context_list_families (PangoContext *context, + PangoFontFamily ***families, + int *n_families); + PangoFont * pango_context_load_font (PangoContext *context, + PangoFontDescription *desc); + PangoFontset *pango_context_load_fontset (PangoContext *context, + PangoFontDescription *desc, + PangoLanguage *language); + + PangoFontMetrics *pango_context_get_metrics (PangoContext *context, + PangoFontDescription *desc, + PangoLanguage *language); + + void pango_context_set_font_description (PangoContext *context, + PangoFontDescription *desc); + PangoFontDescription * pango_context_get_font_description (PangoContext *context); + PangoLanguage *pango_context_get_language (PangoContext *context); + void pango_context_set_language (PangoContext *context, + PangoLanguage *language); + void pango_context_set_base_dir (PangoContext *context, + PangoDirection direction); + PangoDirection pango_context_get_base_dir (PangoContext *context); + + void pango_context_set_matrix (PangoContext *context, + PangoMatrix *matrix); + PangoMatrix *pango_context_get_matrix (PangoContext *context); + + + + + + GList *pango_itemize (PangoContext *context, + char *text, + int start_index, + int length, + PangoAttrList *attrs, + PangoAttrIterator *cached_iter); + GList *pango_itemize_with_base_dir (PangoContext *context, + PangoDirection base_dir, + char *text, + int start_index, + int length, + PangoAttrList *attrs, + PangoAttrIterator *cached_iter); + + + + + + alias _PangoGlyphGeometry PangoGlyphGeometry; + + alias _PangoGlyphVisAttr PangoGlyphVisAttr; + + alias _PangoGlyphInfo PangoGlyphInfo; + + alias _PangoGlyphString PangoGlyphString; + + + + alias gint32 PangoGlyphUnit; + + + + struct _PangoGlyphGeometry { + PangoGlyphUnit width; + PangoGlyphUnit x_offset; + PangoGlyphUnit y_offset; + } + + + + struct _PangoGlyphVisAttr { + guint is_cluster_start; + } + + + + struct _PangoGlyphInfo { + PangoGlyph glyph; + PangoGlyphGeometry geometry; + PangoGlyphVisAttr attr; + } + + + + + struct _PangoGlyphString { + gint num_glyphs; + + PangoGlyphInfo *glyphs; + + + + + + + gint *log_clusters; + + + gint space; + } + + + + PangoGlyphString *pango_glyph_string_new (); + void pango_glyph_string_set_size (PangoGlyphString *string, + gint new_len); + GType pango_glyph_string_get_type (); + PangoGlyphString *pango_glyph_string_copy (PangoGlyphString *string); + void pango_glyph_string_free (PangoGlyphString *string); + void pango_glyph_string_extents (PangoGlyphString *glyphs, + PangoFont *font, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + + void pango_glyph_string_extents_range (PangoGlyphString *glyphs, + int start, + int end, + PangoFont *font, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + + void pango_glyph_string_get_logical_widths (PangoGlyphString *glyphs, + char *text, + int length, + int embedding_level, + int *logical_widths); + + void pango_glyph_string_index_to_x (PangoGlyphString *glyphs, + char *text, + int length, + PangoAnalysis *analysis, + int index_, + gboolean trailing, + int *x_pos); + void pango_glyph_string_x_to_index (PangoGlyphString *glyphs, + char *text, + int length, + PangoAnalysis *analysis, + int x_pos, + int *index_, + int *trailing); + + + + void pango_shape ( gchar *text, + gint length, + PangoAnalysis *analysis, + PangoGlyphString *glyphs); + + GList *pango_reorder_items (GList *logical_items); + + + + + + + + + + + alias _PangoScriptIter PangoScriptIter; + alias void _PangoScriptIter; + + const int PANGO_SCALE = 1024; + enum PangoScript { + PANGO_SCRIPT_INVALID_CODE = -1, + PANGO_SCRIPT_COMMON = 0, + PANGO_SCRIPT_INHERITED, + PANGO_SCRIPT_ARABIC, + PANGO_SCRIPT_ARMENIAN, + PANGO_SCRIPT_BENGALI, + PANGO_SCRIPT_BOPOMOFO, + PANGO_SCRIPT_CHEROKEE, + PANGO_SCRIPT_COPTIC, + PANGO_SCRIPT_CYRILLIC, + PANGO_SCRIPT_DESERET, + PANGO_SCRIPT_DEVANAGARI, + PANGO_SCRIPT_ETHIOPIC, + PANGO_SCRIPT_GEORGIAN, + PANGO_SCRIPT_GOTHIC, + PANGO_SCRIPT_GREEK, + PANGO_SCRIPT_GUJARATI, + PANGO_SCRIPT_GURMUKHI, + PANGO_SCRIPT_HAN, + PANGO_SCRIPT_HANGUL, + PANGO_SCRIPT_HEBREW, + PANGO_SCRIPT_HIRAGANA, + PANGO_SCRIPT_KANNADA, + PANGO_SCRIPT_KATAKANA, + PANGO_SCRIPT_KHMER, + PANGO_SCRIPT_LAO, + PANGO_SCRIPT_LATIN, + PANGO_SCRIPT_MALAYALAM, + PANGO_SCRIPT_MONGOLIAN, + PANGO_SCRIPT_MYANMAR, + PANGO_SCRIPT_OGHAM, + PANGO_SCRIPT_OLD_ITALIC, + PANGO_SCRIPT_ORIYA, + PANGO_SCRIPT_RUNIC, + PANGO_SCRIPT_SINHALA, + PANGO_SCRIPT_SYRIAC, + PANGO_SCRIPT_TAMIL, + PANGO_SCRIPT_TELUGU, + PANGO_SCRIPT_THAANA, + PANGO_SCRIPT_THAI, + PANGO_SCRIPT_TIBETAN, + PANGO_SCRIPT_CANADIAN_ABORIGINAL, + PANGO_SCRIPT_YI, + PANGO_SCRIPT_TAGALOG, + PANGO_SCRIPT_HANUNOO, + PANGO_SCRIPT_BUHID, + PANGO_SCRIPT_TAGBANWA, + + + PANGO_SCRIPT_BRAILLE, + PANGO_SCRIPT_CYPRIOT, + PANGO_SCRIPT_LIMBU, + PANGO_SCRIPT_OSMANYA, + PANGO_SCRIPT_SHAVIAN, + PANGO_SCRIPT_LINEAR_B, + PANGO_SCRIPT_TAI_LE, + PANGO_SCRIPT_UGARITIC + }; + + + PangoScript pango_script_for_unichar (gunichar ch); + + PangoScriptIter *pango_script_iter_new ( char *text, + int length); + void pango_script_iter_get_range (PangoScriptIter *iter, + char **start, + char **end, + PangoScript *script); + gboolean pango_script_iter_next (PangoScriptIter *iter); + void pango_script_iter_free (PangoScriptIter *iter); + + PangoLanguage *pango_script_get_sample_language (PangoScript script); + gboolean pango_language_includes_script (PangoLanguage *language, + PangoScript script); + + + + + + + + + + GType pango_attr_type_get_type (); + + + GType pango_underline_get_type (); + + + + + GType pango_coverage_level_get_type (); + + + + + GType pango_style_get_type (); + + + GType pango_variant_get_type (); + + + GType pango_weight_get_type (); + + + GType pango_stretch_get_type (); + + + GType pango_font_mask_get_type (); + + + + + GType pango_alignment_get_type (); + + + GType pango_wrap_mode_get_type (); + + + GType pango_ellipsize_mode_get_type (); + + + + + GType pango_script_get_type (); + + + + + GType pango_tab_align_get_type (); + + + + + GType pango_direction_get_type (); + + + + + + + + + + alias _PangoGlyphItem PangoGlyphItem; + + + struct _PangoGlyphItem { + PangoItem *item; + PangoGlyphString *glyphs; + } + + PangoGlyphItem *pango_glyph_item_split (PangoGlyphItem *orig, + char *text, + int split_index); + void pango_glyph_item_free (PangoGlyphItem *glyph_item); + GSList * pango_glyph_item_apply_attrs (PangoGlyphItem *glyph_item, + char *text, + PangoAttrList *list); + void pango_glyph_item_letter_space (PangoGlyphItem *glyph_item, + char *text, + PangoLogAttr *log_attrs, + int letter_spacing); + + + + + alias _PangoTabArray PangoTabArray; + alias void _PangoTabArray; + + + enum PangoTabAlign { + PANGO_TAB_LEFT + }; + + + + + PangoTabArray *pango_tab_array_new (gint initial_size, + gboolean positions_in_pixels); + PangoTabArray *pango_tab_array_new_with_positions (gint size, + gboolean positions_in_pixels, + PangoTabAlign first_alignment, + gint first_position, + ...); + GType pango_tab_array_get_type (); + PangoTabArray *pango_tab_array_copy (PangoTabArray *src); + void pango_tab_array_free (PangoTabArray *tab_array); + gint pango_tab_array_get_size (PangoTabArray *tab_array); + void pango_tab_array_resize (PangoTabArray *tab_array, + gint new_size); + void pango_tab_array_set_tab (PangoTabArray *tab_array, + gint tab_index, + PangoTabAlign alignment, + gint location); + void pango_tab_array_get_tab (PangoTabArray *tab_array, + gint tab_index, + PangoTabAlign *alignment, + gint *location); + void pango_tab_array_get_tabs (PangoTabArray *tab_array, + PangoTabAlign **alignments, + gint **locations); + + gboolean pango_tab_array_get_positions_in_pixels (PangoTabArray *tab_array); + + + + + + + alias _PangoLayout PangoLayout; + alias void _PangoLayout; + + alias _PangoLayoutClass PangoLayoutClass; + alias void _PangoLayoutClass; + + alias _PangoLayoutLine PangoLayoutLine; + + + + alias PangoGlyphItem PangoLayoutRun; + + enum PangoAlignment { + PANGO_ALIGN_LEFT, + PANGO_ALIGN_CENTER, + PANGO_ALIGN_RIGHT + }; + + + enum PangoWrapMode { + PANGO_WRAP_WORD, + PANGO_WRAP_CHAR, + PANGO_WRAP_WORD_CHAR + }; + + enum PangoEllipsizeMode { + PANGO_ELLIPSIZE_NONE, + PANGO_ELLIPSIZE_START, + PANGO_ELLIPSIZE_MIDDLE, + PANGO_ELLIPSIZE_END + }; + + + struct _PangoLayoutLine { + PangoLayout *layout; + gint start_index; + gint length; + GSList *runs; + guint is_paragraph_start; + guint resolved_dir; + } + GType pango_layout_get_type () ; + PangoLayout *pango_layout_new (PangoContext *context); + PangoLayout *pango_layout_copy (PangoLayout *src); + + PangoContext *pango_layout_get_context (PangoLayout *layout); + + void pango_layout_set_attributes (PangoLayout *layout, + PangoAttrList *attrs); + PangoAttrList *pango_layout_get_attributes (PangoLayout *layout); + + void pango_layout_set_text (PangoLayout *layout, + char *text, + int length); + char *pango_layout_get_text (PangoLayout *layout); + + void pango_layout_set_markup (PangoLayout *layout, + char *markup, + int length); + + void pango_layout_set_markup_with_accel (PangoLayout *layout, + char *markup, + int length, + gunichar accel_marker, + gunichar *accel_char); + + void pango_layout_set_font_description (PangoLayout *layout, + PangoFontDescription *desc); + void pango_layout_set_width (PangoLayout *layout, + int width); + int pango_layout_get_width (PangoLayout *layout); + void pango_layout_set_wrap (PangoLayout *layout, + PangoWrapMode wrap); + PangoWrapMode pango_layout_get_wrap (PangoLayout *layout); + void pango_layout_set_indent (PangoLayout *layout, + int indent); + int pango_layout_get_indent (PangoLayout *layout); + void pango_layout_set_spacing (PangoLayout *layout, + int spacing); + int pango_layout_get_spacing (PangoLayout *layout); + void pango_layout_set_justify (PangoLayout *layout, + gboolean justify); + gboolean pango_layout_get_justify (PangoLayout *layout); + void pango_layout_set_auto_dir (PangoLayout *layout, + gboolean auto_dir); + gboolean pango_layout_get_auto_dir (PangoLayout *layout); + void pango_layout_set_alignment (PangoLayout *layout, + PangoAlignment alignment); + PangoAlignment pango_layout_get_alignment (PangoLayout *layout); + + void pango_layout_set_tabs (PangoLayout *layout, + PangoTabArray *tabs); + + PangoTabArray* pango_layout_get_tabs (PangoLayout *layout); + + void pango_layout_set_single_paragraph_mode (PangoLayout *layout, + gboolean setting); + gboolean pango_layout_get_single_paragraph_mode (PangoLayout *layout); + + void pango_layout_set_ellipsize (PangoLayout *layout, + PangoEllipsizeMode ellipsize); + PangoEllipsizeMode pango_layout_get_ellipsize (PangoLayout *layout); + + void pango_layout_context_changed (PangoLayout *layout); + + void pango_layout_get_log_attrs (PangoLayout *layout, + PangoLogAttr **attrs, + gint *n_attrs); + + void pango_layout_index_to_pos (PangoLayout *layout, + int index_, + PangoRectangle *pos); + void pango_layout_get_cursor_pos (PangoLayout *layout, + int index_, + PangoRectangle *strong_pos, + PangoRectangle *weak_pos); + void pango_layout_move_cursor_visually (PangoLayout *layout, + gboolean strong, + int old_index, + int old_trailing, + int direction, + int *new_index, + int *new_trailing); + gboolean pango_layout_xy_to_index (PangoLayout *layout, + int x, + int y, + int *index_, + int *trailing); + void pango_layout_get_extents (PangoLayout *layout, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + void pango_layout_get_pixel_extents (PangoLayout *layout, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + void pango_layout_get_size (PangoLayout *layout, + int *width, + int *height); + void pango_layout_get_pixel_size (PangoLayout *layout, + int *width, + int *height); + + int pango_layout_get_line_count (PangoLayout *layout); + PangoLayoutLine *pango_layout_get_line (PangoLayout *layout, + int line); + GSList * pango_layout_get_lines (PangoLayout *layout); + + void pango_layout_line_ref (PangoLayoutLine *line); + void pango_layout_line_unref (PangoLayoutLine *line); + gboolean pango_layout_line_x_to_index (PangoLayoutLine *line, + int x_pos, + int *index_, + int *trailing); + void pango_layout_line_index_to_x (PangoLayoutLine *line, + int index_, + gboolean trailing, + int *x_pos); + void pango_layout_line_get_x_ranges (PangoLayoutLine *line, + int start_index, + int end_index, + int **ranges, + int *n_ranges); + void pango_layout_line_get_extents (PangoLayoutLine *line, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + void pango_layout_line_get_pixel_extents (PangoLayoutLine *layout_line, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + + alias _PangoLayoutIter PangoLayoutIter; + alias void _PangoLayoutIter; + + + + + GType pango_layout_iter_get_type (); + + PangoLayoutIter *pango_layout_get_iter (PangoLayout *layout); + void pango_layout_iter_free (PangoLayoutIter *iter); + + int pango_layout_iter_get_index (PangoLayoutIter *iter); + PangoLayoutRun *pango_layout_iter_get_run (PangoLayoutIter *iter); + PangoLayoutLine *pango_layout_iter_get_line (PangoLayoutIter *iter); + gboolean pango_layout_iter_at_last_line (PangoLayoutIter *iter); + + gboolean pango_layout_iter_next_char (PangoLayoutIter *iter); + gboolean pango_layout_iter_next_cluster (PangoLayoutIter *iter); + gboolean pango_layout_iter_next_run (PangoLayoutIter *iter); + gboolean pango_layout_iter_next_line (PangoLayoutIter *iter); + + void pango_layout_iter_get_char_extents (PangoLayoutIter *iter, + PangoRectangle *logical_rect); + void pango_layout_iter_get_cluster_extents (PangoLayoutIter *iter, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + void pango_layout_iter_get_run_extents (PangoLayoutIter *iter, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + void pango_layout_iter_get_line_extents (PangoLayoutIter *iter, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + + + + void pango_layout_iter_get_line_yrange (PangoLayoutIter *iter, + int *y0_, + int *y1_); + void pango_layout_iter_get_layout_extents (PangoLayoutIter *iter, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect); + int pango_layout_iter_get_baseline (PangoLayoutIter *iter); + + + alias _GdkPoint GdkPoint; + + alias _GdkRectangle GdkRectangle; + + alias _GdkSegment GdkSegment; + + alias _GdkSpan GdkSpan; + + + + + + + + alias guint32 GdkWChar; + + alias _GdkAtom *GdkAtom; + alias void _GdkAtom; + + alias guint32 GdkNativeWindow; + + + + + alias _GdkColor GdkColor; + + alias _GdkColormap GdkColormap; + + alias _GdkCursor GdkCursor; + + alias _GdkFont GdkFont; + + alias _GdkGC GdkGC; + + alias _GdkImage GdkImage; + + alias _GdkRegion GdkRegion; + alias void _GdkRegion; + + alias _GdkVisual GdkVisual; + + + alias _GdkDrawable GdkDrawable; + + alias _GdkDrawable GdkBitmap; + + alias _GdkDrawable GdkPixmap; + + alias _GdkDrawable GdkWindow; + + alias _GdkDisplay GdkDisplay; + + alias _GdkScreen GdkScreen; + + + enum GdkByteOrder { + GDK_LSB_FIRST, + GDK_MSB_FIRST + }; + + + + + enum GdkModifierType { + GDK_SHIFT_MASK = 1 << 0, + GDK_LOCK_MASK = 1 << 1, + GDK_CONTROL_MASK = 1 << 2, + GDK_MOD1_MASK = 1 << 3, + GDK_MOD2_MASK = 1 << 4, + GDK_MOD3_MASK = 1 << 5, + GDK_MOD4_MASK = 1 << 6, + GDK_MOD5_MASK = 1 << 7, + GDK_BUTTON1_MASK = 1 << 8, + GDK_BUTTON2_MASK = 1 << 9, + GDK_BUTTON3_MASK = 1 << 10, + GDK_BUTTON4_MASK = 1 << 11, + GDK_BUTTON5_MASK = 1 << 12, + + + + + GDK_RELEASE_MASK = 1 << 30, + GDK_MODIFIER_MASK = GDK_RELEASE_MASK | 0x1fff + }; + + + enum GdkInputCondition { + GDK_INPUT_READ = 1 << 0, + GDK_INPUT_WRITE = 1 << 1, + GDK_INPUT_EXCEPTION = 1 << 2 + }; + + + enum GdkStatus { + GDK_OK = 0, + GDK_ERROR = -1, + GDK_ERROR_PARAM = -2, + GDK_ERROR_FILE = -3, + GDK_ERROR_MEM = -4 + }; + + + + + + + enum GdkGrabStatus { + GDK_GRAB_SUCCESS = 0, + GDK_GRAB_ALREADY_GRABBED = 1, + GDK_GRAB_INVALID_TIME = 2, + GDK_GRAB_NOT_VIEWABLE = 3, + GDK_GRAB_FROZEN = 4 + }; + + + alias void (*GdkInputFunction) (gpointer data, + gint source, + GdkInputCondition condition); + + alias void (*GdkDestroyNotify) (gpointer data); + + struct _GdkPoint { + gint x; + gint y; + } + + struct _GdkRectangle { + gint x; + gint y; + gint width; + gint height; + } + + struct _GdkSegment { + gint x1; + gint y1; + gint x2; + gint y2; + } + + struct _GdkSpan { + gint x; + gint y; + gint width; + } + + struct _GdkColor { + guint32 pixel; + guint16 red; + guint16 green; + guint16 blue; + } + + + + + alias _GdkColormapClass GdkColormapClass; + + struct _GdkColormap { + GObject parent_instance; + + + gint size; + GdkColor *colors; + + + GdkVisual *visual; + + gpointer windowing_data; + } + + struct _GdkColormapClass { + GObjectClass parent_class; + + } + + GType gdk_colormap_get_type () ; + + GdkColormap* gdk_colormap_new (GdkVisual *visual, + gboolean allocate); + + + GdkColormap* gdk_colormap_ref (GdkColormap *cmap); + void gdk_colormap_unref (GdkColormap *cmap); + + + + GdkColormap* gdk_colormap_get_system (); + + + GdkScreen *gdk_colormap_get_screen (GdkColormap *cmap); + + + gint gdk_colormap_get_system_size (); + + + + + void gdk_colormap_change (GdkColormap *colormap, + gint ncolors); + + + gint gdk_colormap_alloc_colors (GdkColormap *colormap, + GdkColor *colors, + gint ncolors, + gboolean writeable, + gboolean best_match, + gboolean *success); + gboolean gdk_colormap_alloc_color (GdkColormap *colormap, + GdkColor *color, + gboolean writeable, + gboolean best_match); + void gdk_colormap_free_colors (GdkColormap *colormap, + GdkColor *colors, + gint ncolors); + void gdk_colormap_query_color (GdkColormap *colormap, + gulong pixel, + GdkColor *result); + + GdkVisual *gdk_colormap_get_visual (GdkColormap *colormap); + + GdkColor *gdk_color_copy ( GdkColor *color); + void gdk_color_free (GdkColor *color); + gint gdk_color_parse ( gchar *spec, + GdkColor *color); + guint gdk_color_hash ( GdkColor *colora); + gboolean gdk_color_equal ( GdkColor *colora, + GdkColor *colorb); + + GType gdk_color_get_type (); + + + + void gdk_colors_store (GdkColormap *colormap, + GdkColor *colors, + gint ncolors); + gint gdk_color_white (GdkColormap *colormap, + GdkColor *color); + gint gdk_color_black (GdkColormap *colormap, + GdkColor *color); + gint gdk_color_alloc (GdkColormap *colormap, + GdkColor *color); + gint gdk_color_change (GdkColormap *colormap, + GdkColor *color); + + + + + gint gdk_colors_alloc (GdkColormap *colormap, + gboolean contiguous, + gulong *planes, + gint nplanes, + gulong *pixels, + gint npixels); + void gdk_colors_free (GdkColormap *colormap, + gulong *pixels, + gint npixels, + gulong planes); + + + + + guint gdk_pixbuf_major_version, gdk_pixbuf_minor_version, gdk_pixbuf_micro_version; + char *gdk_pixbuf_version; + + + + + + + + enum GdkPixbufAlphaMode { + GDK_PIXBUF_ALPHA_BILEVEL, + GDK_PIXBUF_ALPHA_FULL + }; + + + + + + + enum GdkColorspace { + GDK_COLORSPACE_RGB + }; + + + + alias _GdkPixbuf GdkPixbuf; + alias void _GdkPixbuf; + + alias _GdkPixbufAnimation GdkPixbufAnimation; + alias void _GdkPixbufAnimation; + + alias _GdkPixbufAnimationIter GdkPixbufAnimationIter; + alias void _GdkPixbufAnimationIter; + + alias void (* GdkPixbufDestroyNotify) (guchar *pixels, gpointer data); + + + + enum GdkPixbufError { + + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + + GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, + + GDK_PIXBUF_ERROR_BAD_OPTION, + + GDK_PIXBUF_ERROR_UNKNOWN_TYPE, + + GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION, + GDK_PIXBUF_ERROR_FAILED + }; + + + GQuark gdk_pixbuf_error_quark () ; + + + + GType gdk_pixbuf_get_type () ; + + + + + GdkPixbuf *gdk_pixbuf_ref (GdkPixbuf *pixbuf); + void gdk_pixbuf_unref (GdkPixbuf *pixbuf); + + + + + GdkColorspace gdk_pixbuf_get_colorspace ( GdkPixbuf *pixbuf); + int gdk_pixbuf_get_n_channels ( GdkPixbuf *pixbuf); + gboolean gdk_pixbuf_get_has_alpha ( GdkPixbuf *pixbuf); + int gdk_pixbuf_get_bits_per_sample ( GdkPixbuf *pixbuf); + guchar *gdk_pixbuf_get_pixels ( GdkPixbuf *pixbuf); + int gdk_pixbuf_get_width ( GdkPixbuf *pixbuf); + int gdk_pixbuf_get_height ( GdkPixbuf *pixbuf); + int gdk_pixbuf_get_rowstride ( GdkPixbuf *pixbuf); + + + + + GdkPixbuf *gdk_pixbuf_new (GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample, + int width, int height); + + + + GdkPixbuf *gdk_pixbuf_copy ( GdkPixbuf *pixbuf); + + + GdkPixbuf *gdk_pixbuf_new_subpixbuf (GdkPixbuf *src_pixbuf, + int src_x, + int src_y, + int width, + int height); + + + + GdkPixbuf *gdk_pixbuf_new_from_file ( char *filename, + GError **error); + + GdkPixbuf *gdk_pixbuf_new_from_file_at_size ( char *filename, + int width, + int height, + GError **error); + + GdkPixbuf *gdk_pixbuf_new_from_data ( guchar *data, + GdkColorspace colorspace, + gboolean has_alpha, + int bits_per_sample, + int width, int height, + int rowstride, + GdkPixbufDestroyNotify destroy_fn, + gpointer destroy_fn_data); + + GdkPixbuf *gdk_pixbuf_new_from_xpm_data ( char **data); + GdkPixbuf* gdk_pixbuf_new_from_inline (gint data_length, + guint8 *data, + gboolean copy_pixels, + GError **error); + + + void gdk_pixbuf_fill (GdkPixbuf *pixbuf, + guint32 pixel); + + + + gboolean gdk_pixbuf_save (GdkPixbuf *pixbuf, + char *filename, + char *type, + GError **error, + ...); + + gboolean gdk_pixbuf_savev (GdkPixbuf *pixbuf, + char *filename, + char *type, + char **option_keys, + char **option_values, + GError **error); + + + + alias gboolean (*GdkPixbufSaveFunc) ( gchar *buf, + gsize count, + GError **error, + gpointer data); + + gboolean gdk_pixbuf_save_to_callback (GdkPixbuf *pixbuf, + GdkPixbufSaveFunc save_func, + gpointer user_data, + char *type, + GError **error, + ...); + + gboolean gdk_pixbuf_save_to_callbackv (GdkPixbuf *pixbuf, + GdkPixbufSaveFunc save_func, + gpointer user_data, + char *type, + char **option_keys, + char **option_values, + GError **error); + + + + gboolean gdk_pixbuf_save_to_buffer (GdkPixbuf *pixbuf, + gchar **buffer, + gsize *buffer_size, + char *type, + GError **error, + ...); + + gboolean gdk_pixbuf_save_to_bufferv (GdkPixbuf *pixbuf, + gchar **buffer, + gsize *buffer_size, + char *type, + char **option_keys, + char **option_values, + GError **error); + + + GdkPixbuf *gdk_pixbuf_add_alpha ( GdkPixbuf *pixbuf, gboolean substitute_color, + guchar r, guchar g, guchar b); + + + void gdk_pixbuf_copy_area ( GdkPixbuf *src_pixbuf, + int src_x, int src_y, + int width, int height, + GdkPixbuf *dest_pixbuf, + int dest_x, int dest_y); + + + void gdk_pixbuf_saturate_and_pixelate ( GdkPixbuf *src, + GdkPixbuf *dest, + gfloat saturation, + gboolean pixelate); + enum GdkInterpType { + GDK_INTERP_NEAREST, + GDK_INTERP_TILES, + GDK_INTERP_BILINEAR, + GDK_INTERP_HYPER + }; + + + void gdk_pixbuf_scale ( GdkPixbuf *src, + GdkPixbuf *dest, + int dest_x, + int dest_y, + int dest_width, + int dest_height, + double offset_x, + double offset_y, + double scale_x, + double scale_y, + GdkInterpType interp_type); + void gdk_pixbuf_composite ( GdkPixbuf *src, + GdkPixbuf *dest, + int dest_x, + int dest_y, + int dest_width, + int dest_height, + double offset_x, + double offset_y, + double scale_x, + double scale_y, + GdkInterpType interp_type, + int overall_alpha); + void gdk_pixbuf_composite_color ( GdkPixbuf *src, + GdkPixbuf *dest, + int dest_x, + int dest_y, + int dest_width, + int dest_height, + double offset_x, + double offset_y, + double scale_x, + double scale_y, + GdkInterpType interp_type, + int overall_alpha, + int check_x, + int check_y, + int check_size, + guint32 color1, + guint32 color2); + + GdkPixbuf *gdk_pixbuf_scale_simple ( GdkPixbuf *src, + int dest_width, + int dest_height, + GdkInterpType interp_type); + + GdkPixbuf *gdk_pixbuf_composite_color_simple ( GdkPixbuf *src, + int dest_width, + int dest_height, + GdkInterpType interp_type, + int overall_alpha, + int check_size, + guint32 color1, + guint32 color2); + + + + + + GType gdk_pixbuf_animation_get_type () ; + + GdkPixbufAnimation *gdk_pixbuf_animation_new_from_file ( char *filename, + GError **error); + + + GdkPixbufAnimation *gdk_pixbuf_animation_ref (GdkPixbufAnimation *animation); + void gdk_pixbuf_animation_unref (GdkPixbufAnimation *animation); + + + int gdk_pixbuf_animation_get_width (GdkPixbufAnimation *animation); + int gdk_pixbuf_animation_get_height (GdkPixbufAnimation *animation); + gboolean gdk_pixbuf_animation_is_static_image (GdkPixbufAnimation *animation); + GdkPixbuf *gdk_pixbuf_animation_get_static_image (GdkPixbufAnimation *animation); + + GdkPixbufAnimationIter *gdk_pixbuf_animation_get_iter (GdkPixbufAnimation *animation, + GTimeVal *start_time); + GType gdk_pixbuf_animation_iter_get_type () ; + int gdk_pixbuf_animation_iter_get_delay_time (GdkPixbufAnimationIter *iter); + GdkPixbuf *gdk_pixbuf_animation_iter_get_pixbuf (GdkPixbufAnimationIter *iter); + gboolean gdk_pixbuf_animation_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter); + gboolean gdk_pixbuf_animation_iter_advance (GdkPixbufAnimationIter *iter, + GTimeVal *current_time); + + + + + gchar * gdk_pixbuf_get_option (GdkPixbuf *pixbuf, + gchar *key); + + + + alias _GdkPixbufFormat GdkPixbufFormat; + alias void _GdkPixbufFormat; + + + GSList *gdk_pixbuf_get_formats (); + gchar *gdk_pixbuf_format_get_name (GdkPixbufFormat *format); + gchar *gdk_pixbuf_format_get_description (GdkPixbufFormat *format); + gchar **gdk_pixbuf_format_get_mime_types (GdkPixbufFormat *format); + gchar **gdk_pixbuf_format_get_extensions (GdkPixbufFormat *format); + gboolean gdk_pixbuf_format_is_writable (GdkPixbufFormat *format); + + GdkPixbufFormat *gdk_pixbuf_get_file_info ( gchar *filename, + gint *width, + gint *height); + + + + + alias _GdkPixbufLoader GdkPixbufLoader; + + struct _GdkPixbufLoader { + GObject parent_instance; + + + gpointer priv; + } + + alias _GdkPixbufLoaderClass GdkPixbufLoaderClass; + + struct _GdkPixbufLoaderClass { + GObjectClass parent_class; + + void (*size_prepared) (GdkPixbufLoader *loader, + int width, + int height); + + void (*area_prepared) (GdkPixbufLoader *loader); + + + void (*area_updated) (GdkPixbufLoader *loader, + int x, + int y, + int width, + int height); + + void (*closed) (GdkPixbufLoader *loader); + } + + GType gdk_pixbuf_loader_get_type () ; + GdkPixbufLoader * gdk_pixbuf_loader_new (); + GdkPixbufLoader * gdk_pixbuf_loader_new_with_type ( char *image_type, + GError **error); + GdkPixbufLoader * gdk_pixbuf_loader_new_with_mime_type ( char *mime_type, + GError **error); + void gdk_pixbuf_loader_set_size (GdkPixbufLoader *loader, + int width, + int height); + gboolean gdk_pixbuf_loader_write (GdkPixbufLoader *loader, + guchar *buf, + gsize count, + GError **error); + GdkPixbuf * gdk_pixbuf_loader_get_pixbuf (GdkPixbufLoader *loader); + GdkPixbufAnimation * gdk_pixbuf_loader_get_animation (GdkPixbufLoader *loader); + gboolean gdk_pixbuf_loader_close (GdkPixbufLoader *loader, + GError **error); + GdkPixbufFormat *gdk_pixbuf_loader_get_format (GdkPixbufLoader *loader); + + + + + + + GType gdk_pixbuf_alpha_mode_get_type (); + + + GType gdk_colorspace_get_type (); + + + GType gdk_pixbuf_error_get_type (); + + + GType gdk_interp_type_get_type (); + + + + enum GdkCursorType { + 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_CURSOR_IS_PIXMAP = -1 + }; + + + struct _GdkCursor { + GdkCursorType type; + guint ref_count; + } + + + + + GType gdk_cursor_get_type (); + + GdkCursor* gdk_cursor_new_for_display (GdkDisplay *display, + GdkCursorType cursor_type); + + GdkCursor* gdk_cursor_new (GdkCursorType cursor_type); + + GdkCursor* gdk_cursor_new_from_pixmap (GdkPixmap *source, + GdkPixmap *mask, + GdkColor *fg, + GdkColor *bg, + gint x, + gint y); + GdkCursor* gdk_cursor_new_from_pixbuf (GdkDisplay *display, + GdkPixbuf *pixbuf, + gint x, + gint y); + GdkDisplay* gdk_cursor_get_display (GdkCursor *cursor); + GdkCursor* gdk_cursor_ref (GdkCursor *cursor); + void gdk_cursor_unref (GdkCursor *cursor); + + + + + + alias _GdkDragContext GdkDragContext; + + + enum GdkDragAction { + GDK_ACTION_DEFAULT = 1 << 0, + GDK_ACTION_COPY = 1 << 1, + GDK_ACTION_MOVE = 1 << 2, + GDK_ACTION_LINK = 1 << 3, + GDK_ACTION_PRIVATE = 1 << 4, + GDK_ACTION_ASK = 1 << 5 + }; + + + enum GdkDragProtocol { + 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 + }; + + + + + + + alias _GdkDragContextClass GdkDragContextClass; + + struct _GdkDragContext { + GObject parent_instance; + + + + GdkDragProtocol protocol; + + gboolean is_source; + + GdkWindow *source_window; + GdkWindow *dest_window; + + GList *targets; + GdkDragAction actions; + GdkDragAction suggested_action; + GdkDragAction action; + + guint32 start_time; + + + + gpointer windowing_data; + } + + struct _GdkDragContextClass { + GObjectClass parent_class; + + + } + + + + GType gdk_drag_context_get_type () ; + GdkDragContext * gdk_drag_context_new (); + + + void gdk_drag_context_ref (GdkDragContext *context); + void gdk_drag_context_unref (GdkDragContext *context); + + + + + void gdk_drag_status (GdkDragContext *context, + GdkDragAction action, + guint32 time_); + void gdk_drop_reply (GdkDragContext *context, + gboolean ok, + guint32 time_); + void gdk_drop_finish (GdkDragContext *context, + gboolean success, + guint32 time_); + GdkAtom gdk_drag_get_selection (GdkDragContext *context); + + + + GdkDragContext * gdk_drag_begin (GdkWindow *window, + GList *targets); + + guint32 gdk_drag_get_protocol_for_display (GdkDisplay *display, + guint32 xid, + GdkDragProtocol *protocol); + void gdk_drag_find_window_for_screen (GdkDragContext *context, + GdkWindow *drag_window, + GdkScreen *screen, + gint x_root, + gint y_root, + GdkWindow **dest_window, + GdkDragProtocol *protocol); + + + guint32 gdk_drag_get_protocol (guint32 xid, + GdkDragProtocol *protocol); + void gdk_drag_find_window (GdkDragContext *context, + GdkWindow *drag_window, + gint x_root, + gint y_root, + GdkWindow **dest_window, + GdkDragProtocol *protocol); + + + gboolean gdk_drag_motion (GdkDragContext *context, + GdkWindow *dest_window, + GdkDragProtocol protocol, + gint x_root, + gint y_root, + GdkDragAction suggested_action, + GdkDragAction possible_actions, + guint32 time_); + void gdk_drag_drop (GdkDragContext *context, + guint32 time_); + void gdk_drag_abort (GdkDragContext *context, + guint32 time_); + alias _GdkDeviceKey GdkDeviceKey; + + alias _GdkDeviceAxis GdkDeviceAxis; + + alias _GdkDevice GdkDevice; + + alias _GdkDeviceClass GdkDeviceClass; + alias void _GdkDeviceClass; + + alias _GdkTimeCoord GdkTimeCoord; + + + enum GdkExtensionMode { + GDK_EXTENSION_EVENTS_NONE, + GDK_EXTENSION_EVENTS_ALL, + GDK_EXTENSION_EVENTS_CURSOR + }; + + + enum GdkInputSource { + GDK_SOURCE_MOUSE, + GDK_SOURCE_PEN, + GDK_SOURCE_ERASER, + GDK_SOURCE_CURSOR + }; + + + enum GdkInputMode { + GDK_MODE_DISABLED, + GDK_MODE_SCREEN, + GDK_MODE_WINDOW + }; + + + enum GdkAxisUse { + GDK_AXIS_IGNORE, + GDK_AXIS_X, + GDK_AXIS_Y, + GDK_AXIS_PRESSURE, + GDK_AXIS_XTILT, + GDK_AXIS_YTILT, + GDK_AXIS_WHEEL, + GDK_AXIS_LAST + }; + + + struct _GdkDeviceKey { + guint keyval; + GdkModifierType modifiers; + } + + struct _GdkDeviceAxis { + GdkAxisUse use; + gdouble min; + gdouble max; + } + + struct _GdkDevice { + GObject parent_instance; + + + gchar *name; + GdkInputSource source; + GdkInputMode mode; + gboolean has_cursor; + + gint num_axes; + GdkDeviceAxis *axes; + + gint num_keys; + GdkDeviceKey *keys; + } + + + + + + + struct _GdkTimeCoord { + guint32 time; + gdouble axes[128]; + } + + GType gdk_device_get_type (); + + + + GList * gdk_devices_list (); + + + + void gdk_device_set_source (GdkDevice *device, + GdkInputSource source); + + gboolean gdk_device_set_mode (GdkDevice *device, + GdkInputMode mode); + + void gdk_device_set_key (GdkDevice *device, + guint index_, + guint keyval, + GdkModifierType modifiers); + + void gdk_device_set_axis_use (GdkDevice *device, + guint index_, + GdkAxisUse use); + void gdk_device_get_state (GdkDevice *device, + GdkWindow *window, + gdouble *axes, + GdkModifierType *mask); + gboolean gdk_device_get_history (GdkDevice *device, + GdkWindow *window, + guint32 start, + guint32 stop, + GdkTimeCoord ***events, + gint *n_events); + void gdk_device_free_history (GdkTimeCoord **events, + gint n_events); + gboolean gdk_device_get_axis (GdkDevice *device, + gdouble *axes, + GdkAxisUse use, + gdouble *value); + + void gdk_input_set_extension_events (GdkWindow *window, + gint mask, + GdkExtensionMode mode); + + + GdkDevice *gdk_device_get_core_pointer (); + alias _GdkEventAny GdkEventAny; + + alias _GdkEventExpose GdkEventExpose; + + alias _GdkEventNoExpose GdkEventNoExpose; + + alias _GdkEventVisibility GdkEventVisibility; + + alias _GdkEventMotion GdkEventMotion; + + alias _GdkEventButton GdkEventButton; + + alias _GdkEventScroll GdkEventScroll; + + alias _GdkEventKey GdkEventKey; + + alias _GdkEventFocus GdkEventFocus; + + alias _GdkEventCrossing GdkEventCrossing; + + alias _GdkEventConfigure GdkEventConfigure; + + alias _GdkEventProperty GdkEventProperty; + + alias _GdkEventSelection GdkEventSelection; + + alias _GdkEventProximity GdkEventProximity; + + alias _GdkEventClient GdkEventClient; + + alias _GdkEventDND GdkEventDND; + + alias _GdkEventWindowState GdkEventWindowState; + + alias _GdkEventSetting GdkEventSetting; + + + alias _GdkEvent GdkEvent; + + + alias void (*GdkEventFunc) (GdkEvent *event, + gpointer data); + + + + alias void GdkXEvent; + + + + enum GdkFilterReturn { + GDK_FILTER_CONTINUE, + GDK_FILTER_TRANSLATE, + + + GDK_FILTER_REMOVE + }; + + + alias GdkFilterReturn (*GdkFilterFunc) (GdkXEvent *xevent, + GdkEvent *event, + gpointer data); + enum GdkEventType { + 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 = 24, + GDK_DRAG_STATUS = 25, + 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 + }; + + + + + + enum GdkEventMask { + GDK_EXPOSURE_MASK = 1 << 1, + GDK_POINTER_MOTION_MASK = 1 << 2, + GDK_POINTER_MOTION_HINT_MASK = 1 << 3, + GDK_BUTTON_MOTION_MASK = 1 << 4, + GDK_BUTTON1_MOTION_MASK = 1 << 5, + GDK_BUTTON2_MOTION_MASK = 1 << 6, + GDK_BUTTON3_MOTION_MASK = 1 << 7, + GDK_BUTTON_PRESS_MASK = 1 << 8, + GDK_BUTTON_RELEASE_MASK = 1 << 9, + GDK_KEY_PRESS_MASK = 1 << 10, + GDK_KEY_RELEASE_MASK = 1 << 11, + GDK_ENTER_NOTIFY_MASK = 1 << 12, + GDK_LEAVE_NOTIFY_MASK = 1 << 13, + GDK_FOCUS_CHANGE_MASK = 1 << 14, + GDK_STRUCTURE_MASK = 1 << 15, + GDK_PROPERTY_CHANGE_MASK = 1 << 16, + GDK_VISIBILITY_NOTIFY_MASK = 1 << 17, + GDK_PROXIMITY_IN_MASK = 1 << 18, + GDK_PROXIMITY_OUT_MASK = 1 << 19, + GDK_SUBSTRUCTURE_MASK = 1 << 20, + GDK_SCROLL_MASK = 1 << 21, + GDK_ALL_EVENTS_MASK = 0x3FFFFE + }; + + + enum GdkVisibilityState { + GDK_VISIBILITY_UNOBSCURED, + GDK_VISIBILITY_PARTIAL, + GDK_VISIBILITY_FULLY_OBSCURED + }; + + + enum GdkScrollDirection { + GDK_SCROLL_UP, + GDK_SCROLL_DOWN, + GDK_SCROLL_LEFT, + GDK_SCROLL_RIGHT + }; + + enum GdkNotifyType { + 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 + }; + + + + + + + + enum GdkCrossingMode { + GDK_CROSSING_NORMAL, + GDK_CROSSING_GRAB, + GDK_CROSSING_UNGRAB + }; + + + enum GdkPropertyState { + GDK_PROPERTY_NEW_VALUE, + GDK_PROPERTY_DELETE + }; + + + enum GdkWindowState { + GDK_WINDOW_STATE_WITHDRAWN = 1 << 0, + GDK_WINDOW_STATE_ICONIFIED = 1 << 1, + GDK_WINDOW_STATE_MAXIMIZED = 1 << 2, + GDK_WINDOW_STATE_STICKY = 1 << 3, + GDK_WINDOW_STATE_FULLSCREEN = 1 << 4, + GDK_WINDOW_STATE_ABOVE = 1 << 5, + GDK_WINDOW_STATE_BELOW = 1 << 6 + }; + + + enum GdkSettingAction { + GDK_SETTING_ACTION_NEW, + GDK_SETTING_ACTION_CHANGED, + GDK_SETTING_ACTION_DELETED + }; + + + struct _GdkEventAny { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + } + + struct _GdkEventExpose { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkRectangle area; + GdkRegion *region; + gint count; + } + + struct _GdkEventNoExpose { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + } + + struct _GdkEventVisibility { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkVisibilityState state; + } + + struct _GdkEventMotion { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + gdouble x; + gdouble y; + gdouble *axes; + guint state; + gint16 is_hint; + GdkDevice *device; + gdouble x_root, y_root; + } + + struct _GdkEventButton { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + gdouble x; + gdouble y; + gdouble *axes; + guint state; + guint button; + GdkDevice *device; + gdouble x_root, y_root; + } + + struct _GdkEventScroll { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + gdouble x; + gdouble y; + guint state; + GdkScrollDirection direction; + GdkDevice *device; + gdouble x_root, y_root; + } + + struct _GdkEventKey { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + guint state; + guint keyval; + gint length; + gchar *string; + guint16 hardware_keycode; + guint8 group; + } + + struct _GdkEventCrossing { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkWindow *subwindow; + guint32 time; + gdouble x; + gdouble y; + gdouble x_root; + gdouble y_root; + GdkCrossingMode mode; + GdkNotifyType detail; + gboolean focus; + guint state; + } + + struct _GdkEventFocus { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + gint16 In; + } + + struct _GdkEventConfigure { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + gint x, y; + gint width; + gint height; + } + + struct _GdkEventProperty { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkAtom atom; + guint32 time; + guint state; + } + + struct _GdkEventSelection { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkAtom selection; + GdkAtom target; + GdkAtom property; + guint32 time; + GdkNativeWindow requestor; + } + + + + + struct _GdkEventProximity { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + guint32 time; + GdkDevice *device; + } + + struct _GdkEventClient { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkAtom message_type; + gushort data_format; + union data_union { + char b[20]; + short s[10]; + int l[5]; + } + data_union data; + } + + struct _GdkEventSetting { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkSettingAction action; + char *name; + } + + struct _GdkEventWindowState { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkWindowState changed_mask; + GdkWindowState new_window_state; + } + + + + struct _GdkEventDND { + GdkEventType type; + GdkWindow *window; + gint8 send_event; + GdkDragContext *context; + + guint32 time; + gshort x_root, y_root; + } + + union _GdkEvent { + GdkEventType type; + GdkEventAny any; + GdkEventExpose expose; + GdkEventNoExpose no_expose; + GdkEventVisibility visibility; + GdkEventMotion motion; + GdkEventButton button; + GdkEventScroll scroll; + GdkEventKey key; + GdkEventCrossing crossing; + GdkEventFocus focus_change; + GdkEventConfigure configure; + GdkEventProperty property; + GdkEventSelection selection; + GdkEventProximity proximity; + GdkEventClient client; + GdkEventDND dnd; + GdkEventWindowState window_state; + GdkEventSetting setting; + } + + GType gdk_event_get_type (); + + gboolean gdk_events_pending (); + GdkEvent* gdk_event_get (); + + GdkEvent* gdk_event_peek (); + GdkEvent* gdk_event_get_graphics_expose (GdkWindow *window); + void gdk_event_put (GdkEvent *event); + + GdkEvent* gdk_event_new (GdkEventType type); + GdkEvent* gdk_event_copy (GdkEvent *event); + void gdk_event_free (GdkEvent *event); + + guint32 gdk_event_get_time (GdkEvent *event); + gboolean gdk_event_get_state (GdkEvent *event, + GdkModifierType *state); + gboolean gdk_event_get_coords (GdkEvent *event, + gdouble *x_win, + gdouble *y_win); + gboolean gdk_event_get_root_coords (GdkEvent *event, + gdouble *x_root, + gdouble *y_root); + gboolean gdk_event_get_axis (GdkEvent *event, + GdkAxisUse axis_use, + gdouble *value); + void gdk_event_handler_set (GdkEventFunc func, + gpointer data, + GDestroyNotify notify); + + void gdk_event_set_screen (GdkEvent *event, + GdkScreen *screen); + GdkScreen *gdk_event_get_screen (GdkEvent *event); + + void gdk_set_show_events (gboolean show_events); + gboolean gdk_get_show_events (); + + + void gdk_add_client_message_filter (GdkAtom message_type, + GdkFilterFunc func, + gpointer data); + + gboolean gdk_setting_get ( gchar *name, + GValue *value); + + + + + alias _GdkDisplayClass GdkDisplayClass; + + alias _GdkDisplayPointerHooks GdkDisplayPointerHooks; + + struct _GdkDisplay { + GObject parent_instance; + + + GList *queued_events; + GList *queued_tail; + + + + + guint32 button_click_time[2]; + GdkWindow *button_window[2]; + gint button_number[2]; + + guint double_click_time; + GdkDevice *core_pointer; + + GdkDisplayPointerHooks *pointer_hooks; + + guint closed; + + guint double_click_distance; + gint button_x[2]; + gint button_y[2]; + } + + struct _GdkDisplayClass { + GObjectClass parent_class; + + gchar * (*get_display_name) (GdkDisplay *display); + gint (*get_n_screens) (GdkDisplay *display); + GdkScreen * (*get_screen) (GdkDisplay *display, + gint screen_num); + GdkScreen * (*get_default_screen) (GdkDisplay *display); + + + + void (*closed) (GdkDisplay *display, + gboolean is_error); + } + + struct _GdkDisplayPointerHooks { + void (*get_pointer) (GdkDisplay *display, + GdkScreen **screen, + gint *x, + gint *y, + GdkModifierType *mask); + GdkWindow* (*window_get_pointer) (GdkDisplay *display, + GdkWindow *window, + gint *x, + gint *y, + GdkModifierType *mask); + GdkWindow* (*window_at_pointer) (GdkDisplay *display, + gint *win_x, + gint *win_y); + } + + GType gdk_display_get_type (); + GdkDisplay *gdk_display_open ( gchar *display_name); + + gchar * gdk_display_get_name (GdkDisplay *display); + + gint gdk_display_get_n_screens (GdkDisplay *display); + GdkScreen * gdk_display_get_screen (GdkDisplay *display, + gint screen_num); + GdkScreen * gdk_display_get_default_screen (GdkDisplay *display); + void gdk_display_pointer_ungrab (GdkDisplay *display, + guint32 time_); + void gdk_display_keyboard_ungrab (GdkDisplay *display, + guint32 time_); + gboolean gdk_display_pointer_is_grabbed (GdkDisplay *display); + void gdk_display_beep (GdkDisplay *display); + void gdk_display_sync (GdkDisplay *display); + void gdk_display_flush (GdkDisplay *display); + + void gdk_display_close (GdkDisplay *display); + + GList * gdk_display_list_devices (GdkDisplay *display); + + GdkEvent* gdk_display_get_event (GdkDisplay *display); + GdkEvent* gdk_display_peek_event (GdkDisplay *display); + void gdk_display_put_event (GdkDisplay *display, + GdkEvent *event); + + void gdk_display_add_client_message_filter (GdkDisplay *display, + GdkAtom message_type, + GdkFilterFunc func, + gpointer data); + + void gdk_display_set_double_click_time (GdkDisplay *display, + guint msec); + void gdk_display_set_double_click_distance (GdkDisplay *display, + guint distance); + + GdkDisplay *gdk_display_get_default (); + + GdkDevice *gdk_display_get_core_pointer (GdkDisplay *display); + + void gdk_display_get_pointer (GdkDisplay *display, + GdkScreen **screen, + gint *x, + gint *y, + GdkModifierType *mask); + GdkWindow * gdk_display_get_window_at_pointer (GdkDisplay *display, + gint *win_x, + gint *win_y); + + GdkDisplayPointerHooks *gdk_display_set_pointer_hooks (GdkDisplay *display, + GdkDisplayPointerHooks *new_hooks); + + GdkDisplay *gdk_display_open_default_libgtk_only (); + + gboolean gdk_display_supports_cursor_alpha (GdkDisplay *display); + gboolean gdk_display_supports_cursor_color (GdkDisplay *display); + guint gdk_display_get_default_cursor_size (GdkDisplay *display); + void gdk_display_get_maximal_cursor_size (GdkDisplay *display, + guint *width, + guint *height); + + GdkWindow *gdk_display_get_default_group (GdkDisplay *display); + + + + + + + + alias _GdkGCValues GdkGCValues; + + alias _GdkGCClass GdkGCClass; + + + + + + + + + enum GdkCapStyle { + GDK_CAP_NOT_LAST, + GDK_CAP_BUTT, + GDK_CAP_ROUND, + GDK_CAP_PROJECTING + }; + + + + + + + + + enum GdkFill { + GDK_SOLID, + GDK_TILED, + GDK_STIPPLED, + GDK_OPAQUE_STIPPLED + }; + + enum GdkFunction { + 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 + }; + + + + + + + + enum GdkJoinStyle { + GDK_JOIN_MITER, + GDK_JOIN_ROUND, + GDK_JOIN_BEVEL + }; + + + + + + + + enum GdkLineStyle { + GDK_LINE_SOLID, + GDK_LINE_ON_OFF_DASH, + GDK_LINE_DOUBLE_DASH + }; + + + enum GdkSubwindowMode { + GDK_CLIP_BY_CHILDREN = 0, + GDK_INCLUDE_INFERIORS = 1 + }; + + + enum GdkGCValuesMask { + GDK_GC_FOREGROUND = 1 << 0, + GDK_GC_BACKGROUND = 1 << 1, + GDK_GC_FONT = 1 << 2, + GDK_GC_FUNCTION = 1 << 3, + GDK_GC_FILL = 1 << 4, + GDK_GC_TILE = 1 << 5, + GDK_GC_STIPPLE = 1 << 6, + GDK_GC_CLIP_MASK = 1 << 7, + GDK_GC_SUBWINDOW = 1 << 8, + GDK_GC_TS_X_ORIGIN = 1 << 9, + GDK_GC_TS_Y_ORIGIN = 1 << 10, + GDK_GC_CLIP_X_ORIGIN = 1 << 11, + GDK_GC_CLIP_Y_ORIGIN = 1 << 12, + GDK_GC_EXPOSURES = 1 << 13, + GDK_GC_LINE_WIDTH = 1 << 14, + GDK_GC_LINE_STYLE = 1 << 15, + GDK_GC_CAP_STYLE = 1 << 16, + GDK_GC_JOIN_STYLE = 1 << 17 + }; + + + struct _GdkGCValues { + GdkColor foreground; + GdkColor background; + GdkFont *font; + GdkFunction Function; + GdkFill fill; + GdkPixmap *tile; + GdkPixmap *stipple; + GdkPixmap *clip_mask; + GdkSubwindowMode subwindow_mode; + gint ts_x_origin; + gint ts_y_origin; + gint clip_x_origin; + gint clip_y_origin; + gint graphics_exposures; + gint line_width; + GdkLineStyle line_style; + GdkCapStyle cap_style; + GdkJoinStyle join_style; + } + struct _GdkGC { + GObject parent_instance; + + gint clip_x_origin; + gint clip_y_origin; + gint ts_x_origin; + gint ts_y_origin; + + GdkColormap *colormap; + } + + struct _GdkGCClass { + GObjectClass parent_class; + + void (*get_values) (GdkGC *gc, + GdkGCValues *values); + void (*set_values) (GdkGC *gc, + GdkGCValues *values, + GdkGCValuesMask mask); + void (*set_dashes) (GdkGC *gc, + gint dash_offset, + gint8* dash_list, + gint n); + + + void (*_gdk_reserved1) (); + void (*_gdk_reserved2) (); + void (*_gdk_reserved3) (); + void (*_gdk_reserved4) (); + } + + + GType gdk_gc_get_type () ; + GdkGC *gdk_gc_new (GdkDrawable *drawable); + GdkGC *gdk_gc_new_with_values (GdkDrawable *drawable, + GdkGCValues *values, + GdkGCValuesMask values_mask); + + + GdkGC *gdk_gc_ref (GdkGC *gc); + void gdk_gc_unref (GdkGC *gc); + + + void gdk_gc_get_values (GdkGC *gc, + GdkGCValues *values); + void gdk_gc_set_values (GdkGC *gc, + GdkGCValues *values, + GdkGCValuesMask values_mask); + void gdk_gc_set_foreground (GdkGC *gc, + GdkColor *color); + void gdk_gc_set_background (GdkGC *gc, + GdkColor *color); + + void gdk_gc_set_font (GdkGC *gc, + GdkFont *font); + + void gdk_gc_set_function (GdkGC *gc, + GdkFunction Function); + void gdk_gc_set_fill (GdkGC *gc, + GdkFill fill); + void gdk_gc_set_tile (GdkGC *gc, + GdkPixmap *tile); + void gdk_gc_set_stipple (GdkGC *gc, + GdkPixmap *stipple); + void gdk_gc_set_ts_origin (GdkGC *gc, + gint x, + gint y); + void gdk_gc_set_clip_origin (GdkGC *gc, + gint x, + gint y); + void gdk_gc_set_clip_mask (GdkGC *gc, + GdkBitmap *mask); + void gdk_gc_set_clip_rectangle (GdkGC *gc, + GdkRectangle *rectangle); + void gdk_gc_set_clip_region (GdkGC *gc, + GdkRegion *region); + void gdk_gc_set_subwindow (GdkGC *gc, + GdkSubwindowMode mode); + void gdk_gc_set_exposures (GdkGC *gc, + gboolean exposures); + void gdk_gc_set_line_attributes (GdkGC *gc, + gint line_width, + GdkLineStyle line_style, + GdkCapStyle cap_style, + GdkJoinStyle join_style); + void gdk_gc_set_dashes (GdkGC *gc, + gint dash_offset, + gint8* dash_list, + gint n); + void gdk_gc_offset (GdkGC *gc, + gint x_offset, + gint y_offset); + void gdk_gc_copy (GdkGC *dst_gc, + GdkGC *src_gc); + + + void gdk_gc_set_colormap (GdkGC *gc, + GdkColormap *colormap); + GdkColormap *gdk_gc_get_colormap (GdkGC *gc); + void gdk_gc_set_rgb_fg_color (GdkGC *gc, + GdkColor *color); + void gdk_gc_set_rgb_bg_color (GdkGC *gc, + GdkColor *color); + GdkScreen * gdk_gc_get_screen (GdkGC *gc); + alias _GdkRgbCmap GdkRgbCmap; + + + struct _GdkRgbCmap { + guint32 colors[256]; + gint n_colors; + + + GSList *info_list; + } + + + void gdk_rgb_init (); + + gulong gdk_rgb_xpixel_from_rgb (guint32 rgb) ; + void gdk_rgb_gc_set_foreground (GdkGC *gc, + guint32 rgb); + void gdk_rgb_gc_set_background (GdkGC *gc, + guint32 rgb); + + + + void gdk_rgb_find_color (GdkColormap *colormap, + GdkColor *color); + + enum GdkRgbDither { + GDK_RGB_DITHER_NONE, + GDK_RGB_DITHER_NORMAL, + GDK_RGB_DITHER_MAX + }; + + + void gdk_draw_rgb_image (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + gint width, + gint height, + GdkRgbDither dith, + guchar *rgb_buf, + gint rowstride); + void gdk_draw_rgb_image_dithalign (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + gint width, + gint height, + GdkRgbDither dith, + guchar *rgb_buf, + gint rowstride, + gint xdith, + gint ydith); + void gdk_draw_rgb_32_image (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + gint width, + gint height, + GdkRgbDither dith, + guchar *buf, + gint rowstride); + void gdk_draw_rgb_32_image_dithalign (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + gint width, + gint height, + GdkRgbDither dith, + guchar *buf, + gint rowstride, + gint xdith, + gint ydith); + void gdk_draw_gray_image (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + gint width, + gint height, + GdkRgbDither dith, + guchar *buf, + gint rowstride); + void gdk_draw_indexed_image (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + gint width, + gint height, + GdkRgbDither dith, + guchar *buf, + gint rowstride, + GdkRgbCmap *cmap); + GdkRgbCmap *gdk_rgb_cmap_new (guint32 *colors, + gint n_colors); + void gdk_rgb_cmap_free (GdkRgbCmap *cmap); + + void gdk_rgb_set_verbose (gboolean verbose); + + + void gdk_rgb_set_install (gboolean install); + void gdk_rgb_set_min_colors (gint min_colors); + + + GdkColormap *gdk_rgb_get_colormap (); + GdkVisual * gdk_rgb_get_visual (); + gboolean gdk_rgb_ditherable (); + + + + + + + alias _GdkDrawableClass GdkDrawableClass; + + struct _GdkDrawable { + GObject parent_instance; + } + + struct _GdkDrawableClass { + GObjectClass parent_class; + + GdkGC *(*create_gc) (GdkDrawable *drawable, + GdkGCValues *values, + GdkGCValuesMask mask); + void (*draw_rectangle) (GdkDrawable *drawable, + GdkGC *gc, + gboolean filled, + gint x, + gint y, + gint width, + gint height); + void (*draw_arc) (GdkDrawable *drawable, + GdkGC *gc, + gboolean filled, + gint x, + gint y, + gint width, + gint height, + gint angle1, + gint angle2); + void (*draw_polygon) (GdkDrawable *drawable, + GdkGC *gc, + gboolean filled, + GdkPoint *points, + gint npoints); + void (*draw_text) (GdkDrawable *drawable, + GdkFont *font, + GdkGC *gc, + gint x, + gint y, + gchar *text, + gint text_length); + void (*draw_text_wc) (GdkDrawable *drawable, + GdkFont *font, + GdkGC *gc, + gint x, + gint y, + GdkWChar *text, + gint text_length); + void (*draw_drawable) (GdkDrawable *drawable, + GdkGC *gc, + GdkDrawable *src, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); + void (*draw_points) (GdkDrawable *drawable, + GdkGC *gc, + GdkPoint *points, + gint npoints); + void (*draw_segments) (GdkDrawable *drawable, + GdkGC *gc, + GdkSegment *segs, + gint nsegs); + void (*draw_lines) (GdkDrawable *drawable, + GdkGC *gc, + GdkPoint *points, + gint npoints); + + void (*draw_glyphs) (GdkDrawable *drawable, + GdkGC *gc, + PangoFont *font, + gint x, + gint y, + PangoGlyphString *glyphs); + + void (*draw_image) (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); + + gint (*get_depth) (GdkDrawable *drawable); + void (*get_size) (GdkDrawable *drawable, + gint *width, + gint *height); + + void (*set_colormap) (GdkDrawable *drawable, + GdkColormap *cmap); + + GdkColormap* (*get_colormap) (GdkDrawable *drawable); + GdkVisual* (*get_visual) (GdkDrawable *drawable); + GdkScreen* (*get_screen) (GdkDrawable *drawable); + + GdkImage* (*get_image) (GdkDrawable *drawable, + gint x, + gint y, + gint width, + gint height); + + GdkRegion* (*get_clip_region) (GdkDrawable *drawable); + GdkRegion* (*get_visible_region) (GdkDrawable *drawable); + + GdkDrawable* (*get_composite_drawable) (GdkDrawable *drawable, + gint x, + gint y, + gint width, + gint height, + gint *composite_x_offset, + gint *composite_y_offset); + + void (*draw_pixbuf) (GdkDrawable *drawable, + GdkGC *gc, + GdkPixbuf *pixbuf, + gint src_x, + gint src_y, + gint dest_x, + gint dest_y, + gint width, + gint height, + GdkRgbDither dither, + gint x_dither, + gint y_dither); + GdkImage* (*_copy_to_image) (GdkDrawable *drawable, + GdkImage *image, + gint src_x, + gint src_y, + gint dest_x, + gint dest_y, + gint width, + gint height); + + + void (*_gdk_reserved1) (); + void (*_gdk_reserved2) (); + void (*_gdk_reserved3) (); + void (*_gdk_reserved4) (); + void (*_gdk_reserved5) (); + void (*_gdk_reserved6) (); + void (*_gdk_reserved7) (); + void (*_gdk_reserved9) (); + void (*_gdk_reserved10) (); + void (*_gdk_reserved11) (); + void (*_gdk_reserved12) (); + void (*_gdk_reserved13) (); + void (*_gdk_reserved14) (); + void (*_gdk_reserved15) (); + void (*_gdk_reserved16) (); + } + + GType gdk_drawable_get_type (); + + + + + + void gdk_drawable_set_data (GdkDrawable *drawable, + gchar *key, + gpointer data, + GDestroyNotify destroy_func); + gpointer gdk_drawable_get_data (GdkDrawable *drawable, + gchar *key); + + + void gdk_drawable_get_size (GdkDrawable *drawable, + gint *width, + gint *height); + void gdk_drawable_set_colormap (GdkDrawable *drawable, + GdkColormap *colormap); + GdkColormap* gdk_drawable_get_colormap (GdkDrawable *drawable); + GdkVisual* gdk_drawable_get_visual (GdkDrawable *drawable); + gint gdk_drawable_get_depth (GdkDrawable *drawable); + GdkScreen* gdk_drawable_get_screen (GdkDrawable *drawable); + GdkDisplay* gdk_drawable_get_display (GdkDrawable *drawable); + + + GdkDrawable* gdk_drawable_ref (GdkDrawable *drawable); + void gdk_drawable_unref (GdkDrawable *drawable); + + + + + void gdk_draw_point (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y); + void gdk_draw_line (GdkDrawable *drawable, + GdkGC *gc, + gint x1_, + gint y1_, + gint x2_, + gint y2_); + void gdk_draw_rectangle (GdkDrawable *drawable, + GdkGC *gc, + gboolean filled, + gint x, + gint y, + gint width, + gint height); + void gdk_draw_arc (GdkDrawable *drawable, + GdkGC *gc, + gboolean filled, + gint x, + gint y, + gint width, + gint height, + gint angle1, + gint angle2); + void gdk_draw_polygon (GdkDrawable *drawable, + GdkGC *gc, + gboolean filled, + GdkPoint *points, + gint npoints); + + + void gdk_draw_string (GdkDrawable *drawable, + GdkFont *font, + GdkGC *gc, + gint x, + gint y, + gchar *string); + + + + void gdk_draw_text (GdkDrawable *drawable, + GdkFont *font, + GdkGC *gc, + gint x, + gint y, + gchar *text, + gint text_length); + + void gdk_draw_text_wc (GdkDrawable *drawable, + GdkFont *font, + GdkGC *gc, + gint x, + gint y, + GdkWChar *text, + gint text_length); + + void gdk_draw_drawable (GdkDrawable *drawable, + GdkGC *gc, + GdkDrawable *src, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); + void gdk_draw_image (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); + void gdk_draw_points (GdkDrawable *drawable, + GdkGC *gc, + GdkPoint *points, + gint npoints); + void gdk_draw_segments (GdkDrawable *drawable, + GdkGC *gc, + GdkSegment *segs, + gint nsegs); + void gdk_draw_lines (GdkDrawable *drawable, + GdkGC *gc, + GdkPoint *points, + gint npoints); + void gdk_draw_pixbuf (GdkDrawable *drawable, + GdkGC *gc, + GdkPixbuf *pixbuf, + gint src_x, + gint src_y, + gint dest_x, + gint dest_y, + gint width, + gint height, + GdkRgbDither dither, + gint x_dither, + gint y_dither); + + void gdk_draw_glyphs (GdkDrawable *drawable, + GdkGC *gc, + PangoFont *font, + gint x, + gint y, + PangoGlyphString *glyphs); + void gdk_draw_layout_line (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + PangoLayoutLine *line); + void gdk_draw_layout (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + PangoLayout *layout); + + void gdk_draw_layout_line_with_colors (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + PangoLayoutLine *line, + GdkColor *foreground, + GdkColor *background); + void gdk_draw_layout_with_colors (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + PangoLayout *layout, + GdkColor *foreground, + GdkColor *background); + + + + + + + GdkImage* gdk_drawable_get_image (GdkDrawable *drawable, + gint x, + gint y, + gint width, + gint height); + GdkImage *gdk_drawable_copy_to_image (GdkDrawable *drawable, + GdkImage *image, + gint src_x, + gint src_y, + gint dest_x, + gint dest_y, + gint width, + gint height); + + GdkRegion *gdk_drawable_get_clip_region (GdkDrawable *drawable); + GdkRegion *gdk_drawable_get_visible_region (GdkDrawable *drawable); + + + + + GType gdk_cursor_type_get_type (); + + + + + GType gdk_drag_action_get_type (); + + + GType gdk_drag_protocol_get_type (); + + + + + GType gdk_filter_return_get_type (); + + + GType gdk_event_type_get_type (); + + + GType gdk_event_mask_get_type (); + + + GType gdk_visibility_state_get_type (); + + + GType gdk_scroll_direction_get_type (); + + + GType gdk_notify_type_get_type (); + + + GType gdk_crossing_mode_get_type (); + + + GType gdk_property_state_get_type (); + + + GType gdk_window_state_get_type (); + + + GType gdk_setting_action_get_type (); + + + + + GType gdk_font_type_get_type (); + + + + + GType gdk_cap_style_get_type (); + + + GType gdk_fill_get_type (); + + + GType gdk_function_get_type (); + + + GType gdk_join_style_get_type (); + + + GType gdk_line_style_get_type (); + + + GType gdk_subwindow_mode_get_type (); + + + GType gdk_gc_values_mask_get_type (); + + + + + GType gdk_image_type_get_type (); + + + + + GType gdk_extension_mode_get_type (); + + + GType gdk_input_source_get_type (); + + + GType gdk_input_mode_get_type (); + + + GType gdk_axis_use_get_type (); + + + + + GType gdk_prop_mode_get_type (); + + + + + GType gdk_fill_rule_get_type (); + + + GType gdk_overlap_type_get_type (); + + + + + GType gdk_rgb_dither_get_type (); + + + + + GType gdk_byte_order_get_type (); + + + GType gdk_modifier_type_get_type (); + + + GType gdk_input_condition_get_type (); + + + GType gdk_status_get_type (); + + + GType gdk_grab_status_get_type (); + + + + + GType gdk_visual_type_get_type (); + + + + + GType gdk_window_class_get_type (); + + + GType gdk_window_type_get_type (); + + + GType gdk_window_attributes_type_get_type (); + + + GType gdk_window_hints_get_type (); + + + GType gdk_window_type_hint_get_type (); + + + GType gdk_wm_decoration_get_type (); + + + GType gdk_wm_function_get_type (); + + + GType gdk_gravity_get_type (); + + + GType gdk_window_edge_get_type (); + + + + + enum GdkFontType { + GDK_FONT_FONT, + GDK_FONT_FONTSET + }; + + + struct _GdkFont { + GdkFontType type; + gint ascent; + gint descent; + } + + GType gdk_font_get_type (); + + GdkFont* gdk_font_ref (GdkFont *font); + void gdk_font_unref (GdkFont *font); + gint gdk_font_id ( GdkFont *font); + gboolean gdk_font_equal ( GdkFont *fonta, + GdkFont *fontb); + + GdkFont *gdk_font_load_for_display (GdkDisplay *display, + gchar *font_name); + GdkFont *gdk_fontset_load_for_display (GdkDisplay *display, + gchar *fontset_name); + GdkFont *gdk_font_from_description_for_display (GdkDisplay *display, + PangoFontDescription *font_desc); + + + + + GdkFont* gdk_font_load ( gchar *font_name); + GdkFont* gdk_fontset_load ( gchar *fontset_name); + GdkFont* gdk_font_from_description (PangoFontDescription *font_desc); + + + gint gdk_string_width (GdkFont *font, + gchar *string); + gint gdk_text_width (GdkFont *font, + gchar *text, + gint text_length); + gint gdk_text_width_wc (GdkFont *font, + GdkWChar *text, + gint text_length); + gint gdk_char_width (GdkFont *font, + gchar character); + gint gdk_char_width_wc (GdkFont *font, + GdkWChar character); + gint gdk_string_measure (GdkFont *font, + gchar *string); + gint gdk_text_measure (GdkFont *font, + gchar *text, + gint text_length); + gint gdk_char_measure (GdkFont *font, + gchar character); + gint gdk_string_height (GdkFont *font, + gchar *string); + gint gdk_text_height (GdkFont *font, + gchar *text, + gint text_length); + gint gdk_char_height (GdkFont *font, + gchar character); + + void gdk_text_extents (GdkFont *font, + gchar *text, + gint text_length, + gint *lbearing, + gint *rbearing, + gint *width, + gint *ascent, + gint *descent); + void gdk_text_extents_wc (GdkFont *font, + GdkWChar *text, + gint text_length, + gint *lbearing, + gint *rbearing, + gint *width, + gint *ascent, + gint *descent); + void gdk_string_extents (GdkFont *font, + gchar *string, + gint *lbearing, + gint *rbearing, + gint *width, + gint *ascent, + gint *descent); + + GdkDisplay * gdk_font_get_display (GdkFont *font); + + enum GdkImageType { + GDK_IMAGE_NORMAL, + GDK_IMAGE_SHARED, + GDK_IMAGE_FASTEST + }; + + + alias _GdkImageClass GdkImageClass; + + struct _GdkImage { + GObject parent_instance; + + + + GdkImageType type; + GdkVisual *visual; + GdkByteOrder byte_order; + gint width; + gint height; + guint16 depth; + guint16 bpp; + guint16 bpl; + guint16 bits_per_pixel; + gpointer mem; + + GdkColormap *colormap; + + gpointer windowing_data; + } + + struct _GdkImageClass { + GObjectClass parent_class; + } + + GType gdk_image_get_type () ; + + GdkImage* gdk_image_new (GdkImageType type, + GdkVisual *visual, + gint width, + gint height); + + + GdkImage* gdk_image_get (GdkDrawable *drawable, + gint x, + gint y, + gint width, + gint height); + + GdkImage * gdk_image_ref (GdkImage *image); + void gdk_image_unref (GdkImage *image); + + + void gdk_image_put_pixel (GdkImage *image, + gint x, + gint y, + guint32 pixel); + guint32 gdk_image_get_pixel (GdkImage *image, + gint x, + gint y); + + void gdk_image_set_colormap (GdkImage *image, + GdkColormap *colormap); + GdkColormap* gdk_image_get_colormap (GdkImage *image); + + alias _GdkKeymapKey GdkKeymapKey; + + + + struct _GdkKeymapKey { + guint keycode; + gint group; + gint level; + } + alias _GdkKeymap GdkKeymap; + + alias _GdkKeymapClass GdkKeymapClass; + + struct _GdkKeymap { + GObject parent_instance; + GdkDisplay *display; + } + + struct _GdkKeymapClass { + GObjectClass parent_class; + + void (*direction_changed) (GdkKeymap *keymap); + void (*keys_changed) (GdkKeymap *keymap); + } + + GType gdk_keymap_get_type () ; + + + GdkKeymap* gdk_keymap_get_default (); + + GdkKeymap* gdk_keymap_get_for_display (GdkDisplay *display); + + + guint gdk_keymap_lookup_key (GdkKeymap *keymap, + GdkKeymapKey *key); + gboolean gdk_keymap_translate_keyboard_state (GdkKeymap *keymap, + guint hardware_keycode, + GdkModifierType state, + gint group, + guint *keyval, + gint *effective_group, + gint *level, + GdkModifierType *consumed_modifiers); + gboolean gdk_keymap_get_entries_for_keyval (GdkKeymap *keymap, + guint keyval, + GdkKeymapKey **keys, + gint *n_keys); + gboolean gdk_keymap_get_entries_for_keycode (GdkKeymap *keymap, + guint hardware_keycode, + GdkKeymapKey **keys, + guint **keyvals, + gint *n_entries); + PangoDirection gdk_keymap_get_direction (GdkKeymap *keymap); + + + + gchar* gdk_keyval_name (guint keyval) ; + guint gdk_keyval_from_name ( gchar *keyval_name); + void gdk_keyval_convert_case (guint symbol, + guint *lower, + guint *upper); + guint gdk_keyval_to_upper (guint keyval) ; + guint gdk_keyval_to_lower (guint keyval) ; + gboolean gdk_keyval_is_upper (guint keyval) ; + gboolean gdk_keyval_is_lower (guint keyval) ; + + guint32 gdk_keyval_to_unicode (guint keyval) ; + guint gdk_unicode_to_keyval (guint32 wc) ; + + + alias _GdkDisplayManager GdkDisplayManager; + alias void _GdkDisplayManager; + + alias _GdkDisplayManagerClass GdkDisplayManagerClass; + + struct _GdkDisplayManagerClass { + GObjectClass parent_class; + + void (*display_opened) (GdkDisplayManager *display_manager, + GdkDisplay *display); + } + + GType gdk_display_manager_get_type () ; + + GdkDisplayManager *gdk_display_manager_get (); + GdkDisplay * gdk_display_manager_get_default_display (GdkDisplayManager *display_manager); + void gdk_display_manager_set_default_display (GdkDisplayManager *display_manager, + GdkDisplay *display); + GSList * gdk_display_manager_list_displays (GdkDisplayManager *display_manager); + + + PangoContext *gdk_pango_context_get_for_screen (GdkScreen *screen); + + PangoContext *gdk_pango_context_get (); + + void gdk_pango_context_set_colormap (PangoContext *context, + GdkColormap *colormap); + GdkRegion *gdk_pango_layout_line_get_clip_region (PangoLayoutLine *line, + gint x_origin, + gint y_origin, + gint *index_ranges, + gint n_ranges); + GdkRegion *gdk_pango_layout_get_clip_region (PangoLayout *layout, + gint x_origin, + gint y_origin, + gint *index_ranges, + gint n_ranges); + + + + + + alias _GdkPangoAttrStipple GdkPangoAttrStipple; + + alias _GdkPangoAttrEmbossed GdkPangoAttrEmbossed; + + + struct _GdkPangoAttrStipple { + PangoAttribute attr; + GdkBitmap *stipple; + } + + struct _GdkPangoAttrEmbossed { + PangoAttribute attr; + gboolean embossed; + } + + PangoAttribute *gdk_pango_attr_stipple_new (GdkBitmap *stipple); + PangoAttribute *gdk_pango_attr_embossed_new (gboolean embossed); + void gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, + GdkBitmap *bitmap, + int src_x, + int src_y, + int dest_x, + int dest_y, + int width, + int height, + int alpha_threshold); + + void gdk_pixbuf_render_to_drawable (GdkPixbuf *pixbuf, + GdkDrawable *drawable, + GdkGC *gc, + int src_x, + int src_y, + int dest_x, + int dest_y, + int width, + int height, + GdkRgbDither dither, + int x_dither, + int y_dither); + void gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, + GdkDrawable *drawable, + int src_x, + int src_y, + int dest_x, + int dest_y, + int width, + int height, + GdkPixbufAlphaMode alpha_mode, + int alpha_threshold, + GdkRgbDither dither, + int x_dither, + int y_dither); + + void gdk_pixbuf_render_pixmap_and_mask_for_colormap (GdkPixbuf *pixbuf, + GdkColormap *colormap, + GdkPixmap **pixmap_return, + GdkBitmap **mask_return, + int alpha_threshold); + + void gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf, + GdkPixmap **pixmap_return, + GdkBitmap **mask_return, + int alpha_threshold); + + + + + GdkPixbuf *gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, + GdkDrawable *src, + GdkColormap *cmap, + int src_x, + int src_y, + int dest_x, + int dest_y, + int width, + int height); + + GdkPixbuf *gdk_pixbuf_get_from_image (GdkPixbuf *dest, + GdkImage *src, + GdkColormap *cmap, + int src_x, + int src_y, + int dest_x, + int dest_y, + int width, + int height); + alias _GdkPixmapObject GdkPixmapObject; + + alias _GdkPixmapObjectClass GdkPixmapObjectClass; + + struct _GdkPixmapObject { + GdkDrawable parent_instance; + + GdkDrawable *impl; + + gint depth; + } + + struct _GdkPixmapObjectClass { + GdkDrawableClass parent_class; + + } + + GType gdk_pixmap_get_type () ; + + + + GdkPixmap* gdk_pixmap_new (GdkDrawable *drawable, + gint width, + gint height, + gint depth); + GdkBitmap* gdk_bitmap_create_from_data (GdkDrawable *drawable, + gchar *data, + gint width, + gint height); + GdkPixmap* gdk_pixmap_create_from_data (GdkDrawable *drawable, + gchar *data, + gint width, + gint height, + gint depth, + GdkColor *fg, + GdkColor *bg); + + GdkPixmap* gdk_pixmap_create_from_xpm (GdkDrawable *drawable, + GdkBitmap **mask, + GdkColor *transparent_color, + gchar *filename); + GdkPixmap* gdk_pixmap_colormap_create_from_xpm (GdkDrawable *drawable, + GdkColormap *colormap, + GdkBitmap **mask, + GdkColor *transparent_color, + gchar *filename); + GdkPixmap* gdk_pixmap_create_from_xpm_d (GdkDrawable *drawable, + GdkBitmap **mask, + GdkColor *transparent_color, + gchar **data); + GdkPixmap* gdk_pixmap_colormap_create_from_xpm_d (GdkDrawable *drawable, + GdkColormap *colormap, + GdkBitmap **mask, + GdkColor *transparent_color, + gchar **data); + + + + + GdkPixmap* gdk_pixmap_foreign_new (GdkNativeWindow anid); + GdkPixmap* gdk_pixmap_lookup (GdkNativeWindow anid); + + + GdkPixmap* gdk_pixmap_foreign_new_for_display (GdkDisplay *display, + GdkNativeWindow anid); + GdkPixmap* gdk_pixmap_lookup_for_display (GdkDisplay *display, + GdkNativeWindow anid); + enum GdkPropMode { + GDK_PROP_MODE_REPLACE, + GDK_PROP_MODE_PREPEND, + GDK_PROP_MODE_APPEND + }; + + + GdkAtom gdk_atom_intern ( gchar *atom_name, + gboolean only_if_exists); + gchar* gdk_atom_name (GdkAtom atom); + + gboolean gdk_property_get (GdkWindow *window, + GdkAtom property, + GdkAtom type, + gulong offset, + gulong length, + gint pdelete, + GdkAtom *actual_property_type, + gint *actual_format, + gint *actual_length, + guchar **data); + void gdk_property_change (GdkWindow *window, + GdkAtom property, + GdkAtom type, + gint format, + GdkPropMode mode, + guchar *data, + gint nelements); + void gdk_property_delete (GdkWindow *window, + GdkAtom property); + + gint gdk_text_property_to_text_list (GdkAtom encoding, + gint format, + guchar *text, + gint length, + gchar ***list); + gint gdk_text_property_to_utf8_list (GdkAtom encoding, + gint format, + guchar *text, + gint length, + gchar ***list); + gboolean gdk_utf8_to_compound_text ( gchar *str, + GdkAtom *encoding, + gint *format, + guchar **ctext, + gint *length); + gint gdk_string_to_compound_text ( gchar *str, + GdkAtom *encoding, + gint *format, + guchar **ctext, + gint *length); + + + gint gdk_text_property_to_text_list_for_display (GdkDisplay *display, + GdkAtom encoding, + gint format, + guchar *text, + gint length, + gchar ***list); + gint gdk_text_property_to_utf8_list_for_display (GdkDisplay *display, + GdkAtom encoding, + gint format, + guchar *text, + gint length, + gchar ***list); + + gchar *gdk_utf8_to_string_target ( gchar *str); + gint gdk_string_to_compound_text_for_display (GdkDisplay *display, + gchar *str, + GdkAtom *encoding, + gint *format, + guchar **ctext, + gint *length); + gboolean gdk_utf8_to_compound_text_for_display (GdkDisplay *display, + gchar *str, + GdkAtom *encoding, + gint *format, + guchar **ctext, + gint *length); + + void gdk_free_text_list (gchar **list); + void gdk_free_compound_text (guchar *ctext); + enum GdkFillRule { + GDK_EVEN_ODD_RULE, + GDK_WINDING_RULE + }; + + + + + + + + enum GdkOverlapType { + GDK_OVERLAP_RECTANGLE_IN, + GDK_OVERLAP_RECTANGLE_OUT, + GDK_OVERLAP_RECTANGLE_PART + }; + + + alias void (*GdkSpanFunc) (GdkSpan *span, + gpointer data); + + GdkRegion *gdk_region_new (); + GdkRegion *gdk_region_polygon (GdkPoint *points, + gint npoints, + GdkFillRule fill_rule); + GdkRegion *gdk_region_copy (GdkRegion *region); + GdkRegion *gdk_region_rectangle (GdkRectangle *rectangle); + void gdk_region_destroy (GdkRegion *region); + + void gdk_region_get_clipbox (GdkRegion *region, + GdkRectangle *rectangle); + void gdk_region_get_rectangles (GdkRegion *region, + GdkRectangle **rectangles, + gint *n_rectangles); + + gboolean gdk_region_empty (GdkRegion *region); + gboolean gdk_region_equal (GdkRegion *region1, + GdkRegion *region2); + gboolean gdk_region_point_in (GdkRegion *region, + int x, + int y); + GdkOverlapType gdk_region_rect_in (GdkRegion *region, + GdkRectangle *rect); + + void gdk_region_offset (GdkRegion *region, + gint dx, + gint dy); + void gdk_region_shrink (GdkRegion *region, + gint dx, + gint dy); + void gdk_region_union_with_rect (GdkRegion *region, + GdkRectangle *rect); + void gdk_region_intersect (GdkRegion *source1, + GdkRegion *source2); + void gdk_region_union (GdkRegion *source1, + GdkRegion *source2); + void gdk_region_subtract (GdkRegion *source1, + GdkRegion *source2); + void gdk_region_xor (GdkRegion *source1, + GdkRegion *source2); + + void gdk_region_spans_intersect_foreach (GdkRegion *region, + GdkSpan *spans, + int n_spans, + gboolean sorted, + GdkSpanFunc Function, + gpointer data); + + + + alias _GdkScreenClass GdkScreenClass; + + struct _GdkScreen { + GObject parent_instance; + + guint closed; + + GdkGC *normal_gcs[32]; + GdkGC *exposure_gcs[32]; + } + + struct _GdkScreenClass { + GObjectClass parent_class; + + void (*size_changed) (GdkScreen *screen); + } + + GType gdk_screen_get_type (); + GdkColormap *gdk_screen_get_default_colormap (GdkScreen *screen); + void gdk_screen_set_default_colormap (GdkScreen *screen, + GdkColormap *colormap); + GdkColormap* gdk_screen_get_system_colormap (GdkScreen *screen); + GdkVisual* gdk_screen_get_system_visual (GdkScreen *screen); + GdkColormap *gdk_screen_get_rgb_colormap (GdkScreen *screen); + GdkVisual * gdk_screen_get_rgb_visual (GdkScreen *screen); + + GdkWindow * gdk_screen_get_root_window (GdkScreen *screen); + GdkDisplay * gdk_screen_get_display (GdkScreen *screen); + gint gdk_screen_get_number (GdkScreen *screen); + gint gdk_screen_get_width (GdkScreen *screen); + gint gdk_screen_get_height (GdkScreen *screen); + gint gdk_screen_get_width_mm (GdkScreen *screen); + gint gdk_screen_get_height_mm (GdkScreen *screen); + + GList * gdk_screen_list_visuals (GdkScreen *screen); + GList * gdk_screen_get_toplevel_windows (GdkScreen *screen); + gchar * gdk_screen_make_display_name (GdkScreen *screen); + + gint gdk_screen_get_n_monitors (GdkScreen *screen); + void gdk_screen_get_monitor_geometry (GdkScreen *screen, + gint monitor_num, + GdkRectangle *dest); + gint gdk_screen_get_monitor_at_point (GdkScreen *screen, + gint x, + gint y); + gint gdk_screen_get_monitor_at_window (GdkScreen *screen, + GdkWindow *window); + + void gdk_screen_broadcast_client_message (GdkScreen *screen, + GdkEvent *event); + + GdkScreen *gdk_screen_get_default (); + + gboolean gdk_screen_get_setting (GdkScreen *screen, + gchar *name, + GValue *value); + + + alias GdkAtom GdkSelection; + alias GdkAtom GdkTarget; + alias GdkAtom GdkSelectionType; + + + + + + + + gboolean gdk_selection_owner_set (GdkWindow *owner, + GdkAtom selection, + guint32 time_, + gboolean send_event); + GdkWindow* gdk_selection_owner_get (GdkAtom selection); + + + gboolean gdk_selection_owner_set_for_display (GdkDisplay *display, + GdkWindow *owner, + GdkAtom selection, + guint32 time_, + gboolean send_event); + GdkWindow *gdk_selection_owner_get_for_display (GdkDisplay *display, + GdkAtom selection); + + void gdk_selection_convert (GdkWindow *requestor, + GdkAtom selection, + GdkAtom target, + guint32 time_); + gboolean gdk_selection_property_get (GdkWindow *requestor, + guchar **data, + GdkAtom *prop_type, + gint *prop_format); + + + void gdk_selection_send_notify (guint32 requestor, + GdkAtom selection, + GdkAtom target, + GdkAtom property, + guint32 time_); + + + void gdk_selection_send_notify_for_display (GdkDisplay *display, + guint32 requestor, + GdkAtom selection, + GdkAtom target, + GdkAtom property, + guint32 time_); + + + gboolean gdk_spawn_on_screen (GdkScreen *screen, + gchar *working_directory, + gchar **argv, + gchar **envp, + GSpawnFlags flags, + GSpawnChildSetupFunc child_setup, + gpointer user_data, + gint *child_pid, + GError **error); + + gboolean gdk_spawn_on_screen_with_pipes (GdkScreen *screen, + gchar *working_directory, + gchar **argv, + gchar **envp, + GSpawnFlags flags, + GSpawnChildSetupFunc child_setup, + gpointer user_data, + gint *child_pid, + gint *standard_input, + gint *standard_output, + gint *standard_error, + GError **error); + + gboolean gdk_spawn_command_line_on_screen (GdkScreen *screen, + gchar *command_line, + GError **error); + + + + + + + + + + alias _GdkVisualClass GdkVisualClass; + alias void _GdkVisualClass; + + enum GdkVisualType { + GDK_VISUAL_STATIC_GRAY, + GDK_VISUAL_GRAYSCALE, + GDK_VISUAL_STATIC_COLOR, + GDK_VISUAL_PSEUDO_COLOR, + GDK_VISUAL_TRUE_COLOR, + GDK_VISUAL_DIRECT_COLOR + }; + + struct _GdkVisual { + GObject parent_instance; + + GdkVisualType type; + gint depth; + GdkByteOrder byte_order; + gint colormap_size; + gint bits_per_rgb; + + guint32 red_mask; + gint red_shift; + gint red_prec; + + guint32 green_mask; + gint green_shift; + gint green_prec; + + guint32 blue_mask; + gint blue_shift; + gint blue_prec; + } + + GType gdk_visual_get_type (); + + + gint gdk_visual_get_best_depth (); + GdkVisualType gdk_visual_get_best_type (); + GdkVisual* gdk_visual_get_system (); + GdkVisual* gdk_visual_get_best (); + GdkVisual* gdk_visual_get_best_with_depth (gint depth); + GdkVisual* gdk_visual_get_best_with_type (GdkVisualType visual_type); + GdkVisual* gdk_visual_get_best_with_both (gint depth, + GdkVisualType visual_type); + + void gdk_query_depths (gint **depths, + gint *count); + void gdk_query_visual_types (GdkVisualType **visual_types, + gint *count); + + GList* gdk_list_visuals (); + + + GdkScreen *gdk_visual_get_screen (GdkVisual *visual); + + + + + + + + alias _GdkGeometry GdkGeometry; + + alias _GdkWindowAttr GdkWindowAttr; + + alias _GdkPointerHooks GdkPointerHooks; + + enum GdkWindowClass { + GDK_INPUT_OUTPUT, + GDK_INPUT_ONLY + }; + + enum GdkWindowType { + GDK_WINDOW_ROOT, + GDK_WINDOW_TOPLEVEL, + GDK_WINDOW_CHILD, + GDK_WINDOW_DIALOG, + GDK_WINDOW_TEMP, + GDK_WINDOW_FOREIGN + }; + + enum GdkWindowAttributesType { + GDK_WA_TITLE = 1 << 1, + GDK_WA_X = 1 << 2, + GDK_WA_Y = 1 << 3, + GDK_WA_CURSOR = 1 << 4, + GDK_WA_COLORMAP = 1 << 5, + GDK_WA_VISUAL = 1 << 6, + GDK_WA_WMCLASS = 1 << 7, + GDK_WA_NOREDIR = 1 << 8 + }; + + + + + enum GdkWindowHints { + GDK_HINT_POS = 1 << 0, + GDK_HINT_MIN_SIZE = 1 << 1, + GDK_HINT_MAX_SIZE = 1 << 2, + GDK_HINT_BASE_SIZE = 1 << 3, + GDK_HINT_ASPECT = 1 << 4, + GDK_HINT_RESIZE_INC = 1 << 5, + GDK_HINT_WIN_GRAVITY = 1 << 6, + GDK_HINT_USER_POS = 1 << 7, + GDK_HINT_USER_SIZE = 1 << 8 + }; + + enum GdkWindowTypeHint { + GDK_WINDOW_TYPE_HINT_NORMAL, + GDK_WINDOW_TYPE_HINT_DIALOG, + GDK_WINDOW_TYPE_HINT_MENU, + GDK_WINDOW_TYPE_HINT_TOOLBAR, + GDK_WINDOW_TYPE_HINT_SPLASHSCREEN, + GDK_WINDOW_TYPE_HINT_UTILITY, + GDK_WINDOW_TYPE_HINT_DOCK, + GDK_WINDOW_TYPE_HINT_DESKTOP + }; + + + + + + + + + enum GdkWMDecoration { + GDK_DECOR_ALL = 1 << 0, + GDK_DECOR_BORDER = 1 << 1, + GDK_DECOR_RESIZEH = 1 << 2, + GDK_DECOR_TITLE = 1 << 3, + GDK_DECOR_MENU = 1 << 4, + GDK_DECOR_MINIMIZE = 1 << 5, + GDK_DECOR_MAXIMIZE = 1 << 6 + }; + + + enum GdkWMFunction { + GDK_FUNC_ALL = 1 << 0, + GDK_FUNC_RESIZE = 1 << 1, + GDK_FUNC_MOVE = 1 << 2, + GDK_FUNC_MINIMIZE = 1 << 3, + GDK_FUNC_MAXIMIZE = 1 << 4, + GDK_FUNC_CLOSE = 1 << 5 + }; + + + + + + + enum GdkGravity { + GDK_GRAVITY_NORTH_WEST = 1, + GDK_GRAVITY_NORTH, + GDK_GRAVITY_NORTH_EAST, + GDK_GRAVITY_WEST, + GDK_GRAVITY_CENTER, + GDK_GRAVITY_EAST, + GDK_GRAVITY_SOUTH_WEST, + GDK_GRAVITY_SOUTH, + GDK_GRAVITY_SOUTH_EAST, + GDK_GRAVITY_STATIC + }; + + + + enum GdkWindowEdge { + 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 + }; + + + struct _GdkWindowAttr { + gchar *title; + gint event_mask; + gint x, y; + gint width; + gint height; + GdkWindowClass wclass; + GdkVisual *visual; + GdkColormap *colormap; + GdkWindowType window_type; + GdkCursor *cursor; + gchar *wmclass_name; + gchar *wmclass_class; + gboolean override_redirect; + } + + struct _GdkGeometry { + gint min_width; + gint min_height; + gint max_width; + gint max_height; + gint base_width; + gint base_height; + gint width_inc; + gint height_inc; + gdouble min_aspect; + gdouble max_aspect; + GdkGravity win_gravity; + } + + struct _GdkPointerHooks { + GdkWindow* (*get_pointer) (GdkWindow *window, + gint *x, + gint *y, + GdkModifierType *mask); + GdkWindow* (*window_at_pointer) (GdkScreen *screen, + gint *win_x, + gint *win_y); + } + + alias _GdkWindowObject GdkWindowObject; + + alias _GdkWindowObjectClass GdkWindowObjectClass; + + struct _GdkWindowObject { + GdkDrawable parent_instance; + + GdkDrawable *impl; + + GdkWindowObject *parent; + + gpointer user_data; + + gint x; + gint y; + + gint extension_events; + + GList *filters; + GList *children; + + GdkColor bg_color; + GdkPixmap *bg_pixmap; + + GSList *paint_stack; + + GdkRegion *update_area; + guint update_freeze_count; + + guint8 window_type; + guint8 depth; + guint8 resize_count; + + GdkWindowState state; + + guint guffaw_gravity; + guint input_only; + guint modal_hint; + + guint destroyed; + + guint accept_focus; + + GdkEventMask event_mask; + } + + struct _GdkWindowObjectClass { + GdkDrawableClass parent_class; + } + + + + GType gdk_window_object_get_type () ; + GdkWindow* gdk_window_new (GdkWindow *parent, + GdkWindowAttr *attributes, + gint attributes_mask); + void gdk_window_destroy (GdkWindow *window); + GdkWindowType gdk_window_get_window_type (GdkWindow *window); + GdkWindow* gdk_window_at_pointer (gint *win_x, + gint *win_y); + void gdk_window_show (GdkWindow *window); + void gdk_window_hide (GdkWindow *window); + void gdk_window_withdraw (GdkWindow *window); + void gdk_window_show_unraised (GdkWindow *window); + void gdk_window_move (GdkWindow *window, + gint x, + gint y); + void gdk_window_resize (GdkWindow *window, + gint width, + gint height); + void gdk_window_move_resize (GdkWindow *window, + gint x, + gint y, + gint width, + gint height); + void gdk_window_reparent (GdkWindow *window, + GdkWindow *new_parent, + gint x, + gint y); + void gdk_window_clear (GdkWindow *window); + void gdk_window_clear_area (GdkWindow *window, + gint x, + gint y, + gint width, + gint height); + void gdk_window_clear_area_e (GdkWindow *window, + gint x, + gint y, + gint width, + gint height); + void gdk_window_raise (GdkWindow *window); + void gdk_window_lower (GdkWindow *window); + void gdk_window_focus (GdkWindow *window, + guint32 timestamp); + void gdk_window_set_user_data (GdkWindow *window, + gpointer user_data); + void gdk_window_set_override_redirect (GdkWindow *window, + gboolean override_redirect); + void gdk_window_set_accept_focus (GdkWindow *window, + gboolean accept_focus); + void gdk_window_add_filter (GdkWindow *window, + GdkFilterFunc Function, + gpointer data); + void gdk_window_remove_filter (GdkWindow *window, + GdkFilterFunc Function, + gpointer data); + void gdk_window_scroll (GdkWindow *window, + gint dx, + gint dy); + + + + + + + + void gdk_window_shape_combine_mask (GdkWindow *window, + GdkBitmap *mask, + gint x, + gint y); + void gdk_window_shape_combine_region (GdkWindow *window, + GdkRegion *shape_region, + gint offset_x, + gint offset_y); + void gdk_window_set_child_shapes (GdkWindow *window); + void gdk_window_merge_child_shapes (GdkWindow *window); + + + + + + + + gboolean gdk_window_is_visible (GdkWindow *window); + gboolean gdk_window_is_viewable (GdkWindow *window); + + GdkWindowState gdk_window_get_state (GdkWindow *window); + + + + + gboolean gdk_window_set_static_gravities (GdkWindow *window, + gboolean use_static); + + + + GdkWindow* gdk_window_foreign_new (GdkNativeWindow anid); + GdkWindow* gdk_window_lookup (GdkNativeWindow anid); + + GdkWindow *gdk_window_foreign_new_for_display (GdkDisplay *display, + GdkNativeWindow anid); + GdkWindow* gdk_window_lookup_for_display (GdkDisplay *display, + GdkNativeWindow anid); + + + + + + void gdk_window_set_hints (GdkWindow *window, + gint x, + gint y, + gint min_width, + gint min_height, + gint max_width, + gint max_height, + gint flags); + + void gdk_window_set_type_hint (GdkWindow *window, + GdkWindowTypeHint hint); + void gdk_window_set_modal_hint (GdkWindow *window, + gboolean modal); + + void gdk_window_set_skip_taskbar_hint (GdkWindow *window, + gboolean skips_taskbar); + void gdk_window_set_skip_pager_hint (GdkWindow *window, + gboolean skips_pager); + + void gdk_window_set_geometry_hints (GdkWindow *window, + GdkGeometry *geometry, + GdkWindowHints geom_mask); + void gdk_set_sm_client_id ( gchar *sm_client_id); + + void gdk_window_begin_paint_rect (GdkWindow *window, + GdkRectangle *rectangle); + void gdk_window_begin_paint_region (GdkWindow *window, + GdkRegion *region); + void gdk_window_end_paint (GdkWindow *window); + + void gdk_window_set_title (GdkWindow *window, + gchar *title); + void gdk_window_set_role (GdkWindow *window, + gchar *role); + void gdk_window_set_transient_for (GdkWindow *window, + GdkWindow *parent); + void gdk_window_set_background (GdkWindow *window, + GdkColor *color); + void gdk_window_set_back_pixmap (GdkWindow *window, + GdkPixmap *pixmap, + gboolean parent_relative); + void gdk_window_set_cursor (GdkWindow *window, + GdkCursor *cursor); + void gdk_window_get_user_data (GdkWindow *window, + gpointer *data); + void gdk_window_get_geometry (GdkWindow *window, + gint *x, + gint *y, + gint *width, + gint *height, + gint *depth); + void gdk_window_get_position (GdkWindow *window, + gint *x, + gint *y); + gint gdk_window_get_origin (GdkWindow *window, + gint *x, + gint *y); + + + + gboolean gdk_window_get_deskrelative_origin (GdkWindow *window, + gint *x, + gint *y); + + + void gdk_window_get_root_origin (GdkWindow *window, + gint *x, + gint *y); + void gdk_window_get_frame_extents (GdkWindow *window, + GdkRectangle *rect); + GdkWindow* gdk_window_get_pointer (GdkWindow *window, + gint *x, + gint *y, + GdkModifierType *mask); + GdkWindow * gdk_window_get_parent (GdkWindow *window); + GdkWindow * gdk_window_get_toplevel (GdkWindow *window); + + GList * gdk_window_get_children (GdkWindow *window); + GList * gdk_window_peek_children (GdkWindow *window); + GdkEventMask gdk_window_get_events (GdkWindow *window); + void gdk_window_set_events (GdkWindow *window, + GdkEventMask event_mask); + + void gdk_window_set_icon_list (GdkWindow *window, + GList *pixbufs); + void gdk_window_set_icon (GdkWindow *window, + GdkWindow *icon_window, + GdkPixmap *pixmap, + GdkBitmap *mask); + void gdk_window_set_icon_name (GdkWindow *window, + gchar *name); + void gdk_window_set_group (GdkWindow *window, + GdkWindow *leader); + GdkWindow* gdk_window_get_group (GdkWindow *window); + void gdk_window_set_decorations (GdkWindow *window, + GdkWMDecoration decorations); + gboolean gdk_window_get_decorations (GdkWindow *window, + GdkWMDecoration *decorations); + void gdk_window_set_functions (GdkWindow *window, + GdkWMFunction functions); + + GList * gdk_window_get_toplevels (); + + + void gdk_window_iconify (GdkWindow *window); + void gdk_window_deiconify (GdkWindow *window); + void gdk_window_stick (GdkWindow *window); + void gdk_window_unstick (GdkWindow *window); + void gdk_window_maximize (GdkWindow *window); + void gdk_window_unmaximize (GdkWindow *window); + void gdk_window_fullscreen (GdkWindow *window); + void gdk_window_unfullscreen (GdkWindow *window); + void gdk_window_set_keep_above (GdkWindow *window, + gboolean setting); + void gdk_window_set_keep_below (GdkWindow *window, + gboolean setting); + + void gdk_window_register_dnd (GdkWindow *window); + + void gdk_window_begin_resize_drag (GdkWindow *window, + GdkWindowEdge edge, + gint button, + gint root_x, + gint root_y, + guint32 timestamp); + void gdk_window_begin_move_drag (GdkWindow *window, + gint button, + gint root_x, + gint root_y, + guint32 timestamp); + + + void gdk_window_invalidate_rect (GdkWindow *window, + GdkRectangle *rect, + gboolean invalidate_children); + void gdk_window_invalidate_region (GdkWindow *window, + GdkRegion *region, + gboolean invalidate_children); + void gdk_window_invalidate_maybe_recurse (GdkWindow *window, + GdkRegion *region, + gboolean (*child_func) (GdkWindow *, gpointer), + gpointer user_data); + GdkRegion *gdk_window_get_update_area (GdkWindow *window); + + void gdk_window_freeze_updates (GdkWindow *window); + void gdk_window_thaw_updates (GdkWindow *window); + + gint gdk_window_get_update_serial (); + void gdk_window_process_all_updates (); + void gdk_window_process_updates (GdkWindow *window, + gboolean update_children); + + + void gdk_window_set_debug_updates (gboolean setting); + + void gdk_window_rain_size (GdkGeometry *geometry, + guint flags, + gint width, + gint height, + gint *new_width, + gint *new_height); + + void gdk_window_get_internal_paint_info (GdkWindow *window, + GdkDrawable **real_drawable, + gint *x_offset, + gint *y_offset); + + + GdkPointerHooks *gdk_set_pointer_hooks ( GdkPointerHooks *new_hooks); + + + GdkWindow *gdk_get_default_root_window (); + void gdk_parse_args (gint *argc, + gchar ***argv); + void gdk_init (gint *argc, + gchar ***argv); + gboolean gdk_init_check (gint *argc, + gchar ***argv); + + + void gdk_exit (gint error_code); + + gchar* gdk_set_locale (); + + char *gdk_get_program_class (); + void gdk_set_program_class ( char *program_class); + + + + void gdk_error_trap_push (); + gint gdk_error_trap_pop (); + + + void gdk_set_use_xshm (gboolean use_xshm); + gboolean gdk_get_use_xshm (); + + + gchar* gdk_get_display (); + gchar* gdk_get_display_arg_name (); + + + + gint gdk_input_add_full (gint source, + GdkInputCondition condition, + GdkInputFunction Function, + gpointer data, + GdkDestroyNotify destroy); + + + gint gdk_input_add (gint source, + GdkInputCondition condition, + GdkInputFunction Function, + gpointer data); + void gdk_input_remove (gint tag); + + + GdkGrabStatus gdk_pointer_grab (GdkWindow *window, + gboolean owner_events, + GdkEventMask event_mask, + GdkWindow *confine_to, + GdkCursor *cursor, + guint32 time_); + GdkGrabStatus gdk_keyboard_grab (GdkWindow *window, + gboolean owner_events, + guint32 time_); + + + void gdk_pointer_ungrab (guint32 time_); + void gdk_keyboard_ungrab (guint32 time_); + gboolean gdk_pointer_is_grabbed (); + + gint gdk_screen_width () ; + gint gdk_screen_height () ; + + gint gdk_screen_width_mm () ; + gint gdk_screen_height_mm () ; + + void gdk_beep (); + + + void gdk_flush (); + + + void gdk_set_double_click_time (guint msec); + + + + + gboolean gdk_rectangle_intersect (GdkRectangle *src1, + GdkRectangle *src2, + GdkRectangle *dest); + void gdk_rectangle_union (GdkRectangle *src1, + GdkRectangle *src2, + GdkRectangle *dest); + + GType gdk_rectangle_get_type (); + + + + + + + gchar *gdk_wcstombs ( GdkWChar *src); + gint gdk_mbstowcs (GdkWChar *dest, + gchar *src, + gint dest_max); + + + + + gboolean gdk_event_send_client_message (GdkEvent *event, + GdkNativeWindow winid); + void gdk_event_send_clientmessage_toall (GdkEvent *event); + + gboolean gdk_event_send_client_message_for_display (GdkDisplay *display, + GdkEvent *event, + GdkNativeWindow winid); + + void gdk_notify_startup_complete (); + + + + + + GMutex *gdk_threads_mutex; + + + GCallback gdk_threads_lock; + GCallback gdk_threads_unlock; + + void gdk_threads_enter (); + void gdk_threads_leave (); + void gdk_threads_init (); + void gdk_threads_set_lock_functions (GCallback enter_fn, + GCallback leave_fn); + enum GtkAnchorType { + GTK_ANCHOR_CENTER, + GTK_ANCHOR_NORTH, + GTK_ANCHOR_NORTH_WEST, + GTK_ANCHOR_NORTH_EAST, + GTK_ANCHOR_SOUTH, + GTK_ANCHOR_SOUTH_WEST, + GTK_ANCHOR_SOUTH_EAST, + GTK_ANCHOR_WEST, + GTK_ANCHOR_EAST, + GTK_ANCHOR_N = GTK_ANCHOR_NORTH, + GTK_ANCHOR_NW = GTK_ANCHOR_NORTH_WEST, + GTK_ANCHOR_NE = GTK_ANCHOR_NORTH_EAST, + GTK_ANCHOR_S = GTK_ANCHOR_SOUTH, + GTK_ANCHOR_SW = GTK_ANCHOR_SOUTH_WEST, + GTK_ANCHOR_SE = GTK_ANCHOR_SOUTH_EAST, + GTK_ANCHOR_W = GTK_ANCHOR_WEST, + GTK_ANCHOR_E = GTK_ANCHOR_EAST + }; + + + + enum GtkArrowType { + GTK_ARROW_UP, + GTK_ARROW_DOWN, + GTK_ARROW_LEFT, + GTK_ARROW_RIGHT + }; + + + + enum GtkAttachOptions { + GTK_EXPAND = 1 << 0, + GTK_SHRINK = 1 << 1, + GTK_FILL = 1 << 2 + }; + + + + enum GtkButtonBoxStyle { + GTK_BUTTONBOX_DEFAULT_STYLE, + GTK_BUTTONBOX_SPREAD, + GTK_BUTTONBOX_EDGE, + GTK_BUTTONBOX_START, + GTK_BUTTONBOX_END + }; + + + + enum GtkCurveType { + GTK_CURVE_TYPE_LINEAR, + GTK_CURVE_TYPE_SPLINE, + GTK_CURVE_TYPE_FREE + }; + + + enum GtkDeleteType { + GTK_DELETE_CHARS, + GTK_DELETE_WORD_ENDS, + + + GTK_DELETE_WORDS, + GTK_DELETE_DISPLAY_LINES, + GTK_DELETE_DISPLAY_LINE_ENDS, + GTK_DELETE_PARAGRAPH_ENDS, + GTK_DELETE_PARAGRAPHS, + GTK_DELETE_WHITESPACE + }; + + + + enum GtkDirectionType { + GTK_DIR_TAB_FORWARD, + GTK_DIR_TAB_BACKWARD, + GTK_DIR_UP, + GTK_DIR_DOWN, + GTK_DIR_LEFT, + GTK_DIR_RIGHT + }; + + + + enum GtkExpanderStyle { + GTK_EXPANDER_COLLAPSED, + GTK_EXPANDER_SEMI_COLLAPSED, + GTK_EXPANDER_SEMI_EXPANDED, + GTK_EXPANDER_EXPANDED + }; + + + + enum GtkIconSize { + GTK_ICON_SIZE_INVALID, + GTK_ICON_SIZE_MENU, + GTK_ICON_SIZE_SMALL_TOOLBAR, + GTK_ICON_SIZE_LARGE_TOOLBAR, + GTK_ICON_SIZE_BUTTON, + GTK_ICON_SIZE_DND, + GTK_ICON_SIZE_DIALOG + }; + + + + + enum GtkSideType { + GTK_SIDE_TOP, + GTK_SIDE_BOTTOM, + GTK_SIDE_LEFT, + GTK_SIDE_RIGHT + }; + + + + + enum GtkTextDirection { + GTK_TEXT_DIR_NONE, + GTK_TEXT_DIR_LTR, + GTK_TEXT_DIR_RTL + }; + + + + enum GtkJustification { + GTK_JUSTIFY_LEFT, + GTK_JUSTIFY_RIGHT, + GTK_JUSTIFY_CENTER, + GTK_JUSTIFY_FILL + }; + + + + + enum GtkMatchType { + GTK_MATCH_ALL, + GTK_MATCH_ALL_TAIL, + GTK_MATCH_HEAD, + GTK_MATCH_TAIL, + GTK_MATCH_EXACT, + GTK_MATCH_LAST + }; + + + + + enum GtkMenuDirectionType { + GTK_MENU_DIR_PARENT, + GTK_MENU_DIR_CHILD, + GTK_MENU_DIR_NEXT, + GTK_MENU_DIR_PREV + }; + + + enum GtkMetricType { + GTK_PIXELS, + GTK_INCHES, + GTK_CENTIMETERS + }; + + + enum GtkMovementStep { + GTK_MOVEMENT_LOGICAL_POSITIONS, + GTK_MOVEMENT_VISUAL_POSITIONS, + GTK_MOVEMENT_WORDS, + GTK_MOVEMENT_DISPLAY_LINES, + GTK_MOVEMENT_DISPLAY_LINE_ENDS, + GTK_MOVEMENT_PARAGRAPHS, + GTK_MOVEMENT_PARAGRAPH_ENDS, + GTK_MOVEMENT_PAGES, + GTK_MOVEMENT_BUFFER_ENDS, + GTK_MOVEMENT_HORIZONTAL_PAGES + }; + + + enum GtkScrollStep { + GTK_SCROLL_STEPS, + GTK_SCROLL_PAGES, + GTK_SCROLL_ENDS, + GTK_SCROLL_HORIZONTAL_STEPS, + GTK_SCROLL_HORIZONTAL_PAGES, + GTK_SCROLL_HORIZONTAL_ENDS + }; + + + + enum GtkOrientation { + GTK_ORIENTATION_HORIZONTAL, + GTK_ORIENTATION_VERTICAL + }; + + + + enum GtkCornerType { + GTK_CORNER_TOP_LEFT, + GTK_CORNER_BOTTOM_LEFT, + GTK_CORNER_TOP_RIGHT, + GTK_CORNER_BOTTOM_RIGHT + }; + + + + enum GtkPackType { + GTK_PACK_START, + GTK_PACK_END + }; + + + + enum GtkPathPriorityType { + GTK_PATH_PRIO_LOWEST = 0, + GTK_PATH_PRIO_GTK = 4, + GTK_PATH_PRIO_APPLICATION = 8, + GTK_PATH_PRIO_THEME = 10, + GTK_PATH_PRIO_RC = 12, + GTK_PATH_PRIO_HIGHEST = 15 + }; + + + + + enum GtkPathType { + GTK_PATH_WIDGET, + GTK_PATH_WIDGET_CLASS, + GTK_PATH_CLASS + }; + + + + enum GtkPolicyType { + GTK_POLICY_ALWAYS, + GTK_POLICY_AUTOMATIC, + GTK_POLICY_NEVER + }; + + + enum GtkPositionType { + GTK_POS_LEFT, + GTK_POS_RIGHT, + GTK_POS_TOP, + GTK_POS_BOTTOM + }; + + + + enum GtkPreviewType { + GTK_PREVIEW_COLOR, + GTK_PREVIEW_GRAYSCALE + }; + + + + + enum GtkReliefStyle { + GTK_RELIEF_NORMAL, + GTK_RELIEF_HALF, + GTK_RELIEF_NONE + }; + + + + enum GtkResizeMode { + GTK_RESIZE_PARENT, + GTK_RESIZE_QUEUE, + GTK_RESIZE_IMMEDIATE + }; + + + + + enum GtkSignalRunType { + GTK_RUN_FIRST = GSignalFlags.G_SIGNAL_RUN_FIRST, + GTK_RUN_LAST = GSignalFlags.G_SIGNAL_RUN_LAST, + GTK_RUN_BOTH = (GTK_RUN_FIRST | GTK_RUN_LAST), + GTK_RUN_NO_RECURSE = GSignalFlags.G_SIGNAL_NO_RECURSE, + GTK_RUN_ACTION = GSignalFlags.G_SIGNAL_ACTION, + GTK_RUN_NO_HOOKS = GSignalFlags.G_SIGNAL_NO_HOOKS + }; + + + + + enum GtkScrollType { + GTK_SCROLL_NONE, + GTK_SCROLL_JUMP, + GTK_SCROLL_STEP_BACKWARD, + GTK_SCROLL_STEP_FORWARD, + GTK_SCROLL_PAGE_BACKWARD, + GTK_SCROLL_PAGE_FORWARD, + GTK_SCROLL_STEP_UP, + GTK_SCROLL_STEP_DOWN, + GTK_SCROLL_PAGE_UP, + GTK_SCROLL_PAGE_DOWN, + GTK_SCROLL_STEP_LEFT, + GTK_SCROLL_STEP_RIGHT, + GTK_SCROLL_PAGE_LEFT, + GTK_SCROLL_PAGE_RIGHT, + GTK_SCROLL_START, + GTK_SCROLL_END + }; + + + + enum GtkSelectionMode { + GTK_SELECTION_NONE, + GTK_SELECTION_SINGLE, + GTK_SELECTION_BROWSE, + GTK_SELECTION_MULTIPLE, + GTK_SELECTION_EXTENDED = GTK_SELECTION_MULTIPLE + }; + + + + enum GtkShadowType { + GTK_SHADOW_NONE, + GTK_SHADOW_IN, + GTK_SHADOW_OUT, + GTK_SHADOW_ETCHED_IN, + GTK_SHADOW_ETCHED_OUT + }; + + + + enum GtkStateType { + GTK_STATE_NORMAL, + GTK_STATE_ACTIVE, + GTK_STATE_PRELIGHT, + GTK_STATE_SELECTED, + GTK_STATE_INSENSITIVE + }; + + + + + enum GtkSubmenuDirection { + GTK_DIRECTION_LEFT, + GTK_DIRECTION_RIGHT + }; + + + + enum GtkSubmenuPlacement { + GTK_TOP_BOTTOM, + GTK_LEFT_RIGHT + }; + + + + + enum GtkToolbarStyle { + GTK_TOOLBAR_ICONS, + GTK_TOOLBAR_TEXT, + GTK_TOOLBAR_BOTH, + GTK_TOOLBAR_BOTH_HORIZ + }; + + + + enum GtkUpdateType { + GTK_UPDATE_CONTINUOUS, + GTK_UPDATE_DISCONTINUOUS, + GTK_UPDATE_DELAYED + }; + + + + enum GtkVisibility { + GTK_VISIBILITY_NONE, + GTK_VISIBILITY_PARTIAL, + GTK_VISIBILITY_FULL + }; + + + + enum GtkWindowPosition { + GTK_WIN_POS_NONE, + GTK_WIN_POS_CENTER, + GTK_WIN_POS_MOUSE, + GTK_WIN_POS_CENTER_ALWAYS, + GTK_WIN_POS_CENTER_ON_PARENT + }; + + + + enum GtkWindowType { + GTK_WINDOW_TOPLEVEL, + GTK_WINDOW_POPUP + }; + + + + enum GtkWrapMode { + GTK_WRAP_NONE, + GTK_WRAP_CHAR, + GTK_WRAP_WORD, + GTK_WRAP_WORD_CHAR + }; + + + + enum GtkSortType { + GTK_SORT_ASCENDING, + GTK_SORT_DESCENDING + }; + + + + enum GtkIMPreeditStyle { + GTK_IM_PREEDIT_NOTHING, + GTK_IM_PREEDIT_CALLBACK, + GTK_IM_PREEDIT_NONE + }; + + + enum GtkIMStatusStyle { + GTK_IM_STATUS_NOTHING, + GTK_IM_STATUS_CALLBACK, + GTK_IM_STATUS_NONE + }; + + + + enum GtkAccelFlags { + GTK_ACCEL_VISIBLE = 1 << 0, + GTK_ACCEL_LOCKED = 1 << 1, + GTK_ACCEL_MASK = 0x07 + }; + + + + + alias _GtkAccelGroup GtkAccelGroup; + + alias _GtkAccelGroupClass GtkAccelGroupClass; + + alias _GtkAccelKey GtkAccelKey; + + alias _GtkAccelGroupEntry GtkAccelGroupEntry; + + alias gboolean (*GtkAccelGroupActivate) (GtkAccelGroup *accel_group, + GObject *acceleratable, + guint keyval, + GdkModifierType modifier); + + alias gboolean (*GtkAccelGroupFindFunc) (GtkAccelKey *key, + GClosure *closure, + gpointer data); + + struct _GtkAccelGroup { + GObject parent; + guint lock_count; + GdkModifierType modifier_mask; + GSList *acceleratables; + guint n_accels; + GtkAccelGroupEntry *priv_accels; + } + + struct _GtkAccelGroupClass { + GObjectClass parent_class; + + void (*accel_changed) (GtkAccelGroup *accel_group, + guint keyval, + GdkModifierType modifier, + GClosure *accel_closure); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + struct _GtkAccelKey { + guint accel_key; + GdkModifierType accel_mods; + guint accel_flags; + } + + + + GType gtk_accel_group_get_type (); + GtkAccelGroup* gtk_accel_group_new (); + void gtk_accel_group_lock (GtkAccelGroup *accel_group); + void gtk_accel_group_unlock (GtkAccelGroup *accel_group); + void gtk_accel_group_connect (GtkAccelGroup *accel_group, + guint accel_key, + GdkModifierType accel_mods, + GtkAccelFlags accel_flags, + GClosure *closure); + void gtk_accel_group_connect_by_path (GtkAccelGroup *accel_group, + gchar *accel_path, + GClosure *closure); + gboolean gtk_accel_group_disconnect (GtkAccelGroup *accel_group, + GClosure *closure); + gboolean gtk_accel_group_disconnect_key (GtkAccelGroup *accel_group, + guint accel_key, + GdkModifierType accel_mods); + gboolean gtk_accel_group_activate (GtkAccelGroup *accel_group, + GQuark accel_quark, + GObject *acceleratable, + guint accel_key, + GdkModifierType accel_mods); + + + + void _gtk_accel_group_attach (GtkAccelGroup *accel_group, + GObject *object); + void _gtk_accel_group_detach (GtkAccelGroup *accel_group, + GObject *object); + gboolean gtk_accel_groups_activate (GObject *object, + guint accel_key, + GdkModifierType accel_mods); + GSList* gtk_accel_groups_from_object (GObject *object); + GtkAccelKey* gtk_accel_group_find (GtkAccelGroup *accel_group, + GtkAccelGroupFindFunc find_func, + gpointer data); + GtkAccelGroup* gtk_accel_group_from_accel_closure (GClosure *closure); + + + + gboolean gtk_accelerator_valid (guint keyval, + GdkModifierType modifiers) ; + void gtk_accelerator_parse ( gchar *accelerator, + guint *accelerator_key, + GdkModifierType *accelerator_mods); + gchar* gtk_accelerator_name (guint accelerator_key, + GdkModifierType accelerator_mods); + void gtk_accelerator_set_default_mod_mask (GdkModifierType default_mod_mask); + guint gtk_accelerator_get_default_mod_mask (); + + + + GtkAccelGroupEntry* gtk_accel_group_query (GtkAccelGroup *accel_group, + guint accel_key, + GdkModifierType accel_mods, + guint *n_entries); + + void _gtk_accel_group_reconnect (GtkAccelGroup *accel_group, + GQuark accel_path_quark); + + struct _GtkAccelGroupEntry { + GtkAccelKey key; + GClosure *closure; + GQuark accel_path_quark; + } + + + + + + + + + + alias GType GtkFundamentalType; + alias GType GtkType; + + + + alias GTypeInstance GtkTypeObject; + alias GTypeClass GtkTypeClass; + alias GBaseInitFunc GtkClassInitFunc; + alias GInstanceInitFunc GtkObjectInitFunc; + + + + + + + + + + + + GType gtk_accel_flags_get_type (); + + + + + GType gtk_calendar_display_options_get_type (); + + + + + GType gtk_cell_renderer_state_get_type (); + + + GType gtk_cell_renderer_mode_get_type (); + + + + + GType gtk_cell_type_get_type (); + + + GType gtk_clist_drag_pos_get_type (); + + + GType gtk_button_action_get_type (); + + + + + GType gtk_ctree_pos_get_type (); + + + GType gtk_ctree_line_style_get_type (); + + + GType gtk_ctree_expander_style_get_type (); + + + GType gtk_ctree_expansion_type_get_type (); + + + + + GType gtk_debug_flag_get_type (); + + + + + GType gtk_dialog_flags_get_type (); + + + GType gtk_response_type_get_type (); + + + + + GType gtk_dest_defaults_get_type (); + + + GType gtk_target_flags_get_type (); + + + + + GType gtk_anchor_type_get_type (); + + + GType gtk_arrow_type_get_type (); + + + GType gtk_attach_options_get_type (); + + + GType gtk_button_box_style_get_type (); + + + GType gtk_curve_type_get_type (); + + + GType gtk_delete_type_get_type (); + + + GType gtk_direction_type_get_type (); + + + GType gtk_expander_style_get_type (); + + + GType gtk_icon_size_get_type (); + + + GType gtk_side_type_get_type (); + + + GType gtk_text_direction_get_type (); + + + GType gtk_justification_get_type (); + + + GType gtk_match_type_get_type (); + + + GType gtk_menu_direction_type_get_type (); + + + GType gtk_metric_type_get_type (); + + + GType gtk_movement_step_get_type (); + + + GType gtk_scroll_step_get_type (); + + + GType gtk_orientation_get_type (); + + + GType gtk_corner_type_get_type (); + + + GType gtk_pack_type_get_type (); + + + GType gtk_path_priority_type_get_type (); + + + GType gtk_path_type_get_type (); + + + GType gtk_policy_type_get_type (); + + + GType gtk_position_type_get_type (); + + + GType gtk_preview_type_get_type (); + + + GType gtk_relief_style_get_type (); + + + GType gtk_resize_mode_get_type (); + + + GType gtk_signal_run_type_get_type (); + + + GType gtk_scroll_type_get_type (); + + + GType gtk_selection_mode_get_type (); + + + GType gtk_shadow_type_get_type (); + + + GType gtk_state_type_get_type (); + + + GType gtk_submenu_direction_get_type (); + + + GType gtk_submenu_placement_get_type (); + + + GType gtk_toolbar_style_get_type (); + + + GType gtk_update_type_get_type (); + + + GType gtk_visibility_get_type (); + + + GType gtk_window_position_get_type (); + + + GType gtk_window_type_get_type (); + + + GType gtk_wrap_mode_get_type (); + + + GType gtk_sort_type_get_type (); + + + GType gtk_im_preedit_style_get_type (); + + + GType gtk_im_status_style_get_type (); + + + + + GType gtk_file_chooser_action_get_type (); + + + GType gtk_file_chooser_error_get_type (); + + + + + GType gtk_file_filter_flags_get_type (); + + + + + GType gtk_icon_lookup_flags_get_type (); + + + GType gtk_icon_theme_error_get_type (); + + + + + GType gtk_image_type_get_type (); + + + + + GType gtk_message_type_get_type (); + + + GType gtk_buttons_type_get_type (); + + + + + GType gtk_notebook_tab_get_type (); + + + + + GType gtk_object_flags_get_type (); + + + GType gtk_arg_flags_get_type (); + + + + + GType gtk_private_flags_get_type (); + + + + + GType gtk_progress_bar_style_get_type (); + + + GType gtk_progress_bar_orientation_get_type (); + + + + + GType gtk_rc_flags_get_type (); + + + GType gtk_rc_token_type_get_type (); + + + + + GType gtk_size_group_mode_get_type (); + + + + + GType gtk_spin_button_update_policy_get_type (); + + + GType gtk_spin_type_get_type (); + + + + + GType gtk_text_search_flags_get_type (); + + + + + GType gtk_text_window_type_get_type (); + + + + + GType gtk_toolbar_child_type_get_type (); + + + GType gtk_toolbar_space_style_get_type (); + + + + + GType gtk_tree_view_mode_get_type (); + + + + + GType gtk_tree_model_flags_get_type (); + + + + + GType gtk_tree_view_drop_position_get_type (); + + + + + GType gtk_tree_view_column_sizing_get_type (); + + + + + GType gtk_ui_manager_item_type_get_type (); + + + + + GType gtk_widget_flags_get_type (); + + + GType gtk_widget_help_type_get_type (); + + + + + + + + + GType gtk_identifier_get_type (); + + + + + + alias _GtkArg GtkArg; + + alias _GtkObject GtkObject; + + alias gboolean (*GtkFunction) (gpointer data); + alias void (*GtkDestroyNotify) (gpointer data); + alias void (*GtkCallbackMarshal) (GtkObject *object, + gpointer data, + guint n_args, + GtkArg *args); + alias void (*GtkSignalFunc) (); + + + + alias _GtkTypeInfo GtkTypeInfo; + + alias GSignalCMarshaller GtkSignalMarshaller; + + + + + + + struct _GtkArg { + GtkType type; + gchar *name; + + + + + + + + union d_union { + + gchar char_data; + guchar uchar_data; + gboolean int_data1; + gint int_data2; + guint uint_data; + glong int_data3; + gulong ulong_data; + gfloat float_data; + gdouble double_data; + gchar *string_data; + GtkObject *object_data; + gpointer pointer_data; + + + struct signal_data_struct { + GtkSignalFunc f; + gpointer d; + } + } + d_union d; + } + struct _GtkTypeInfo { + gchar *type_name; + guint object_size; + guint class_size; + GtkClassInitFunc class_init_func; + GtkObjectInitFunc object_init_func; + gpointer reserved_1; + gpointer reserved_2; + GtkClassInitFunc base_class_init_func; + } + + + + gpointer gtk_type_class (GtkType type); + + + + GtkType gtk_type_unique (GtkType parent_type, + GtkTypeInfo *gtkinfo); + gpointer gtk_type_new (GtkType type); + alias GEnumValue GtkEnumValue; + alias GFlagsValue GtkFlagValue; + GtkEnumValue* gtk_type_enum_get_values (GtkType enum_type); + GtkFlagValue* gtk_type_flags_get_values (GtkType flags_type); + GtkEnumValue* gtk_type_enum_find_value (GtkType enum_type, + gchar *value_name); + GtkFlagValue* gtk_type_flags_find_value (GtkType flags_type, + gchar *value_name); + + + + + + void gtk_type_init (GTypeDebugFlags debug_flags); + + + + + + enum GtkDebugFlag { + GTK_DEBUG_MISC = 1 << 0, + GTK_DEBUG_PLUGSOCKET = 1 << 1, + GTK_DEBUG_TEXT = 1 << 2, + GTK_DEBUG_TREE = 1 << 3, + GTK_DEBUG_UPDATES = 1 << 4, + GTK_DEBUG_KEYBINDINGS = 1 << 5, + GTK_DEBUG_MULTIHEAD = 1 << 6 + }; + + guint gtk_debug_flags; + + + + + enum GtkObjectFlags { + GTK_IN_DESTRUCTION = 1 << 0, + GTK_FLOATING = 1 << 1, + GTK_RESERVED_1 = 1 << 2, + GTK_RESERVED_2 = 1 << 3 + }; + + alias _GtkObjectClass GtkObjectClass; + + + + struct _GtkObject { + GObject parent_instance; + + + + + + + guint32 flags; + } + + struct _GtkObjectClass { + GObjectClass parent_class; + + + void (*set_arg) (GtkObject *object, + GtkArg *arg, + guint arg_id); + void (*get_arg) (GtkObject *object, + GtkArg *arg, + guint arg_id); + void (*destroy) (GtkObject *object); + } + + + + + + GtkType gtk_object_get_type () ; + + void gtk_object_sink (GtkObject *object); + void gtk_object_destroy (GtkObject *object); + + + + + + GtkObject* gtk_object_new (GtkType type, + gchar *first_property_name, + ...); + GtkObject* gtk_object_ref (GtkObject *object); + void gtk_object_unref (GtkObject *object); + void gtk_object_weakref (GtkObject *object, + GtkDestroyNotify notify, + gpointer data); + void gtk_object_weakunref (GtkObject *object, + GtkDestroyNotify notify, + gpointer data); + void gtk_object_set_data (GtkObject *object, + gchar *key, + gpointer data); + void gtk_object_set_data_full (GtkObject *object, + gchar *key, + gpointer data, + GtkDestroyNotify destroy); + void gtk_object_remove_data (GtkObject *object, + gchar *key); + gpointer gtk_object_get_data (GtkObject *object, + gchar *key); + void gtk_object_remove_no_notify (GtkObject *object, + gchar *key); + + + + + + + void gtk_object_set_user_data (GtkObject *object, + gpointer data); + gpointer gtk_object_get_user_data (GtkObject *object); + + + + + + void gtk_object_set_data_by_id (GtkObject *object, + GQuark data_id, + gpointer data); + void gtk_object_set_data_by_id_full (GtkObject *object, + GQuark data_id, + gpointer data, + GtkDestroyNotify destroy); + gpointer gtk_object_get_data_by_id (GtkObject *object, + GQuark data_id); + void gtk_object_remove_data_by_id (GtkObject *object, + GQuark data_id); + void gtk_object_remove_no_notify_by_id (GtkObject *object, + GQuark key_id); + + + + + + enum GtkArgFlags { + GTK_ARG_READABLE = GParamFlags.G_PARAM_READABLE, + GTK_ARG_WRITABLE = GParamFlags.G_PARAM_WRITABLE, + GTK_ARG_CONSTRUCT = GParamFlags.G_PARAM_CONSTRUCT, + GTK_ARG_CONSTRUCT_ONLY = GParamFlags.G_PARAM_CONSTRUCT_ONLY, + GTK_ARG_CHILD_ARG = 1 << 4 + }; + + + void gtk_object_get (GtkObject *object, + gchar *first_property_name, + ...); + void gtk_object_set (GtkObject *object, + gchar *first_property_name, + ...); + void gtk_object_add_arg_type ( gchar *arg_name, + GtkType arg_type, + guint arg_flags, + guint arg_id); + + + + + alias _GtkAdjustment GtkAdjustment; + + alias _GtkAdjustmentClass GtkAdjustmentClass; + + + struct _GtkAdjustment { + GtkObject parent_instance; + + gdouble lower; + gdouble upper; + gdouble value; + gdouble step_increment; + gdouble page_increment; + gdouble page_size; + } + + struct _GtkAdjustmentClass { + GtkObjectClass parent_class; + + void (* changed) (GtkAdjustment *adjustment); + void (* value_changed) (GtkAdjustment *adjustment); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_adjustment_get_type () ; + GtkObject* gtk_adjustment_new (gdouble value, + gdouble lower, + gdouble upper, + gdouble step_increment, + gdouble page_increment, + gdouble page_size); + void gtk_adjustment_changed (GtkAdjustment *adjustment); + void gtk_adjustment_value_changed (GtkAdjustment *adjustment); + void gtk_adjustment_clamp_page (GtkAdjustment *adjustment, + gdouble lower, + gdouble upper); + gdouble gtk_adjustment_get_value (GtkAdjustment *adjustment); + void gtk_adjustment_set_value (GtkAdjustment *adjustment, + gdouble value); + + void gtk_adjustment_goto_value (GtkAdjustment *adjustment, + gdouble value); + void gtk_adjustment_home (GtkAdjustment *adjustment); + void gtk_adjustment_end (GtkAdjustment *adjustment); + void gtk_adjustment_step_up (GtkAdjustment *adjustment); + void gtk_adjustment_step_down (GtkAdjustment *adjustment); + void gtk_adjustment_wheel_up (GtkAdjustment *adjustment); + void gtk_adjustment_wheel_down (GtkAdjustment *adjustment); + void gtk_adjustment_page_up (GtkAdjustment *adjustment); + void gtk_adjustment_page_down (GtkAdjustment *adjustment); + alias _GtkBorder GtkBorder; + + alias _GtkStyle GtkStyle; + + alias _GtkStyleClass GtkStyleClass; + + alias _GtkThemeEngine GtkThemeEngine; + alias void _GtkThemeEngine; + + alias _GtkRcStyle GtkRcStyle; + + alias _GtkIconSet GtkIconSet; + alias void _GtkIconSet; + + alias _GtkIconSource GtkIconSource; + alias void _GtkIconSource; + + alias _GtkRcProperty GtkRcProperty; + + alias _GtkSettings GtkSettings; + + alias gboolean (*GtkRcPropertyParser) ( GParamSpec *pspec, + GString *rc_string, + GValue *property_value); + + + + + alias _GtkWidget GtkWidget; + + + + +align(1) struct _GtkStyle { + GObject parent_instance; + + + + GdkColor fg[5]; + GdkColor bg[5]; + GdkColor light[5]; + GdkColor dark[5]; + GdkColor mid[5]; + GdkColor text[5]; + GdkColor base[5]; + GdkColor text_aa[5]; + + GdkColor black; + GdkColor white; + PangoFontDescription *font_desc; + + gint xthickness; + gint ythickness; + + GdkGC *fg_gc[5]; + GdkGC *bg_gc[5]; + GdkGC *light_gc[5]; + GdkGC *dark_gc[5]; + GdkGC *mid_gc[5]; + GdkGC *text_gc[5]; + GdkGC *base_gc[5]; + GdkGC *text_aa_gc[5]; + GdkGC *black_gc; + GdkGC *white_gc; + + GdkPixmap *bg_pixmap[5]; + + + + gint attach_count; + + gint depth; + GdkColormap *colormap; + GdkFont *private_font; + PangoFontDescription *private_font_desc; + + + GtkRcStyle *rc_style; + + GSList *styles; + GArray *property_cache; + GSList *icon_factories; + } + + struct _GtkStyleClass { + GObjectClass parent_class; + + + + + + void (*realize) (GtkStyle *style); + + + + + void (*unrealize) (GtkStyle *style); + + + + void (*copy) (GtkStyle *style, + GtkStyle *src); + + + + + + + GtkStyle *(*clone) (GtkStyle *style); + + + + + void (*init_from_rc) (GtkStyle *style, + GtkRcStyle *rc_style); + + void (*set_background) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type); + + + GdkPixbuf * (* render_icon) (GtkStyle *style, + GtkIconSource *source, + GtkTextDirection direction, + GtkStateType state, + GtkIconSize size, + GtkWidget *widget, + gchar *detail); + + + + + void (*draw_hline) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x1, + gint x2, + gint y); + void (*draw_vline) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint y1_, + gint y2_, + gint x); + void (*draw_shadow) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void (*draw_polygon) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + GdkPoint *point, + gint npoints, + gboolean fill); + void (*draw_arrow) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + GtkArrowType arrow_type, + gboolean fill, + gint x, + gint y, + gint width, + gint height); + void (*draw_diamond) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void (*draw_string) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gchar *string); + void (*draw_box) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void (*draw_flat_box) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void (*draw_check) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void (*draw_option) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void (*draw_tab) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void (*draw_shadow_gap) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side, + gint gap_x, + gint gap_width); + void (*draw_box_gap) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side, + gint gap_x, + gint gap_width); + void (*draw_extension) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side); + void (*draw_focus) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void (*draw_slider) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height, + GtkOrientation orientation); + void (*draw_handle) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height, + GtkOrientation orientation); + + void (*draw_expander) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + GtkExpanderStyle expander_style); + void (*draw_layout) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + gboolean use_text, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + PangoLayout *layout); + void (*draw_resize_grip) (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + GdkWindowEdge edge, + gint x, + gint y, + gint width, + gint height); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + void (*_gtk_reserved5) (); + void (*_gtk_reserved6) (); + void (*_gtk_reserved7) (); + void (*_gtk_reserved8) (); + void (*_gtk_reserved9) (); + void (*_gtk_reserved10) (); + void (*_gtk_reserved11) (); + void (*_gtk_reserved12) (); + } + + struct _GtkBorder { + gint left; + gint right; + gint top; + gint bottom; + } + + GType gtk_style_get_type () ; + GtkStyle* gtk_style_new (); + GtkStyle* gtk_style_copy (GtkStyle *style); + GtkStyle* gtk_style_attach (GtkStyle *style, + GdkWindow *window); + void gtk_style_detach (GtkStyle *style); + + + GtkStyle* gtk_style_ref (GtkStyle *style); + void gtk_style_unref (GtkStyle *style); + + GdkFont * gtk_style_get_font (GtkStyle *style); + void gtk_style_set_font (GtkStyle *style, + GdkFont *font); + + + void gtk_style_set_background (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type); + void gtk_style_apply_default_background (GtkStyle *style, + GdkWindow *window, + gboolean set_bg, + GtkStateType state_type, + GdkRectangle *area, + gint x, + gint y, + gint width, + gint height); + + GtkIconSet* gtk_style_lookup_icon_set (GtkStyle *style, + gchar *stock_id); + GdkPixbuf* gtk_style_render_icon (GtkStyle *style, + GtkIconSource *source, + GtkTextDirection direction, + GtkStateType state, + GtkIconSize size, + GtkWidget *widget, + gchar *detail); + + void gtk_draw_hline (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + gint x1, + gint x2, + gint y); + void gtk_draw_vline (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + gint y1_, + gint y2_, + gint x); + void gtk_draw_shadow (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height); + void gtk_draw_polygon (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkPoint *points, + gint npoints, + gboolean fill); + void gtk_draw_arrow (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GtkArrowType arrow_type, + gboolean fill, + gint x, + gint y, + gint width, + gint height); + void gtk_draw_diamond (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height); + void gtk_draw_box (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height); + void gtk_draw_flat_box (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height); + void gtk_draw_check (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height); + void gtk_draw_option (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height); + void gtk_draw_tab (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height); + void gtk_draw_shadow_gap (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side, + gint gap_x, + gint gap_width); + void gtk_draw_box_gap (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side, + gint gap_x, + gint gap_width); + void gtk_draw_extension (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side); + void gtk_draw_focus (GtkStyle *style, + GdkWindow *window, + gint x, + gint y, + gint width, + gint height); + void gtk_draw_slider (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height, + GtkOrientation orientation); + void gtk_draw_handle (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height, + GtkOrientation orientation); + void gtk_draw_expander (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + gint x, + gint y, + GtkExpanderStyle expander_style); + void gtk_draw_layout (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + gboolean use_text, + gint x, + gint y, + PangoLayout *layout); + void gtk_draw_resize_grip (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkWindowEdge edge, + gint x, + gint y, + gint width, + gint height); + + + void gtk_paint_hline (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x1, + gint x2, + gint y); + void gtk_paint_vline (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint y1_, + gint y2_, + gint x); + void gtk_paint_shadow (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void gtk_paint_polygon (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + GdkPoint *points, + gint npoints, + gboolean fill); + void gtk_paint_arrow (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + GtkArrowType arrow_type, + gboolean fill, + gint x, + gint y, + gint width, + gint height); + void gtk_paint_diamond (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void gtk_paint_box (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void gtk_paint_flat_box (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void gtk_paint_check (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void gtk_paint_option (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void gtk_paint_tab (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void gtk_paint_shadow_gap (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side, + gint gap_x, + gint gap_width); + void gtk_paint_box_gap (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side, + gint gap_x, + gint gap_width); + void gtk_paint_extension (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side); + void gtk_paint_focus (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height); + void gtk_paint_slider (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height, + GtkOrientation orientation); + void gtk_paint_handle (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gint width, + gint height, + GtkOrientation orientation); + void gtk_paint_expander (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + GtkExpanderStyle expander_style); + void gtk_paint_layout (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + gboolean use_text, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + PangoLayout *layout); + + void gtk_paint_resize_grip (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + GdkWindowEdge edge, + gint x, + gint y, + gint width, + gint height); + + + GType gtk_border_get_type (); + GtkBorder *gtk_border_copy ( GtkBorder *border_); + void gtk_border_free ( GtkBorder *border_); + + + GValue* _gtk_style_peek_property_value (GtkStyle *style, + GType widget_type, + GParamSpec *pspec, + GtkRcPropertyParser parser); + + void _gtk_style_init_for_settings (GtkStyle *style, + GtkSettings *settings); + + + + + void gtk_draw_string (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + gint x, + gint y, + gchar *string); + void gtk_paint_string (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GdkRectangle *area, + GtkWidget *widget, + gchar *detail, + gint x, + gint y, + gchar *string); + + + void gtk_draw_insertion_cursor (GtkWidget *widget, + GdkDrawable *drawable, + GdkRectangle *area, + GdkRectangle *location, + gboolean is_primary, + GtkTextDirection direction, + gboolean draw_arrow); + alias _GtkIconFactory GtkIconFactory; + + alias _GtkRcContext GtkRcContext; + alias void _GtkRcContext; + + + alias _GtkRcStyleClass GtkRcStyleClass; + + enum GtkRcFlags { + GTK_RC_FG = 1 << 0, + GTK_RC_BG = 1 << 1, + GTK_RC_TEXT = 1 << 2, + GTK_RC_BASE = 1 << 3 + }; + + + struct _GtkRcStyle { + GObject parent_instance; + + + + gchar *name; + gchar *bg_pixmap_name[5]; + PangoFontDescription *font_desc; + + GtkRcFlags color_flags[5]; + GdkColor fg[5]; + GdkColor bg[5]; + GdkColor text[5]; + GdkColor base[5]; + + gint xthickness; + gint ythickness; + + + GArray *rc_properties; + + + GSList *rc_style_lists; + + GSList *icon_factories; + + guint engine_specified; + } + + struct _GtkRcStyleClass { + GObjectClass parent_class; + + + + + + + GtkRcStyle * (*create_rc_style) (GtkRcStyle *rc_style); + + + + + + guint (*parse) (GtkRcStyle *rc_style, + GtkSettings *settings, + GScanner *scanner); + + + + + void (*merge) (GtkRcStyle *dest, + GtkRcStyle *src); + + + + GtkStyle * (*create_style) (GtkRcStyle *rc_style); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + void _gtk_rc_init (); + void gtk_rc_add_default_file ( gchar *filename); + void gtk_rc_set_default_files (gchar **filenames); + gchar** gtk_rc_get_default_files (); + GtkStyle* gtk_rc_get_style (GtkWidget *widget); + GtkStyle* gtk_rc_get_style_by_paths (GtkSettings *settings, + char *widget_path, + char *class_path, + GType type); + + gboolean gtk_rc_reparse_all_for_settings (GtkSettings *settings, + gboolean force_load); + void gtk_rc_reset_styles (GtkSettings *settings); + + gchar* gtk_rc_find_pixmap_in_path (GtkSettings *settings, + GScanner *scanner, + gchar *pixmap_file); + + void gtk_rc_parse ( gchar *filename); + void gtk_rc_parse_string ( gchar *rc_string); + gboolean gtk_rc_reparse_all (); + + + void gtk_rc_add_widget_name_style (GtkRcStyle *rc_style, + gchar *pattern); + void gtk_rc_add_widget_class_style (GtkRcStyle *rc_style, + gchar *pattern); + void gtk_rc_add_class_style (GtkRcStyle *rc_style, + gchar *pattern); + + + + GType gtk_rc_style_get_type () ; + GtkRcStyle* gtk_rc_style_new (); + GtkRcStyle* gtk_rc_style_copy (GtkRcStyle *orig); + void gtk_rc_style_ref (GtkRcStyle *rc_style); + void gtk_rc_style_unref (GtkRcStyle *rc_style); + + gchar* gtk_rc_find_module_in_path ( gchar *module_file); + gchar* gtk_rc_get_theme_dir (); + gchar* gtk_rc_get_module_dir (); + gchar* gtk_rc_get_im_module_path (); + gchar* gtk_rc_get_im_module_file (); + + + enum GtkRcTokenType { + GTK_RC_TOKEN_INVALID = GTokenType.G_TOKEN_LAST, + GTK_RC_TOKEN_INCLUDE, + GTK_RC_TOKEN_NORMAL, + GTK_RC_TOKEN_ACTIVE, + GTK_RC_TOKEN_PRELIGHT, + GTK_RC_TOKEN_SELECTED, + GTK_RC_TOKEN_INSENSITIVE, + GTK_RC_TOKEN_FG, + GTK_RC_TOKEN_BG, + GTK_RC_TOKEN_TEXT, + GTK_RC_TOKEN_BASE, + GTK_RC_TOKEN_XTHICKNESS, + GTK_RC_TOKEN_YTHICKNESS, + GTK_RC_TOKEN_FONT, + GTK_RC_TOKEN_FONTSET, + GTK_RC_TOKEN_FONT_NAME, + GTK_RC_TOKEN_BG_PIXMAP, + GTK_RC_TOKEN_PIXMAP_PATH, + GTK_RC_TOKEN_STYLE, + GTK_RC_TOKEN_BINDING, + GTK_RC_TOKEN_BIND, + GTK_RC_TOKEN_WIDGET, + GTK_RC_TOKEN_WIDGET_CLASS, + GTK_RC_TOKEN_CLASS, + GTK_RC_TOKEN_LOWEST, + GTK_RC_TOKEN_GTK, + GTK_RC_TOKEN_APPLICATION, + GTK_RC_TOKEN_THEME, + GTK_RC_TOKEN_RC, + GTK_RC_TOKEN_HIGHEST, + GTK_RC_TOKEN_ENGINE, + GTK_RC_TOKEN_MODULE_PATH, + GTK_RC_TOKEN_IM_MODULE_PATH, + GTK_RC_TOKEN_IM_MODULE_FILE, + GTK_RC_TOKEN_STOCK, + GTK_RC_TOKEN_LTR, + GTK_RC_TOKEN_RTL, + GTK_RC_TOKEN_LAST + }; + + + GScanner* gtk_rc_scanner_new (); + guint gtk_rc_parse_color (GScanner *scanner, + GdkColor *color); + guint gtk_rc_parse_state (GScanner *scanner, + GtkStateType *state); + guint gtk_rc_parse_priority (GScanner *scanner, + GtkPathPriorityType *priority); + + + + + struct _GtkRcProperty { + + GQuark type_name; + GQuark property_name; + + + gchar *origin; + GValue value; + } + GtkRcProperty* _gtk_rc_style_lookup_rc_property (GtkRcStyle *rc_style, + GQuark type_name, + GQuark property_name); + + gchar* _gtk_rc_context_get_default_font_name (GtkSettings *settings); + + + alias _GtkSettingsClass GtkSettingsClass; + + alias _GtkSettingsValue GtkSettingsValue; + + alias _GtkSettingsPropertyValue GtkSettingsPropertyValue; + alias void _GtkSettingsPropertyValue; + + + struct _GtkSettings { + GObject parent_instance; + + GData *queued_settings; + GtkSettingsPropertyValue *property_values; + + GtkRcContext *rc_context; + GdkScreen *screen; + } + struct _GtkSettingsClass { + GObjectClass parent_class; + + } + struct _GtkSettingsValue { + + + + gchar *origin; + + + + + GValue value; + } + + + + GType gtk_settings_get_type (); + + GtkSettings* gtk_settings_get_default (); + + GtkSettings* gtk_settings_get_for_screen (GdkScreen *screen); + + void gtk_settings_install_property (GParamSpec *pspec); + void gtk_settings_install_property_parser (GParamSpec *pspec, + GtkRcPropertyParser parser); + + + gboolean gtk_rc_property_parse_color ( GParamSpec *pspec, + GString *gstring, + GValue *property_value); + gboolean gtk_rc_property_parse_enum ( GParamSpec *pspec, + GString *gstring, + GValue *property_value); + gboolean gtk_rc_property_parse_flags ( GParamSpec *pspec, + GString *gstring, + GValue *property_value); + gboolean gtk_rc_property_parse_requisition ( GParamSpec *pspec, + GString *gstring, + GValue *property_value); + gboolean gtk_rc_property_parse_border ( GParamSpec *pspec, + GString *gstring, + GValue *property_value); + + + void gtk_settings_set_property_value (GtkSettings *settings, + gchar *name, + GtkSettingsValue *svalue); + void gtk_settings_set_string_property (GtkSettings *settings, + gchar *name, + gchar *v_string, + gchar *origin); + void gtk_settings_set_long_property (GtkSettings *settings, + gchar *name, + glong v_long, + gchar *origin); + void gtk_settings_set_double_property (GtkSettings *settings, + gchar *name, + gdouble v_double, + gchar *origin); + + + + void _gtk_settings_set_property_value_from_rc (GtkSettings *settings, + gchar *name, + GtkSettingsValue *svalue); + void _gtk_settings_reset_rc_values (GtkSettings *settings); + + void _gtk_settings_handle_event (GdkEventSetting *event); + GtkRcPropertyParser _gtk_rc_property_parser_from_type (GType type); + gboolean _gtk_settings_parse_convert (GtkRcPropertyParser parser, + GValue *src_value, + GParamSpec *pspec, + GValue *dest_value); + + + + enum AtkStateType { + ATK_STATE_INVALID, + ATK_STATE_ACTIVE, + ATK_STATE_ARMED, + ATK_STATE_BUSY, + ATK_STATE_CHECKED, + ATK_STATE_DEFUNCT, + ATK_STATE_EDITABLE, + ATK_STATE_ENABLED, + ATK_STATE_EXPANDABLE, + ATK_STATE_EXPANDED, + ATK_STATE_FOCUSABLE, + ATK_STATE_FOCUSED, + ATK_STATE_HORIZONTAL, + ATK_STATE_ICONIFIED, + ATK_STATE_MODAL, + ATK_STATE_MULTI_LINE, + ATK_STATE_MULTISELECTABLE, + ATK_STATE_OPAQUE, + ATK_STATE_PRESSED, + ATK_STATE_RESIZABLE, + ATK_STATE_SELECTABLE, + ATK_STATE_SELECTED, + ATK_STATE_SENSITIVE, + ATK_STATE_SHOWING, + ATK_STATE_SINGLE_LINE, + ATK_STATE_STALE, + ATK_STATE_TRANSIENT, + ATK_STATE_VERTICAL, + ATK_STATE_VISIBLE, + ATK_STATE_MANAGES_DESCENDANTS, + ATK_STATE_INDETERMINATE, + ATK_STATE_LAST_DEFINED + }; + + + alias guint64 AtkState; + + AtkStateType atk_state_type_register ( gchar *name); + + gchar* atk_state_type_get_name (AtkStateType type); + AtkStateType atk_state_type_for_name ( gchar *name); + enum AtkRelationType { + ATK_RELATION_NULL = 0, + ATK_RELATION_CONTROLLED_BY, + ATK_RELATION_CONTROLLER_FOR, + ATK_RELATION_LABEL_FOR, + ATK_RELATION_LABELLED_BY, + ATK_RELATION_MEMBER_OF, + ATK_RELATION_NODE_CHILD_OF, + ATK_RELATION_FLOWS_TO, + ATK_RELATION_FLOWS_FROM, + ATK_RELATION_SUBWINDOW_OF, + ATK_RELATION_EMBEDS, + ATK_RELATION_EMBEDDED_BY, + ATK_RELATION_POPUP_FOR, + ATK_RELATION_LAST_DEFINED + }; + + enum AtkRole { + ATK_ROLE_INVALID = 0, + ATK_ROLE_ACCEL_LABEL, + ATK_ROLE_ALERT, + ATK_ROLE_ANIMATION, + ATK_ROLE_ARROW, + ATK_ROLE_CALENDAR, + ATK_ROLE_CANVAS, + ATK_ROLE_CHECK_BOX, + ATK_ROLE_CHECK_MENU_ITEM, + ATK_ROLE_COLOR_CHOOSER, + ATK_ROLE_COLUMN_HEADER, + ATK_ROLE_COMBO_BOX, + ATK_ROLE_DATE_EDITOR, + ATK_ROLE_DESKTOP_ICON, + ATK_ROLE_DESKTOP_FRAME, + ATK_ROLE_DIAL, + ATK_ROLE_DIALOG, + ATK_ROLE_DIRECTORY_PANE, + ATK_ROLE_DRAWING_AREA, + ATK_ROLE_FILE_CHOOSER, + ATK_ROLE_FILLER, + ATK_ROLE_FONT_CHOOSER, + ATK_ROLE_FRAME, + ATK_ROLE_GLASS_PANE, + ATK_ROLE_HTML_CONTAINER, + ATK_ROLE_ICON, + ATK_ROLE_IMAGE, + ATK_ROLE_INTERNAL_FRAME, + ATK_ROLE_LABEL, + ATK_ROLE_LAYERED_PANE, + ATK_ROLE_LIST, + ATK_ROLE_LIST_ITEM, + ATK_ROLE_MENU, + ATK_ROLE_MENU_BAR, + ATK_ROLE_MENU_ITEM, + ATK_ROLE_OPTION_PANE, + ATK_ROLE_PAGE_TAB, + ATK_ROLE_PAGE_TAB_LIST, + ATK_ROLE_PANEL, + ATK_ROLE_PASSWORD_TEXT, + ATK_ROLE_POPUP_MENU, + ATK_ROLE_PROGRESS_BAR, + ATK_ROLE_PUSH_BUTTON, + ATK_ROLE_RADIO_BUTTON, + ATK_ROLE_RADIO_MENU_ITEM, + ATK_ROLE_ROOT_PANE, + ATK_ROLE_ROW_HEADER, + ATK_ROLE_SCROLL_BAR, + ATK_ROLE_SCROLL_PANE, + ATK_ROLE_SEPARATOR, + ATK_ROLE_SLIDER, + ATK_ROLE_SPLIT_PANE, + ATK_ROLE_SPIN_BUTTON, + ATK_ROLE_STATUSBAR, + ATK_ROLE_TABLE, + ATK_ROLE_TABLE_CELL, + ATK_ROLE_TABLE_COLUMN_HEADER, + ATK_ROLE_TABLE_ROW_HEADER, + ATK_ROLE_TEAR_OFF_MENU_ITEM, + ATK_ROLE_TERMINAL, + ATK_ROLE_TEXT, + ATK_ROLE_TOGGLE_BUTTON, + ATK_ROLE_TOOL_BAR, + ATK_ROLE_TOOL_TIP, + ATK_ROLE_TREE, + ATK_ROLE_TREE_TABLE, + ATK_ROLE_UNKNOWN, + ATK_ROLE_VIEWPORT, + ATK_ROLE_WINDOW, + ATK_ROLE_HEADER, + ATK_ROLE_FOOTER, + ATK_ROLE_PARAGRAPH, + ATK_ROLE_RULER, + ATK_ROLE_APPLICATION, + ATK_ROLE_AUTOCOMPLETE, + ATK_ROLE_EDITBAR, + ATK_ROLE_LAST_DEFINED + }; + + + AtkRole atk_role_register ( gchar *name); + enum AtkLayer { + ATK_LAYER_INVALID, + ATK_LAYER_BACKGROUND, + ATK_LAYER_CANVAS, + ATK_LAYER_WIDGET, + ATK_LAYER_MDI, + ATK_LAYER_POPUP, + ATK_LAYER_OVERLAY, + ATK_LAYER_WINDOW + }; + + alias _AtkImplementor AtkImplementor; + alias void _AtkImplementor; + + alias _AtkImplementorIface AtkImplementorIface; + + + + alias _AtkObject AtkObject; + + alias _AtkObjectClass AtkObjectClass; + + alias _AtkRelationSet AtkRelationSet; + + alias _AtkStateSet AtkStateSet; + + + struct _AtkPropertyValues { + gchar *property_name; + GValue old_value; + GValue new_value; + } + + alias _AtkPropertyValues AtkPropertyValues; + + + alias gboolean (*AtkFunction) (gpointer data); + alias void (*AtkPropertyChangeHandler) (AtkObject*, AtkPropertyValues*); + + + struct _AtkObject { + GObject parent; + + gchar *description; + gchar *name; + AtkObject *accessible_parent; + AtkRole role; + AtkRelationSet *relation_set; + AtkLayer layer; + } + + struct _AtkObjectClass { + GObjectClass parent; + + + + + gchar* (* get_name) (AtkObject *accessible); + + + + gchar* (* get_description) (AtkObject *accessible); + + + + AtkObject* (*get_parent) (AtkObject *accessible); + + + + + gint (* get_n_children) (AtkObject *accessible); + + + + + + AtkObject* (* ref_child) (AtkObject *accessible, + gint i); + + + + + gint (* get_index_in_parent) (AtkObject *accessible); + + + + AtkRelationSet* (* ref_relation_set) (AtkObject *accessible); + + + + AtkRole (* get_role) (AtkObject *accessible); + AtkLayer (* get_layer) (AtkObject *accessible); + gint (* get_mdi_zorder) (AtkObject *accessible); + + + + AtkStateSet* (* ref_state_set) (AtkObject *accessible); + + + + void (* set_name) (AtkObject *accessible, + gchar *name); + + + + void (* set_description) (AtkObject *accessible, + gchar *description); + + + + void (* set_parent) (AtkObject *accessible, + AtkObject *parent); + + + + void (* set_role) (AtkObject *accessible, + AtkRole role); + + + + guint (* connect_property_change_handler) (AtkObject + *accessible, + AtkPropertyChangeHandler *handler); + + + + + void (* remove_property_change_handler) (AtkObject + *accessible, + guint + handler_id); + void (* initialize) (AtkObject *accessible, + gpointer data); + + + + + void (* children_changed) (AtkObject *accessible, + guint change_index, + gpointer changed_child); + + + + + void (* focus_event) (AtkObject *accessible, + gboolean focus_in); + + + + + void (* property_change) (AtkObject *accessible, + AtkPropertyValues *values); + + + + + void (* state_change) (AtkObject *accessible, + gchar *name, + gboolean state_set); + + + + + void (*visible_data_changed) (AtkObject *accessible); + + + + + + + + void (*active_descendant_changed) (AtkObject *accessible, + gpointer *child); + + AtkFunction pad1; + AtkFunction pad2; + AtkFunction pad3; + + } + + GType atk_object_get_type (); + + struct _AtkImplementorIface { + GTypeInterface parent; + + AtkObject* (*ref_accessible) (AtkImplementor *implementor); + } + GType atk_implementor_get_type (); + AtkObject* atk_implementor_ref_accessible (AtkImplementor *implementor); + + + + + + gchar* atk_object_get_name (AtkObject *accessible); + gchar* atk_object_get_description (AtkObject *accessible); + AtkObject* atk_object_get_parent (AtkObject *accessible); + gint atk_object_get_n_accessible_children (AtkObject *accessible); + AtkObject* atk_object_ref_accessible_child (AtkObject *accessible, + gint i); + AtkRelationSet* atk_object_ref_relation_set (AtkObject *accessible); + AtkRole atk_object_get_role (AtkObject *accessible); + AtkLayer atk_object_get_layer (AtkObject *accessible); + gint atk_object_get_mdi_zorder (AtkObject *accessible); + AtkStateSet* atk_object_ref_state_set (AtkObject *accessible); + gint atk_object_get_index_in_parent (AtkObject *accessible); + void atk_object_set_name (AtkObject *accessible, + gchar *name); + void atk_object_set_description (AtkObject *accessible, + gchar *description); + void atk_object_set_parent (AtkObject *accessible, + AtkObject *parent); + void atk_object_set_role (AtkObject *accessible, + AtkRole role); + + + guint atk_object_connect_property_change_handler (AtkObject *accessible, + AtkPropertyChangeHandler *handler); + void atk_object_remove_property_change_handler (AtkObject *accessible, + guint handler_id); + + void atk_object_notify_state_change (AtkObject *accessible, + AtkState state, + gboolean value); + void atk_object_initialize (AtkObject *accessible, + gpointer data); + + gchar* atk_role_get_name (AtkRole role); + AtkRole atk_role_for_name ( gchar *name); + + + + gboolean atk_object_add_relationship (AtkObject *object, + AtkRelationType relationship, + AtkObject *target); + gboolean atk_object_remove_relationship (AtkObject *object, + AtkRelationType relationship, + AtkObject *target); + gchar* atk_role_get_localized_name (AtkRole role); + enum GtkWidgetFlags { + GTK_TOPLEVEL = 1 << 4, + GTK_NO_WINDOW = 1 << 5, + GTK_REALIZED = 1 << 6, + GTK_MAPPED = 1 << 7, + GTK_VISIBLE = 1 << 8, + GTK_SENSITIVE = 1 << 9, + GTK_PARENT_SENSITIVE = 1 << 10, + GTK_CAN_FOCUS = 1 << 11, + GTK_HAS_FOCUS = 1 << 12, + + + + + GTK_CAN_DEFAULT = 1 << 13, + + + + + GTK_HAS_DEFAULT = 1 << 14, + + GTK_HAS_GRAB = 1 << 15, + GTK_RC_STYLE = 1 << 16, + GTK_COMPOSITE_CHILD = 1 << 17, + GTK_NO_REPARENT = 1 << 18, + GTK_APP_PAINTABLE = 1 << 19, + + + + + GTK_RECEIVES_DEFAULT = 1 << 20, + + GTK_DOUBLE_BUFFERED = 1 << 21, + GTK_NO_SHOW_ALL = 1 << 22 + }; + + + + enum GtkWidgetHelpType { + GTK_WIDGET_HELP_TOOLTIP, + GTK_WIDGET_HELP_WHATS_THIS + }; + + alias _GtkRequisition GtkRequisition; + + alias GdkRectangle GtkAllocation; + alias _GtkSelectionData GtkSelectionData; + + alias _GtkWidgetClass GtkWidgetClass; + + alias _GtkWidgetAuxInfo GtkWidgetAuxInfo; + + alias _GtkWidgetShapeInfo GtkWidgetShapeInfo; + + alias _GtkClipboard GtkClipboard; + alias void _GtkClipboard; + + alias void (*GtkCallback) (GtkWidget *widget, + gpointer data); + + + + + struct _GtkRequisition { + gint width; + gint height; + } + + + + + + + struct _GtkWidget { + + + + + + + GtkObject object; + + + + + + + guint16 private_flags; + + + + + guint8 state; + + + + + + + + guint8 saved_state; + + + + + + + + gchar *name; + GtkStyle *style; + + + + GtkRequisition requisition; + + + + GtkAllocation allocation; + + + + + + GdkWindow *window; + + + + GtkWidget *parent; + } + + struct _GtkWidgetClass { + + + + + + + GtkObjectClass parent_class; + + + + guint activate_signal; + + guint set_scroll_adjustments_signal; + + + + + void (*dispatch_child_properties_changed) (GtkWidget *widget, + guint n_pspecs, + GParamSpec **pspecs); + + + void (* show) (GtkWidget *widget); + void (* show_all) (GtkWidget *widget); + void (* hide) (GtkWidget *widget); + void (* hide_all) (GtkWidget *widget); + void (* map) (GtkWidget *widget); + void (* unmap) (GtkWidget *widget); + void (* realize) (GtkWidget *widget); + void (* unrealize) (GtkWidget *widget); + void (* size_request) (GtkWidget *widget, + GtkRequisition *requisition); + void (* size_allocate) (GtkWidget *widget, + GtkAllocation *allocation); + void (* state_changed) (GtkWidget *widget, + GtkStateType previous_state); + void (* parent_set) (GtkWidget *widget, + GtkWidget *previous_parent); + void (* hierarchy_changed) (GtkWidget *widget, + GtkWidget *previous_toplevel); + void (* style_set) (GtkWidget *widget, + GtkStyle *previous_style); + void (* direction_changed) (GtkWidget *widget, + GtkTextDirection previous_direction); + void (* grab_notify) (GtkWidget *widget, + gboolean was_grabbed); + void (* child_notify) (GtkWidget *widget, + GParamSpec *pspec); + + + gboolean (* mnemonic_activate) (GtkWidget *widget, + gboolean group_cycling); + + + void (* grab_focus) (GtkWidget *widget); + gboolean (* focus) (GtkWidget *widget, + GtkDirectionType direction); + + + gboolean (* event) (GtkWidget *widget, + GdkEvent *event); + gboolean (* button_press_event) (GtkWidget *widget, + GdkEventButton *event); + gboolean (* button_release_event) (GtkWidget *widget, + GdkEventButton *event); + gboolean (* scroll_event) (GtkWidget *widget, + GdkEventScroll *event); + gboolean (* motion_notify_event) (GtkWidget *widget, + GdkEventMotion *event); + gboolean (* delete_event) (GtkWidget *widget, + GdkEventAny *event); + gboolean (* destroy_event) (GtkWidget *widget, + GdkEventAny *event); + gboolean (* expose_event) (GtkWidget *widget, + GdkEventExpose *event); + gboolean (* key_press_event) (GtkWidget *widget, + GdkEventKey *event); + gboolean (* key_release_event) (GtkWidget *widget, + GdkEventKey *event); + gboolean (* enter_notify_event) (GtkWidget *widget, + GdkEventCrossing *event); + gboolean (* leave_notify_event) (GtkWidget *widget, + GdkEventCrossing *event); + gboolean (* configure_event) (GtkWidget *widget, + GdkEventConfigure *event); + gboolean (* focus_in_event) (GtkWidget *widget, + GdkEventFocus *event); + gboolean (* focus_out_event) (GtkWidget *widget, + GdkEventFocus *event); + gboolean (* map_event) (GtkWidget *widget, + GdkEventAny *event); + gboolean (* unmap_event) (GtkWidget *widget, + GdkEventAny *event); + gboolean (* property_notify_event) (GtkWidget *widget, + GdkEventProperty *event); + gboolean (* selection_clear_event) (GtkWidget *widget, + GdkEventSelection *event); + gboolean (* selection_request_event) (GtkWidget *widget, + GdkEventSelection *event); + gboolean (* selection_notify_event) (GtkWidget *widget, + GdkEventSelection *event); + gboolean (* proximity_in_event) (GtkWidget *widget, + GdkEventProximity *event); + gboolean (* proximity_out_event) (GtkWidget *widget, + GdkEventProximity *event); + gboolean (* visibility_notify_event) (GtkWidget *widget, + GdkEventVisibility *event); + gboolean (* client_event) (GtkWidget *widget, + GdkEventClient *event); + gboolean (* no_expose_event) (GtkWidget *widget, + GdkEventAny *event); + gboolean (* window_state_event) (GtkWidget *widget, + GdkEventWindowState *event); + + + void (* selection_get) (GtkWidget *widget, + GtkSelectionData *selection_data, + guint info, + guint time_); + void (* selection_received) (GtkWidget *widget, + GtkSelectionData *selection_data, + guint time_); + + + void (* drag_begin) (GtkWidget *widget, + GdkDragContext *context); + void (* drag_end) (GtkWidget *widget, + GdkDragContext *context); + void (* drag_data_get) (GtkWidget *widget, + GdkDragContext *context, + GtkSelectionData *selection_data, + guint info, + guint time_); + void (* drag_data_delete) (GtkWidget *widget, + GdkDragContext *context); + + + void (* drag_leave) (GtkWidget *widget, + GdkDragContext *context, + guint time_); + gboolean (* drag_motion) (GtkWidget *widget, + GdkDragContext *context, + gint x, + gint y, + guint time_); + gboolean (* drag_drop) (GtkWidget *widget, + GdkDragContext *context, + gint x, + gint y, + guint time_); + void (* drag_data_received) (GtkWidget *widget, + GdkDragContext *context, + gint x, + gint y, + GtkSelectionData *selection_data, + guint info, + guint time_); + + + gboolean (* popup_menu) (GtkWidget *widget); + + + + + + + gboolean (* show_help) (GtkWidget *widget, + GtkWidgetHelpType help_type); + + + + AtkObject* (*get_accessible) (GtkWidget *widget); + + void (*screen_changed) (GtkWidget *widget, + GdkScreen *previous_screen); + gboolean (*can_activate_accel) (GtkWidget *widget, + guint signal_id); + + + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + void (*_gtk_reserved5) (); + void (*_gtk_reserved6) (); + void (*_gtk_reserved7) (); + } + + struct _GtkWidgetAuxInfo { + gint x; + gint y; + gint width; + gint height; + guint x_set; + guint y_set; + } + + struct _GtkWidgetShapeInfo { + gint16 offset_x; + gint16 offset_y; + GdkBitmap *shape_mask; + } + + GType gtk_widget_get_type () ; + GtkWidget* gtk_widget_new (GType type, + gchar *first_property_name, + ...); + GtkWidget* gtk_widget_ref (GtkWidget *widget); + void gtk_widget_unref (GtkWidget *widget); + void gtk_widget_destroy (GtkWidget *widget); + void gtk_widget_destroyed (GtkWidget *widget, + GtkWidget **widget_pointer); + + void gtk_widget_set (GtkWidget *widget, + gchar *first_property_name, + ...); + + void gtk_widget_unparent (GtkWidget *widget); + void gtk_widget_show (GtkWidget *widget); + void gtk_widget_show_now (GtkWidget *widget); + void gtk_widget_hide (GtkWidget *widget); + void gtk_widget_show_all (GtkWidget *widget); + void gtk_widget_hide_all (GtkWidget *widget); + void gtk_widget_set_no_show_all (GtkWidget *widget, + gboolean no_show_all); + gboolean gtk_widget_get_no_show_all (GtkWidget *widget); + void gtk_widget_map (GtkWidget *widget); + void gtk_widget_unmap (GtkWidget *widget); + void gtk_widget_realize (GtkWidget *widget); + void gtk_widget_unrealize (GtkWidget *widget); + + + void gtk_widget_queue_draw (GtkWidget *widget); + void gtk_widget_queue_draw_area (GtkWidget *widget, + gint x, + gint y, + gint width, + gint height); + + void gtk_widget_queue_clear (GtkWidget *widget); + void gtk_widget_queue_clear_area (GtkWidget *widget, + gint x, + gint y, + gint width, + gint height); + + + + void gtk_widget_queue_resize (GtkWidget *widget); + void gtk_widget_queue_resize_no_redraw (GtkWidget *widget); + + void gtk_widget_draw (GtkWidget *widget, + GdkRectangle *area); + + void gtk_widget_size_request (GtkWidget *widget, + GtkRequisition *requisition); + void gtk_widget_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); + void gtk_widget_get_child_requisition (GtkWidget *widget, + GtkRequisition *requisition); + void gtk_widget_add_accelerator (GtkWidget *widget, + gchar *accel_signal, + GtkAccelGroup *accel_group, + guint accel_key, + GdkModifierType accel_mods, + GtkAccelFlags accel_flags); + gboolean gtk_widget_remove_accelerator (GtkWidget *widget, + GtkAccelGroup *accel_group, + guint accel_key, + GdkModifierType accel_mods); + void gtk_widget_set_accel_path (GtkWidget *widget, + gchar *accel_path, + GtkAccelGroup *accel_group); + gchar* _gtk_widget_get_accel_path (GtkWidget *widget, + gboolean *locked); + GList* gtk_widget_list_accel_closures (GtkWidget *widget); + gboolean gtk_widget_can_activate_accel (GtkWidget *widget, + guint signal_id); + gboolean gtk_widget_mnemonic_activate (GtkWidget *widget, + gboolean group_cycling); + gboolean gtk_widget_event (GtkWidget *widget, + GdkEvent *event); + gint gtk_widget_send_expose (GtkWidget *widget, + GdkEvent *event); + + gboolean gtk_widget_activate (GtkWidget *widget); + gboolean gtk_widget_set_scroll_adjustments (GtkWidget *widget, + GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); + + void gtk_widget_reparent (GtkWidget *widget, + GtkWidget *new_parent); + gboolean gtk_widget_intersect (GtkWidget *widget, + GdkRectangle *area, + GdkRectangle *intersection); + GdkRegion *gtk_widget_region_intersect (GtkWidget *widget, + GdkRegion *region); + + void gtk_widget_freeze_child_notify (GtkWidget *widget); + void gtk_widget_child_notify (GtkWidget *widget, + gchar *child_property); + void gtk_widget_thaw_child_notify (GtkWidget *widget); + + gboolean gtk_widget_is_focus (GtkWidget *widget); + void gtk_widget_grab_focus (GtkWidget *widget); + void gtk_widget_grab_default (GtkWidget *widget); + + void gtk_widget_set_name (GtkWidget *widget, + gchar *name); + gchar* gtk_widget_get_name (GtkWidget *widget); + void gtk_widget_set_state (GtkWidget *widget, + GtkStateType state); + void gtk_widget_set_sensitive (GtkWidget *widget, + gboolean sensitive); + void gtk_widget_set_app_paintable (GtkWidget *widget, + gboolean app_paintable); + void gtk_widget_set_double_buffered (GtkWidget *widget, + gboolean double_buffered); + void gtk_widget_set_redraw_on_allocate (GtkWidget *widget, + gboolean redraw_on_allocate); + void gtk_widget_set_parent (GtkWidget *widget, + GtkWidget *parent); + void gtk_widget_set_parent_window (GtkWidget *widget, + GdkWindow *parent_window); + void gtk_widget_set_child_visible (GtkWidget *widget, + gboolean is_visible); + gboolean gtk_widget_get_child_visible (GtkWidget *widget); + + GtkWidget *gtk_widget_get_parent (GtkWidget *widget); + GdkWindow *gtk_widget_get_parent_window (GtkWidget *widget); + + gboolean gtk_widget_child_focus (GtkWidget *widget, + GtkDirectionType direction); + + void gtk_widget_set_size_request (GtkWidget *widget, + gint width, + gint height); + void gtk_widget_get_size_request (GtkWidget *widget, + gint *width, + gint *height); + + void gtk_widget_set_uposition (GtkWidget *widget, + gint x, + gint y); + void gtk_widget_set_usize (GtkWidget *widget, + gint width, + gint height); + + + void gtk_widget_set_events (GtkWidget *widget, + gint events); + void gtk_widget_add_events (GtkWidget *widget, + gint events); + void gtk_widget_set_extension_events (GtkWidget *widget, + GdkExtensionMode mode); + + GdkExtensionMode gtk_widget_get_extension_events (GtkWidget *widget); + GtkWidget* gtk_widget_get_toplevel (GtkWidget *widget); + GtkWidget* gtk_widget_get_ancestor (GtkWidget *widget, + GType widget_type); + GdkColormap* gtk_widget_get_colormap (GtkWidget *widget); + GdkVisual* gtk_widget_get_visual (GtkWidget *widget); + + GdkScreen * gtk_widget_get_screen (GtkWidget *widget); + gboolean gtk_widget_has_screen (GtkWidget *widget); + GdkDisplay * gtk_widget_get_display (GtkWidget *widget); + GdkWindow * gtk_widget_get_root_window (GtkWidget *widget); + GtkSettings* gtk_widget_get_settings (GtkWidget *widget); + GtkClipboard *gtk_widget_get_clipboard (GtkWidget *widget, + GdkAtom selection); + AtkObject* gtk_widget_get_accessible (GtkWidget *widget); + + + + + + + + void gtk_widget_set_colormap (GtkWidget *widget, + GdkColormap *colormap); + + gint gtk_widget_get_events (GtkWidget *widget); + void gtk_widget_get_pointer (GtkWidget *widget, + gint *x, + gint *y); + + gboolean gtk_widget_is_ancestor (GtkWidget *widget, + GtkWidget *ancestor); + + gboolean gtk_widget_translate_coordinates (GtkWidget *src_widget, + GtkWidget *dest_widget, + gint src_x, + gint src_y, + gint *dest_x, + gint *dest_y); + + + + gboolean gtk_widget_hide_on_delete (GtkWidget *widget); + + + + void gtk_widget_set_style (GtkWidget *widget, + GtkStyle *style); + void gtk_widget_ensure_style (GtkWidget *widget); + GtkStyle* gtk_widget_get_style (GtkWidget *widget); + + void gtk_widget_modify_style (GtkWidget *widget, + GtkRcStyle *style); + GtkRcStyle *gtk_widget_get_modifier_style (GtkWidget *widget); + void gtk_widget_modify_fg (GtkWidget *widget, + GtkStateType state, + GdkColor *color); + void gtk_widget_modify_bg (GtkWidget *widget, + GtkStateType state, + GdkColor *color); + void gtk_widget_modify_text (GtkWidget *widget, + GtkStateType state, + GdkColor *color); + void gtk_widget_modify_base (GtkWidget *widget, + GtkStateType state, + GdkColor *color); + void gtk_widget_modify_font (GtkWidget *widget, + PangoFontDescription *font_desc); + + + + + + + PangoContext *gtk_widget_create_pango_context (GtkWidget *widget); + PangoContext *gtk_widget_get_pango_context (GtkWidget *widget); + PangoLayout *gtk_widget_create_pango_layout (GtkWidget *widget, + gchar *text); + + GdkPixbuf *gtk_widget_render_icon (GtkWidget *widget, + gchar *stock_id, + GtkIconSize size, + gchar *detail); + + + + + void gtk_widget_set_composite_name (GtkWidget *widget, + gchar *name); + gchar* gtk_widget_get_composite_name (GtkWidget *widget); + + + void gtk_widget_reset_rc_styles (GtkWidget *widget); + + + + + + void gtk_widget_push_colormap (GdkColormap *cmap); + void gtk_widget_push_composite_child (); + void gtk_widget_pop_composite_child (); + void gtk_widget_pop_colormap (); + + + + void gtk_widget_class_install_style_property (GtkWidgetClass *klass, + GParamSpec *pspec); + void gtk_widget_class_install_style_property_parser (GtkWidgetClass *klass, + GParamSpec *pspec, + GtkRcPropertyParser parser); + GParamSpec* gtk_widget_class_find_style_property (GtkWidgetClass *klass, + gchar *property_name); + GParamSpec** gtk_widget_class_list_style_properties (GtkWidgetClass *klass, + guint *n_properties); + void gtk_widget_style_get_property (GtkWidget *widget, + gchar *property_name, + GValue *value); + void gtk_widget_style_get_valist (GtkWidget *widget, + gchar *first_property_name, + va_list var_args); + void gtk_widget_style_get (GtkWidget *widget, + gchar *first_property_name, + ...); + + + + + void gtk_widget_set_default_colormap (GdkColormap *colormap); + GtkStyle* gtk_widget_get_default_style (); + + GdkColormap* gtk_widget_get_default_colormap (); + GdkVisual* gtk_widget_get_default_visual (); + + + + + + void gtk_widget_set_direction (GtkWidget *widget, + GtkTextDirection dir); + GtkTextDirection gtk_widget_get_direction (GtkWidget *widget); + + void gtk_widget_set_default_direction (GtkTextDirection dir); + GtkTextDirection gtk_widget_get_default_direction (); + + + + void gtk_widget_shape_combine_mask (GtkWidget *widget, + GdkBitmap *shape_mask, + gint offset_x, + gint offset_y); + + + void gtk_widget_reset_shapes (GtkWidget *widget); + + + + + void gtk_widget_path (GtkWidget *widget, + guint *path_length, + gchar **path, + gchar **path_reversed); + void gtk_widget_class_path (GtkWidget *widget, + guint *path_length, + gchar **path, + gchar **path_reversed); + + GList* gtk_widget_list_mnemonic_labels (GtkWidget *widget); + void gtk_widget_add_mnemonic_label (GtkWidget *widget, + GtkWidget *label); + void gtk_widget_remove_mnemonic_label (GtkWidget *widget, + GtkWidget *label); + + GType gtk_requisition_get_type (); + GtkRequisition *gtk_requisition_copy ( GtkRequisition *requisition); + void gtk_requisition_free (GtkRequisition *requisition); + + + + + + + void _gtk_widget_grab_notify (GtkWidget *widget, + gboolean was_grabbed); + + GtkWidgetAuxInfo *_gtk_widget_get_aux_info (GtkWidget *widget, + gboolean create); + void _gtk_widget_propagate_hierarchy_changed (GtkWidget *widget, + GtkWidget *previous_toplevel); + void _gtk_widget_propagate_screen_changed (GtkWidget *widget, + GdkScreen *previous_screen); + + GdkColormap* _gtk_widget_peek_colormap (); + alias _GtkMisc GtkMisc; + + alias _GtkMiscClass GtkMiscClass; + + + struct _GtkMisc { + GtkWidget widget; + + gfloat xalign; + gfloat yalign; + + guint16 xpad; + guint16 ypad; + } + + struct _GtkMiscClass { + GtkWidgetClass parent_class; + } + + + GType gtk_misc_get_type () ; + void gtk_misc_set_alignment (GtkMisc *misc, + gfloat xalign, + gfloat yalign); + void gtk_misc_get_alignment (GtkMisc *misc, + gfloat *xalign, + gfloat *yalign); + void gtk_misc_set_padding (GtkMisc *misc, + gint xpad, + gint ypad); + void gtk_misc_get_padding (GtkMisc *misc, + gint *xpad, + gint *ypad); + alias _GtkContainer GtkContainer; + + alias _GtkContainerClass GtkContainerClass; + + + struct _GtkContainer { + GtkWidget widget; + + GtkWidget *focus_child; + + guint border_width; + /* needs alignment work BVH + guint need_resize; + guint resize_mode; + guint reallocate_redraws; + guint has_focus_chain; + */ + } + + struct _GtkContainerClass { + GtkWidgetClass parent_class; + + void (*add) (GtkContainer *container, + GtkWidget *widget); + void (*remove) (GtkContainer *container, + GtkWidget *widget); + void (*check_resize) (GtkContainer *container); + void (*forall) (GtkContainer *container, + gboolean include_internals, + GtkCallback callback, + gpointer callback_data); + void (*set_focus_child) (GtkContainer *container, + GtkWidget *widget); + GType (*child_type) (GtkContainer *container); + gchar* (*composite_name) (GtkContainer *container, + GtkWidget *child); + void (*set_child_property) (GtkContainer *container, + GtkWidget *child, + guint property_id, + GValue *value, + GParamSpec *pspec); + void (*get_child_property) (GtkContainer *container, + GtkWidget *child, + guint property_id, + GValue *value, + GParamSpec *pspec); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + + GType gtk_container_get_type () ; + void gtk_container_set_border_width (GtkContainer *container, + guint border_width); + guint gtk_container_get_border_width (GtkContainer *container); + void gtk_container_add (GtkContainer *container, + GtkWidget *widget); + void gtk_container_remove (GtkContainer *container, + GtkWidget *widget); + + void gtk_container_set_resize_mode (GtkContainer *container, + GtkResizeMode resize_mode); + GtkResizeMode gtk_container_get_resize_mode (GtkContainer *container); + + void gtk_container_check_resize (GtkContainer *container); + + void gtk_container_foreach (GtkContainer *container, + GtkCallback callback, + gpointer callback_data); + + void gtk_container_foreach_full (GtkContainer *container, + GtkCallback callback, + GtkCallbackMarshal marshal, + gpointer callback_data, + GtkDestroyNotify notify); + + GList* gtk_container_get_children (GtkContainer *container); + + + + + + void gtk_container_propagate_expose (GtkContainer *container, + GtkWidget *child, + GdkEventExpose *event); + + void gtk_container_set_focus_chain (GtkContainer *container, + GList *focusable_widgets); + gboolean gtk_container_get_focus_chain (GtkContainer *container, + GList **focusable_widgets); + void gtk_container_unset_focus_chain (GtkContainer *container); + + + + void gtk_container_set_reallocate_redraws (GtkContainer *container, + gboolean needs_redraws); + void gtk_container_set_focus_child (GtkContainer *container, + GtkWidget *child); + void gtk_container_set_focus_vadjustment (GtkContainer *container, + GtkAdjustment *adjustment); + GtkAdjustment *gtk_container_get_focus_vadjustment (GtkContainer *container); + void gtk_container_set_focus_hadjustment (GtkContainer *container, + GtkAdjustment *adjustment); + GtkAdjustment *gtk_container_get_focus_hadjustment (GtkContainer *container); + + void gtk_container_resize_children (GtkContainer *container); + + GType gtk_container_child_type (GtkContainer *container); + + + void gtk_container_class_install_child_property (GtkContainerClass *cclass, + guint property_id, + GParamSpec *pspec); + GParamSpec* gtk_container_class_find_child_property (GObjectClass *cclass, + gchar *property_name); + GParamSpec** gtk_container_class_list_child_properties (GObjectClass *cclass, + guint *n_properties); + void gtk_container_add_with_properties (GtkContainer *container, + GtkWidget *widget, + gchar *first_prop_name, + ...); + void gtk_container_child_set (GtkContainer *container, + GtkWidget *child, + gchar *first_prop_name, + ...); + void gtk_container_child_get (GtkContainer *container, + GtkWidget *child, + gchar *first_prop_name, + ...); + void gtk_container_child_set_valist (GtkContainer *container, + GtkWidget *child, + gchar *first_property_name, + va_list var_args); + void gtk_container_child_get_valist (GtkContainer *container, + GtkWidget *child, + gchar *first_property_name, + va_list var_args); + void gtk_container_child_set_property (GtkContainer *container, + GtkWidget *child, + gchar *property_name, + GValue *value); + void gtk_container_child_get_property (GtkContainer *container, + GtkWidget *child, + gchar *property_name, + GValue *value); + + + + + + void gtk_container_forall (GtkContainer *container, + GtkCallback callback, + gpointer callback_data); + + + void _gtk_container_queue_resize (GtkContainer *container); + void _gtk_container_clear_resize_widgets (GtkContainer *container); + gchar* _gtk_container_child_composite_name (GtkContainer *container, + GtkWidget *child); + void _gtk_container_dequeue_resize_handler (GtkContainer *container); + GList *_gtk_container_focus_sort (GtkContainer *container, + GList *children, + GtkDirectionType direction, + GtkWidget *old_focus); + alias _GtkBin GtkBin; + + alias _GtkBinClass GtkBinClass; + + + struct _GtkBin { + GtkContainer container; + + GtkWidget *child; + } + + struct _GtkBinClass { + GtkContainerClass parent_class; + } + + + GType gtk_bin_get_type () ; + + GtkWidget *gtk_bin_get_child (GtkBin *bin); + alias _GtkWindow GtkWindow; + + alias _GtkWindowClass GtkWindowClass; + + alias _GtkWindowGeometryInfo GtkWindowGeometryInfo; + alias void _GtkWindowGeometryInfo; + + alias _GtkWindowGroup GtkWindowGroup; + + alias _GtkWindowGroupClass GtkWindowGroupClass; + + + struct _GtkWindow { + GtkBin bin; + + gchar *title; + gchar *wmclass_name; + gchar *wmclass_class; + gchar *wm_role; + + GtkWidget *focus_widget; + GtkWidget *default_widget; + GtkWindow *transient_parent; + GtkWindowGeometryInfo *geometry_info; + GdkWindow *frame; + GtkWindowGroup *group; + + guint16 configure_request_count; + guint allow_shrink; + guint allow_grow; + guint configure_notify_received; + + + + + + + guint need_default_position; + guint need_default_size; + guint position; + guint type; + guint has_user_ref_count; + guint has_focus; + + guint modal; + guint destroy_with_parent; + + guint has_frame; + + + guint iconify_initially; + guint stick_initially; + guint maximize_initially; + guint decorated; + + guint type_hint; + guint gravity; + + guint is_active; + guint has_toplevel_focus; + + guint frame_left; + guint frame_top; + guint frame_right; + guint frame_bottom; + + guint keys_changed_handler; + + GdkModifierType mnemonic_modifier; + GdkScreen *screen; + } + + struct _GtkWindowClass { + GtkBinClass parent_class; + + void (* set_focus) (GtkWindow *window, + GtkWidget *focus); + gboolean (* frame_event) (GtkWindow *window, + GdkEvent *event); + + + + void (* activate_focus) (GtkWindow *window); + void (* activate_default) (GtkWindow *window); + void (* move_focus) (GtkWindow *window, + GtkDirectionType direction); + + void (*keys_changed) (GtkWindow *window); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + struct _GtkWindowGroup { + GObject parent_instance; + + GSList *grabs; + } + + struct _GtkWindowGroupClass { + GObjectClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_window_get_type () ; + GtkWidget* gtk_window_new (GtkWindowType type); + void gtk_window_set_title (GtkWindow *window, + gchar *title); + gchar *gtk_window_get_title (GtkWindow *window); + void gtk_window_set_wmclass (GtkWindow *window, + gchar *wmclass_name, + gchar *wmclass_class); + void gtk_window_set_role (GtkWindow *window, + gchar *role); + gchar *gtk_window_get_role (GtkWindow *window); + void gtk_window_add_accel_group (GtkWindow *window, + GtkAccelGroup *accel_group); + void gtk_window_remove_accel_group (GtkWindow *window, + GtkAccelGroup *accel_group); + void gtk_window_set_position (GtkWindow *window, + GtkWindowPosition position); + gboolean gtk_window_activate_focus (GtkWindow *window); + void gtk_window_set_focus (GtkWindow *window, + GtkWidget *focus); + GtkWidget *gtk_window_get_focus (GtkWindow *window); + void gtk_window_set_default (GtkWindow *window, + GtkWidget *default_widget); + gboolean gtk_window_activate_default (GtkWindow *window); + + void gtk_window_set_transient_for (GtkWindow *window, + GtkWindow *parent); + GtkWindow *gtk_window_get_transient_for (GtkWindow *window); + void gtk_window_set_type_hint (GtkWindow *window, + GdkWindowTypeHint hint); + GdkWindowTypeHint gtk_window_get_type_hint (GtkWindow *window); + void gtk_window_set_skip_taskbar_hint (GtkWindow *window, + gboolean setting); + gboolean gtk_window_get_skip_taskbar_hint (GtkWindow *window); + void gtk_window_set_skip_pager_hint (GtkWindow *window, + gboolean setting); + gboolean gtk_window_get_skip_pager_hint (GtkWindow *window); + void gtk_window_set_accept_focus (GtkWindow *window, + gboolean setting); + gboolean gtk_window_get_accept_focus (GtkWindow *window); + void gtk_window_set_destroy_with_parent (GtkWindow *window, + gboolean setting); + gboolean gtk_window_get_destroy_with_parent (GtkWindow *window); + + void gtk_window_set_resizable (GtkWindow *window, + gboolean resizable); + gboolean gtk_window_get_resizable (GtkWindow *window); + + void gtk_window_set_gravity (GtkWindow *window, + GdkGravity gravity); + GdkGravity gtk_window_get_gravity (GtkWindow *window); + + + void gtk_window_set_geometry_hints (GtkWindow *window, + GtkWidget *geometry_widget, + GdkGeometry *geometry, + GdkWindowHints geom_mask); + + void gtk_window_set_screen (GtkWindow *window, + GdkScreen *screen); + GdkScreen* gtk_window_get_screen (GtkWindow *window); + + gboolean gtk_window_is_active (GtkWindow *window); + gboolean gtk_window_has_toplevel_focus (GtkWindow *window); + + + + + void gtk_window_set_has_frame (GtkWindow *window, + gboolean setting); + gboolean gtk_window_get_has_frame (GtkWindow *window); + void gtk_window_set_frame_dimensions (GtkWindow *window, + gint left, + gint top, + gint right, + gint bottom); + void gtk_window_get_frame_dimensions (GtkWindow *window, + gint *left, + gint *top, + gint *right, + gint *bottom); + void gtk_window_set_decorated (GtkWindow *window, + gboolean setting); + gboolean gtk_window_get_decorated (GtkWindow *window); + + void gtk_window_set_icon_list (GtkWindow *window, + GList *list); + GList* gtk_window_get_icon_list (GtkWindow *window); + void gtk_window_set_icon (GtkWindow *window, + GdkPixbuf *icon); + gboolean gtk_window_set_icon_from_file (GtkWindow *window, + gchar *filename, + GError **err); + GdkPixbuf* gtk_window_get_icon (GtkWindow *window); + void gtk_window_set_default_icon_list (GList *list); + GList* gtk_window_get_default_icon_list (); + void gtk_window_set_default_icon (GdkPixbuf *icon); + gboolean gtk_window_set_default_icon_from_file ( gchar *filename, + GError **err); + + void gtk_window_set_auto_startup_notification (gboolean setting); + + + void gtk_window_set_modal (GtkWindow *window, + gboolean modal); + gboolean gtk_window_get_modal (GtkWindow *window); + GList* gtk_window_list_toplevels (); + + void gtk_window_add_mnemonic (GtkWindow *window, + guint keyval, + GtkWidget *target); + void gtk_window_remove_mnemonic (GtkWindow *window, + guint keyval, + GtkWidget *target); + gboolean gtk_window_mnemonic_activate (GtkWindow *window, + guint keyval, + GdkModifierType modifier); + void gtk_window_set_mnemonic_modifier (GtkWindow *window, + GdkModifierType modifier); + GdkModifierType gtk_window_get_mnemonic_modifier (GtkWindow *window); + + gboolean gtk_window_activate_key (GtkWindow *window, + GdkEventKey *event); + gboolean gtk_window_propagate_key_event (GtkWindow *window, + GdkEventKey *event); + + void gtk_window_present (GtkWindow *window); + void gtk_window_iconify (GtkWindow *window); + void gtk_window_deiconify (GtkWindow *window); + void gtk_window_stick (GtkWindow *window); + void gtk_window_unstick (GtkWindow *window); + void gtk_window_maximize (GtkWindow *window); + void gtk_window_unmaximize (GtkWindow *window); + void gtk_window_fullscreen (GtkWindow *window); + void gtk_window_unfullscreen (GtkWindow *window); + void gtk_window_set_keep_above (GtkWindow *window, gboolean setting); + void gtk_window_set_keep_below (GtkWindow *window, gboolean setting); + + void gtk_window_begin_resize_drag (GtkWindow *window, + GdkWindowEdge edge, + gint button, + gint root_x, + gint root_y, + guint32 timestamp); + void gtk_window_begin_move_drag (GtkWindow *window, + gint button, + gint root_x, + gint root_y, + guint32 timestamp); + + + void gtk_window_set_policy (GtkWindow *window, + gint allow_shrink, + gint allow_grow, + gint auto_shrink); + + + + + + + void gtk_window_set_default_size (GtkWindow *window, + gint width, + gint height); + void gtk_window_get_default_size (GtkWindow *window, + gint *width, + gint *height); + void gtk_window_resize (GtkWindow *window, + gint width, + gint height); + void gtk_window_get_size (GtkWindow *window, + gint *width, + gint *height); + void gtk_window_move (GtkWindow *window, + gint x, + gint y); + void gtk_window_get_position (GtkWindow *window, + gint *root_x, + gint *root_y); + gboolean gtk_window_parse_geometry (GtkWindow *window, + gchar *geometry); + + + void gtk_window_reshow_with_initial_size (GtkWindow *window); + + + + GType gtk_window_group_get_type () ; + + GtkWindowGroup * gtk_window_group_new (); + void gtk_window_group_add_window (GtkWindowGroup *window_group, + GtkWindow *window); + void gtk_window_group_remove_window (GtkWindowGroup *window_group, + GtkWindow *window); + + + void _gtk_window_internal_set_focus (GtkWindow *window, + GtkWidget *focus); + void gtk_window_remove_embedded_xid (GtkWindow *window, + guint xid); + void gtk_window_add_embedded_xid (GtkWindow *window, + guint xid); + void _gtk_window_reposition (GtkWindow *window, + gint x, + gint y); + void _gtk_window_rain_size (GtkWindow *window, + gint width, + gint height, + gint *new_width, + gint *new_height); + GtkWindowGroup *_gtk_window_get_group (GtkWindow *window); + + void _gtk_window_set_has_toplevel_focus (GtkWindow *window, + gboolean has_toplevel_focus); + void _gtk_window_unset_focus_and_default (GtkWindow *window, + GtkWidget *widget); + + void _gtk_window_set_is_active (GtkWindow *window, + gboolean is_active); + + alias void (*GtkWindowKeysForeachFunc) (GtkWindow *window, + guint keyval, + GdkModifierType modifiers, + gboolean is_mnemonic, + gpointer data); + + void _gtk_window_keys_foreach (GtkWindow *window, + GtkWindowKeysForeachFunc func, + gpointer func_data); + + + gboolean _gtk_window_query_nonaccels (GtkWindow *window, + guint accel_key, + GdkModifierType accel_mods); + alias _GtkMenuShell GtkMenuShell; + + alias _GtkMenuShellClass GtkMenuShellClass; + + + struct _GtkMenuShell { + GtkContainer container; + + GList *children; + GtkWidget *active_menu_item; + GtkWidget *parent_menu_shell; + + guint button; + guint32 activate_time; + + guint active; + guint have_grab; + guint have_xgrab; + guint ignore_leave; + guint menu_flag; + guint ignore_enter; + } + + struct _GtkMenuShellClass { + GtkContainerClass parent_class; + + guint submenu_placement; + + void (*deactivate) (GtkMenuShell *menu_shell); + void (*selection_done) (GtkMenuShell *menu_shell); + + void (*move_current) (GtkMenuShell *menu_shell, + GtkMenuDirectionType direction); + void (*activate_current) (GtkMenuShell *menu_shell, + gboolean force_hide); + void (*cancel) (GtkMenuShell *menu_shell); + void (*select_item) (GtkMenuShell *menu_shell, + GtkWidget *menu_item); + void (*insert) (GtkMenuShell *menu_shell, + GtkWidget *child, + gint position); + gint (*get_popup_delay) (GtkMenuShell *menu_shell); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + } + + + GType gtk_menu_shell_get_type () ; + void gtk_menu_shell_append (GtkMenuShell *menu_shell, + GtkWidget *child); + void gtk_menu_shell_prepend (GtkMenuShell *menu_shell, + GtkWidget *child); + void gtk_menu_shell_insert (GtkMenuShell *menu_shell, + GtkWidget *child, + gint position); + void gtk_menu_shell_deactivate (GtkMenuShell *menu_shell); + void gtk_menu_shell_select_item (GtkMenuShell *menu_shell, + GtkWidget *menu_item); + void gtk_menu_shell_deselect (GtkMenuShell *menu_shell); + void gtk_menu_shell_activate_item (GtkMenuShell *menu_shell, + GtkWidget *menu_item, + gboolean force_deactivate); + void gtk_menu_shell_select_first (GtkMenuShell *menu_shell, + gboolean search_sensitive); + void _gtk_menu_shell_select_last (GtkMenuShell *menu_shell, + gboolean search_sensitive); + void _gtk_menu_shell_activate (GtkMenuShell *menu_shell); + gint _gtk_menu_shell_get_popup_delay (GtkMenuShell *menu_shell); + void gtk_menu_shell_cancel (GtkMenuShell *menu_shell); + alias _GtkMenu GtkMenu; + + alias _GtkMenuClass GtkMenuClass; + + + alias void (*GtkMenuPositionFunc) (GtkMenu *menu, + gint *x, + gint *y, + gboolean *push_in, + gpointer user_data); + alias void (*GtkMenuDetachFunc) (GtkWidget *attach_widget, + GtkMenu *menu); + + struct _GtkMenu { + GtkMenuShell menu_shell; + + GtkWidget *parent_menu_item; + GtkWidget *old_active_menu_item; + + GtkAccelGroup *accel_group; + gchar *accel_path; + GtkMenuPositionFunc position_func; + gpointer position_func_data; + + guint toggle_size; + + + + + GtkWidget *toplevel; + + GtkWidget *tearoff_window; + GtkWidget *tearoff_hbox; + GtkWidget *tearoff_scrollbar; + GtkAdjustment *tearoff_adjustment; + + GdkWindow *view_window; + GdkWindow *bin_window; + + gint scroll_offset; + gint saved_scroll_offset; + gint scroll_step; + guint timeout_id; + + + + + GdkRegion *navigation_region; + guint navigation_timeout; + + guint torn_off; + + + + guint tearoff_active; + + guint scroll_fast; + + guint upper_arrow_visible; + guint lower_arrow_visible; + guint upper_arrow_prelight; + guint lower_arrow_prelight; + } + + struct _GtkMenuClass { + GtkMenuShellClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_menu_get_type () ; + GtkWidget* gtk_menu_new (); + + + void gtk_menu_popup (GtkMenu *menu, + GtkWidget *parent_menu_shell, + GtkWidget *parent_menu_item, + GtkMenuPositionFunc func, + gpointer data, + guint button, + guint32 activate_time); + + + + + void gtk_menu_reposition (GtkMenu *menu); + + void gtk_menu_popdown (GtkMenu *menu); + + + + + GtkWidget* gtk_menu_get_active (GtkMenu *menu); + void gtk_menu_set_active (GtkMenu *menu, + guint index_); + + + + + void gtk_menu_set_accel_group (GtkMenu *menu, + GtkAccelGroup *accel_group); + GtkAccelGroup* gtk_menu_get_accel_group (GtkMenu *menu); + void gtk_menu_set_accel_path (GtkMenu *menu, + gchar *accel_path); + + + + + + void gtk_menu_attach_to_widget (GtkMenu *menu, + GtkWidget *attach_widget, + GtkMenuDetachFunc detacher); + void gtk_menu_detach (GtkMenu *menu); + + + + + + GtkWidget* gtk_menu_get_attach_widget (GtkMenu *menu); + + void gtk_menu_set_tearoff_state (GtkMenu *menu, + gboolean torn_off); + gboolean gtk_menu_get_tearoff_state (GtkMenu *menu); + + + + + void gtk_menu_set_title (GtkMenu *menu, + gchar *title); + gchar *gtk_menu_get_title (GtkMenu *menu); + + void gtk_menu_reorder_child (GtkMenu *menu, + GtkWidget *child, + gint position); + + void gtk_menu_set_screen (GtkMenu *menu, + GdkScreen *screen); + + void gtk_menu_attach (GtkMenu *menu, + GtkWidget *child, + guint left_attach, + guint right_attach, + guint top_attach, + guint bottom_attach); + + void gtk_menu_set_monitor (GtkMenu *menu, + gint monitor_num); + alias _GtkLabel GtkLabel; + + alias _GtkLabelClass GtkLabelClass; + + + alias _GtkLabelSelectionInfo GtkLabelSelectionInfo; + alias void _GtkLabelSelectionInfo; + + + struct _GtkLabel { + GtkMisc misc; + + + gchar *label; + guint jtype; + guint wrap; + guint use_underline; + guint use_markup; + + guint mnemonic_keyval; + + gchar *text; + PangoAttrList *attrs; + PangoAttrList *effective_attrs; + + PangoLayout *layout; + + GtkWidget *mnemonic_widget; + GtkWindow *mnemonic_window; + + GtkLabelSelectionInfo *select_info; + } + + struct _GtkLabelClass { + GtkMiscClass parent_class; + + void (* move_cursor) (GtkLabel *label, + GtkMovementStep step, + gint count, + gboolean extend_selection); + void (* copy_clipboard) (GtkLabel *label); + + + void (* populate_popup) (GtkLabel *label, + GtkMenu *menu); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_label_get_type () ; + GtkWidget* gtk_label_new ( char *str); + GtkWidget* gtk_label_new_with_mnemonic ( char *str); + void gtk_label_set_text (GtkLabel *label, + char *str); + gchar* gtk_label_get_text (GtkLabel *label); + void gtk_label_set_attributes (GtkLabel *label, + PangoAttrList *attrs); + PangoAttrList *gtk_label_get_attributes (GtkLabel *label); + void gtk_label_set_label (GtkLabel *label, + gchar *str); + gchar *gtk_label_get_label (GtkLabel *label); + void gtk_label_set_markup (GtkLabel *label, + gchar *str); + void gtk_label_set_use_markup (GtkLabel *label, + gboolean setting); + gboolean gtk_label_get_use_markup (GtkLabel *label); + void gtk_label_set_use_underline (GtkLabel *label, + gboolean setting); + gboolean gtk_label_get_use_underline (GtkLabel *label); + + void gtk_label_set_markup_with_mnemonic (GtkLabel *label, + gchar *str); + guint gtk_label_get_mnemonic_keyval (GtkLabel *label); + void gtk_label_set_mnemonic_widget (GtkLabel *label, + GtkWidget *widget); + GtkWidget *gtk_label_get_mnemonic_widget (GtkLabel *label); + void gtk_label_set_text_with_mnemonic (GtkLabel *label, + gchar *str); + void gtk_label_set_justify (GtkLabel *label, + GtkJustification jtype); + GtkJustification gtk_label_get_justify (GtkLabel *label); + void gtk_label_set_pattern (GtkLabel *label, + gchar *pattern); + void gtk_label_set_line_wrap (GtkLabel *label, + gboolean wrap); + gboolean gtk_label_get_line_wrap (GtkLabel *label); + void gtk_label_set_selectable (GtkLabel *label, + gboolean setting); + gboolean gtk_label_get_selectable (GtkLabel *label); + void gtk_label_select_region (GtkLabel *label, + gint start_offset, + gint end_offset); + gboolean gtk_label_get_selection_bounds (GtkLabel *label, + gint *start, + gint *end); + + PangoLayout *gtk_label_get_layout (GtkLabel *label); + void gtk_label_get_layout_offsets (GtkLabel *label, + gint *x, + gint *y); + + + + + + void gtk_label_get (GtkLabel *label, + char **str); + + + + + + guint gtk_label_parse_uline (GtkLabel *label, + gchar *string); + alias _GtkAccelLabel GtkAccelLabel; + + alias _GtkAccelLabelClass GtkAccelLabelClass; + + + struct _GtkAccelLabel { + GtkLabel label; + + guint gtk_reserved; + guint accel_padding; + GtkWidget *accel_widget; + GClosure *accel_closure; + GtkAccelGroup *accel_group; + gchar *accel_string; + guint16 accel_string_width; + } + + struct _GtkAccelLabelClass { + GtkLabelClass parent_class; + + gchar *signal_quote1; + gchar *signal_quote2; + gchar *mod_name_shift; + gchar *mod_name_control; + gchar *mod_name_alt; + gchar *mod_separator; + gchar *accel_seperator; + guint latin1_to_char; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + + + + GType gtk_accel_label_get_type () ; + GtkWidget* gtk_accel_label_new ( gchar *string); + GtkWidget* gtk_accel_label_get_accel_widget (GtkAccelLabel *accel_label); + guint gtk_accel_label_get_accel_width (GtkAccelLabel *accel_label); + void gtk_accel_label_set_accel_widget (GtkAccelLabel *accel_label, + GtkWidget *accel_widget); + void gtk_accel_label_set_accel_closure (GtkAccelLabel *accel_label, + GClosure *accel_closure); + gboolean gtk_accel_label_refetch (GtkAccelLabel *accel_label); + + alias _GtkAccelMap GtkAccelMap; + alias void _GtkAccelMap; + + alias _GtkAccelMapClass GtkAccelMapClass; + alias void _GtkAccelMapClass; + + alias void (*GtkAccelMapForeach) (gpointer data, + gchar *accel_path, + guint accel_key, + GdkModifierType accel_mods, + gboolean changed); + + + + void gtk_accel_map_add_entry ( gchar *accel_path, + guint accel_key, + GdkModifierType accel_mods); + gboolean gtk_accel_map_lookup_entry ( gchar *accel_path, + GtkAccelKey *key); + gboolean gtk_accel_map_change_entry ( gchar *accel_path, + guint accel_key, + GdkModifierType accel_mods, + gboolean replace); + void gtk_accel_map_load ( gchar *file_name); + void gtk_accel_map_save ( gchar *file_name); + void gtk_accel_map_foreach (gpointer data, + GtkAccelMapForeach foreach_func); + void gtk_accel_map_load_fd (gint fd); + void gtk_accel_map_load_scanner (GScanner *scanner); + void gtk_accel_map_save_fd (gint fd); + + void gtk_accel_map_lock_path ( gchar *accel_path); + void gtk_accel_map_unlock_path ( gchar *accel_path); + + + void gtk_accel_map_add_filter ( gchar *filter_pattern); + void gtk_accel_map_foreach_unfiltered (gpointer data, + GtkAccelMapForeach foreach_func); + + + GType gtk_accel_map_get_type (); + GtkAccelMap *gtk_accel_map_get (); + + + + void _gtk_accel_map_init (); + + void _gtk_accel_map_add_group ( gchar *accel_path, + GtkAccelGroup *accel_group); + void _gtk_accel_map_remove_group ( gchar *accel_path, + GtkAccelGroup *accel_group); + gboolean _gtk_accel_path_is_valid ( gchar *accel_path); + + + + alias _AtkAction AtkAction; + alias void _AtkAction; + + + alias _AtkActionIface AtkActionIface; + + + struct _AtkActionIface { + GTypeInterface parent; + + gboolean (*do_action) (AtkAction *action, + gint i); + gint (*get_n_actions) (AtkAction *action); + gchar* (*get_description) (AtkAction *action, + gint i); + gchar* (*get_name) (AtkAction *action, + gint i); + gchar* (*get_keybinding) (AtkAction *action, + gint i); + gboolean (*set_description) (AtkAction *action, + gint i, + gchar *desc); + gchar* (*get_localized_name)(AtkAction *action, + gint i); + AtkFunction pad2; + } + + GType atk_action_get_type (); + gboolean atk_action_do_action (AtkAction *action, + gint i); + gint atk_action_get_n_actions (AtkAction *action); + gchar* atk_action_get_description (AtkAction *action, + gint i); + gchar* atk_action_get_name (AtkAction *action, + gint i); + gchar* atk_action_get_keybinding (AtkAction *action, + gint i); + gboolean atk_action_set_description (AtkAction *action, + gint i, + gchar *desc); + + + + gchar* atk_action_get_localized_name (AtkAction *action, + gint i); + alias _AtkUtil AtkUtil; + + alias _AtkUtilClass AtkUtilClass; + + alias _AtkKeyEventStruct AtkKeyEventStruct; + + + + + + + + alias void (*AtkEventListener) (AtkObject*); + alias void (*AtkEventListenerInit) (); + alias gint (*AtkKeySnoopFunc) (AtkKeyEventStruct *event, + gpointer func_data); + + struct _AtkKeyEventStruct { + gint type; + guint state; + guint keyval; + gint length; + gchar *string; + guint16 keycode; + guint32 timestamp; + } + enum AtkKeyEventType { + ATK_KEY_EVENT_PRESS, + ATK_KEY_EVENT_RELEASE, + ATK_KEY_EVENT_LAST_DEFINED + }; + + + struct _AtkUtil { + GObject parent; + } + + struct _AtkUtilClass { + GObjectClass parent; + guint (* add_global_event_listener) (GSignalEmissionHook listener, + gchar *event_type); + void (* remove_global_event_listener) (guint listener_id); + guint (* add_key_event_listener) (AtkKeySnoopFunc listener, + gpointer data); + void (* remove_key_event_listener) (guint listener_id); + AtkObject* (* get_root) (); + gchar* (* get_toolkit_name) (); + gchar* (* get_toolkit_version) (); + } + GType atk_util_get_type (); + enum AtkCoordType { + ATK_XY_SCREEN, + ATK_XY_WINDOW + }; + + + + + + + guint atk_add_focus_tracker (AtkEventListener focus_tracker); + + + + + + void atk_remove_focus_tracker (guint tracker_id); + + + + + + + + void atk_focus_tracker_init (AtkEventListenerInit add_function); + + + + + + void atk_focus_tracker_notify (AtkObject *object); + + + + + + guint atk_add_global_event_listener (GSignalEmissionHook listener, + gchar *event_type); + + + + + void atk_remove_global_event_listener (guint listener_id); + + + + + + guint atk_add_key_event_listener (AtkKeySnoopFunc listener, gpointer data); + + + + + void atk_remove_key_event_listener (guint listener_id); + + + + + AtkObject* atk_get_root(); + + AtkObject* atk_get_focus_object (); + + + + + gchar *atk_get_toolkit_name (); + + + + + gchar *atk_get_toolkit_version (); + alias _AtkComponent AtkComponent; + alias void _AtkComponent; + + + alias _AtkComponentIface AtkComponentIface; + + + alias void (*AtkFocusHandler) (AtkObject*, gboolean); + + + struct _AtkComponentIface { + GTypeInterface parent; + + guint (* add_focus_handler) (AtkComponent *component, + AtkFocusHandler handler); + + gboolean (* contains) (AtkComponent *component, + gint x, + gint y, + AtkCoordType coord_type); + + AtkObject* (* ref_accessible_at_point) (AtkComponent *component, + gint x, + gint y, + AtkCoordType coord_type); + void (* get_extents) (AtkComponent *component, + gint *x, + gint *y, + gint *width, + gint *height, + AtkCoordType coord_type); + void (* get_position) (AtkComponent *component, + gint *x, + gint *y, + AtkCoordType coord_type); + void (* get_size) (AtkComponent *component, + gint *width, + gint *height); + gboolean (* grab_focus) (AtkComponent *component); + void (* remove_focus_handler) (AtkComponent *component, + guint handler_id); + gboolean (* set_extents) (AtkComponent *component, + gint x, + gint y, + gint width, + gint height, + AtkCoordType coord_type); + gboolean (* set_position) (AtkComponent *component, + gint x, + gint y, + AtkCoordType coord_type); + gboolean (* set_size) (AtkComponent *component, + gint width, + gint height); + + AtkLayer (* get_layer) (AtkComponent *component); + gint (* get_mdi_zorder) (AtkComponent *component); + + AtkFunction pad1; + AtkFunction pad2; + } + + GType atk_component_get_type (); + + + + guint atk_component_add_focus_handler (AtkComponent *component, + AtkFocusHandler handler); + gboolean atk_component_contains (AtkComponent *component, + gint x, + gint y, + AtkCoordType coord_type); + AtkObject* atk_component_ref_accessible_at_point(AtkComponent *component, + gint x, + gint y, + AtkCoordType coord_type); + void atk_component_get_extents (AtkComponent *component, + gint *x, + gint *y, + gint *width, + gint *height, + AtkCoordType coord_type); + void atk_component_get_position (AtkComponent *component, + gint *x, + gint *y, + AtkCoordType coord_type); + void atk_component_get_size (AtkComponent *component, + gint *width, + gint *height); + AtkLayer atk_component_get_layer (AtkComponent *component); + gint atk_component_get_mdi_zorder (AtkComponent *component); + gboolean atk_component_grab_focus (AtkComponent *component); + void atk_component_remove_focus_handler (AtkComponent *component, + guint handler_id); + gboolean atk_component_set_extents (AtkComponent *component, + gint x, + gint y, + gint width, + gint height, + AtkCoordType coord_type); + gboolean atk_component_set_position (AtkComponent *component, + gint x, + gint y, + AtkCoordType coord_type); + gboolean atk_component_set_size (AtkComponent *component, + gint width, + gint height); + alias _AtkDocument AtkDocument; + alias void _AtkDocument; + + + alias _AtkDocumentIface AtkDocumentIface; + + + struct _AtkDocumentIface { + GTypeInterface parent; + gchar* ( *get_document_type) (AtkDocument *document); + gpointer ( *get_document) (AtkDocument *document); + + AtkFunction pad1; + AtkFunction pad2; + AtkFunction pad3; + AtkFunction pad4; + AtkFunction pad5; + AtkFunction pad6; + AtkFunction pad7; + AtkFunction pad8; + } + + GType atk_document_get_type (); + + gchar* atk_document_get_document_type (AtkDocument *document); + gpointer atk_document_get_document (AtkDocument *document); + alias GSList AtkAttributeSet; + alias _AtkAttribute AtkAttribute; + + + struct _AtkAttribute { + gchar* name; + gchar* value; + } + enum AtkTextAttribute { + ATK_TEXT_ATTR_INVALID = 0, + ATK_TEXT_ATTR_LEFT_MARGIN, + ATK_TEXT_ATTR_RIGHT_MARGIN, + ATK_TEXT_ATTR_INDENT, + ATK_TEXT_ATTR_INVISIBLE, + ATK_TEXT_ATTR_EDITABLE, + ATK_TEXT_ATTR_PIXELS_ABOVE_LINES, + ATK_TEXT_ATTR_PIXELS_BELOW_LINES, + ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP, + ATK_TEXT_ATTR_BG_FULL_HEIGHT, + ATK_TEXT_ATTR_RISE, + ATK_TEXT_ATTR_UNDERLINE, + ATK_TEXT_ATTR_STRIKETHROUGH, + ATK_TEXT_ATTR_SIZE, + ATK_TEXT_ATTR_SCALE, + ATK_TEXT_ATTR_WEIGHT, + ATK_TEXT_ATTR_LANGUAGE, + ATK_TEXT_ATTR_FAMILY_NAME, + ATK_TEXT_ATTR_BG_COLOR, + ATK_TEXT_ATTR_FG_COLOR, + ATK_TEXT_ATTR_BG_STIPPLE, + ATK_TEXT_ATTR_FG_STIPPLE, + ATK_TEXT_ATTR_WRAP_MODE, + ATK_TEXT_ATTR_DIRECTION, + ATK_TEXT_ATTR_JUSTIFICATION, + ATK_TEXT_ATTR_STRETCH, + ATK_TEXT_ATTR_VARIANT, + ATK_TEXT_ATTR_STYLE, + ATK_TEXT_ATTR_LAST_DEFINED + }; + + + AtkTextAttribute atk_text_attribute_register ( gchar *name); + alias _AtkText AtkText; + alias void _AtkText; + + + alias _AtkTextIface AtkTextIface; + + enum AtkTextBoundary { + ATK_TEXT_BOUNDARY_CHAR, + ATK_TEXT_BOUNDARY_WORD_START, + ATK_TEXT_BOUNDARY_WORD_END, + ATK_TEXT_BOUNDARY_SENTENCE_START, + ATK_TEXT_BOUNDARY_SENTENCE_END, + ATK_TEXT_BOUNDARY_LINE_START, + ATK_TEXT_BOUNDARY_LINE_END + }; + + alias _AtkTextRectangle AtkTextRectangle; + + + struct _AtkTextRectangle { + gint x; + gint y; + gint width; + gint height; + } + alias _AtkTextRange AtkTextRange; + + + struct _AtkTextRange { + AtkTextRectangle bounds; + gint start_offset; + gint end_offset; + gchar* content; + } + enum AtkTextClipType { + ATK_TEXT_CLIP_NONE, + ATK_TEXT_CLIP_MIN, + ATK_TEXT_CLIP_MAX, + ATK_TEXT_CLIP_BOTH + }; + + + struct _AtkTextIface { + GTypeInterface parent; + + gchar* (* get_text) (AtkText *text, + gint start_offset, + gint end_offset); + gchar* (* get_text_after_offset) (AtkText *text, + gint offset, + AtkTextBoundary boundary_type, + gint *start_offset, + gint *end_offset); + gchar* (* get_text_at_offset) (AtkText *text, + gint offset, + AtkTextBoundary boundary_type, + gint *start_offset, + gint *end_offset); + gunichar (* get_character_at_offset) (AtkText *text, + gint offset); + gchar* (* get_text_before_offset) (AtkText *text, + gint offset, + AtkTextBoundary boundary_type, + gint *start_offset, + gint *end_offset); + gint (* get_caret_offset) (AtkText *text); + AtkAttributeSet* (* get_run_attributes) (AtkText *text, + gint offset, + gint *start_offset, + gint *end_offset); + AtkAttributeSet* (* get_default_attributes) (AtkText *text); + void (* get_character_extents) (AtkText *text, + gint offset, + gint *x, + gint *y, + gint *width, + gint *height, + AtkCoordType coords); + gint (* get_character_count) (AtkText *text); + gint (* get_offset_at_point) (AtkText *text, + gint x, + gint y, + AtkCoordType coords); + gint (* get_n_selections) (AtkText *text); + gchar* (* get_selection) (AtkText *text, + gint selection_num, + gint *start_offset, + gint *end_offset); + gboolean (* add_selection) (AtkText *text, + gint start_offset, + gint end_offset); + gboolean (* remove_selection) (AtkText *text, + gint selection_num); + gboolean (* set_selection) (AtkText *text, + gint selection_num, + gint start_offset, + gint end_offset); + gboolean (* set_caret_offset) (AtkText *text, + gint offset); + + + + + void (* text_changed) (AtkText *text, + gint position, + gint length); + void (* text_caret_moved) (AtkText *text, + gint location); + void (* text_selection_changed) (AtkText *text); + + void (* text_attributes_changed) (AtkText *text); + + + void (* get_range_extents) (AtkText *text, + gint start_offset, + gint end_offset, + AtkCoordType coord_type, + AtkTextRectangle *rect); + + AtkTextRange** (* get_bounded_ranges) (AtkText *text, + AtkTextRectangle *rect, + AtkCoordType coord_type, + AtkTextClipType x_clip_type, + AtkTextClipType y_clip_type); + + + AtkFunction pad4; + } + + GType atk_text_get_type (); + gchar* atk_text_get_text (AtkText *text, + gint start_offset, + gint end_offset); + gunichar atk_text_get_character_at_offset (AtkText *text, + gint offset); + gchar* atk_text_get_text_after_offset (AtkText *text, + gint offset, + AtkTextBoundary boundary_type, + gint *start_offset, + gint *end_offset); + gchar* atk_text_get_text_at_offset (AtkText *text, + gint offset, + AtkTextBoundary boundary_type, + gint *start_offset, + gint *end_offset); + gchar* atk_text_get_text_before_offset (AtkText *text, + gint offset, + AtkTextBoundary boundary_type, + gint *start_offset, + gint *end_offset); + gint atk_text_get_caret_offset (AtkText *text); + void atk_text_get_character_extents (AtkText *text, + gint offset, + gint *x, + gint *y, + gint *width, + gint *height, + AtkCoordType coords); + AtkAttributeSet* atk_text_get_run_attributes (AtkText *text, + gint offset, + gint *start_offset, + gint *end_offset); + AtkAttributeSet* atk_text_get_default_attributes (AtkText *text); + gint atk_text_get_character_count (AtkText *text); + gint atk_text_get_offset_at_point (AtkText *text, + gint x, + gint y, + AtkCoordType coords); + gint atk_text_get_n_selections (AtkText *text); + gchar* atk_text_get_selection (AtkText *text, + gint selection_num, + gint *start_offset, + gint *end_offset); + gboolean atk_text_add_selection (AtkText *text, + gint start_offset, + gint end_offset); + gboolean atk_text_remove_selection (AtkText *text, + gint selection_num); + gboolean atk_text_set_selection (AtkText *text, + gint selection_num, + gint start_offset, + gint end_offset); + gboolean atk_text_set_caret_offset (AtkText *text, + gint offset); + void atk_text_get_range_extents (AtkText *text, + + gint start_offset, + gint end_offset, + AtkCoordType coord_type, + AtkTextRectangle *rect); + AtkTextRange** atk_text_get_bounded_ranges (AtkText *text, + AtkTextRectangle *rect, + AtkCoordType coord_type, + AtkTextClipType x_clip_type, + AtkTextClipType y_clip_type); + void atk_text_free_ranges (AtkTextRange **ranges); + void atk_attribute_set_free (AtkAttributeSet *attrib_set); + gchar* atk_text_attribute_get_name (AtkTextAttribute attr); + AtkTextAttribute atk_text_attribute_for_name ( gchar *name); + gchar* atk_text_attribute_get_value (AtkTextAttribute attr, + gint index_); + alias _AtkEditableText AtkEditableText; + alias void _AtkEditableText; + + + alias _AtkEditableTextIface AtkEditableTextIface; + + + struct _AtkEditableTextIface { + GTypeInterface parent_interface; + + gboolean (* set_run_attributes) (AtkEditableText *text, + AtkAttributeSet *attrib_set, + gint start_offset, + gint end_offset); + void (* set_text_contents) (AtkEditableText *text, + gchar *string); + void (* insert_text) (AtkEditableText *text, + gchar *string, + gint length, + gint *position); + void (* copy_text) (AtkEditableText *text, + gint start_pos, + gint end_pos); + void (* cut_text) (AtkEditableText *text, + gint start_pos, + gint end_pos); + void (* delete_text) (AtkEditableText *text, + gint start_pos, + gint end_pos); + void (* paste_text) (AtkEditableText *text, + gint position); + + AtkFunction pad1; + AtkFunction pad2; + } + GType atk_editable_text_get_type (); + + + gboolean atk_editable_text_set_run_attributes (AtkEditableText *text, + AtkAttributeSet *attrib_set, + gint start_offset, + gint end_offset); + void atk_editable_text_set_text_contents (AtkEditableText *text, + gchar *string); + void atk_editable_text_insert_text (AtkEditableText *text, + gchar *string, + gint length, + gint *position); + void atk_editable_text_copy_text (AtkEditableText *text, + gint start_pos, + gint end_pos); + void atk_editable_text_cut_text (AtkEditableText *text, + gint start_pos, + gint end_pos); + void atk_editable_text_delete_text (AtkEditableText *text, + gint start_pos, + gint end_pos); + void atk_editable_text_paste_text (AtkEditableText *text, + gint position); + alias _AtkGObjectAccessible AtkGObjectAccessible; + + alias _AtkGObjectAccessibleClass AtkGObjectAccessibleClass; + + + struct _AtkGObjectAccessible { + AtkObject parent; + } + + GType atk_gobject_accessible_get_type (); + + struct _AtkGObjectAccessibleClass { + AtkObjectClass parent_class; + + AtkFunction pad1; + AtkFunction pad2; + } + + AtkObject *atk_gobject_accessible_for_object (GObject *obj); + GObject *atk_gobject_accessible_get_object (AtkGObjectAccessible *obj); + enum AtkHyperlinkStateFlags { + ATK_HYPERLINK_IS_INLINE = 1 << 0 + }; + + alias _AtkHyperlink AtkHyperlink; + + alias _AtkHyperlinkClass AtkHyperlinkClass; + + + struct _AtkHyperlink { + GObject parent; + } + + struct _AtkHyperlinkClass { + GObjectClass parent; + + gchar* (* get_uri) (AtkHyperlink *link_, + gint i); + AtkObject* (* get_object) (AtkHyperlink *link_, + gint i); + gint (* get_end_index) (AtkHyperlink *link_); + gint (* get_start_index) (AtkHyperlink *link_); + gboolean (* is_valid) (AtkHyperlink *link_); + gint (* get_n_anchors) (AtkHyperlink *link_); + guint (* link_state) (AtkHyperlink *link_); + gboolean (* is_selected_link) (AtkHyperlink *link_); + + + void ( *link_activated) (AtkHyperlink *link_); + AtkFunction pad1; + } + + GType atk_hyperlink_get_type (); + + gchar* atk_hyperlink_get_uri (AtkHyperlink *link_, + gint i); + + AtkObject* atk_hyperlink_get_object (AtkHyperlink *link_, + gint i); + + gint atk_hyperlink_get_end_index (AtkHyperlink *link_); + + gint atk_hyperlink_get_start_index (AtkHyperlink *link_); + + gboolean atk_hyperlink_is_valid (AtkHyperlink *link_); + + gboolean atk_hyperlink_is_inline (AtkHyperlink *link_); + + gint atk_hyperlink_get_n_anchors (AtkHyperlink *link_); + gboolean atk_hyperlink_is_selected_link (AtkHyperlink *link_); + alias _AtkHypertext AtkHypertext; + alias void _AtkHypertext; + + + alias _AtkHypertextIface AtkHypertextIface; + + + struct _AtkHypertextIface { + GTypeInterface parent; + + AtkHyperlink*(* get_link) (AtkHypertext *hypertext, + gint link_index); + gint (* get_n_links) (AtkHypertext *hypertext); + gint (* get_link_index) (AtkHypertext *hypertext, + gint char_index); + + + + + void (* link_selected) (AtkHypertext *hypertext, + gint link_index); + + AtkFunction pad1; + AtkFunction pad2; + AtkFunction pad3; + } + GType atk_hypertext_get_type (); + + AtkHyperlink* atk_hypertext_get_link (AtkHypertext *hypertext, + gint link_index); + gint atk_hypertext_get_n_links (AtkHypertext *hypertext); + gint atk_hypertext_get_link_index (AtkHypertext *hypertext, + gint char_index); + alias _AtkImage AtkImage; + alias void _AtkImage; + + + alias _AtkImageIface AtkImageIface; + + + struct _AtkImageIface { + GTypeInterface parent; + void ( *get_image_position) (AtkImage *image, + gint *x, + gint *y, + AtkCoordType coord_type); + gchar* ( *get_image_description) (AtkImage *image); + void ( *get_image_size) (AtkImage *image, + gint *width, + gint *height); + gboolean ( *set_image_description) (AtkImage *image, + gchar *description); + + AtkFunction pad1; + AtkFunction pad2; + } + + GType atk_image_get_type (); + + gchar* atk_image_get_image_description (AtkImage *image); + + void atk_image_get_image_size (AtkImage *image, + gint *width, + gint *height); + + gboolean atk_image_set_image_description (AtkImage *image, + gchar *description); + void atk_image_get_image_position (AtkImage *image, + gint *x, + gint *y, + AtkCoordType coord_type); + + alias _AtkNoOpObject AtkNoOpObject; + + alias _AtkNoOpObjectClass AtkNoOpObjectClass; + + + struct _AtkNoOpObject { + AtkObject parent; + } + + GType atk_no_op_object_get_type (); + + struct _AtkNoOpObjectClass { + AtkObjectClass parent_class; + } + + AtkObject *atk_no_op_object_new (GObject *obj); + + + alias _AtkObjectFactory AtkObjectFactory; + + alias _AtkObjectFactoryClass AtkObjectFactoryClass; + + + struct _AtkObjectFactory { + GObject parent; + } + + struct _AtkObjectFactoryClass { + GObjectClass parent_class; + + AtkObject* (* create_accessible) (GObject *obj); + void (* invalidate) (AtkObjectFactory *factory); + GType (* get_accessible_type) (); + + AtkFunction pad1; + AtkFunction pad2; + } + + GType atk_object_factory_get_type(); + + AtkObject* atk_object_factory_create_accessible (AtkObjectFactory *factory, GObject *obj); + void atk_object_factory_invalidate (AtkObjectFactory *factory); + GType atk_object_factory_get_accessible_type (AtkObjectFactory *factory); + alias _AtkNoOpObjectFactory AtkNoOpObjectFactory; + + alias _AtkNoOpObjectFactoryClass AtkNoOpObjectFactoryClass; + + + struct _AtkNoOpObjectFactory { + AtkObjectFactory parent; + } + + struct _AtkNoOpObjectFactoryClass { + AtkObjectFactoryClass parent_class; + } + + GType atk_no_op_object_factory_get_type(); + + AtkObjectFactory *atk_no_op_object_factory_new(); + + struct _AtkRegistry { + GObject parent; + GHashTable *factory_type_registry; + GHashTable *factory_singleton_cache; + } + + struct _AtkRegistryClass { + GObjectClass parent_class; + } + + alias _AtkRegistry AtkRegistry; + + alias _AtkRegistryClass AtkRegistryClass; + + + + GType atk_registry_get_type (); + void atk_registry_set_factory_type (AtkRegistry *registry, + GType type, + GType factory_type); + GType atk_registry_get_factory_type (AtkRegistry *registry, + GType type); + AtkObjectFactory* atk_registry_get_factory (AtkRegistry *registry, + GType type); + + AtkRegistry* atk_get_default_registry (); + alias _AtkRelation AtkRelation; + + alias _AtkRelationClass AtkRelationClass; + + + struct _AtkRelation { + GObject parent; + + GPtrArray *target; + AtkRelationType relationship; + } + + struct _AtkRelationClass { + GObjectClass parent; + } + + GType atk_relation_get_type (); + + AtkRelationType atk_relation_type_register ( gchar *name); + gchar* atk_relation_type_get_name (AtkRelationType type); + AtkRelationType atk_relation_type_for_name ( gchar *name); + + + + + + AtkRelation* atk_relation_new (AtkObject **targets, + gint n_targets, + AtkRelationType relationship); + + + + AtkRelationType atk_relation_get_relation_type (AtkRelation *relation); + + + + GPtrArray* atk_relation_get_target (AtkRelation *relation); + alias _AtkRelationSetClass AtkRelationSetClass; + + + + struct _AtkRelationSet { + GObject parent; + + GPtrArray *relations; + } + + struct _AtkRelationSetClass { + GObjectClass parent; + + AtkFunction pad1; + AtkFunction pad2; + } + + GType atk_relation_set_get_type (); + + AtkRelationSet* atk_relation_set_new (); + gboolean atk_relation_set_contains (AtkRelationSet *set, + AtkRelationType relationship); + void atk_relation_set_remove (AtkRelationSet *set, + AtkRelation *relation); + void atk_relation_set_add (AtkRelationSet *set, + AtkRelation *relation); + gint atk_relation_set_get_n_relations (AtkRelationSet *set); + AtkRelation* atk_relation_set_get_relation (AtkRelationSet *set, + gint i); + AtkRelation* atk_relation_set_get_relation_by_type (AtkRelationSet *set, + AtkRelationType relationship); + + alias _AtkSelection AtkSelection; + alias void _AtkSelection; + + + alias _AtkSelectionIface AtkSelectionIface; + + + struct _AtkSelectionIface { + GTypeInterface parent; + + gboolean (* add_selection) (AtkSelection *selection, + gint i); + gboolean (* clear_selection) (AtkSelection *selection); + AtkObject* (* ref_selection) (AtkSelection *selection, + gint i); + gint (* get_selection_count) (AtkSelection *selection); + gboolean (* is_child_selected) (AtkSelection *selection, + gint i); + gboolean (* remove_selection) (AtkSelection *selection, + gint i); + gboolean (* select_all_selection) (AtkSelection *selection); + + + + void (*selection_changed) (AtkSelection *selection); + + AtkFunction pad1; + AtkFunction pad2; + } + + GType atk_selection_get_type (); + + gboolean atk_selection_add_selection (AtkSelection *selection, + gint i); + + gboolean atk_selection_clear_selection (AtkSelection *selection); + + AtkObject* atk_selection_ref_selection (AtkSelection *selection, + gint i); + + gint atk_selection_get_selection_count (AtkSelection *selection); + + gboolean atk_selection_is_child_selected (AtkSelection *selection, + gint i); + + gboolean atk_selection_remove_selection (AtkSelection *selection, + gint i); + + gboolean atk_selection_select_all_selection (AtkSelection *selection); + + alias _AtkStateSetClass AtkStateSetClass; + + + + struct _AtkStateSet { + GObject parent; + + } + + struct _AtkStateSetClass { + GObjectClass parent; + } + + GType atk_state_set_get_type (); + + AtkStateSet* atk_state_set_new (); + gboolean atk_state_set_is_empty (AtkStateSet *set); + gboolean atk_state_set_add_state (AtkStateSet *set, + AtkStateType type); + void atk_state_set_add_states (AtkStateSet *set, + AtkStateType *types, + gint n_types); + void atk_state_set_clear_states (AtkStateSet *set); + gboolean atk_state_set_contains_state (AtkStateSet *set, + AtkStateType type); + gboolean atk_state_set_contains_states (AtkStateSet *set, + AtkStateType *types, + gint n_types); + gboolean atk_state_set_remove_state (AtkStateSet *set, + AtkStateType type); + AtkStateSet* atk_state_set_and_sets (AtkStateSet *set, + AtkStateSet *compare_set); + AtkStateSet* atk_state_set_or_sets (AtkStateSet *set, + AtkStateSet *compare_set); + AtkStateSet* atk_state_set_xor_sets (AtkStateSet *set, + AtkStateSet *compare_set); + alias _AtkStreamableContent AtkStreamableContent; + alias void _AtkStreamableContent; + + + alias _AtkStreamableContentIface AtkStreamableContentIface; + + + struct _AtkStreamableContentIface { + GTypeInterface parent; + + + + + gint (* get_n_mime_types) (AtkStreamableContent *streamable); + gchar* (* get_mime_type) (AtkStreamableContent *streamable, + gint i); + + + + + + + GIOChannel* (* get_stream) (AtkStreamableContent *streamable, + gchar *mime_type); + + AtkFunction pad1; + AtkFunction pad2; + AtkFunction pad3; + AtkFunction pad4; + } + GType atk_streamable_content_get_type (); + + gint atk_streamable_content_get_n_mime_types (AtkStreamableContent *streamable); + + gchar* atk_streamable_content_get_mime_type (AtkStreamableContent *streamable, + gint i); + GIOChannel* atk_streamable_content_get_stream (AtkStreamableContent *streamable, + gchar *mime_type); + alias _AtkTable AtkTable; + alias void _AtkTable; + + + alias _AtkTableIface AtkTableIface; + + + struct _AtkTableIface { + GTypeInterface parent; + + AtkObject* (* ref_at) (AtkTable *table, + gint row, + gint column); + gint (* get_index_at) (AtkTable *table, + gint row, + gint column); + gint (* get_column_at_index) (AtkTable *table, + gint index_); + gint (* get_row_at_index) (AtkTable *table, + gint index_); + gint (* get_n_columns) (AtkTable *table); + gint (* get_n_rows) (AtkTable *table); + gint (* get_column_extent_at) (AtkTable *table, + gint row, + gint column); + gint (* get_row_extent_at) (AtkTable *table, + gint row, + gint column); + AtkObject* + (* get_caption) (AtkTable *table); + gchar* + (* get_column_description) (AtkTable *table, + gint column); + AtkObject* (* get_column_header) (AtkTable *table, + gint column); + gchar* + (* get_row_description) (AtkTable *table, + gint row); + AtkObject* (* get_row_header) (AtkTable *table, + gint row); + AtkObject* (* get_summary) (AtkTable *table); + void (* set_caption) (AtkTable *table, + AtkObject *caption); + void (* set_column_description) (AtkTable *table, + gint column, + gchar *description); + void (* set_column_header) (AtkTable *table, + gint column, + AtkObject *header); + void (* set_row_description) (AtkTable *table, + gint row, + gchar *description); + void (* set_row_header) (AtkTable *table, + gint row, + AtkObject *header); + void (* set_summary) (AtkTable *table, + AtkObject *accessible); + gint (* get_selected_columns) (AtkTable *table, + gint **selected); + gint (* get_selected_rows) (AtkTable *table, + gint **selected); + gboolean (* is_column_selected) (AtkTable *table, + gint column); + gboolean (* is_row_selected) (AtkTable *table, + gint row); + gboolean (* is_selected) (AtkTable *table, + gint row, + gint column); + gboolean (* add_row_selection) (AtkTable *table, + gint row); + gboolean (* remove_row_selection) (AtkTable *table, + gint row); + gboolean (* add_column_selection) (AtkTable *table, + gint column); + gboolean (* remove_column_selection) (AtkTable *table, + gint column); + + + + + void (* row_inserted) (AtkTable *table, + gint row, + gint num_inserted); + void (* column_inserted) (AtkTable *table, + gint column, + gint num_inserted); + void (* row_deleted) (AtkTable *table, + gint row, + gint num_deleted); + void (* column_deleted) (AtkTable *table, + gint column, + gint num_deleted); + void (* row_reordered) (AtkTable *table); + void (* column_reordered) (AtkTable *table); + void (* model_changed) (AtkTable *table); + + AtkFunction pad1; + AtkFunction pad2; + AtkFunction pad3; + AtkFunction pad4; + } + + GType atk_table_get_type (); + + AtkObject* atk_table_ref_at (AtkTable *table, + gint row, + gint column); + gint atk_table_get_index_at (AtkTable *table, + gint row, + gint column); + gint atk_table_get_column_at_index (AtkTable *table, + gint index_); + gint atk_table_get_row_at_index (AtkTable *table, + gint index_); + gint atk_table_get_n_columns (AtkTable *table); + gint atk_table_get_n_rows (AtkTable *table); + gint atk_table_get_column_extent_at (AtkTable *table, + gint row, + gint column); + gint atk_table_get_row_extent_at (AtkTable *table, + gint row, + gint column); + AtkObject* + atk_table_get_caption (AtkTable *table); + gchar* + atk_table_get_column_description (AtkTable *table, + gint column); + AtkObject* atk_table_get_column_header (AtkTable *table, + gint column); + gchar* + atk_table_get_row_description (AtkTable *table, + gint row); + AtkObject* atk_table_get_row_header (AtkTable *table, + gint row); + AtkObject* atk_table_get_summary (AtkTable *table); + void atk_table_set_caption (AtkTable *table, + AtkObject *caption); + void atk_table_set_column_description + (AtkTable *table, + gint column, + gchar *description); + void atk_table_set_column_header (AtkTable *table, + gint column, + AtkObject *header); + void atk_table_set_row_description (AtkTable *table, + gint row, + gchar *description); + void atk_table_set_row_header (AtkTable *table, + gint row, + AtkObject *header); + void atk_table_set_summary (AtkTable *table, + AtkObject *accessible); + gint atk_table_get_selected_columns (AtkTable *table, + gint **selected); + gint atk_table_get_selected_rows (AtkTable *table, + gint **selected); + gboolean atk_table_is_column_selected (AtkTable *table, + gint column); + gboolean atk_table_is_row_selected (AtkTable *table, + gint row); + gboolean atk_table_is_selected (AtkTable *table, + gint row, + gint column); + gboolean atk_table_add_row_selection (AtkTable *table, + gint row); + gboolean atk_table_remove_row_selection (AtkTable *table, + gint row); + gboolean atk_table_add_column_selection (AtkTable *table, + gint column); + gboolean atk_table_remove_column_selection + (AtkTable *table, + gint column); + + + alias _AtkValue AtkValue; + alias void _AtkValue; + + + alias _AtkValueIface AtkValueIface; + + + struct _AtkValueIface { + GTypeInterface parent; + + void (* get_current_value) (AtkValue *obj, + GValue *value); + void (* get_maximum_value) (AtkValue *obj, + GValue *value); + void (* get_minimum_value) (AtkValue *obj, + GValue *value); + gboolean (* set_current_value) (AtkValue *obj, + GValue *value); + + AtkFunction pad1; + AtkFunction pad2; + } + + GType atk_value_get_type (); + + void atk_value_get_current_value (AtkValue *obj, + GValue *value); + + + void atk_value_get_maximum_value (AtkValue *obj, + GValue *value); + + void atk_value_get_minimum_value (AtkValue *obj, + GValue *value); + + gboolean atk_value_set_current_value (AtkValue *obj, + GValue *value); + alias _GtkAccessible GtkAccessible; + + alias _GtkAccessibleClass GtkAccessibleClass; + + + + + + + struct _GtkAccessible { + AtkObject parent; + + + + + + GtkWidget *widget; + } + + struct _GtkAccessibleClass { + AtkObjectClass parent_class; + + void (*connect_widget_destroyed) (GtkAccessible *accessible); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_accessible_get_type (); + + void gtk_accessible_connect_widget_destroyed (GtkAccessible *accessible); + + alias _GtkAction GtkAction; + + alias _GtkActionClass GtkActionClass; + + alias _GtkActionPrivate GtkActionPrivate; + alias void _GtkActionPrivate; + + + struct _GtkAction { + GObject object; + + + + GtkActionPrivate *private_data; + } + + struct _GtkActionClass { + GObjectClass parent_class; + + + void (* activate) (GtkAction *action); + + GType menu_item_type; + GType toolbar_item_type; + + + GtkWidget *(* create_menu_item) (GtkAction *action); + GtkWidget *(* create_tool_item) (GtkAction *action); + void (* connect_proxy) (GtkAction *action, + GtkWidget *proxy); + void (* disconnect_proxy) (GtkAction *action, + GtkWidget *proxy); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_action_get_type (); + GtkAction *gtk_action_new ( gchar *name, + gchar *label, + gchar *tooltip, + gchar *stock_id); + gchar* gtk_action_get_name (GtkAction *action); + gboolean gtk_action_is_sensitive (GtkAction *action); + gboolean gtk_action_get_sensitive (GtkAction *action); + gboolean gtk_action_is_visible (GtkAction *action); + gboolean gtk_action_get_visible (GtkAction *action); + void gtk_action_activate (GtkAction *action); + GtkWidget* gtk_action_create_icon (GtkAction *action, + GtkIconSize icon_size); + GtkWidget* gtk_action_create_menu_item (GtkAction *action); + GtkWidget* gtk_action_create_tool_item (GtkAction *action); + void gtk_action_connect_proxy (GtkAction *action, + GtkWidget *proxy); + void gtk_action_disconnect_proxy (GtkAction *action, + GtkWidget *proxy); + GSList* gtk_action_get_proxies (GtkAction *action); + void gtk_action_connect_accelerator (GtkAction *action); + void gtk_action_disconnect_accelerator (GtkAction *action); + + + void gtk_action_block_activate_from (GtkAction *action, + GtkWidget *proxy); + void gtk_action_unblock_activate_from (GtkAction *action, + GtkWidget *proxy); + void _gtk_action_emit_activate (GtkAction *action); + + + void gtk_action_set_accel_path (GtkAction *action, + gchar *accel_path); + void gtk_action_set_accel_group (GtkAction *action, + GtkAccelGroup *accel_group); + + + + alias gchar * (*GtkTranslateFunc) ( gchar *path, + gpointer func_data); + + + + alias void (*GtkPrintFunc) (gpointer func_data, + gchar *str); + + + + + + alias void (*GtkItemFactoryCallback) (); + alias void (*GtkItemFactoryCallback1) (gpointer callback_data, + guint callback_action, + GtkWidget *widget); + alias _GtkItemFactory GtkItemFactory; + + alias _GtkItemFactoryClass GtkItemFactoryClass; + + alias _GtkItemFactoryEntry GtkItemFactoryEntry; + + alias _GtkItemFactoryItem GtkItemFactoryItem; + + + struct _GtkItemFactory { + GtkObject object; + + gchar *path; + GtkAccelGroup *accel_group; + GtkWidget *widget; + GSList *items; + + GtkTranslateFunc translate_func; + gpointer translate_data; + GtkDestroyNotify translate_notify; + } + + struct _GtkItemFactoryClass { + GtkObjectClass object_class; + + GHashTable *item_ht; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + struct _GtkItemFactoryEntry { + gchar *path; + gchar *accelerator; + + GtkItemFactoryCallback callback; + guint callback_action; + gchar *item_type; + + + + + + gpointer extra_data; + } + + struct _GtkItemFactoryItem { + gchar *path; + GSList *widgets; + } + + + GType gtk_item_factory_get_type () ; + + + + + GtkItemFactory* gtk_item_factory_new (GType container_type, + gchar *path, + GtkAccelGroup *accel_group); + void gtk_item_factory_ruct (GtkItemFactory *ifactory, + GType container_type, + gchar *path, + GtkAccelGroup *accel_group); + + + + void gtk_item_factory_add_foreign (GtkWidget *accel_widget, + gchar *full_path, + GtkAccelGroup *accel_group, + guint keyval, + GdkModifierType modifiers); + + GtkItemFactory* gtk_item_factory_from_widget (GtkWidget *widget); + gchar* gtk_item_factory_path_from_widget (GtkWidget *widget); + + GtkWidget* gtk_item_factory_get_item (GtkItemFactory *ifactory, + gchar *path); + GtkWidget* gtk_item_factory_get_widget (GtkItemFactory *ifactory, + gchar *path); + GtkWidget* gtk_item_factory_get_widget_by_action (GtkItemFactory *ifactory, + guint action); + GtkWidget* gtk_item_factory_get_item_by_action (GtkItemFactory *ifactory, + guint action); + + void gtk_item_factory_create_item (GtkItemFactory *ifactory, + GtkItemFactoryEntry *entry, + gpointer callback_data, + guint callback_type); + void gtk_item_factory_create_items (GtkItemFactory *ifactory, + guint n_entries, + GtkItemFactoryEntry *entries, + gpointer callback_data); + void gtk_item_factory_delete_item (GtkItemFactory *ifactory, + gchar *path); + void gtk_item_factory_delete_entry (GtkItemFactory *ifactory, + GtkItemFactoryEntry *entry); + void gtk_item_factory_delete_entries (GtkItemFactory *ifactory, + guint n_entries, + GtkItemFactoryEntry *entries); + void gtk_item_factory_popup (GtkItemFactory *ifactory, + guint x, + guint y, + guint mouse_button, + guint32 time_); + void gtk_item_factory_popup_with_data(GtkItemFactory *ifactory, + gpointer popup_data, + GtkDestroyNotify destroy, + guint x, + guint y, + guint mouse_button, + guint32 time_); + gpointer gtk_item_factory_popup_data (GtkItemFactory *ifactory); + gpointer gtk_item_factory_popup_data_from_widget (GtkWidget *widget); + void gtk_item_factory_set_translate_func (GtkItemFactory *ifactory, + GtkTranslateFunc func, + gpointer data, + GtkDestroyNotify notify); + + + + + + alias void (*GtkMenuCallback) (GtkWidget *widget, + gpointer user_data); + struct GtkMenuEntry { + gchar *path; + gchar *accelerator; + GtkMenuCallback callback; + gpointer callback_data; + GtkWidget *widget; + }; + + + + alias void (*GtkItemFactoryCallback2) (GtkWidget *widget, + gpointer callback_data, + guint callback_action); + + + void gtk_item_factory_create_items_ac (GtkItemFactory *ifactory, + guint n_entries, + GtkItemFactoryEntry *entries, + gpointer callback_data, + guint callback_type); + + GtkItemFactory* gtk_item_factory_from_path ( gchar *path); + void gtk_item_factory_create_menu_entries (guint n_entries, + GtkMenuEntry *entries); + void gtk_item_factories_path_delete ( gchar *ifactory_path, + gchar *path); + + + alias _GtkActionGroup GtkActionGroup; + + alias _GtkActionGroupPrivate GtkActionGroupPrivate; + alias void _GtkActionGroupPrivate; + + alias _GtkActionGroupClass GtkActionGroupClass; + + alias _GtkActionEntry GtkActionEntry; + + alias _GtkToggleActionEntry GtkToggleActionEntry; + + alias _GtkRadioActionEntry GtkRadioActionEntry; + + + struct _GtkActionGroup { + GObject parent; + + + + GtkActionGroupPrivate *private_data; + } + + struct _GtkActionGroupClass { + GObjectClass parent_class; + + GtkAction *(* get_action) (GtkActionGroup *action_group, + gchar *action_name); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + struct _GtkActionEntry { + gchar *name; + gchar *stock_id; + gchar *label; + gchar *accelerator; + gchar *tooltip; + GCallback callback; + } + + struct _GtkToggleActionEntry { + gchar *name; + gchar *stock_id; + gchar *label; + gchar *accelerator; + gchar *tooltip; + GCallback callback; + gboolean is_active; + } + + struct _GtkRadioActionEntry { + gchar *name; + gchar *stock_id; + gchar *label; + gchar *accelerator; + gchar *tooltip; + gint value; + } + + GType gtk_action_group_get_type (); + GtkActionGroup *gtk_action_group_new ( gchar *name); + gchar *gtk_action_group_get_name (GtkActionGroup *action_group); + gboolean gtk_action_group_get_sensitive (GtkActionGroup *action_group); + void gtk_action_group_set_sensitive (GtkActionGroup *action_group, + gboolean sensitive); + gboolean gtk_action_group_get_visible (GtkActionGroup *action_group); + void gtk_action_group_set_visible (GtkActionGroup *action_group, + gboolean visible); + GtkAction *gtk_action_group_get_action (GtkActionGroup *action_group, + gchar *action_name); + GList *gtk_action_group_list_actions (GtkActionGroup *action_group); + void gtk_action_group_add_action (GtkActionGroup *action_group, + GtkAction *action); + void gtk_action_group_add_action_with_accel (GtkActionGroup *action_group, + GtkAction *action, + gchar *accelerator); + + void gtk_action_group_remove_action (GtkActionGroup *action_group, + GtkAction *action); + void gtk_action_group_add_actions (GtkActionGroup *action_group, + GtkActionEntry *entries, + guint n_entries, + gpointer user_data); + void gtk_action_group_add_toggle_actions (GtkActionGroup *action_group, + GtkToggleActionEntry *entries, + guint n_entries, + gpointer user_data); + void gtk_action_group_add_radio_actions (GtkActionGroup *action_group, + GtkRadioActionEntry *entries, + guint n_entries, + gint value, + GCallback on_change, + gpointer user_data); + void gtk_action_group_add_actions_full (GtkActionGroup *action_group, + GtkActionEntry *entries, + guint n_entries, + gpointer user_data, + GDestroyNotify destroy); + void gtk_action_group_add_toggle_actions_full (GtkActionGroup *action_group, + GtkToggleActionEntry *entries, + guint n_entries, + gpointer user_data, + GDestroyNotify destroy); + void gtk_action_group_add_radio_actions_full (GtkActionGroup *action_group, + GtkRadioActionEntry *entries, + guint n_entries, + gint value, + GCallback on_change, + gpointer user_data, + GDestroyNotify destroy); + void gtk_action_group_set_translate_func (GtkActionGroup *action_group, + GtkTranslateFunc func, + gpointer data, + GtkDestroyNotify notify); + void gtk_action_group_set_translation_domain (GtkActionGroup *action_group, + gchar *domain); + + + void _gtk_action_group_emit_connect_proxy (GtkActionGroup *action_group, + GtkAction *action, + GtkWidget *proxy); + void _gtk_action_group_emit_disconnect_proxy (GtkActionGroup *action_group, + GtkAction *action, + GtkWidget *proxy); + void _gtk_action_group_emit_pre_activate (GtkActionGroup *action_group, + GtkAction *action); + void _gtk_action_group_emit_post_activate (GtkActionGroup *action_group, + GtkAction *action); + + + + alias _GtkAlignment GtkAlignment; + + alias _GtkAlignmentClass GtkAlignmentClass; + + alias _GtkAlignmentPrivate GtkAlignmentPrivate; + alias void _GtkAlignmentPrivate; + + + struct _GtkAlignment { + GtkBin bin; + + gfloat xalign; + gfloat yalign; + gfloat xscale; + gfloat yscale; + } + + struct _GtkAlignmentClass { + GtkBinClass parent_class; + } + + + GType gtk_alignment_get_type () ; + GtkWidget* gtk_alignment_new (gfloat xalign, + gfloat yalign, + gfloat xscale, + gfloat yscale); + void gtk_alignment_set (GtkAlignment *alignment, + gfloat xalign, + gfloat yalign, + gfloat xscale, + gfloat yscale); + + void gtk_alignment_set_padding (GtkAlignment *alignment, + guint padding_top, + guint padding_bottom, + guint padding_left, + guint padding_right); + + void gtk_alignment_get_padding (GtkAlignment *alignment, + guint *padding_top, + guint *padding_bottom, + guint *padding_left, + guint *padding_right); + alias _GtkArrow GtkArrow; + + alias _GtkArrowClass GtkArrowClass; + + + struct _GtkArrow { + GtkMisc misc; + + gint16 arrow_type; + gint16 shadow_type; + } + + struct _GtkArrowClass { + GtkMiscClass parent_class; + } + + + GType gtk_arrow_get_type () ; + GtkWidget* gtk_arrow_new (GtkArrowType arrow_type, + GtkShadowType shadow_type); + void gtk_arrow_set (GtkArrow *arrow, + GtkArrowType arrow_type, + GtkShadowType shadow_type); + alias _GtkFrame GtkFrame; + + alias _GtkFrameClass GtkFrameClass; + + + struct _GtkFrame { + GtkBin bin; + + GtkWidget *label_widget; + gint16 shadow_type; + gfloat label_xalign; + gfloat label_yalign; + + GtkAllocation child_allocation; + } + + struct _GtkFrameClass { + GtkBinClass parent_class; + + void (*compute_child_allocation) (GtkFrame *frame, GtkAllocation *allocation); + } + + + GType gtk_frame_get_type () ; + GtkWidget* gtk_frame_new ( gchar *label); + + void gtk_frame_set_label (GtkFrame *frame, + gchar *label); + gchar *gtk_frame_get_label (GtkFrame *frame); + + void gtk_frame_set_label_widget (GtkFrame *frame, + GtkWidget *label_widget); + GtkWidget *gtk_frame_get_label_widget (GtkFrame *frame); + void gtk_frame_set_label_align (GtkFrame *frame, + gfloat xalign, + gfloat yalign); + void gtk_frame_get_label_align (GtkFrame *frame, + gfloat *xalign, + gfloat *yalign); + void gtk_frame_set_shadow_type (GtkFrame *frame, + GtkShadowType type); + GtkShadowType gtk_frame_get_shadow_type (GtkFrame *frame); + alias _GtkAspectFrame GtkAspectFrame; + + alias _GtkAspectFrameClass GtkAspectFrameClass; + + + struct _GtkAspectFrame { + GtkFrame frame; + + gfloat xalign; + gfloat yalign; + gfloat ratio; + gboolean obey_child; + + GtkAllocation center_allocation; + } + + struct _GtkAspectFrameClass { + GtkFrameClass parent_class; + } + + + GType gtk_aspect_frame_get_type () ; + GtkWidget* gtk_aspect_frame_new ( gchar *label, + gfloat xalign, + gfloat yalign, + gfloat ratio, + gboolean obey_child); + void gtk_aspect_frame_set (GtkAspectFrame *aspect_frame, + gfloat xalign, + gfloat yalign, + gfloat ratio, + gboolean obey_child); + alias _GtkBox GtkBox; + + alias _GtkBoxClass GtkBoxClass; + + alias _GtkBoxChild GtkBoxChild; + + + struct _GtkBox { + GtkContainer container; + + + GList *children; + gint16 spacing; + guint homogeneous; + } + + struct _GtkBoxClass { + GtkContainerClass parent_class; + } + + struct _GtkBoxChild { + GtkWidget *widget; + guint16 padding; + guint expand; + guint fill; + guint pack; + guint is_secondary; + } + + + GType gtk_box_get_type () ; + void gtk_box_pack_start (GtkBox *box, + GtkWidget *child, + gboolean expand, + gboolean fill, + guint padding); + void gtk_box_pack_end (GtkBox *box, + GtkWidget *child, + gboolean expand, + gboolean fill, + guint padding); + void gtk_box_pack_start_defaults (GtkBox *box, + GtkWidget *widget); + void gtk_box_pack_end_defaults (GtkBox *box, + GtkWidget *widget); + void gtk_box_set_homogeneous (GtkBox *box, + gboolean homogeneous); + gboolean gtk_box_get_homogeneous (GtkBox *box); + void gtk_box_set_spacing (GtkBox *box, + gint spacing); + gint gtk_box_get_spacing (GtkBox *box); + void gtk_box_reorder_child (GtkBox *box, + GtkWidget *child, + gint position); + void gtk_box_query_child_packing (GtkBox *box, + GtkWidget *child, + gboolean *expand, + gboolean *fill, + guint *padding, + GtkPackType *pack_type); + void gtk_box_set_child_packing (GtkBox *box, + GtkWidget *child, + gboolean expand, + gboolean fill, + guint padding, + GtkPackType pack_type); + alias _GtkButtonBox GtkButtonBox; + + alias _GtkButtonBoxClass GtkButtonBoxClass; + + + struct _GtkButtonBox { + GtkBox box; + gint child_min_width; + gint child_min_height; + gint child_ipad_x; + gint child_ipad_y; + GtkButtonBoxStyle layout_style; + } + + struct _GtkButtonBoxClass { + GtkBoxClass parent_class; + } + + + GType gtk_button_box_get_type () ; + + GtkButtonBoxStyle gtk_button_box_get_layout (GtkButtonBox *widget); + void gtk_button_box_set_layout (GtkButtonBox *widget, + GtkButtonBoxStyle layout_style); + gboolean gtk_button_box_get_child_secondary (GtkButtonBox *widget, + GtkWidget *child); + void gtk_button_box_set_child_secondary (GtkButtonBox *widget, + GtkWidget *child, + gboolean is_secondary); + + + + + + void gtk_button_box_set_child_size (GtkButtonBox *widget, + gint min_width, + gint min_height); + void gtk_button_box_set_child_ipadding (GtkButtonBox *widget, + gint ipad_x, + gint ipad_y); + void gtk_button_box_get_child_size (GtkButtonBox *widget, + gint *min_width, + gint *min_height); + void gtk_button_box_get_child_ipadding (GtkButtonBox *widget, + gint *ipad_x, + gint *ipad_y); + + + + void _gtk_button_box_child_requisition (GtkWidget *widget, + int *nvis_children, + int *nvis_secondaries, + int *width, + int *height); + + alias _GtkBindingSet GtkBindingSet; + + alias _GtkBindingEntry GtkBindingEntry; + + alias _GtkBindingSignal GtkBindingSignal; + + alias _GtkBindingArg GtkBindingArg; + + + struct _GtkBindingSet { + gchar *set_name; + gint priority; + GSList *widget_path_pspecs; + GSList *widget_class_pspecs; + GSList *class_branch_pspecs; + GtkBindingEntry *entries; + GtkBindingEntry *current; + guint parsed; + } + + struct _GtkBindingEntry { + + + guint keyval; + GdkModifierType modifiers; + + GtkBindingSet *binding_set; + guint destroyed; + guint in_emission; + GtkBindingEntry *set_next; + GtkBindingEntry *hash_next; + GtkBindingSignal *signals; + } + + struct _GtkBindingSignal { + GtkBindingSignal *next; + gchar *signal_name; + guint n_args; + GtkBindingArg *args; + } + + struct _GtkBindingArg { + GType arg_type; + union d_union { + glong int_data; + gdouble double_data; + gchar *string_data; + } + d_union d; + } + + + + + GtkBindingSet* gtk_binding_set_new ( gchar *set_name); + GtkBindingSet* gtk_binding_set_by_class(gpointer object_class); + GtkBindingSet* gtk_binding_set_find ( gchar *set_name); + gboolean gtk_bindings_activate (GtkObject *object, + guint keyval, + GdkModifierType modifiers); + gboolean gtk_bindings_activate_event (GtkObject *object, + GdkEventKey *event); + gboolean gtk_binding_set_activate (GtkBindingSet *binding_set, + guint keyval, + GdkModifierType modifiers, + GtkObject *object); + + void gtk_binding_entry_clear (GtkBindingSet *binding_set, + guint keyval, + GdkModifierType modifiers); + void gtk_binding_entry_add_signal (GtkBindingSet *binding_set, + guint keyval, + GdkModifierType modifiers, + gchar *signal_name, + guint n_args, + ...); + void gtk_binding_set_add_path (GtkBindingSet *binding_set, + GtkPathType path_type, + gchar *path_pattern, + GtkPathPriorityType priority); + + + + + void gtk_binding_entry_remove (GtkBindingSet *binding_set, + guint keyval, + GdkModifierType modifiers); + void gtk_binding_entry_add_signall (GtkBindingSet *binding_set, + guint keyval, + GdkModifierType modifiers, + gchar *signal_name, + GSList *binding_args); + guint gtk_binding_parse_binding (GScanner *scanner); + + + void _gtk_binding_reset_parsed (); + + + + + guint _gtk_binding_signal_new ( gchar *signal_name, + GType itype, + GSignalFlags signal_flags, + GCallback handler, + GSignalAccumulator accumulator, + gpointer accu_data, + GSignalCMarshaller c_marshaller, + GType return_type, + guint n_params, + ...); + + alias _GtkButton GtkButton; + + alias _GtkButtonClass GtkButtonClass; + + + struct _GtkButton { + GtkBin bin; + + GdkWindow *event_window; + + gchar *label_text; + + guint activate_timeout; + + guint in_button; + guint button_down; + guint relief; + guint use_underline; + guint use_stock; + guint depressed; + guint depress_on_activate; + guint focus_on_click; + } + + struct _GtkButtonClass { + GtkBinClass parent_class; + + void (* pressed) (GtkButton *button); + void (* released) (GtkButton *button); + void (* clicked) (GtkButton *button); + void (* enter) (GtkButton *button); + void (* leave) (GtkButton *button); + void (* activate) (GtkButton *button); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_button_get_type () ; + GtkWidget* gtk_button_new (); + GtkWidget* gtk_button_new_with_label ( gchar *label); + GtkWidget* gtk_button_new_from_stock ( gchar *stock_id); + GtkWidget* gtk_button_new_with_mnemonic ( gchar *label); + void gtk_button_pressed (GtkButton *button); + void gtk_button_released (GtkButton *button); + void gtk_button_clicked (GtkButton *button); + void gtk_button_enter (GtkButton *button); + void gtk_button_leave (GtkButton *button); + + void gtk_button_set_relief (GtkButton *button, + GtkReliefStyle newstyle); + GtkReliefStyle gtk_button_get_relief (GtkButton *button); + void gtk_button_set_label (GtkButton *button, + gchar *label); + gchar *gtk_button_get_label (GtkButton *button); + void gtk_button_set_use_underline (GtkButton *button, + gboolean use_underline); + gboolean gtk_button_get_use_underline (GtkButton *button); + void gtk_button_set_use_stock (GtkButton *button, + gboolean use_stock); + gboolean gtk_button_get_use_stock (GtkButton *button); + void gtk_button_set_focus_on_click (GtkButton *button, + gboolean focus_on_click); + gboolean gtk_button_get_focus_on_click (GtkButton *button); + void gtk_button_set_alignment (GtkButton *button, + gfloat xalign, + gfloat yalign); + void gtk_button_get_alignment (GtkButton *button, + gfloat *xalign, + gfloat *yalign); + + + void _gtk_button_set_depressed (GtkButton *button, + gboolean depressed); + void _gtk_button_paint (GtkButton *button, + GdkRectangle *area, + GtkStateType state_type, + GtkShadowType shadow_type, + gchar *main_detail, + gchar *default_detail); + + + + + + + + + + + void gtk_marshal_BOOLEAN__VOID (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_BOOLEAN__POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_BOOLEAN__POINTER_POINTER_INT_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_BOOLEAN__POINTER_INT_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_BOOLEAN__POINTER_INT_INT_UINT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_BOOLEAN__POINTER_STRING_STRING_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_ENUM__ENUM (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void gtk_marshal_INT__POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + void gtk_marshal_INT__POINTER_CHAR_CHAR (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + void gtk_marshal_VOID__ENUM_FLOAT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + + + + + void gtk_marshal_VOID__INT_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__INT_INT_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + void gtk_marshal_VOID__POINTER_INT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__POINTER_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__POINTER_POINTER_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__POINTER_STRING_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__POINTER_UINT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__POINTER_UINT_ENUM (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__POINTER_POINTER_UINT_UINT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__POINTER_INT_INT_POINTER_UINT_UINT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__POINTER_UINT_UINT (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + void gtk_marshal_VOID__STRING_INT_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + + + + + void gtk_marshal_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__UINT_POINTER_UINT_UINT_ENUM (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + void gtk_marshal_VOID__UINT_STRING (GClosure *closure, + GValue *return_value, + guint n_param_values, + GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data); + + + + + + guint gtk_signal_newv ( gchar *name, + GtkSignalRunType signal_flags, + GtkType object_type, + guint function_offset, + GtkSignalMarshaller marshaller, + GtkType return_val, + guint n_args, + GtkType *args); + guint gtk_signal_new ( gchar *name, + GtkSignalRunType signal_flags, + GtkType object_type, + guint function_offset, + GtkSignalMarshaller marshaller, + GtkType return_val, + guint n_args, + ...); + void gtk_signal_emit_stop_by_name (GtkObject *object, + gchar *name); + void gtk_signal_connect_object_while_alive (GtkObject *object, + gchar *name, + GtkSignalFunc func, + GtkObject *alive_object); + void gtk_signal_connect_while_alive (GtkObject *object, + gchar *name, + GtkSignalFunc func, + gpointer func_data, + GtkObject *alive_object); + gulong gtk_signal_connect_full (GtkObject *object, + gchar *name, + GtkSignalFunc func, + GtkCallbackMarshal unsupported, + gpointer data, + GtkDestroyNotify destroy_func, + gint object_signal, + gint after); + void gtk_signal_emitv (GtkObject *object, + guint signal_id, + GtkArg *args); + void gtk_signal_emit (GtkObject *object, + guint signal_id, + ...); + void gtk_signal_emit_by_name (GtkObject *object, + gchar *name, + ...); + void gtk_signal_emitv_by_name (GtkObject *object, + gchar *name, + GtkArg *args); + void gtk_signal_compat_matched (GtkObject *object, + GtkSignalFunc func, + gpointer data, + GSignalMatchType match, + guint action); + + + + + alias _GtkCalendar GtkCalendar; + + alias _GtkCalendarClass GtkCalendarClass; + + + enum GtkCalendarDisplayOptions { + GTK_CALENDAR_SHOW_HEADING = 1 << 0, + GTK_CALENDAR_SHOW_DAY_NAMES = 1 << 1, + GTK_CALENDAR_NO_MONTH_CHANGE = 1 << 2, + GTK_CALENDAR_SHOW_WEEK_NUMBERS = 1 << 3, + GTK_CALENDAR_WEEK_START_MONDAY = 1 << 4 + }; + + + struct _GtkCalendar { + GtkWidget widget; + + GtkStyle *header_style; + GtkStyle *label_style; + + gint month; + gint year; + gint selected_day; + + gint day_month[6][7]; + gint day[6][7]; + + gint num_marked_dates; + gint marked_date[31]; + GtkCalendarDisplayOptions display_flags; + GdkColor marked_date_color[31]; + + GdkGC *gc; + GdkGC *xor_gc; + + gint focus_row; + gint focus_col; + + gint highlight_row; + gint highlight_col; + + gpointer private_data; + gchar grow_space [32]; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + struct _GtkCalendarClass { + GtkWidgetClass parent_class; + + + void (* month_changed) (GtkCalendar *calendar); + void (* day_selected) (GtkCalendar *calendar); + void (* day_selected_double_click) (GtkCalendar *calendar); + void (* prev_month) (GtkCalendar *calendar); + void (* next_month) (GtkCalendar *calendar); + void (* prev_year) (GtkCalendar *calendar); + void (* next_year) (GtkCalendar *calendar); + + } + + + GType gtk_calendar_get_type () ; + GtkWidget* gtk_calendar_new (); + + gboolean gtk_calendar_select_month (GtkCalendar *calendar, + guint month, + guint year); + void gtk_calendar_select_day (GtkCalendar *calendar, + guint day); + + gboolean gtk_calendar_mark_day (GtkCalendar *calendar, + guint day); + gboolean gtk_calendar_unmark_day (GtkCalendar *calendar, + guint day); + void gtk_calendar_clear_marks (GtkCalendar *calendar); + + + void gtk_calendar_set_display_options (GtkCalendar *calendar, + GtkCalendarDisplayOptions flags); + GtkCalendarDisplayOptions + gtk_calendar_get_display_options (GtkCalendar *calendar); + + void gtk_calendar_display_options (GtkCalendar *calendar, + GtkCalendarDisplayOptions flags); + + + void gtk_calendar_get_date (GtkCalendar *calendar, + guint *year, + guint *month, + guint *day); + void gtk_calendar_freeze (GtkCalendar *calendar); + void gtk_calendar_thaw (GtkCalendar *calendar); + + + + + + + + + alias _GtkCellEditable GtkCellEditable; + alias void _GtkCellEditable; + + alias _GtkCellEditableIface GtkCellEditableIface; + + + struct _GtkCellEditableIface { + GTypeInterface g_iface; + + + void (* editing_done) (GtkCellEditable *cell_editable); + void (* remove_widget) (GtkCellEditable *cell_editable); + + + void (* start_editing) (GtkCellEditable *cell_editable, + GdkEvent *event); + } + + + GType gtk_cell_editable_get_type () ; + + void gtk_cell_editable_start_editing (GtkCellEditable *cell_editable, + GdkEvent *event); + void gtk_cell_editable_editing_done (GtkCellEditable *cell_editable); + void gtk_cell_editable_remove_widget (GtkCellEditable *cell_editable); + + + + + + + enum GtkCellRendererState { + GTK_CELL_RENDERER_SELECTED = 1 << 0, + GTK_CELL_RENDERER_PRELIT = 1 << 1, + GTK_CELL_RENDERER_INSENSITIVE = 1 << 2, + + GTK_CELL_RENDERER_SORTED = 1 << 3, + GTK_CELL_RENDERER_FOCUSED = 1 << 4 + }; + + + enum GtkCellRendererMode { + GTK_CELL_RENDERER_MODE_INERT, + GTK_CELL_RENDERER_MODE_ACTIVATABLE, + GTK_CELL_RENDERER_MODE_EDITABLE + }; + + alias _GtkCellRenderer GtkCellRenderer; + + alias _GtkCellRendererClass GtkCellRendererClass; + + + struct _GtkCellRenderer { + GtkObject parent; + + gfloat xalign; + gfloat yalign; + + gint width; + gint height; + + guint16 xpad; + guint16 ypad; + + guint mode; + guint visible; + guint is_expander; + guint is_expanded; + guint cell_background_set; + } + + struct _GtkCellRendererClass { + GtkObjectClass parent_class; + + + void (* get_size) (GtkCellRenderer *cell, + GtkWidget *widget, + GdkRectangle *cell_area, + gint *x_offset, + gint *y_offset, + gint *width, + gint *height); + void (* render) (GtkCellRenderer *cell, + GdkDrawable *window, + GtkWidget *widget, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GdkRectangle *expose_area, + GtkCellRendererState flags); + gboolean (* activate) (GtkCellRenderer *cell, + GdkEvent *event, + GtkWidget *widget, + gchar *path, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GtkCellRendererState flags); + GtkCellEditable *(* start_editing) (GtkCellRenderer *cell, + GdkEvent *event, + GtkWidget *widget, + gchar *path, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GtkCellRendererState flags); + + + void (* editing_canceled) (GtkCellRenderer *cell); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + } + + GType gtk_cell_renderer_get_type () ; + + void gtk_cell_renderer_get_size (GtkCellRenderer *cell, + GtkWidget *widget, + GdkRectangle *cell_area, + gint *x_offset, + gint *y_offset, + gint *width, + gint *height); + void gtk_cell_renderer_render (GtkCellRenderer *cell, + GdkWindow *window, + GtkWidget *widget, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GdkRectangle *expose_area, + GtkCellRendererState flags); + gboolean gtk_cell_renderer_activate (GtkCellRenderer *cell, + GdkEvent *event, + GtkWidget *widget, + gchar *path, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GtkCellRendererState flags); + GtkCellEditable *gtk_cell_renderer_start_editing (GtkCellRenderer *cell, + GdkEvent *event, + GtkWidget *widget, + gchar *path, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GtkCellRendererState flags); + void gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell, + gint width, + gint height); + void gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell, + gint *width, + gint *height); + + + void gtk_cell_renderer_editing_canceled (GtkCellRenderer *cell); + + + + + alias _GtkTreeIter GtkTreeIter; + + alias _GtkTreePath GtkTreePath; + alias void _GtkTreePath; + + alias _GtkTreeRowReference GtkTreeRowReference; + alias void _GtkTreeRowReference; + + alias _GtkTreeModel GtkTreeModel; + alias void _GtkTreeModel; + + alias _GtkTreeModelIface GtkTreeModelIface; + + alias gboolean (* GtkTreeModelForeachFunc) (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data); + + + enum GtkTreeModelFlags { + GTK_TREE_MODEL_ITERS_PERSIST = 1 << 0, + GTK_TREE_MODEL_LIST_ONLY = 1 << 1 + }; + + + struct _GtkTreeIter { + gint stamp; + gpointer user_data; + gpointer user_data2; + gpointer user_data3; + } + + struct _GtkTreeModelIface { + GTypeInterface g_iface; + + + void (* row_changed) (GtkTreeModel *tree_model, + GtkTreePath *path, + GtkTreeIter *iter); + void (* row_inserted) (GtkTreeModel *tree_model, + GtkTreePath *path, + GtkTreeIter *iter); + void (* row_has_child_toggled) (GtkTreeModel *tree_model, + GtkTreePath *path, + GtkTreeIter *iter); + void (* row_deleted) (GtkTreeModel *tree_model, + GtkTreePath *path); + void (* rows_reordered) (GtkTreeModel *tree_model, + GtkTreePath *path, + GtkTreeIter *iter, + gint *new_order); + + + GtkTreeModelFlags (* get_flags) (GtkTreeModel *tree_model); + + gint (* get_n_columns) (GtkTreeModel *tree_model); + GType (* get_column_type) (GtkTreeModel *tree_model, + gint index_); + gboolean (* get_iter) (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path); + GtkTreePath *(* get_path) (GtkTreeModel *tree_model, + GtkTreeIter *iter); + void (* get_value) (GtkTreeModel *tree_model, + GtkTreeIter *iter, + gint column, + GValue *value); + gboolean (* iter_next) (GtkTreeModel *tree_model, + GtkTreeIter *iter); + gboolean (* iter_children) (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent); + gboolean (* iter_has_child) (GtkTreeModel *tree_model, + GtkTreeIter *iter); + gint (* iter_n_children) (GtkTreeModel *tree_model, + GtkTreeIter *iter); + gboolean (* iter_nth_child) (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + gint n); + gboolean (* iter_parent) (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child); + void (* ref_node) (GtkTreeModel *tree_model, + GtkTreeIter *iter); + void (* unref_node) (GtkTreeModel *tree_model, + GtkTreeIter *iter); + } + + + + GtkTreePath *gtk_tree_path_new (); + GtkTreePath *gtk_tree_path_new_from_string ( gchar *path); + GtkTreePath *gtk_tree_path_new_from_indices (gint first_index, + ...); + gchar *gtk_tree_path_to_string (GtkTreePath *path); + GtkTreePath *gtk_tree_path_new_first (); + void gtk_tree_path_append_index (GtkTreePath *path, + gint index_); + void gtk_tree_path_prepend_index (GtkTreePath *path, + gint index_); + gint gtk_tree_path_get_depth (GtkTreePath *path); + gint *gtk_tree_path_get_indices (GtkTreePath *path); + void gtk_tree_path_free (GtkTreePath *path); + GtkTreePath *gtk_tree_path_copy ( GtkTreePath *path); + GType gtk_tree_path_get_type (); + gint gtk_tree_path_compare ( GtkTreePath *a, + GtkTreePath *b); + void gtk_tree_path_next (GtkTreePath *path); + gboolean gtk_tree_path_prev (GtkTreePath *path); + gboolean gtk_tree_path_up (GtkTreePath *path); + void gtk_tree_path_down (GtkTreePath *path); + + gboolean gtk_tree_path_is_ancestor (GtkTreePath *path, + GtkTreePath *descendant); + gboolean gtk_tree_path_is_descendant (GtkTreePath *path, + GtkTreePath *ancestor); + GType gtk_tree_row_reference_get_type (); + GtkTreeRowReference *gtk_tree_row_reference_new (GtkTreeModel *model, + GtkTreePath *path); + GtkTreeRowReference *gtk_tree_row_reference_new_proxy (GObject *proxy, + GtkTreeModel *model, + GtkTreePath *path); + GtkTreePath *gtk_tree_row_reference_get_path (GtkTreeRowReference *reference); + gboolean gtk_tree_row_reference_valid (GtkTreeRowReference *reference); + GtkTreeRowReference *gtk_tree_row_reference_copy (GtkTreeRowReference *reference); + void gtk_tree_row_reference_free (GtkTreeRowReference *reference); + + + void gtk_tree_row_reference_inserted (GObject *proxy, + GtkTreePath *path); + void gtk_tree_row_reference_deleted (GObject *proxy, + GtkTreePath *path); + void gtk_tree_row_reference_reordered (GObject *proxy, + GtkTreePath *path, + GtkTreeIter *iter, + gint *new_order); + + + GtkTreeIter * gtk_tree_iter_copy (GtkTreeIter *iter); + void gtk_tree_iter_free (GtkTreeIter *iter); + GType gtk_tree_iter_get_type (); + + GType gtk_tree_model_get_type () ; + GtkTreeModelFlags gtk_tree_model_get_flags (GtkTreeModel *tree_model); + gint gtk_tree_model_get_n_columns (GtkTreeModel *tree_model); + GType gtk_tree_model_get_column_type (GtkTreeModel *tree_model, + gint index_); + + + + gboolean gtk_tree_model_get_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path); + gboolean gtk_tree_model_get_iter_from_string (GtkTreeModel *tree_model, + GtkTreeIter *iter, + gchar *path_string); + gchar * gtk_tree_model_get_string_from_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter); + gboolean gtk_tree_model_get_iter_first (GtkTreeModel *tree_model, + GtkTreeIter *iter); + GtkTreePath * gtk_tree_model_get_path (GtkTreeModel *tree_model, + GtkTreeIter *iter); + void gtk_tree_model_get_value (GtkTreeModel *tree_model, + GtkTreeIter *iter, + gint column, + GValue *value); + gboolean gtk_tree_model_iter_next (GtkTreeModel *tree_model, + GtkTreeIter *iter); + gboolean gtk_tree_model_iter_children (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent); + gboolean gtk_tree_model_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter); + gint gtk_tree_model_iter_n_children (GtkTreeModel *tree_model, + GtkTreeIter *iter); + gboolean gtk_tree_model_iter_nth_child (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + gint n); + gboolean gtk_tree_model_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child); + void gtk_tree_model_ref_node (GtkTreeModel *tree_model, + GtkTreeIter *iter); + void gtk_tree_model_unref_node (GtkTreeModel *tree_model, + GtkTreeIter *iter); + void gtk_tree_model_get (GtkTreeModel *tree_model, + GtkTreeIter *iter, + ...); + void gtk_tree_model_get_valist (GtkTreeModel *tree_model, + GtkTreeIter *iter, + va_list var_args); + + + void gtk_tree_model_foreach (GtkTreeModel *model, + GtkTreeModelForeachFunc func, + gpointer user_data); + + + + + + + + void gtk_tree_model_row_changed (GtkTreeModel *tree_model, + GtkTreePath *path, + GtkTreeIter *iter); + void gtk_tree_model_row_inserted (GtkTreeModel *tree_model, + GtkTreePath *path, + GtkTreeIter *iter); + void gtk_tree_model_row_has_child_toggled (GtkTreeModel *tree_model, + GtkTreePath *path, + GtkTreeIter *iter); + void gtk_tree_model_row_deleted (GtkTreeModel *tree_model, + GtkTreePath *path); + void gtk_tree_model_rows_reordered (GtkTreeModel *tree_model, + GtkTreePath *path, + GtkTreeIter *iter, + gint *new_order); + + + + + + + + + + + + + + enum { + GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID = -1 + }; + + alias _GtkTreeSortable GtkTreeSortable; + alias void _GtkTreeSortable; + + alias _GtkTreeSortableIface GtkTreeSortableIface; + + + alias gint (* GtkTreeIterCompareFunc) (GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b, + gpointer user_data); + + + struct _GtkTreeSortableIface { + GTypeInterface g_iface; + + + void (* sort_column_changed) (GtkTreeSortable *sortable); + + + gboolean (* get_sort_column_id) (GtkTreeSortable *sortable, + gint *sort_column_id, + GtkSortType *order); + void (* set_sort_column_id) (GtkTreeSortable *sortable, + gint sort_column_id, + GtkSortType order); + void (* set_sort_func) (GtkTreeSortable *sortable, + gint sort_column_id, + GtkTreeIterCompareFunc func, + gpointer data, + GtkDestroyNotify destroy); + void (* set_default_sort_func) (GtkTreeSortable *sortable, + GtkTreeIterCompareFunc func, + gpointer data, + GtkDestroyNotify destroy); + gboolean (* has_default_sort_func) (GtkTreeSortable *sortable); + } + + + GType gtk_tree_sortable_get_type () ; + + void gtk_tree_sortable_sort_column_changed (GtkTreeSortable *sortable); + gboolean gtk_tree_sortable_get_sort_column_id (GtkTreeSortable *sortable, + gint *sort_column_id, + GtkSortType *order); + void gtk_tree_sortable_set_sort_column_id (GtkTreeSortable *sortable, + gint sort_column_id, + GtkSortType order); + void gtk_tree_sortable_set_sort_func (GtkTreeSortable *sortable, + gint sort_column_id, + GtkTreeIterCompareFunc sort_func, + gpointer user_data, + GtkDestroyNotify destroy); + void gtk_tree_sortable_set_default_sort_func (GtkTreeSortable *sortable, + GtkTreeIterCompareFunc sort_func, + gpointer user_data, + GtkDestroyNotify destroy); + gboolean gtk_tree_sortable_has_default_sort_func (GtkTreeSortable *sortable); + + + + enum GtkTreeViewColumnSizing { + GTK_TREE_VIEW_COLUMN_GROW_ONLY, + GTK_TREE_VIEW_COLUMN_AUTOSIZE, + GTK_TREE_VIEW_COLUMN_FIXED + }; + + + alias _GtkTreeViewColumn GtkTreeViewColumn; + + alias _GtkTreeViewColumnClass GtkTreeViewColumnClass; + + + alias void (* GtkTreeCellDataFunc) (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell, + GtkTreeModel *tree_model, + GtkTreeIter *iter, + gpointer data); + + + struct _GtkTreeViewColumn { + GtkObject parent; + + GtkWidget *tree_view; + GtkWidget *button; + GtkWidget *child; + GtkWidget *arrow; + GtkWidget *alignment; + GdkWindow *window; + GtkCellEditable *editable_widget; + gfloat xalign; + guint property_changed_signal; + gint spacing; + + + + GtkTreeViewColumnSizing column_type; + gint requested_width; + gint button_request; + gint resized_width; + gint width; + gint fixed_width; + gint min_width; + gint max_width; + + + gint drag_x; + gint drag_y; + + gchar *title; + GList *cell_list; + + + guint sort_clicked_signal; + guint sort_column_changed_signal; + gint sort_column_id; + GtkSortType sort_order; + + + guint visible; + guint resizable; + guint clickable; + guint dirty; + guint show_sort_indicator; + guint maybe_reordered; + guint reorderable; + guint use_resized_width; + guint expand; + } + + struct _GtkTreeViewColumnClass { + GtkObjectClass parent_class; + + void (*clicked) (GtkTreeViewColumn *tree_column); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_tree_view_column_get_type (); + GtkTreeViewColumn *gtk_tree_view_column_new (); + GtkTreeViewColumn *gtk_tree_view_column_new_with_attributes ( gchar *title, + GtkCellRenderer *cell, + ...); + void gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell, + gboolean expand); + void gtk_tree_view_column_pack_end (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell, + gboolean expand); + void gtk_tree_view_column_clear (GtkTreeViewColumn *tree_column); + GList *gtk_tree_view_column_get_cell_renderers (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer, + gchar *attribute, + gint column); + void gtk_tree_view_column_set_attributes (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer, + ...); + void gtk_tree_view_column_set_cell_data_func (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer, + GtkTreeCellDataFunc func, + gpointer func_data, + GtkDestroyNotify destroy); + void gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer); + void gtk_tree_view_column_set_spacing (GtkTreeViewColumn *tree_column, + gint spacing); + gint gtk_tree_view_column_get_spacing (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column, + gboolean visible); + gboolean gtk_tree_view_column_get_visible (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_resizable (GtkTreeViewColumn *tree_column, + gboolean resizable); + gboolean gtk_tree_view_column_get_resizable (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_sizing (GtkTreeViewColumn *tree_column, + GtkTreeViewColumnSizing type); + GtkTreeViewColumnSizing gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column); + gint gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column); + gint gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column, + gint fixed_width); + void gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column, + gint min_width); + gint gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column, + gint max_width); + gint gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_clicked (GtkTreeViewColumn *tree_column); + + + + + + void gtk_tree_view_column_set_title (GtkTreeViewColumn *tree_column, + gchar *title); + gchar *gtk_tree_view_column_get_title (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_expand (GtkTreeViewColumn *tree_column, + gboolean expand); + gboolean gtk_tree_view_column_get_expand (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_clickable (GtkTreeViewColumn *tree_column, + gboolean clickable); + gboolean gtk_tree_view_column_get_clickable (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_widget (GtkTreeViewColumn *tree_column, + GtkWidget *widget); + GtkWidget *gtk_tree_view_column_get_widget (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_alignment (GtkTreeViewColumn *tree_column, + gfloat xalign); + gfloat gtk_tree_view_column_get_alignment (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_reorderable (GtkTreeViewColumn *tree_column, + gboolean reorderable); + gboolean gtk_tree_view_column_get_reorderable (GtkTreeViewColumn *tree_column); + + + + + + + void gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column, + gint sort_column_id); + gint gtk_tree_view_column_get_sort_column_id (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_sort_indicator (GtkTreeViewColumn *tree_column, + gboolean setting); + gboolean gtk_tree_view_column_get_sort_indicator (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_set_sort_order (GtkTreeViewColumn *tree_column, + GtkSortType order); + GtkSortType gtk_tree_view_column_get_sort_order (GtkTreeViewColumn *tree_column); + + + + + void gtk_tree_view_column_cell_set_cell_data (GtkTreeViewColumn *tree_column, + GtkTreeModel *tree_model, + GtkTreeIter *iter, + gboolean is_expander, + gboolean is_expanded); + void gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column, + GdkRectangle *cell_area, + gint *x_offset, + gint *y_offset, + gint *width, + gint *height); + gboolean gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column); + void gtk_tree_view_column_focus_cell (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell); + gboolean gtk_tree_view_column_cell_get_position (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer, + gint *start_pos, + gint *width); + + + + + + + + + alias _GtkCellLayout GtkCellLayout; + alias void _GtkCellLayout; + + alias _GtkCellLayoutIface GtkCellLayoutIface; + + + + alias void (* GtkCellLayoutDataFunc) (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + GtkTreeModel *tree_model, + GtkTreeIter *iter, + gpointer data); + + struct _GtkCellLayoutIface { + GTypeInterface g_iface; + + + void (* pack_start) (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gboolean expand); + void (* pack_end) (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gboolean expand); + void (* clear) (GtkCellLayout *cell_layout); + void (* add_attribute) (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gchar *attribute, + gint column); + void (* set_cell_data_func) (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + GtkCellLayoutDataFunc func, + gpointer func_data, + GDestroyNotify destroy); + void (* clear_attributes) (GtkCellLayout *cell_layout, + GtkCellRenderer *cell); + void (* reorder) (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gint position); + } + + GType gtk_cell_layout_get_type (); + void gtk_cell_layout_pack_start (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gboolean expand); + void gtk_cell_layout_pack_end (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gboolean expand); + void gtk_cell_layout_clear (GtkCellLayout *cell_layout); + void gtk_cell_layout_set_attributes (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + ...); + void gtk_cell_layout_add_attribute (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gchar *attribute, + gint column); + void gtk_cell_layout_set_cell_data_func (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + GtkCellLayoutDataFunc func, + gpointer func_data, + GDestroyNotify destroy); + void gtk_cell_layout_clear_attributes (GtkCellLayout *cell_layout, + GtkCellRenderer *cell); + void gtk_cell_layout_reorder (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gint position); + + + + + alias _GtkCellRendererPixbuf GtkCellRendererPixbuf; + + alias _GtkCellRendererPixbufClass GtkCellRendererPixbufClass; + + + struct _GtkCellRendererPixbuf { + GtkCellRenderer parent; + + + GdkPixbuf *pixbuf; + GdkPixbuf *pixbuf_expander_open; + GdkPixbuf *pixbuf_expander_closed; + } + + struct _GtkCellRendererPixbufClass { + GtkCellRendererClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_cell_renderer_pixbuf_get_type (); + GtkCellRenderer *gtk_cell_renderer_pixbuf_new (); + alias _GtkCellRendererText GtkCellRendererText; + + alias _GtkCellRendererTextClass GtkCellRendererTextClass; + + + struct _GtkCellRendererText { + GtkCellRenderer parent; + + + gchar *text; + PangoFontDescription *font; + gdouble font_scale; + PangoColor foreground; + PangoColor background; + + PangoAttrList *extra_attrs; + + PangoUnderline underline_style; + + gint rise; + gint fixed_height_rows; + + guint strikethrough; + + guint editable; + + guint scale_set; + + guint foreground_set; + guint background_set; + + guint underline_set; + + guint rise_set; + + guint strikethrough_set; + + guint editable_set; + guint calc_fixed_height; + } + + struct _GtkCellRendererTextClass { + GtkCellRendererClass parent_class; + + void (* edited) (GtkCellRendererText *cell_renderer_text, + gchar *path, + gchar *new_text); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_cell_renderer_text_get_type (); + GtkCellRenderer *gtk_cell_renderer_text_new (); + + void gtk_cell_renderer_text_set_fixed_height_from_font (GtkCellRendererText *renderer, + gint number_of_rows); + alias _GtkCellRendererToggle GtkCellRendererToggle; + + alias _GtkCellRendererToggleClass GtkCellRendererToggleClass; + + + struct _GtkCellRendererToggle { + GtkCellRenderer parent; + + + guint active; + guint activatable; + guint radio; + } + + struct _GtkCellRendererToggleClass { + GtkCellRendererClass parent_class; + + void (* toggled) (GtkCellRendererToggle *cell_renderer_toggle, + gchar *path); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_cell_renderer_toggle_get_type (); + GtkCellRenderer *gtk_cell_renderer_toggle_new (); + + gboolean gtk_cell_renderer_toggle_get_radio (GtkCellRendererToggle *toggle); + void gtk_cell_renderer_toggle_set_radio (GtkCellRendererToggle *toggle, + gboolean radio); + + gboolean gtk_cell_renderer_toggle_get_active (GtkCellRendererToggle *toggle); + void gtk_cell_renderer_toggle_set_active (GtkCellRendererToggle *toggle, + gboolean setting); + alias _GtkToggleButton GtkToggleButton; + + alias _GtkToggleButtonClass GtkToggleButtonClass; + + + struct _GtkToggleButton { + GtkButton button; + + guint active; + guint draw_indicator; + guint inconsistent; + } + + struct _GtkToggleButtonClass { + GtkButtonClass parent_class; + + void (* toggled) (GtkToggleButton *toggle_button); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_toggle_button_get_type () ; + + GtkWidget* gtk_toggle_button_new (); + GtkWidget* gtk_toggle_button_new_with_label ( gchar *label); + GtkWidget* gtk_toggle_button_new_with_mnemonic ( gchar *label); + void gtk_toggle_button_set_mode (GtkToggleButton *toggle_button, + gboolean draw_indicator); + gboolean gtk_toggle_button_get_mode (GtkToggleButton *toggle_button); + void gtk_toggle_button_set_active (GtkToggleButton *toggle_button, + gboolean is_active); + gboolean gtk_toggle_button_get_active (GtkToggleButton *toggle_button); + void gtk_toggle_button_toggled (GtkToggleButton *toggle_button); + void gtk_toggle_button_set_inconsistent (GtkToggleButton *toggle_button, + gboolean setting); + gboolean gtk_toggle_button_get_inconsistent (GtkToggleButton *toggle_button); + alias _GtkCheckButton GtkCheckButton; + + alias _GtkCheckButtonClass GtkCheckButtonClass; + + + struct _GtkCheckButton { + GtkToggleButton toggle_button; + } + + struct _GtkCheckButtonClass { + GtkToggleButtonClass parent_class; + + void (* draw_indicator) (GtkCheckButton *check_button, + GdkRectangle *area); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_check_button_get_type () ; + GtkWidget* gtk_check_button_new (); + GtkWidget* gtk_check_button_new_with_label ( gchar *label); + GtkWidget* gtk_check_button_new_with_mnemonic ( gchar *label); + + void _gtk_check_button_get_props (GtkCheckButton *check_button, + gint *indicator_size, + gint *indicator_spacing); + alias _GtkItem GtkItem; + + alias _GtkItemClass GtkItemClass; + + + struct _GtkItem { + GtkBin bin; + } + + struct _GtkItemClass { + GtkBinClass parent_class; + + void (* select) (GtkItem *item); + void (* deselect) (GtkItem *item); + void (* toggle) (GtkItem *item); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_item_get_type () ; + void gtk_item_select (GtkItem *item); + void gtk_item_deselect (GtkItem *item); + void gtk_item_toggle (GtkItem *item); + alias _GtkMenuItem GtkMenuItem; + + alias _GtkMenuItemClass GtkMenuItemClass; + + + struct _GtkMenuItem { + GtkItem item; + + GtkWidget *submenu; + GdkWindow *event_window; + + guint16 toggle_size; + guint16 accelerator_width; + gchar *accel_path; + + guint show_submenu_indicator; + guint submenu_placement; + guint submenu_direction; + guint right_justify; + guint timer_from_keypress; + guint timer; + } + + struct _GtkMenuItemClass { + GtkItemClass parent_class; + + + + + + + + guint hide_on_activate; + + void (* activate) (GtkMenuItem *menu_item); + void (* activate_item) (GtkMenuItem *menu_item); + void (* toggle_size_request) (GtkMenuItem *menu_item, + gint *requisition); + void (* toggle_size_allocate) (GtkMenuItem *menu_item, + gint allocation); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_menu_item_get_type () ; + GtkWidget* gtk_menu_item_new (); + GtkWidget* gtk_menu_item_new_with_label ( gchar *label); + GtkWidget* gtk_menu_item_new_with_mnemonic ( gchar *label); + void gtk_menu_item_set_submenu (GtkMenuItem *menu_item, + GtkWidget *submenu); + GtkWidget* gtk_menu_item_get_submenu (GtkMenuItem *menu_item); + void gtk_menu_item_remove_submenu (GtkMenuItem *menu_item); + void gtk_menu_item_select (GtkMenuItem *menu_item); + void gtk_menu_item_deselect (GtkMenuItem *menu_item); + void gtk_menu_item_activate (GtkMenuItem *menu_item); + void gtk_menu_item_toggle_size_request (GtkMenuItem *menu_item, + gint *requisition); + void gtk_menu_item_toggle_size_allocate (GtkMenuItem *menu_item, + gint allocation); + void gtk_menu_item_set_right_justified (GtkMenuItem *menu_item, + gboolean right_justified); + gboolean gtk_menu_item_get_right_justified (GtkMenuItem *menu_item); + void gtk_menu_item_set_accel_path (GtkMenuItem *menu_item, + gchar *accel_path); + + + void _gtk_menu_item_refresh_accel_path (GtkMenuItem *menu_item, + gchar *prefix, + GtkAccelGroup *accel_group, + gboolean group_changed); + gboolean _gtk_menu_item_is_selectable (GtkWidget *menu_item); + alias _GtkCheckMenuItem GtkCheckMenuItem; + + alias _GtkCheckMenuItemClass GtkCheckMenuItemClass; + + + struct _GtkCheckMenuItem { + GtkMenuItem menu_item; + + guint active; + guint always_show_toggle; + guint inconsistent; + guint draw_as_radio; + } + + struct _GtkCheckMenuItemClass { + GtkMenuItemClass parent_class; + + void (* toggled) (GtkCheckMenuItem *check_menu_item); + void (* draw_indicator) (GtkCheckMenuItem *check_menu_item, + GdkRectangle *area); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_check_menu_item_get_type () ; + + GtkWidget* gtk_check_menu_item_new (); + GtkWidget* gtk_check_menu_item_new_with_label ( gchar *label); + GtkWidget* gtk_check_menu_item_new_with_mnemonic ( gchar *label); + void gtk_check_menu_item_set_active (GtkCheckMenuItem *check_menu_item, + gboolean is_active); + gboolean gtk_check_menu_item_get_active (GtkCheckMenuItem *check_menu_item); + void gtk_check_menu_item_toggled (GtkCheckMenuItem *check_menu_item); + void gtk_check_menu_item_set_inconsistent (GtkCheckMenuItem *check_menu_item, + gboolean setting); + gboolean gtk_check_menu_item_get_inconsistent (GtkCheckMenuItem *check_menu_item); + void gtk_check_menu_item_set_draw_as_radio (GtkCheckMenuItem *check_menu_item, + gboolean draw_as_radio); + gboolean gtk_check_menu_item_get_draw_as_radio (GtkCheckMenuItem *check_menu_item); + + + + void gtk_check_menu_item_set_show_toggle (GtkCheckMenuItem *menu_item, + gboolean always); + alias _GtkTargetList GtkTargetList; + + alias _GtkTargetEntry GtkTargetEntry; + + struct _GtkSelectionData { + GdkAtom selection; + GdkAtom target; + GdkAtom type; + gint format; + guchar *data; + gint length; + GdkDisplay *display; + } + + struct _GtkTargetEntry { + gchar *target; + guint flags; + guint info; + } + + + + + + alias _GtkTargetPair GtkTargetPair; + + + + struct _GtkTargetList { + GList *list; + guint ref_count; + } + + struct _GtkTargetPair { + GdkAtom target; + guint flags; + guint info; + } + + GtkTargetList *gtk_target_list_new ( GtkTargetEntry *targets, + guint ntargets); + void gtk_target_list_ref (GtkTargetList *list); + void gtk_target_list_unref (GtkTargetList *list); + void gtk_target_list_add (GtkTargetList *list, + GdkAtom target, + guint flags, + guint info); + void gtk_target_list_add_table (GtkTargetList *list, + GtkTargetEntry *targets, + guint ntargets); + void gtk_target_list_remove (GtkTargetList *list, + GdkAtom target); + gboolean gtk_target_list_find (GtkTargetList *list, + GdkAtom target, + guint *info); + + + + gboolean gtk_selection_owner_set (GtkWidget *widget, + GdkAtom selection, + guint32 time_); + gboolean gtk_selection_owner_set_for_display (GdkDisplay *display, + GtkWidget *widget, + GdkAtom selection, + guint32 time_); + + void gtk_selection_add_target (GtkWidget *widget, + GdkAtom selection, + GdkAtom target, + guint info); + void gtk_selection_add_targets (GtkWidget *widget, + GdkAtom selection, + GtkTargetEntry *targets, + guint ntargets); + void gtk_selection_clear_targets (GtkWidget *widget, + GdkAtom selection); + gboolean gtk_selection_convert (GtkWidget *widget, + GdkAtom selection, + GdkAtom target, + guint32 time_); + void gtk_selection_data_set (GtkSelectionData *selection_data, + GdkAtom type, + gint format, + guchar *data, + gint length); + gboolean gtk_selection_data_set_text (GtkSelectionData *selection_data, + gchar *str, + gint len); + guchar * gtk_selection_data_get_text (GtkSelectionData *selection_data); + + gboolean gtk_selection_data_get_targets (GtkSelectionData *selection_data, + GdkAtom **targets, + gint *n_atoms); + gboolean gtk_selection_data_targets_include_text (GtkSelectionData *selection_data); + + + + void gtk_selection_remove_all (GtkWidget *widget); + + + + gboolean gtk_selection_clear (GtkWidget *widget, + GdkEventSelection *event); + + gboolean _gtk_selection_request (GtkWidget *widget, + GdkEventSelection *event); + gboolean _gtk_selection_incr_event (GdkWindow *window, + GdkEventProperty *event); + gboolean _gtk_selection_notify (GtkWidget *widget, + GdkEventSelection *event); + gboolean _gtk_selection_property_notify (GtkWidget *widget, + GdkEventProperty *event); + + GType gtk_selection_data_get_type (); + GtkSelectionData *gtk_selection_data_copy (GtkSelectionData *data); + void gtk_selection_data_free (GtkSelectionData *data); + + + + + + alias void (* GtkClipboardReceivedFunc) (GtkClipboard *clipboard, + GtkSelectionData *selection_data, + gpointer data); + alias void (* GtkClipboardTextReceivedFunc) (GtkClipboard *clipboard, + gchar *text, + gpointer data); + alias void (* GtkClipboardTargetsReceivedFunc) (GtkClipboard *clipboard, + GdkAtom *atoms, + gint n_atoms, + gpointer data); + + + + + + alias void (* GtkClipboardGetFunc) (GtkClipboard *clipboard, + GtkSelectionData *selection_data, + guint info, + gpointer user_data_or_owner); + alias void (* GtkClipboardClearFunc) (GtkClipboard *clipboard, + gpointer user_data_or_owner); + + GType gtk_clipboard_get_type (); + + GtkClipboard *gtk_clipboard_get_for_display (GdkDisplay *display, + GdkAtom selection); + + GtkClipboard *gtk_clipboard_get (GdkAtom selection); + + + GdkDisplay *gtk_clipboard_get_display (GtkClipboard *clipboard); + + + gboolean gtk_clipboard_set_with_data (GtkClipboard *clipboard, + GtkTargetEntry *targets, + guint n_targets, + GtkClipboardGetFunc get_func, + GtkClipboardClearFunc clear_func, + gpointer user_data); + gboolean gtk_clipboard_set_with_owner (GtkClipboard *clipboard, + GtkTargetEntry *targets, + guint n_targets, + GtkClipboardGetFunc get_func, + GtkClipboardClearFunc clear_func, + GObject *owner); + GObject *gtk_clipboard_get_owner (GtkClipboard *clipboard); + void gtk_clipboard_clear (GtkClipboard *clipboard); + void gtk_clipboard_set_text (GtkClipboard *clipboard, + gchar *text, + gint len); + + void gtk_clipboard_request_contents (GtkClipboard *clipboard, + GdkAtom target, + GtkClipboardReceivedFunc callback, + gpointer user_data); + void gtk_clipboard_request_text (GtkClipboard *clipboard, + GtkClipboardTextReceivedFunc callback, + gpointer user_data); + void gtk_clipboard_request_targets (GtkClipboard *clipboard, + GtkClipboardTargetsReceivedFunc callback, + gpointer user_data); + + GtkSelectionData *gtk_clipboard_wait_for_contents (GtkClipboard *clipboard, + GdkAtom target); + gchar * gtk_clipboard_wait_for_text (GtkClipboard *clipboard); + + gboolean gtk_clipboard_wait_is_text_available (GtkClipboard *clipboard); + + gboolean gtk_clipboard_wait_for_targets (GtkClipboard *clipboard, + GdkAtom **targets, + gint *n_targets); + alias _GtkRangeLayout GtkRangeLayout; + alias void _GtkRangeLayout; + + alias _GtkRangeStepTimer GtkRangeStepTimer; + alias void _GtkRangeStepTimer; + + + alias _GtkRange GtkRange; + + alias _GtkRangeClass GtkRangeClass; + + + struct _GtkRange { + GtkWidget widget; + + GtkAdjustment *adjustment; + GtkUpdateType update_policy; + guint inverted; + + + + guint flippable; + + + + + + guint has_stepper_a; + guint has_stepper_b; + guint has_stepper_c; + guint has_stepper_d; + + guint need_recalc; + + guint slider_size_fixed; + + gint min_slider_size; + + GtkOrientation orientation; + + + GdkRectangle range_rect; + + gint slider_start, slider_end; + + + gint round_digits; + + + guint trough_click_forward; + guint update_pending; + GtkRangeLayout *layout; + GtkRangeStepTimer *timer; + gint slide_initial_slider_position; + gint slide_initial_coordinate; + guint update_timeout_id; + GdkWindow *event_window; + } + + struct _GtkRangeClass { + GtkWidgetClass parent_class; + + + gchar *slider_detail; + gchar *stepper_detail; + + void (* value_changed) (GtkRange *range); + void (* adjust_bounds) (GtkRange *range, + gdouble new_value); + + + void (* move_slider) (GtkRange *range, + GtkScrollType scroll); + + + void (* get_range_border) (GtkRange *range, + GtkBorder *border_); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_range_get_type () ; + + void gtk_range_set_update_policy (GtkRange *range, + GtkUpdateType policy); + GtkUpdateType gtk_range_get_update_policy (GtkRange *range); + void gtk_range_set_adjustment (GtkRange *range, + GtkAdjustment *adjustment); + GtkAdjustment* gtk_range_get_adjustment (GtkRange *range); + void gtk_range_set_inverted (GtkRange *range, + gboolean setting); + gboolean gtk_range_get_inverted (GtkRange *range); + void gtk_range_set_increments (GtkRange *range, + gdouble step, + gdouble page); + void gtk_range_set_range (GtkRange *range, + gdouble min, + gdouble max); + void gtk_range_set_value (GtkRange *range, + gdouble value); + gdouble gtk_range_get_value (GtkRange *range); + alias _GtkScrollbar GtkScrollbar; + + alias _GtkScrollbarClass GtkScrollbarClass; + + + struct _GtkScrollbar { + GtkRange range; + } + + struct _GtkScrollbarClass { + GtkRangeClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_scrollbar_get_type () ; + alias _GtkHScrollbar GtkHScrollbar; + + alias _GtkHScrollbarClass GtkHScrollbarClass; + + + struct _GtkHScrollbar { + GtkScrollbar scrollbar; + } + + struct _GtkHScrollbarClass { + GtkScrollbarClass parent_class; + } + + + GType gtk_hscrollbar_get_type () ; + GtkWidget* gtk_hscrollbar_new (GtkAdjustment *adjustment); + alias _GtkVScrollbar GtkVScrollbar; + + alias _GtkVScrollbarClass GtkVScrollbarClass; + + + struct _GtkVScrollbar { + GtkScrollbar scrollbar; + } + + struct _GtkVScrollbarClass { + GtkScrollbarClass parent_class; + } + + + + + + + + GType gtk_vscrollbar_get_type () ; + GtkWidget* gtk_vscrollbar_new (GtkAdjustment *adjustment); + + + + + + + + enum { + GTK_CLIST_IN_DRAG = 1 << 0, + GTK_CLIST_ROW_HEIGHT_SET = 1 << 1, + GTK_CLIST_SHOW_TITLES = 1 << 2, + + GTK_CLIST_ADD_MODE = 1 << 4, + GTK_CLIST_AUTO_SORT = 1 << 5, + GTK_CLIST_AUTO_RESIZE_BLOCKED = 1 << 6, + GTK_CLIST_REORDERABLE = 1 << 7, + GTK_CLIST_USE_DRAG_ICONS = 1 << 8, + GTK_CLIST_DRAW_DRAG_LINE = 1 << 9, + GTK_CLIST_DRAW_DRAG_RECT = 1 << 10 + }; + + + enum GtkCellType { + GTK_CELL_EMPTY, + GTK_CELL_TEXT, + GTK_CELL_PIXMAP, + GTK_CELL_PIXTEXT, + GTK_CELL_WIDGET + }; + + + enum GtkCListDragPos { + GTK_CLIST_DRAG_NONE, + GTK_CLIST_DRAG_BEFORE, + GTK_CLIST_DRAG_INTO, + GTK_CLIST_DRAG_AFTER + }; + + + enum GtkButtonAction { + GTK_BUTTON_IGNORED = 0, + GTK_BUTTON_SELECTS = 1 << 0, + GTK_BUTTON_DRAGS = 1 << 1, + GTK_BUTTON_EXPANDS = 1 << 2 + }; + + alias _GtkCList GtkCList; + + alias _GtkCListClass GtkCListClass; + + alias _GtkCListColumn GtkCListColumn; + + alias _GtkCListRow GtkCListRow; + + + alias _GtkCell GtkCell; + + alias _GtkCellText GtkCellText; + + alias _GtkCellPixmap GtkCellPixmap; + + alias _GtkCellPixText GtkCellPixText; + + alias _GtkCellWidget GtkCellWidget; + + + alias gint (*GtkCListCompareFunc) (GtkCList *clist, + gpointer ptr1, + gpointer ptr2); + + alias _GtkCListCellInfo GtkCListCellInfo; + + alias _GtkCListDestInfo GtkCListDestInfo; + + + struct _GtkCListCellInfo { + gint row; + gint column; + } + + struct _GtkCListDestInfo { + GtkCListCellInfo cell; + GtkCListDragPos insert_pos; + } + + struct _GtkCList { + GtkContainer container; + + guint16 flags; + + + GMemChunk *row_mem_chunk; + GMemChunk *cell_mem_chunk; + + guint freeze_count; + + + + GdkRectangle internal_allocation; + + + gint rows; + gint row_height; + GList *row_list; + GList *row_list_end; + + + gint columns; + GdkRectangle column_title_area; + GdkWindow *title_window; + + + GtkCListColumn *column; + + + + GdkWindow *clist_window; + gint clist_window_width; + gint clist_window_height; + + + gint hoffset; + gint voffset; + + + GtkShadowType shadow_type; + + + GtkSelectionMode selection_mode; + + + GList *selection; + GList *selection_end; + + GList *undo_selection; + GList *undo_unselection; + gint undo_anchor; + + + guint8 button_actions[5]; + + guint8 drag_button; + + + GtkCListCellInfo click_cell; + + + GtkAdjustment *hadjustment; + GtkAdjustment *vadjustment; + + + GdkGC *xor_gc; + + + GdkGC *fg_gc; + GdkGC *bg_gc; + + + GdkCursor *cursor_drag; + + + gint x_drag; + + + gint focus_row; + + gint focus_header_column; + + + gint anchor; + GtkStateType anchor_state; + gint drag_pos; + gint htimer; + gint vtimer; + + GtkSortType sort_type; + GtkCListCompareFunc compare; + gint sort_column; + + gint drag_highlight_row; + GtkCListDragPos drag_highlight_pos; + } + + struct _GtkCListClass { + GtkContainerClass parent_class; + + void (*set_scroll_adjustments) (GtkCList *clist, + GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); + void (*refresh) (GtkCList *clist); + void (*select_row) (GtkCList *clist, + gint row, + gint column, + GdkEvent *event); + void (*unselect_row) (GtkCList *clist, + gint row, + gint column, + GdkEvent *event); + void (*row_move) (GtkCList *clist, + gint source_row, + gint dest_row); + void (*click_column) (GtkCList *clist, + gint column); + void (*resize_column) (GtkCList *clist, + gint column, + gint width); + void (*toggle_focus_row) (GtkCList *clist); + void (*select_all) (GtkCList *clist); + void (*unselect_all) (GtkCList *clist); + void (*undo_selection) (GtkCList *clist); + void (*start_selection) (GtkCList *clist); + void (*end_selection) (GtkCList *clist); + void (*extend_selection) (GtkCList *clist, + GtkScrollType scroll_type, + gfloat position, + gboolean auto_start_selection); + void (*scroll_horizontal) (GtkCList *clist, + GtkScrollType scroll_type, + gfloat position); + void (*scroll_vertical) (GtkCList *clist, + GtkScrollType scroll_type, + gfloat position); + void (*toggle_add_mode) (GtkCList *clist); + void (*abort_column_resize) (GtkCList *clist); + void (*resync_selection) (GtkCList *clist, + GdkEvent *event); + GList* (*selection_find) (GtkCList *clist, + gint row_number, + GList *row_list_element); + void (*draw_row) (GtkCList *clist, + GdkRectangle *area, + gint row, + GtkCListRow *clist_row); + void (*draw_drag_highlight) (GtkCList *clist, + GtkCListRow *target_row, + gint target_row_number, + GtkCListDragPos drag_pos); + void (*clear) (GtkCList *clist); + void (*fake_unselect_all) (GtkCList *clist, + gint row); + void (*sort_list) (GtkCList *clist); + gint (*insert_row) (GtkCList *clist, + gint row, + gchar *text[]); + void (*remove_row) (GtkCList *clist, + gint row); + void (*set_cell_contents) (GtkCList *clist, + GtkCListRow *clist_row, + gint column, + GtkCellType type, + gchar *text, + guint8 spacing, + GdkPixmap *pixmap, + GdkBitmap *mask); + void (*cell_size_request) (GtkCList *clist, + GtkCListRow *clist_row, + gint column, + GtkRequisition *requisition); + + } + + struct _GtkCListColumn { + gchar *title; + GdkRectangle area; + + GtkWidget *button; + GdkWindow *window; + + gint width; + gint min_width; + gint max_width; + GtkJustification justification; + + guint visible; + guint width_set; + guint resizeable; + guint auto_resize; + guint button_passive; + } + + struct _GtkCListRow { + GtkCell *cell; + GtkStateType state; + + GdkColor foreground; + GdkColor background; + + GtkStyle *style; + + gpointer data; + GtkDestroyNotify destroy; + + guint fg_set; + guint bg_set; + guint selectable; + } + + + struct _GtkCellText { + GtkCellType type; + + gint16 vertical; + gint16 horizontal; + + GtkStyle *style; + + gchar *text; + } + + struct _GtkCellPixmap { + GtkCellType type; + + gint16 vertical; + gint16 horizontal; + + GtkStyle *style; + + GdkPixmap *pixmap; + GdkBitmap *mask; + } + + struct _GtkCellPixText { + GtkCellType type; + + gint16 vertical; + gint16 horizontal; + + GtkStyle *style; + + gchar *text; + guint8 spacing; + GdkPixmap *pixmap; + GdkBitmap *mask; + } + + struct _GtkCellWidget { + GtkCellType type; + + gint16 vertical; + gint16 horizontal; + + GtkStyle *style; + + GtkWidget *widget; + } + + struct _GtkCell { + GtkCellType type; + + gint16 vertical; + gint16 horizontal; + + GtkStyle *style; + + union u_union { + gchar *text; + + struct pm_struct { + GdkPixmap *pixmap; + GdkBitmap *mask; + } + + struct pt_struct { + gchar *text; + guint8 spacing; + GdkPixmap *pixmap; + GdkBitmap *mask; + } + + GtkWidget *widget; + } + u_union u; + } + + GtkType gtk_clist_get_type () ; + + + GtkWidget* gtk_clist_new (gint columns); + GtkWidget* gtk_clist_new_with_titles (gint columns, + gchar *titles[]); + + + void gtk_clist_set_hadjustment (GtkCList *clist, + GtkAdjustment *adjustment); + void gtk_clist_set_vadjustment (GtkCList *clist, + GtkAdjustment *adjustment); + + + GtkAdjustment* gtk_clist_get_hadjustment (GtkCList *clist); + GtkAdjustment* gtk_clist_get_vadjustment (GtkCList *clist); + + + void gtk_clist_set_shadow_type (GtkCList *clist, + GtkShadowType type); + + + void gtk_clist_set_selection_mode (GtkCList *clist, + GtkSelectionMode mode); + + + void gtk_clist_set_reorderable (GtkCList *clist, + gboolean reorderable); + void gtk_clist_set_use_drag_icons (GtkCList *clist, + gboolean use_icons); + void gtk_clist_set_button_actions (GtkCList *clist, + guint button, + guint8 button_actions); + + + + + + void gtk_clist_freeze (GtkCList *clist); + void gtk_clist_thaw (GtkCList *clist); + + + void gtk_clist_column_titles_show (GtkCList *clist); + void gtk_clist_column_titles_hide (GtkCList *clist); + + + + + + void gtk_clist_column_title_active (GtkCList *clist, + gint column); + void gtk_clist_column_title_passive (GtkCList *clist, + gint column); + void gtk_clist_column_titles_active (GtkCList *clist); + void gtk_clist_column_titles_passive (GtkCList *clist); + + + void gtk_clist_set_column_title (GtkCList *clist, + gint column, + gchar *title); + + + gchar * gtk_clist_get_column_title (GtkCList *clist, + gint column); + + + void gtk_clist_set_column_widget (GtkCList *clist, + gint column, + GtkWidget *widget); + + + GtkWidget * gtk_clist_get_column_widget (GtkCList *clist, + gint column); + + + void gtk_clist_set_column_justification (GtkCList *clist, + gint column, + GtkJustification justification); + + + void gtk_clist_set_column_visibility (GtkCList *clist, + gint column, + gboolean visible); + + + void gtk_clist_set_column_resizeable (GtkCList *clist, + gint column, + gboolean resizeable); + + + void gtk_clist_set_column_auto_resize (GtkCList *clist, + gint column, + gboolean auto_resize); + + gint gtk_clist_columns_autosize (GtkCList *clist); + + + gint gtk_clist_optimal_column_width (GtkCList *clist, + gint column); + + + + + + void gtk_clist_set_column_width (GtkCList *clist, + gint column, + gint width); + + + void gtk_clist_set_column_min_width (GtkCList *clist, + gint column, + gint min_width); + void gtk_clist_set_column_max_width (GtkCList *clist, + gint column, + gint max_width); + + + + + void gtk_clist_set_row_height (GtkCList *clist, + guint height); + + + + + + + void gtk_clist_moveto (GtkCList *clist, + gint row, + gint column, + gfloat row_align, + gfloat col_align); + + + GtkVisibility gtk_clist_row_is_visible (GtkCList *clist, + gint row); + + + GtkCellType gtk_clist_get_cell_type (GtkCList *clist, + gint row, + gint column); + + + void gtk_clist_set_text (GtkCList *clist, + gint row, + gint column, + gchar *text); + + + + + gint gtk_clist_get_text (GtkCList *clist, + gint row, + gint column, + gchar **text); + + + void gtk_clist_set_pixmap (GtkCList *clist, + gint row, + gint column, + GdkPixmap *pixmap, + GdkBitmap *mask); + + gint gtk_clist_get_pixmap (GtkCList *clist, + gint row, + gint column, + GdkPixmap **pixmap, + GdkBitmap **mask); + + + void gtk_clist_set_pixtext (GtkCList *clist, + gint row, + gint column, + gchar *text, + guint8 spacing, + GdkPixmap *pixmap, + GdkBitmap *mask); + + gint gtk_clist_get_pixtext (GtkCList *clist, + gint row, + gint column, + gchar **text, + guint8 *spacing, + GdkPixmap **pixmap, + GdkBitmap **mask); + + + + + void gtk_clist_set_foreground (GtkCList *clist, + gint row, + GdkColor *color); + + + + + void gtk_clist_set_background (GtkCList *clist, + gint row, + GdkColor *color); + + + void gtk_clist_set_cell_style (GtkCList *clist, + gint row, + gint column, + GtkStyle *style); + + GtkStyle *gtk_clist_get_cell_style (GtkCList *clist, + gint row, + gint column); + + void gtk_clist_set_row_style (GtkCList *clist, + gint row, + GtkStyle *style); + + GtkStyle *gtk_clist_get_row_style (GtkCList *clist, + gint row); + + + + + + void gtk_clist_set_shift (GtkCList *clist, + gint row, + gint column, + gint vertical, + gint horizontal); + + + void gtk_clist_set_selectable (GtkCList *clist, + gint row, + gboolean selectable); + gboolean gtk_clist_get_selectable (GtkCList *clist, + gint row); + + + + + gint gtk_clist_prepend (GtkCList *clist, + gchar *text[]); + gint gtk_clist_append (GtkCList *clist, + gchar *text[]); + + + + + gint gtk_clist_insert (GtkCList *clist, + gint row, + gchar *text[]); + + + void gtk_clist_remove (GtkCList *clist, + gint row); + + + void gtk_clist_set_row_data (GtkCList *clist, + gint row, + gpointer data); + + + void gtk_clist_set_row_data_full (GtkCList *clist, + gint row, + gpointer data, + GtkDestroyNotify destroy); + + + gpointer gtk_clist_get_row_data (GtkCList *clist, + gint row); + + + + + gint gtk_clist_find_row_from_data (GtkCList *clist, + gpointer data); + + + void gtk_clist_select_row (GtkCList *clist, + gint row, + gint column); + + + void gtk_clist_unselect_row (GtkCList *clist, + gint row, + gint column); + + + void gtk_clist_undo_selection (GtkCList *clist); + + + + + void gtk_clist_clear (GtkCList *clist); + + + + + + gint gtk_clist_get_selection_info (GtkCList *clist, + gint x, + gint y, + gint *row, + gint *column); + + + void gtk_clist_select_all (GtkCList *clist); + + + void gtk_clist_unselect_all (GtkCList *clist); + + + void gtk_clist_swap_rows (GtkCList *clist, + gint row1, + gint row2); + + + void gtk_clist_row_move (GtkCList *clist, + gint source_row, + gint dest_row); + + + void gtk_clist_set_compare_func (GtkCList *clist, + GtkCListCompareFunc cmp_func); + + + void gtk_clist_set_sort_column (GtkCList *clist, + gint column); + + + void gtk_clist_set_sort_type (GtkCList *clist, + GtkSortType sort_type); + + + void gtk_clist_sort (GtkCList *clist); + + + void gtk_clist_set_auto_sort (GtkCList *clist, + gboolean auto_sort); + + + + PangoLayout *_gtk_clist_create_cell_layout (GtkCList *clist, + GtkCListRow *clist_row, + gint column); + + alias _GtkColorButton GtkColorButton; + + alias _GtkColorButtonClass GtkColorButtonClass; + + alias _GtkColorButtonPrivate GtkColorButtonPrivate; + alias void _GtkColorButtonPrivate; + + + struct _GtkColorButton { + GtkButton button; + + + + GtkColorButtonPrivate *priv; + } + + struct _GtkColorButtonClass { + GtkButtonClass parent_class; + + void (* color_set) (GtkColorButton *cp); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_color_button_get_type () ; + GtkWidget *gtk_color_button_new (); + GtkWidget *gtk_color_button_new_with_color ( GdkColor *color); + void gtk_color_button_set_color (GtkColorButton *color_button, + GdkColor *color); + void gtk_color_button_set_alpha (GtkColorButton *color_button, + guint16 alpha); + void gtk_color_button_get_color (GtkColorButton *color_button, + GdkColor *color); + guint16 gtk_color_button_get_alpha (GtkColorButton *color_button); + void gtk_color_button_set_use_alpha (GtkColorButton *color_button, + gboolean use_alpha); + gboolean gtk_color_button_get_use_alpha (GtkColorButton *color_button); + void gtk_color_button_set_title (GtkColorButton *color_button, + gchar *title); + gchar *gtk_color_button_get_title (GtkColorButton *color_button); + + + + enum GtkDialogFlags { + GTK_DIALOG_MODAL = 1 << 0, + GTK_DIALOG_DESTROY_WITH_PARENT = 1 << 1, + GTK_DIALOG_NO_SEPARATOR = 1 << 2 + }; + + enum GtkResponseType { + + + + GTK_RESPONSE_NONE = -1, + + + + + + GTK_RESPONSE_REJECT = -2, + GTK_RESPONSE_ACCEPT = -3, + + + GTK_RESPONSE_DELETE_EVENT = -4, + + + + + GTK_RESPONSE_OK = -5, + GTK_RESPONSE_CANCEL = -6, + GTK_RESPONSE_CLOSE = -7, + GTK_RESPONSE_YES = -8, + GTK_RESPONSE_NO = -9, + GTK_RESPONSE_APPLY = -10, + GTK_RESPONSE_HELP = -11 + }; + + alias _GtkDialog GtkDialog; + + alias _GtkDialogClass GtkDialogClass; + + + struct _GtkDialog { + GtkWindow window; + + + GtkWidget *vbox; + GtkWidget *action_area; + + + GtkWidget *separator; + } + + struct _GtkDialogClass { + GtkWindowClass parent_class; + + void (* response) (GtkDialog *dialog, gint response_id); + + + + void (* close) (GtkDialog *dialog); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_dialog_get_type () ; + GtkWidget* gtk_dialog_new (); + + GtkWidget* gtk_dialog_new_with_buttons ( gchar *title, + GtkWindow *parent, + GtkDialogFlags flags, + gchar *first_button_text, + ...); + + void gtk_dialog_add_action_widget (GtkDialog *dialog, + GtkWidget *child, + gint response_id); + GtkWidget* gtk_dialog_add_button (GtkDialog *dialog, + gchar *button_text, + gint response_id); + void gtk_dialog_add_buttons (GtkDialog *dialog, + gchar *first_button_text, + ...); + + void gtk_dialog_set_response_sensitive (GtkDialog *dialog, + gint response_id, + gboolean setting); + void gtk_dialog_set_default_response (GtkDialog *dialog, + gint response_id); + + void gtk_dialog_set_has_separator (GtkDialog *dialog, + gboolean setting); + gboolean gtk_dialog_get_has_separator (GtkDialog *dialog); + + + void gtk_dialog_response (GtkDialog *dialog, + gint response_id); + + + gint gtk_dialog_run (GtkDialog *dialog); + + + + void _gtk_dialog_set_ignore_separator (GtkDialog *dialog, + gboolean ignore_separator); + gint _gtk_dialog_get_response_for_widget (GtkDialog *dialog, + GtkWidget *widget); + alias _GtkVBox GtkVBox; + + alias _GtkVBoxClass GtkVBoxClass; + + + struct _GtkVBox { + GtkBox box; + } + + struct _GtkVBoxClass { + GtkBoxClass parent_class; + } + + + GType gtk_vbox_get_type () ; + GtkWidget* gtk_vbox_new (gboolean homogeneous, + gint spacing); + alias _GtkColorSelection GtkColorSelection; + + alias _GtkColorSelectionClass GtkColorSelectionClass; + + + + alias void (* GtkColorSelectionChangePaletteFunc) ( GdkColor *colors, + gint n_colors); + alias void (* GtkColorSelectionChangePaletteWithScreenFunc) (GdkScreen *screen, + GdkColor *colors, + gint n_colors); + + struct _GtkColorSelection { + GtkVBox parent_instance; + + + gpointer private_data; + } + + struct _GtkColorSelectionClass { + GtkVBoxClass parent_class; + + void (*color_changed) (GtkColorSelection *color_selection); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + + + GType gtk_color_selection_get_type () ; + GtkWidget *gtk_color_selection_new (); + gboolean gtk_color_selection_get_has_opacity_control (GtkColorSelection *colorsel); + void gtk_color_selection_set_has_opacity_control (GtkColorSelection *colorsel, + gboolean has_opacity); + gboolean gtk_color_selection_get_has_palette (GtkColorSelection *colorsel); + void gtk_color_selection_set_has_palette (GtkColorSelection *colorsel, + gboolean has_palette); + + + void gtk_color_selection_set_current_color (GtkColorSelection *colorsel, + GdkColor *color); + void gtk_color_selection_set_current_alpha (GtkColorSelection *colorsel, + guint16 alpha); + void gtk_color_selection_get_current_color (GtkColorSelection *colorsel, + GdkColor *color); + guint16 gtk_color_selection_get_current_alpha (GtkColorSelection *colorsel); + void gtk_color_selection_set_previous_color (GtkColorSelection *colorsel, + GdkColor *color); + void gtk_color_selection_set_previous_alpha (GtkColorSelection *colorsel, + guint16 alpha); + void gtk_color_selection_get_previous_color (GtkColorSelection *colorsel, + GdkColor *color); + guint16 gtk_color_selection_get_previous_alpha (GtkColorSelection *colorsel); + + gboolean gtk_color_selection_is_adjusting (GtkColorSelection *colorsel); + + gboolean gtk_color_selection_palette_from_string ( gchar *str, + GdkColor **colors, + gint *n_colors); + gchar* gtk_color_selection_palette_to_string ( GdkColor *colors, + gint n_colors); + + + + GtkColorSelectionChangePaletteFunc gtk_color_selection_set_change_palette_hook (GtkColorSelectionChangePaletteFunc func); + + + + GtkColorSelectionChangePaletteWithScreenFunc gtk_color_selection_set_change_palette_with_screen_hook (GtkColorSelectionChangePaletteWithScreenFunc func); + + + + void gtk_color_selection_set_color (GtkColorSelection *colorsel, + gdouble *color); + void gtk_color_selection_get_color (GtkColorSelection *colorsel, + gdouble *color); + void gtk_color_selection_set_update_policy (GtkColorSelection *colorsel, + GtkUpdateType policy); + alias _GtkColorSelectionDialog GtkColorSelectionDialog; + + alias _GtkColorSelectionDialogClass GtkColorSelectionDialogClass; + + + + struct _GtkColorSelectionDialog { + GtkDialog parent_instance; + + GtkWidget *colorsel; + GtkWidget *ok_button; + GtkWidget *cancel_button; + GtkWidget *help_button; + } + + struct _GtkColorSelectionDialogClass { + GtkDialogClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + + GType gtk_color_selection_dialog_get_type () ; + GtkWidget* gtk_color_selection_dialog_new ( gchar *title); + alias _GtkHBox GtkHBox; + + alias _GtkHBoxClass GtkHBoxClass; + + + struct _GtkHBox { + GtkBox box; + } + + struct _GtkHBoxClass { + GtkBoxClass parent_class; + } + + + GType gtk_hbox_get_type () ; + GtkWidget* gtk_hbox_new (gboolean homogeneous, + gint spacing); + alias _GtkCombo GtkCombo; + + alias _GtkComboClass GtkComboClass; + + + + struct _GtkCombo { + GtkHBox hbox; + + + GtkWidget *entry; + + + GtkWidget *button; + GtkWidget *popup; + GtkWidget *popwin; + + + GtkWidget *list; + + + guint entry_change_id; + guint list_change_id; + + guint value_in_list; + guint ok_if_empty; + guint case_sensitive; + guint use_arrows; + guint use_arrows_always; + + guint16 current_button; + guint activate_id; + } + + struct _GtkComboClass { + GtkHBoxClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_combo_get_type () ; + + GtkWidget* gtk_combo_new (); + + void gtk_combo_set_value_in_list (GtkCombo* combo, + gboolean val, + gboolean ok_if_empty); + + void gtk_combo_set_use_arrows (GtkCombo* combo, + gboolean val); + + void gtk_combo_set_use_arrows_always (GtkCombo* combo, + gboolean val); + + void gtk_combo_set_case_sensitive (GtkCombo* combo, + gboolean val); + + + void gtk_combo_set_item_string (GtkCombo* combo, + GtkItem* item, + gchar* item_value); + + void gtk_combo_set_popdown_strings (GtkCombo* combo, + GList *strings); + + void gtk_combo_disable_activate (GtkCombo* combo); + enum GtkDestDefaults { + GTK_DEST_DEFAULT_MOTION = 1 << 0, + GTK_DEST_DEFAULT_HIGHLIGHT = 1 << 1, + GTK_DEST_DEFAULT_DROP = 1 << 2, + GTK_DEST_DEFAULT_ALL = 0x07 + }; + + + + + enum GtkTargetFlags { + GTK_TARGET_SAME_APP = 1 << 0, + GTK_TARGET_SAME_WIDGET = 1 << 1 + }; + + + + + void gtk_drag_get_data (GtkWidget *widget, + GdkDragContext *context, + GdkAtom target, + guint32 time_); + void gtk_drag_finish (GdkDragContext *context, + gboolean success, + gboolean del, + guint32 time_); + + GtkWidget *gtk_drag_get_source_widget (GdkDragContext *context); + + void gtk_drag_highlight (GtkWidget *widget); + void gtk_drag_unhighlight (GtkWidget *widget); + + void gtk_drag_dest_set (GtkWidget *widget, + GtkDestDefaults flags, + GtkTargetEntry *targets, + gint n_targets, + GdkDragAction actions); + + void gtk_drag_dest_set_proxy (GtkWidget *widget, + GdkWindow *proxy_window, + GdkDragProtocol protocol, + gboolean use_coordinates); + + void gtk_drag_dest_unset (GtkWidget *widget); + + GdkAtom gtk_drag_dest_find_target (GtkWidget *widget, + GdkDragContext *context, + GtkTargetList *target_list); + GtkTargetList* gtk_drag_dest_get_target_list (GtkWidget *widget); + void gtk_drag_dest_set_target_list (GtkWidget *widget, + GtkTargetList *target_list); + + + + void gtk_drag_source_set (GtkWidget *widget, + GdkModifierType start_button_mask, + GtkTargetEntry *targets, + gint n_targets, + GdkDragAction actions); + + void gtk_drag_source_unset (GtkWidget *widget); + + GtkTargetList* gtk_drag_source_get_target_list (GtkWidget *widget); + void gtk_drag_source_set_target_list (GtkWidget *widget, + GtkTargetList *target_list); + + void gtk_drag_source_set_icon (GtkWidget *widget, + GdkColormap *colormap, + GdkPixmap *pixmap, + GdkBitmap *mask); + void gtk_drag_source_set_icon_pixbuf (GtkWidget *widget, + GdkPixbuf *pixbuf); + void gtk_drag_source_set_icon_stock (GtkWidget *widget, + gchar *stock_id); + + + + + + GdkDragContext *gtk_drag_begin (GtkWidget *widget, + GtkTargetList *targets, + GdkDragAction actions, + gint button, + GdkEvent *event); + + + + void gtk_drag_set_icon_widget (GdkDragContext *context, + GtkWidget *widget, + gint hot_x, + gint hot_y); + void gtk_drag_set_icon_pixmap (GdkDragContext *context, + GdkColormap *colormap, + GdkPixmap *pixmap, + GdkBitmap *mask, + gint hot_x, + gint hot_y); + void gtk_drag_set_icon_pixbuf (GdkDragContext *context, + GdkPixbuf *pixbuf, + gint hot_x, + gint hot_y); + void gtk_drag_set_icon_stock (GdkDragContext *context, + gchar *stock_id, + gint hot_x, + gint hot_y); + + void gtk_drag_set_icon_default (GdkDragContext *context); + + gboolean gtk_drag_check_threshold (GtkWidget *widget, + gint start_x, + gint start_y, + gint current_x, + gint current_y); + + + void _gtk_drag_source_handle_event (GtkWidget *widget, + GdkEvent *event); + void _gtk_drag_dest_handle_event (GtkWidget *toplevel, + GdkEvent *event); + + + void gtk_drag_set_default_icon (GdkColormap *colormap, + GdkPixmap *pixmap, + GdkBitmap *mask, + gint hot_x, + gint hot_y); + + + + + + enum GtkTreeViewDropPosition { + + GTK_TREE_VIEW_DROP_BEFORE, + GTK_TREE_VIEW_DROP_AFTER, + + + + GTK_TREE_VIEW_DROP_INTO_OR_BEFORE, + GTK_TREE_VIEW_DROP_INTO_OR_AFTER + }; + + alias _GtkTreeView GtkTreeView; + + alias _GtkTreeViewClass GtkTreeViewClass; + + alias _GtkTreeViewPrivate GtkTreeViewPrivate; + alias void _GtkTreeViewPrivate; + + alias _GtkTreeSelection GtkTreeSelection; + + alias _GtkTreeSelectionClass GtkTreeSelectionClass; + + + struct _GtkTreeView { + GtkContainer parent; + + GtkTreeViewPrivate *priv; + } + + struct _GtkTreeViewClass { + GtkContainerClass parent_class; + + void (* set_scroll_adjustments) (GtkTreeView *tree_view, + GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); + void (* row_activated) (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewColumn *column); + gboolean (* test_expand_row) (GtkTreeView *tree_view, + GtkTreeIter *iter, + GtkTreePath *path); + gboolean (* test_collapse_row) (GtkTreeView *tree_view, + GtkTreeIter *iter, + GtkTreePath *path); + void (* row_expanded) (GtkTreeView *tree_view, + GtkTreeIter *iter, + GtkTreePath *path); + void (* row_collapsed) (GtkTreeView *tree_view, + GtkTreeIter *iter, + GtkTreePath *path); + void (* columns_changed) (GtkTreeView *tree_view); + void (* cursor_changed) (GtkTreeView *tree_view); + + + gboolean (* move_cursor) (GtkTreeView *tree_view, + GtkMovementStep step, + gint count); + gboolean (* select_all) (GtkTreeView *tree_view); + gboolean (* unselect_all) (GtkTreeView *tree_view); + gboolean (* select_cursor_row) (GtkTreeView *tree_view, + gboolean start_editing); + gboolean (* toggle_cursor_row) (GtkTreeView *tree_view); + gboolean (* expand_collapse_cursor_row) (GtkTreeView *tree_view, + gboolean logical, + gboolean expand, + gboolean open_all); + gboolean (* select_cursor_parent) (GtkTreeView *tree_view); + gboolean (* start_interactive_search) (GtkTreeView *tree_view); + + + void (*_gtk_reserved0) (); + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + alias gboolean (* GtkTreeViewColumnDropFunc) (GtkTreeView *tree_view, + GtkTreeViewColumn *column, + GtkTreeViewColumn *prev_column, + GtkTreeViewColumn *next_column, + gpointer data); + alias void (* GtkTreeViewMappingFunc) (GtkTreeView *tree_view, + GtkTreePath *path, + gpointer user_data); + alias gboolean (*GtkTreeViewSearchEqualFunc) (GtkTreeModel *model, + gint column, + gchar *key, + GtkTreeIter *iter, + gpointer search_data); + + + + GType gtk_tree_view_get_type (); + GtkWidget *gtk_tree_view_new (); + GtkWidget *gtk_tree_view_new_with_model (GtkTreeModel *model); + + + GtkTreeModel *gtk_tree_view_get_model (GtkTreeView *tree_view); + void gtk_tree_view_set_model (GtkTreeView *tree_view, + GtkTreeModel *model); + GtkTreeSelection *gtk_tree_view_get_selection (GtkTreeView *tree_view); + GtkAdjustment *gtk_tree_view_get_hadjustment (GtkTreeView *tree_view); + void gtk_tree_view_set_hadjustment (GtkTreeView *tree_view, + GtkAdjustment *adjustment); + GtkAdjustment *gtk_tree_view_get_vadjustment (GtkTreeView *tree_view); + void gtk_tree_view_set_vadjustment (GtkTreeView *tree_view, + GtkAdjustment *adjustment); + gboolean gtk_tree_view_get_headers_visible (GtkTreeView *tree_view); + void gtk_tree_view_set_headers_visible (GtkTreeView *tree_view, + gboolean headers_visible); + void gtk_tree_view_columns_autosize (GtkTreeView *tree_view); + void gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view, + gboolean setting); + void gtk_tree_view_set_rules_hint (GtkTreeView *tree_view, + gboolean setting); + gboolean gtk_tree_view_get_rules_hint (GtkTreeView *tree_view); + + + gint gtk_tree_view_append_column (GtkTreeView *tree_view, + GtkTreeViewColumn *column); + gint gtk_tree_view_remove_column (GtkTreeView *tree_view, + GtkTreeViewColumn *column); + gint gtk_tree_view_insert_column (GtkTreeView *tree_view, + GtkTreeViewColumn *column, + gint position); + gint gtk_tree_view_insert_column_with_attributes (GtkTreeView *tree_view, + gint position, + gchar *title, + GtkCellRenderer *cell, + ...); + gint gtk_tree_view_insert_column_with_data_func (GtkTreeView *tree_view, + gint position, + gchar *title, + GtkCellRenderer *cell, + GtkTreeCellDataFunc func, + gpointer data, + GDestroyNotify dnotify); + GtkTreeViewColumn *gtk_tree_view_get_column (GtkTreeView *tree_view, + gint n); + GList *gtk_tree_view_get_columns (GtkTreeView *tree_view); + void gtk_tree_view_move_column_after (GtkTreeView *tree_view, + GtkTreeViewColumn *column, + GtkTreeViewColumn *base_column); + void gtk_tree_view_set_expander_column (GtkTreeView *tree_view, + GtkTreeViewColumn *column); + GtkTreeViewColumn *gtk_tree_view_get_expander_column (GtkTreeView *tree_view); + void gtk_tree_view_set_column_drag_function (GtkTreeView *tree_view, + GtkTreeViewColumnDropFunc func, + gpointer user_data, + GtkDestroyNotify destroy); + + + void gtk_tree_view_scroll_to_point (GtkTreeView *tree_view, + gint tree_x, + gint tree_y); + void gtk_tree_view_scroll_to_cell (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewColumn *column, + gboolean use_align, + gfloat row_align, + gfloat col_align); + void gtk_tree_view_row_activated (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewColumn *column); + void gtk_tree_view_expand_all (GtkTreeView *tree_view); + void gtk_tree_view_collapse_all (GtkTreeView *tree_view); + void gtk_tree_view_expand_to_path (GtkTreeView *tree_view, + GtkTreePath *path); + gboolean gtk_tree_view_expand_row (GtkTreeView *tree_view, + GtkTreePath *path, + gboolean open_all); + gboolean gtk_tree_view_collapse_row (GtkTreeView *tree_view, + GtkTreePath *path); + void gtk_tree_view_map_expanded_rows (GtkTreeView *tree_view, + GtkTreeViewMappingFunc func, + gpointer data); + gboolean gtk_tree_view_row_expanded (GtkTreeView *tree_view, + GtkTreePath *path); + void gtk_tree_view_set_reorderable (GtkTreeView *tree_view, + gboolean reorderable); + gboolean gtk_tree_view_get_reorderable (GtkTreeView *tree_view); + void gtk_tree_view_set_cursor (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewColumn *focus_column, + gboolean start_editing); + void gtk_tree_view_set_cursor_on_cell (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewColumn *focus_column, + GtkCellRenderer *focus_cell, + gboolean start_editing); + void gtk_tree_view_get_cursor (GtkTreeView *tree_view, + GtkTreePath **path, + GtkTreeViewColumn **focus_column); + + + + GdkWindow *gtk_tree_view_get_bin_window (GtkTreeView *tree_view); + gboolean gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view, + gint x, + gint y, + GtkTreePath **path, + GtkTreeViewColumn **column, + gint *cell_x, + gint *cell_y); + void gtk_tree_view_get_cell_area (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewColumn *column, + GdkRectangle *rect); + void gtk_tree_view_get_background_area (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewColumn *column, + GdkRectangle *rect); + void gtk_tree_view_get_visible_rect (GtkTreeView *tree_view, + GdkRectangle *visible_rect); + void gtk_tree_view_widget_to_tree_coords (GtkTreeView *tree_view, + gint wx, + gint wy, + gint *tx, + gint *ty); + void gtk_tree_view_tree_to_widget_coords (GtkTreeView *tree_view, + gint tx, + gint ty, + gint *wx, + gint *wy); + + + void gtk_tree_view_enable_model_drag_source (GtkTreeView *tree_view, + GdkModifierType start_button_mask, + GtkTargetEntry *targets, + gint n_targets, + GdkDragAction actions); + void gtk_tree_view_enable_model_drag_dest (GtkTreeView *tree_view, + GtkTargetEntry *targets, + gint n_targets, + GdkDragAction actions); + void gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view); + void gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view); + + + + void gtk_tree_view_set_drag_dest_row (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewDropPosition pos); + void gtk_tree_view_get_drag_dest_row (GtkTreeView *tree_view, + GtkTreePath **path, + GtkTreeViewDropPosition *pos); + gboolean gtk_tree_view_get_dest_row_at_pos (GtkTreeView *tree_view, + gint drag_x, + gint drag_y, + GtkTreePath **path, + GtkTreeViewDropPosition *pos); + GdkPixmap *gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, + GtkTreePath *path); + + + void gtk_tree_view_set_enable_search (GtkTreeView *tree_view, + gboolean enable_search); + gboolean gtk_tree_view_get_enable_search (GtkTreeView *tree_view); + gint gtk_tree_view_get_search_column (GtkTreeView *tree_view); + void gtk_tree_view_set_search_column (GtkTreeView *tree_view, + gint column); + GtkTreeViewSearchEqualFunc gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view); + void gtk_tree_view_set_search_equal_func (GtkTreeView *tree_view, + GtkTreeViewSearchEqualFunc search_equal_func, + gpointer search_user_data, + GtkDestroyNotify search_destroy); + + + + alias void (* GtkTreeDestroyCountFunc) (GtkTreeView *tree_view, + GtkTreePath *path, + gint children, + gpointer user_data); + void gtk_tree_view_set_destroy_count_func (GtkTreeView *tree_view, + GtkTreeDestroyCountFunc func, + gpointer data, + GtkDestroyNotify destroy); + + + alias _GtkComboBox GtkComboBox; + + alias _GtkComboBoxClass GtkComboBoxClass; + + alias _GtkComboBoxPrivate GtkComboBoxPrivate; + alias void _GtkComboBoxPrivate; + + + struct _GtkComboBox { + GtkBin parent_instance; + + + GtkComboBoxPrivate *priv; + } + + struct _GtkComboBoxClass { + GtkBinClass parent_class; + + + void (* changed) (GtkComboBox *combo_box); + + + void (*_gtk_reserved0) (); + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + } + + + + GType gtk_combo_box_get_type (); + GtkWidget *gtk_combo_box_new (); + GtkWidget *gtk_combo_box_new_with_model (GtkTreeModel *model); + + + void gtk_combo_box_set_wrap_width (GtkComboBox *combo_box, + gint width); + void gtk_combo_box_set_row_span_column (GtkComboBox *combo_box, + gint row_span); + void gtk_combo_box_set_column_span_column (GtkComboBox *combo_box, + gint column_span); + + + gint gtk_combo_box_get_active (GtkComboBox *combo_box); + void gtk_combo_box_set_active (GtkComboBox *combo_box, + gint index_); + gboolean gtk_combo_box_get_active_iter (GtkComboBox *combo_box, + GtkTreeIter *iter); + void gtk_combo_box_set_active_iter (GtkComboBox *combo_box, + GtkTreeIter *iter); + + + void gtk_combo_box_set_model (GtkComboBox *combo_box, + GtkTreeModel *model); + GtkTreeModel *gtk_combo_box_get_model (GtkComboBox *combo_box); + + + GtkWidget *gtk_combo_box_new_text (); + void gtk_combo_box_append_text (GtkComboBox *combo_box, + gchar *text); + void gtk_combo_box_insert_text (GtkComboBox *combo_box, + gint position, + gchar *text); + void gtk_combo_box_prepend_text (GtkComboBox *combo_box, + gchar *text); + void gtk_combo_box_remove_text (GtkComboBox *combo_box, + gint position); + + + void gtk_combo_box_popup (GtkComboBox *combo_box); + void gtk_combo_box_popdown (GtkComboBox *combo_box); + + + + alias _GtkComboBoxEntry GtkComboBoxEntry; + + alias _GtkComboBoxEntryClass GtkComboBoxEntryClass; + + alias _GtkComboBoxEntryPrivate GtkComboBoxEntryPrivate; + alias void _GtkComboBoxEntryPrivate; + + + struct _GtkComboBoxEntry { + GtkComboBox parent_instance; + + + GtkComboBoxEntryPrivate *priv; + } + + struct _GtkComboBoxEntryClass { + GtkComboBoxClass parent_class; + + + void (*_gtk_reserved0) (); + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + } + + + GType gtk_combo_box_entry_get_type (); + GtkWidget *gtk_combo_box_entry_new (); + GtkWidget *gtk_combo_box_entry_new_with_model (GtkTreeModel *model, + gint text_column); + + void gtk_combo_box_entry_set_text_column (GtkComboBoxEntry *entry_box, + gint text_column); + gint gtk_combo_box_entry_get_text_column (GtkComboBoxEntry *entry_box); + + + GtkWidget *gtk_combo_box_entry_new_text (); + + + + + enum GtkCTreePos { + GTK_CTREE_POS_BEFORE, + GTK_CTREE_POS_AS_CHILD, + GTK_CTREE_POS_AFTER + }; + + + enum GtkCTreeLineStyle { + GTK_CTREE_LINES_NONE, + GTK_CTREE_LINES_SOLID, + GTK_CTREE_LINES_DOTTED, + GTK_CTREE_LINES_TABBED + }; + + + enum GtkCTreeExpanderStyle { + GTK_CTREE_EXPANDER_NONE, + GTK_CTREE_EXPANDER_SQUARE, + GTK_CTREE_EXPANDER_TRIANGLE, + GTK_CTREE_EXPANDER_CIRCULAR + }; + + + enum GtkCTreeExpansionType { + GTK_CTREE_EXPANSION_EXPAND, + GTK_CTREE_EXPANSION_EXPAND_RECURSIVE, + GTK_CTREE_EXPANSION_COLLAPSE, + GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE, + GTK_CTREE_EXPANSION_TOGGLE, + GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE + }; + + + alias _GtkCTree GtkCTree; + + alias _GtkCTreeClass GtkCTreeClass; + + alias _GtkCTreeRow GtkCTreeRow; + + alias _GtkCTreeNode GtkCTreeNode; + + + alias void (*GtkCTreeFunc) (GtkCTree *ctree, + GtkCTreeNode *node, + gpointer data); + + alias gboolean (*GtkCTreeGNodeFunc) (GtkCTree *ctree, + guint depth, + GNode *gnode, + GtkCTreeNode *cnode, + gpointer data); + + alias gboolean (*GtkCTreeCompareDragFunc) (GtkCTree *ctree, + GtkCTreeNode *source_node, + GtkCTreeNode *new_parent, + GtkCTreeNode *new_sibling); + + struct _GtkCTree { + GtkCList clist; + + GdkGC *lines_gc; + + gint tree_indent; + gint tree_spacing; + gint tree_column; + + guint line_style; + guint expander_style; + guint show_stub; + + GtkCTreeCompareDragFunc drag_compare; + } + + struct _GtkCTreeClass { + GtkCListClass parent_class; + + void (*tree_select_row) (GtkCTree *ctree, + GtkCTreeNode *row, + gint column); + void (*tree_unselect_row) (GtkCTree *ctree, + GtkCTreeNode *row, + gint column); + void (*tree_expand) (GtkCTree *ctree, + GtkCTreeNode *node); + void (*tree_collapse) (GtkCTree *ctree, + GtkCTreeNode *node); + void (*tree_move) (GtkCTree *ctree, + GtkCTreeNode *node, + GtkCTreeNode *new_parent, + GtkCTreeNode *new_sibling); + void (*change_focus_row_expansion) (GtkCTree *ctree, + GtkCTreeExpansionType action); + } + + struct _GtkCTreeRow { + GtkCListRow row; + + GtkCTreeNode *parent; + GtkCTreeNode *sibling; + GtkCTreeNode *children; + + GdkPixmap *pixmap_closed; + GdkBitmap *mask_closed; + GdkPixmap *pixmap_opened; + GdkBitmap *mask_opened; + + guint16 level; + + guint is_leaf; + guint expanded; + } + + struct _GtkCTreeNode { + GList list; + } + + + + + + + GtkType gtk_ctree_get_type () ; + GtkWidget * gtk_ctree_new_with_titles (gint columns, + gint tree_column, + gchar *titles[]); + GtkWidget * gtk_ctree_new (gint columns, + gint tree_column); + GtkCTreeNode * gtk_ctree_insert_node (GtkCTree *ctree, + GtkCTreeNode *parent, + GtkCTreeNode *sibling, + gchar *text[], + guint8 spacing, + GdkPixmap *pixmap_closed, + GdkBitmap *mask_closed, + GdkPixmap *pixmap_opened, + GdkBitmap *mask_opened, + gboolean is_leaf, + gboolean expanded); + void gtk_ctree_remove_node (GtkCTree *ctree, + GtkCTreeNode *node); + GtkCTreeNode * gtk_ctree_insert_gnode (GtkCTree *ctree, + GtkCTreeNode *parent, + GtkCTreeNode *sibling, + GNode *gnode, + GtkCTreeGNodeFunc func, + gpointer data); + GNode * gtk_ctree_export_to_gnode (GtkCTree *ctree, + GNode *parent, + GNode *sibling, + GtkCTreeNode *node, + GtkCTreeGNodeFunc func, + gpointer data); + + + + + + + void gtk_ctree_post_recursive (GtkCTree *ctree, + GtkCTreeNode *node, + GtkCTreeFunc func, + gpointer data); + void gtk_ctree_post_recursive_to_depth (GtkCTree *ctree, + GtkCTreeNode *node, + gint depth, + GtkCTreeFunc func, + gpointer data); + void gtk_ctree_pre_recursive (GtkCTree *ctree, + GtkCTreeNode *node, + GtkCTreeFunc func, + gpointer data); + void gtk_ctree_pre_recursive_to_depth (GtkCTree *ctree, + GtkCTreeNode *node, + gint depth, + GtkCTreeFunc func, + gpointer data); + gboolean gtk_ctree_is_viewable (GtkCTree *ctree, + GtkCTreeNode *node); + GtkCTreeNode * gtk_ctree_last (GtkCTree *ctree, + GtkCTreeNode *node); + GtkCTreeNode * gtk_ctree_find_node_ptr (GtkCTree *ctree, + GtkCTreeRow *ctree_row); + GtkCTreeNode * gtk_ctree_node_nth (GtkCTree *ctree, + guint row); + gboolean gtk_ctree_find (GtkCTree *ctree, + GtkCTreeNode *node, + GtkCTreeNode *child); + gboolean gtk_ctree_is_ancestor (GtkCTree *ctree, + GtkCTreeNode *node, + GtkCTreeNode *child); + GtkCTreeNode * gtk_ctree_find_by_row_data (GtkCTree *ctree, + GtkCTreeNode *node, + gpointer data); + + GList * gtk_ctree_find_all_by_row_data (GtkCTree *ctree, + GtkCTreeNode *node, + gpointer data); + GtkCTreeNode * gtk_ctree_find_by_row_data_custom (GtkCTree *ctree, + GtkCTreeNode *node, + gpointer data, + GCompareFunc func); + + GList * gtk_ctree_find_all_by_row_data_custom (GtkCTree *ctree, + GtkCTreeNode *node, + gpointer data, + GCompareFunc func); + gboolean gtk_ctree_is_hot_spot (GtkCTree *ctree, + gint x, + gint y); + + + + + + void gtk_ctree_move (GtkCTree *ctree, + GtkCTreeNode *node, + GtkCTreeNode *new_parent, + GtkCTreeNode *new_sibling); + void gtk_ctree_expand (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_expand_recursive (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_expand_to_depth (GtkCTree *ctree, + GtkCTreeNode *node, + gint depth); + void gtk_ctree_collapse (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_collapse_recursive (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_collapse_to_depth (GtkCTree *ctree, + GtkCTreeNode *node, + gint depth); + void gtk_ctree_toggle_expansion (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_toggle_expansion_recursive (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_select (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_select_recursive (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_unselect (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_unselect_recursive (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_real_select_recursive (GtkCTree *ctree, + GtkCTreeNode *node, + gint state); + + + + + + void gtk_ctree_node_set_text (GtkCTree *ctree, + GtkCTreeNode *node, + gint column, + gchar *text); + void gtk_ctree_node_set_pixmap (GtkCTree *ctree, + GtkCTreeNode *node, + gint column, + GdkPixmap *pixmap, + GdkBitmap *mask); + void gtk_ctree_node_set_pixtext (GtkCTree *ctree, + GtkCTreeNode *node, + gint column, + gchar *text, + guint8 spacing, + GdkPixmap *pixmap, + GdkBitmap *mask); + void gtk_ctree_set_node_info (GtkCTree *ctree, + GtkCTreeNode *node, + gchar *text, + guint8 spacing, + GdkPixmap *pixmap_closed, + GdkBitmap *mask_closed, + GdkPixmap *pixmap_opened, + GdkBitmap *mask_opened, + gboolean is_leaf, + gboolean expanded); + void gtk_ctree_node_set_shift (GtkCTree *ctree, + GtkCTreeNode *node, + gint column, + gint vertical, + gint horizontal); + void gtk_ctree_node_set_selectable (GtkCTree *ctree, + GtkCTreeNode *node, + gboolean selectable); + gboolean gtk_ctree_node_get_selectable (GtkCTree *ctree, + GtkCTreeNode *node); + GtkCellType gtk_ctree_node_get_cell_type (GtkCTree *ctree, + GtkCTreeNode *node, + gint column); + gboolean gtk_ctree_node_get_text (GtkCTree *ctree, + GtkCTreeNode *node, + gint column, + gchar **text); + gboolean gtk_ctree_node_get_pixmap (GtkCTree *ctree, + GtkCTreeNode *node, + gint column, + GdkPixmap **pixmap, + GdkBitmap **mask); + gboolean gtk_ctree_node_get_pixtext (GtkCTree *ctree, + GtkCTreeNode *node, + gint column, + gchar **text, + guint8 *spacing, + GdkPixmap **pixmap, + GdkBitmap **mask); + gboolean gtk_ctree_get_node_info (GtkCTree *ctree, + GtkCTreeNode *node, + gchar **text, + guint8 *spacing, + GdkPixmap **pixmap_closed, + GdkBitmap **mask_closed, + GdkPixmap **pixmap_opened, + GdkBitmap **mask_opened, + gboolean *is_leaf, + gboolean *expanded); + void gtk_ctree_node_set_row_style (GtkCTree *ctree, + GtkCTreeNode *node, + GtkStyle *style); + GtkStyle * gtk_ctree_node_get_row_style (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_node_set_cell_style (GtkCTree *ctree, + GtkCTreeNode *node, + gint column, + GtkStyle *style); + GtkStyle * gtk_ctree_node_get_cell_style (GtkCTree *ctree, + GtkCTreeNode *node, + gint column); + void gtk_ctree_node_set_foreground (GtkCTree *ctree, + GtkCTreeNode *node, + GdkColor *color); + void gtk_ctree_node_set_background (GtkCTree *ctree, + GtkCTreeNode *node, + GdkColor *color); + void gtk_ctree_node_set_row_data (GtkCTree *ctree, + GtkCTreeNode *node, + gpointer data); + void gtk_ctree_node_set_row_data_full (GtkCTree *ctree, + GtkCTreeNode *node, + gpointer data, + GtkDestroyNotify destroy); + gpointer gtk_ctree_node_get_row_data (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_node_moveto (GtkCTree *ctree, + GtkCTreeNode *node, + gint column, + gfloat row_align, + gfloat col_align); + GtkVisibility gtk_ctree_node_is_visible (GtkCTree *ctree, + GtkCTreeNode *node); + + + + + + void gtk_ctree_set_indent (GtkCTree *ctree, + gint indent); + void gtk_ctree_set_spacing (GtkCTree *ctree, + gint spacing); + void gtk_ctree_set_show_stub (GtkCTree *ctree, + gboolean show_stub); + void gtk_ctree_set_line_style (GtkCTree *ctree, + GtkCTreeLineStyle line_style); + void gtk_ctree_set_expander_style (GtkCTree *ctree, + GtkCTreeExpanderStyle expander_style); + void gtk_ctree_set_drag_compare_func (GtkCTree *ctree, + GtkCTreeCompareDragFunc cmp_func); + + + + + + void gtk_ctree_sort_node (GtkCTree *ctree, + GtkCTreeNode *node); + void gtk_ctree_sort_recursive (GtkCTree *ctree, + GtkCTreeNode *node); + GType gtk_ctree_node_get_type () ; + alias _GtkDrawingArea GtkDrawingArea; + + alias _GtkDrawingAreaClass GtkDrawingAreaClass; + + + struct _GtkDrawingArea { + GtkWidget widget; + + gpointer draw_data; + } + + struct _GtkDrawingAreaClass { + GtkWidgetClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_drawing_area_get_type () ; + GtkWidget* gtk_drawing_area_new (); + + + void gtk_drawing_area_size (GtkDrawingArea *darea, + gint width, + gint height); + alias _GtkCurve GtkCurve; + + alias _GtkCurveClass GtkCurveClass; + + + + struct _GtkCurve { + GtkDrawingArea graph; + + gint cursor_type; + gfloat min_x; + gfloat max_x; + gfloat min_y; + gfloat max_y; + GdkPixmap *pixmap; + GtkCurveType curve_type; + gint height; + gint grab_point; + gint last; + + + gint num_points; + GdkPoint *point; + + + gint num_ctlpoints; + gfloat (*ctlpoint)[2]; + } + + struct _GtkCurveClass { + GtkDrawingAreaClass parent_class; + + void (* curve_type_changed) (GtkCurve *curve); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_curve_get_type () ; + GtkWidget* gtk_curve_new (); + void gtk_curve_reset (GtkCurve *curve); + void gtk_curve_set_gamma (GtkCurve *curve, gfloat gamma_); + void gtk_curve_set_range (GtkCurve *curve, + gfloat min_x, gfloat max_x, + gfloat min_y, gfloat max_y); + void gtk_curve_get_vector (GtkCurve *curve, + int veclen, gfloat vector[]); + void gtk_curve_set_vector (GtkCurve *curve, + int veclen, gfloat vector[]); + void gtk_curve_set_curve_type (GtkCurve *curve, GtkCurveType type); + + + + alias _GtkEditable GtkEditable; + alias void _GtkEditable; + + alias _GtkEditableClass GtkEditableClass; + + + struct _GtkEditableClass { + GTypeInterface base_iface; + + + void (* insert_text) (GtkEditable *editable, + gchar *text, + gint length, + gint *position); + void (* delete_text) (GtkEditable *editable, + gint start_pos, + gint end_pos); + void (* changed) (GtkEditable *editable); + + + void (* do_insert_text) (GtkEditable *editable, + gchar *text, + gint length, + gint *position); + void (* do_delete_text) (GtkEditable *editable, + gint start_pos, + gint end_pos); + + gchar* (* get_chars) (GtkEditable *editable, + gint start_pos, + gint end_pos); + void (* set_selection_bounds) (GtkEditable *editable, + gint start_pos, + gint end_pos); + gboolean (* get_selection_bounds) (GtkEditable *editable, + gint *start_pos, + gint *end_pos); + void (* set_position) (GtkEditable *editable, + gint position); + gint (* get_position) (GtkEditable *editable); + } + + GType gtk_editable_get_type () ; + void gtk_editable_select_region (GtkEditable *editable, + gint start, + gint end); + gboolean gtk_editable_get_selection_bounds (GtkEditable *editable, + gint *start, + gint *end); + void gtk_editable_insert_text (GtkEditable *editable, + gchar *new_text, + gint new_text_length, + gint *position); + void gtk_editable_delete_text (GtkEditable *editable, + gint start_pos, + gint end_pos); + gchar* gtk_editable_get_chars (GtkEditable *editable, + gint start_pos, + gint end_pos); + void gtk_editable_cut_clipboard (GtkEditable *editable); + void gtk_editable_copy_clipboard (GtkEditable *editable); + void gtk_editable_paste_clipboard (GtkEditable *editable); + void gtk_editable_delete_selection (GtkEditable *editable); + void gtk_editable_set_position (GtkEditable *editable, + gint position); + gint gtk_editable_get_position (GtkEditable *editable); + void gtk_editable_set_editable (GtkEditable *editable, + gboolean is_editable); + gboolean gtk_editable_get_editable (GtkEditable *editable); + alias _GtkIMContext GtkIMContext; + + alias _GtkIMContextClass GtkIMContextClass; + + + struct _GtkIMContext { + GObject parent_instance; + } + + struct _GtkIMContextClass { + + + + GtkObjectClass parent_class; + + + void (*preedit_start) (GtkIMContext *context); + void (*preedit_end) (GtkIMContext *context); + void (*preedit_changed) (GtkIMContext *context); + void (*commit) (GtkIMContext *context, gchar *str); + gboolean (*retrieve_surrounding) (GtkIMContext *context); + gboolean (*delete_surrounding) (GtkIMContext *context, + gint offset, + gint n_chars); + + + void (*set_client_window) (GtkIMContext *context, + GdkWindow *window); + void (*get_preedit_string) (GtkIMContext *context, + gchar **str, + PangoAttrList **attrs, + gint *cursor_pos); + gboolean (*filter_keypress) (GtkIMContext *context, + GdkEventKey *event); + void (*focus_in) (GtkIMContext *context); + void (*focus_out) (GtkIMContext *context); + void (*reset) (GtkIMContext *context); + void (*set_cursor_location) (GtkIMContext *context, + GdkRectangle *area); + void (*set_use_preedit) (GtkIMContext *context, + gboolean use_preedit); + void (*set_surrounding) (GtkIMContext *context, + gchar *text, + gint len, + gint cursor_index); + gboolean (*get_surrounding) (GtkIMContext *context, + gchar **text, + gint *cursor_index); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + void (*_gtk_reserved5) (); + void (*_gtk_reserved6) (); + } + + GType gtk_im_context_get_type () ; + + void gtk_im_context_set_client_window (GtkIMContext *context, + GdkWindow *window); + void gtk_im_context_get_preedit_string (GtkIMContext *context, + gchar **str, + PangoAttrList **attrs, + gint *cursor_pos); + gboolean gtk_im_context_filter_keypress (GtkIMContext *context, + GdkEventKey *event); + void gtk_im_context_focus_in (GtkIMContext *context); + void gtk_im_context_focus_out (GtkIMContext *context); + void gtk_im_context_reset (GtkIMContext *context); + void gtk_im_context_set_cursor_location (GtkIMContext *context, + GdkRectangle *area); + void gtk_im_context_set_use_preedit (GtkIMContext *context, + gboolean use_preedit); + void gtk_im_context_set_surrounding (GtkIMContext *context, + gchar *text, + gint len, + gint cursor_index); + gboolean gtk_im_context_get_surrounding (GtkIMContext *context, + gchar **text, + gint *cursor_index); + gboolean gtk_im_context_delete_surrounding (GtkIMContext *context, + gint offset, + gint n_chars); + + alias _GtkListStore GtkListStore; + + alias _GtkListStoreClass GtkListStoreClass; + + + struct _GtkListStore { + GObject parent; + + + gint stamp; + gpointer root; + gpointer tail; + GList *sort_list; + gint n_columns; + gint sort_column_id; + GtkSortType order; + GType *column_headers; + gint length; + GtkTreeIterCompareFunc default_sort_func; + gpointer default_sort_data; + GtkDestroyNotify default_sort_destroy; + guint columns_dirty; + } + + struct _GtkListStoreClass { + GObjectClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_list_store_get_type (); + GtkListStore *gtk_list_store_new (gint n_columns, + ...); + GtkListStore *gtk_list_store_newv (gint n_columns, + GType *types); + void gtk_list_store_set_column_types (GtkListStore *list_store, + gint n_columns, + GType *types); + + + + void gtk_list_store_set_value (GtkListStore *list_store, + GtkTreeIter *iter, + gint column, + GValue *value); + void gtk_list_store_set (GtkListStore *list_store, + GtkTreeIter *iter, + ...); + void gtk_list_store_set_valist (GtkListStore *list_store, + GtkTreeIter *iter, + va_list var_args); + gboolean gtk_list_store_remove (GtkListStore *list_store, + GtkTreeIter *iter); + void gtk_list_store_insert (GtkListStore *list_store, + GtkTreeIter *iter, + gint position); + void gtk_list_store_insert_before (GtkListStore *list_store, + GtkTreeIter *iter, + GtkTreeIter *sibling); + void gtk_list_store_insert_after (GtkListStore *list_store, + GtkTreeIter *iter, + GtkTreeIter *sibling); + void gtk_list_store_prepend (GtkListStore *list_store, + GtkTreeIter *iter); + void gtk_list_store_append (GtkListStore *list_store, + GtkTreeIter *iter); + void gtk_list_store_clear (GtkListStore *list_store); + gboolean gtk_list_store_iter_is_valid (GtkListStore *list_store, + GtkTreeIter *iter); + void gtk_list_store_reorder (GtkListStore *store, + gint *new_order); + void gtk_list_store_swap (GtkListStore *store, + GtkTreeIter *a, + GtkTreeIter *b); + void gtk_list_store_move_after (GtkListStore *store, + GtkTreeIter *iter, + GtkTreeIter *position); + void gtk_list_store_move_before (GtkListStore *store, + GtkTreeIter *iter, + GtkTreeIter *position); + + + alias gboolean (* GtkTreeModelFilterVisibleFunc) (GtkTreeModel *model, + GtkTreeIter *iter, + gpointer data); + alias void (* GtkTreeModelFilterModifyFunc) (GtkTreeModel *model, + GtkTreeIter *iter, + GValue *value, + gint column, + gpointer data); + + alias _GtkTreeModelFilter GtkTreeModelFilter; + + alias _GtkTreeModelFilterClass GtkTreeModelFilterClass; + + alias _GtkTreeModelFilterPrivate GtkTreeModelFilterPrivate; + alias void _GtkTreeModelFilterPrivate; + + + struct _GtkTreeModelFilter { + GObject parent; + + + GtkTreeModelFilterPrivate *priv; + } + + struct _GtkTreeModelFilterClass { + GObjectClass parent_class; + + + void (*_gtk_reserved0) (); + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + } + + + GType gtk_tree_model_filter_get_type (); + GtkTreeModel *gtk_tree_model_filter_new (GtkTreeModel *child_model, + GtkTreePath *root); + void gtk_tree_model_filter_set_visible_func (GtkTreeModelFilter *filter, + GtkTreeModelFilterVisibleFunc func, + gpointer data, + GtkDestroyNotify destroy); + void gtk_tree_model_filter_set_modify_func (GtkTreeModelFilter *filter, + gint n_columns, + GType *types, + GtkTreeModelFilterModifyFunc func, + gpointer data, + GtkDestroyNotify destroy); + void gtk_tree_model_filter_set_visible_column (GtkTreeModelFilter *filter, + gint column); + + GtkTreeModel *gtk_tree_model_filter_get_model (GtkTreeModelFilter *filter); + + + void gtk_tree_model_filter_convert_child_iter_to_iter (GtkTreeModelFilter *filter, + GtkTreeIter *filter_iter, + GtkTreeIter *child_iter); + void gtk_tree_model_filter_convert_iter_to_child_iter (GtkTreeModelFilter *filter, + GtkTreeIter *child_iter, + GtkTreeIter *filter_iter); + GtkTreePath *gtk_tree_model_filter_convert_child_path_to_path (GtkTreeModelFilter *filter, + GtkTreePath *child_path); + GtkTreePath *gtk_tree_model_filter_convert_path_to_child_path (GtkTreeModelFilter *filter, + GtkTreePath *filter_path); + + + void gtk_tree_model_filter_refilter (GtkTreeModelFilter *filter); + void gtk_tree_model_filter_clear_cache (GtkTreeModelFilter *filter); + + + + + alias _GtkEntryCompletion GtkEntryCompletion; + + alias _GtkEntryCompletionClass GtkEntryCompletionClass; + + alias _GtkEntryCompletionPrivate GtkEntryCompletionPrivate; + alias void _GtkEntryCompletionPrivate; + + + alias gboolean (* GtkEntryCompletionMatchFunc) (GtkEntryCompletion *completion, + gchar *key, + GtkTreeIter *iter, + gpointer user_data); + + + struct _GtkEntryCompletion { + GObject parent_instance; + + + GtkEntryCompletionPrivate *priv; + } + + struct _GtkEntryCompletionClass { + GObjectClass parent_class; + + gboolean (* match_selected) (GtkEntryCompletion *completion, + GtkTreeModel *model, + GtkTreeIter *iter); + void (* action_activated) (GtkEntryCompletion *completion, + gint index_); + + + void (*_gtk_reserved0) (); + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + } + + + GType gtk_entry_completion_get_type (); + GtkEntryCompletion *gtk_entry_completion_new (); + + GtkWidget *gtk_entry_completion_get_entry (GtkEntryCompletion *completion); + + void gtk_entry_completion_set_model (GtkEntryCompletion *completion, + GtkTreeModel *model); + GtkTreeModel *gtk_entry_completion_get_model (GtkEntryCompletion *completion); + + void gtk_entry_completion_set_match_func (GtkEntryCompletion *completion, + GtkEntryCompletionMatchFunc func, + gpointer func_data, + GDestroyNotify func_notify); + void gtk_entry_completion_set_minimum_key_length (GtkEntryCompletion *completion, + gint length); + gint gtk_entry_completion_get_minimum_key_length (GtkEntryCompletion *completion); + void gtk_entry_completion_complete (GtkEntryCompletion *completion); + + void gtk_entry_completion_insert_action_text (GtkEntryCompletion *completion, + gint index_, + gchar *text); + void gtk_entry_completion_insert_action_markup (GtkEntryCompletion *completion, + gint index_, + gchar *markup); + void gtk_entry_completion_delete_action (GtkEntryCompletion *completion, + gint index_); + + + void gtk_entry_completion_set_text_column (GtkEntryCompletion *completion, + gint column); + + + alias _GtkEntry GtkEntry; + + alias _GtkEntryClass GtkEntryClass; + + + struct _GtkEntry { + GtkWidget widget; + + gchar *text; + + guint editable; + guint visible; + guint overwrite_mode; + guint in_drag; + + guint16 text_length; + guint16 text_max_length; + + + GdkWindow *text_area; + GtkIMContext *im_context; + GtkWidget *popup_menu; + + gint current_pos; + gint selection_bound; + + PangoLayout *cached_layout; + guint cache_includes_preedit; + + guint need_im_reset; + + guint has_frame; + + guint activates_default; + + guint cursor_visible; + + guint in_click; + + guint is_cell_renderer; + guint editing_canceled; + + guint mouse_cursor_obscured; + + guint select_words; + guint select_lines; + guint resolved_dir; + guint button; + guint blink_timeout; + guint recompute_idle; + gint scroll_offset; + gint ascent; + gint descent; + + guint16 text_size; + guint16 n_bytes; + + guint16 preedit_length; + guint16 preedit_cursor; + + gint dnd_position; + + gint drag_start_x; + gint drag_start_y; + + gunichar invisible_char; + + gint width_chars; + } + + struct _GtkEntryClass { + GtkWidgetClass parent_class; + + + void (* populate_popup) (GtkEntry *entry, + GtkMenu *menu); + + + + void (* activate) (GtkEntry *entry); + void (* move_cursor) (GtkEntry *entry, + GtkMovementStep step, + gint count, + gboolean extend_selection); + void (* insert_at_cursor) (GtkEntry *entry, + gchar *str); + void (* delete_from_cursor) (GtkEntry *entry, + GtkDeleteType type, + gint count); + void (* cut_clipboard) (GtkEntry *entry); + void (* copy_clipboard) (GtkEntry *entry); + void (* paste_clipboard) (GtkEntry *entry); + void (* toggle_overwrite) (GtkEntry *entry); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_entry_get_type () ; + GtkWidget* gtk_entry_new (); + void gtk_entry_set_visibility (GtkEntry *entry, + gboolean visible); + gboolean gtk_entry_get_visibility (GtkEntry *entry); + void gtk_entry_set_invisible_char (GtkEntry *entry, + gunichar ch); + gunichar gtk_entry_get_invisible_char (GtkEntry *entry); + void gtk_entry_set_has_frame (GtkEntry *entry, + gboolean setting); + gboolean gtk_entry_get_has_frame (GtkEntry *entry); + + void gtk_entry_set_max_length (GtkEntry *entry, + gint max); + gint gtk_entry_get_max_length (GtkEntry *entry); + void gtk_entry_set_activates_default (GtkEntry *entry, + gboolean setting); + gboolean gtk_entry_get_activates_default (GtkEntry *entry); + + void gtk_entry_set_width_chars (GtkEntry *entry, + gint n_chars); + gint gtk_entry_get_width_chars (GtkEntry *entry); + + + + void gtk_entry_set_text (GtkEntry *entry, + gchar *text); + + gchar* gtk_entry_get_text (GtkEntry *entry); + + PangoLayout* gtk_entry_get_layout (GtkEntry *entry); + void gtk_entry_get_layout_offsets (GtkEntry *entry, + gint *x, + gint *y); + void gtk_entry_set_alignment (GtkEntry *entry, + gfloat xalign); + gfloat gtk_entry_get_alignment (GtkEntry *entry); + + void gtk_entry_set_completion (GtkEntry *entry, + GtkEntryCompletion *completion); + GtkEntryCompletion *gtk_entry_get_completion (GtkEntry *entry); + + + + + + GtkWidget* gtk_entry_new_with_max_length (gint max); + void gtk_entry_append_text (GtkEntry *entry, + gchar *text); + void gtk_entry_prepend_text (GtkEntry *entry, + gchar *text); + void gtk_entry_set_position (GtkEntry *entry, + gint position); + void gtk_entry_select_region (GtkEntry *entry, + gint start, + gint end); + void gtk_entry_set_editable (GtkEntry *entry, + gboolean editable); + + + alias _GtkEventBox GtkEventBox; + + alias _GtkEventBoxClass GtkEventBoxClass; + + + struct _GtkEventBox { + GtkBin bin; + } + + struct _GtkEventBoxClass { + GtkBinClass parent_class; + } + + GType gtk_event_box_get_type () ; + GtkWidget* gtk_event_box_new (); + gboolean gtk_event_box_get_visible_window (GtkEventBox *event_box); + void gtk_event_box_set_visible_window (GtkEventBox *event_box, + gboolean visible_window); + gboolean gtk_event_box_get_above_child (GtkEventBox *event_box); + void gtk_event_box_set_above_child (GtkEventBox *event_box, + gboolean above_child); + + alias _GtkExpander GtkExpander; + + alias _GtkExpanderClass GtkExpanderClass; + + alias _GtkExpanderPrivate GtkExpanderPrivate; + alias void _GtkExpanderPrivate; + + + struct _GtkExpander { + GtkBin bin; + + GtkExpanderPrivate *priv; + } + + struct _GtkExpanderClass { + GtkBinClass parent_class; + + + + + void (* activate) (GtkExpander *expander); + } + + GType gtk_expander_get_type (); + + GtkWidget *gtk_expander_new ( gchar *label); + GtkWidget *gtk_expander_new_with_mnemonic ( gchar *label); + + void gtk_expander_set_expanded (GtkExpander *expander, + gboolean expanded); + gboolean gtk_expander_get_expanded (GtkExpander *expander); + + + void gtk_expander_set_spacing (GtkExpander *expander, + gint spacing); + gint gtk_expander_get_spacing (GtkExpander *expander); + + void gtk_expander_set_label (GtkExpander *expander, + gchar *label); + gchar *gtk_expander_get_label (GtkExpander *expander); + + void gtk_expander_set_use_underline (GtkExpander *expander, + gboolean use_underline); + gboolean gtk_expander_get_use_underline (GtkExpander *expander); + + void gtk_expander_set_use_markup (GtkExpander *expander, + gboolean use_markup); + gboolean gtk_expander_get_use_markup (GtkExpander *expander); + + void gtk_expander_set_label_widget (GtkExpander *expander, + GtkWidget *label_widget); + GtkWidget *gtk_expander_get_label_widget (GtkExpander *expander); + + + alias _GtkFileSelection GtkFileSelection; + + alias _GtkFileSelectionClass GtkFileSelectionClass; + + + struct _GtkFileSelection { + + GtkDialog parent_instance; + + + GtkWidget *dir_list; + GtkWidget *file_list; + GtkWidget *selection_entry; + GtkWidget *selection_text; + GtkWidget *main_vbox; + GtkWidget *ok_button; + GtkWidget *cancel_button; + GtkWidget *help_button; + GtkWidget *history_pulldown; + GtkWidget *history_menu; + GList *history_list; + GtkWidget *fileop_dialog; + GtkWidget *fileop_entry; + gchar *fileop_file; + gpointer cmpl_state; + + GtkWidget *fileop_c_dir; + GtkWidget *fileop_del_file; + GtkWidget *fileop_ren_file; + + GtkWidget *button_area; + GtkWidget *action_area; + + + GPtrArray *selected_names; + gchar *last_selected; + } + + struct _GtkFileSelectionClass { + GtkDialogClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_file_selection_get_type () ; + GtkWidget* gtk_file_selection_new ( gchar *title); + void gtk_file_selection_set_filename (GtkFileSelection *filesel, + gchar *filename); + + + + + + + gchar* gtk_file_selection_get_filename (GtkFileSelection *filesel); + + void gtk_file_selection_complete (GtkFileSelection *filesel, + gchar *pattern); + void gtk_file_selection_show_fileop_buttons (GtkFileSelection *filesel); + void gtk_file_selection_hide_fileop_buttons (GtkFileSelection *filesel); + + gchar** gtk_file_selection_get_selections (GtkFileSelection *filesel); + + void gtk_file_selection_set_select_multiple (GtkFileSelection *filesel, + gboolean select_multiple); + gboolean gtk_file_selection_get_select_multiple (GtkFileSelection *filesel); + alias _GtkFixed GtkFixed; + + alias _GtkFixedClass GtkFixedClass; + + alias _GtkFixedChild GtkFixedChild; + + + struct _GtkFixed { + GtkContainer container; + + GList *children; + } + + struct _GtkFixedClass { + GtkContainerClass parent_class; + } + + struct _GtkFixedChild { + GtkWidget *widget; + gint x; + gint y; + } + + + GType gtk_fixed_get_type () ; + GtkWidget* gtk_fixed_new (); + void gtk_fixed_put (GtkFixed *fixed, + GtkWidget *widget, + gint x, + gint y); + void gtk_fixed_move (GtkFixed *fixed, + GtkWidget *widget, + gint x, + gint y); + void gtk_fixed_set_has_window (GtkFixed *fixed, + gboolean has_window); + gboolean gtk_fixed_get_has_window (GtkFixed *fixed); + + + + + + + alias _GtkFileFilter GtkFileFilter; + alias void _GtkFileFilter; + + alias _GtkFileFilterInfo GtkFileFilterInfo; + + + enum GtkFileFilterFlags { + GTK_FILE_FILTER_FILENAME = 1 << 0, + GTK_FILE_FILTER_URI = 1 << 1, + GTK_FILE_FILTER_DISPLAY_NAME = 1 << 2, + GTK_FILE_FILTER_MIME_TYPE = 1 << 3 + }; + + + alias gboolean (*GtkFileFilterFunc) ( GtkFileFilterInfo *filter_info, + gpointer data); + + struct _GtkFileFilterInfo { + GtkFileFilterFlags contains; + + gchar *filename; + gchar *uri; + gchar *display_name; + gchar *mime_type; + } + + GType gtk_file_filter_get_type (); + + GtkFileFilter * gtk_file_filter_new (); + void gtk_file_filter_set_name (GtkFileFilter *filter, + gchar *name); + gchar *gtk_file_filter_get_name (GtkFileFilter *filter); + + void gtk_file_filter_add_mime_type (GtkFileFilter *filter, + gchar *mime_type); + void gtk_file_filter_add_pattern (GtkFileFilter *filter, + gchar *pattern); + void gtk_file_filter_add_custom (GtkFileFilter *filter, + GtkFileFilterFlags needed, + GtkFileFilterFunc func, + gpointer data, + GDestroyNotify notify); + + GtkFileFilterFlags gtk_file_filter_get_needed (GtkFileFilter *filter); + gboolean gtk_file_filter_filter (GtkFileFilter *filter, + GtkFileFilterInfo *filter_info); + + + + + + + + + + + alias _GtkFileChooser GtkFileChooser; + alias void _GtkFileChooser; + + + enum GtkFileChooserAction { + GTK_FILE_CHOOSER_ACTION_OPEN, + GTK_FILE_CHOOSER_ACTION_SAVE, + GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, + GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER + }; + + + GType gtk_file_chooser_get_type (); + + + + + + enum GtkFileChooserError { + GTK_FILE_CHOOSER_ERROR_NONEXISTENT, + GTK_FILE_CHOOSER_ERROR_BAD_FILENAME + }; + + + GQuark gtk_file_chooser_error_quark (); + + + + void gtk_file_chooser_set_action (GtkFileChooser *chooser, + GtkFileChooserAction action); + GtkFileChooserAction gtk_file_chooser_get_action (GtkFileChooser *chooser); + void gtk_file_chooser_set_local_only (GtkFileChooser *chooser, + gboolean local_only); + gboolean gtk_file_chooser_get_local_only (GtkFileChooser *chooser); + void gtk_file_chooser_set_select_multiple (GtkFileChooser *chooser, + gboolean select_multiple); + gboolean gtk_file_chooser_get_select_multiple (GtkFileChooser *chooser); + + + + void gtk_file_chooser_set_current_name (GtkFileChooser *chooser, + gchar *name); + + + + gchar * gtk_file_chooser_get_filename (GtkFileChooser *chooser); + gboolean gtk_file_chooser_set_filename (GtkFileChooser *chooser, + char *filename); + gboolean gtk_file_chooser_select_filename (GtkFileChooser *chooser, + char *filename); + void gtk_file_chooser_unselect_filename (GtkFileChooser *chooser, + char *filename); + void gtk_file_chooser_select_all (GtkFileChooser *chooser); + void gtk_file_chooser_unselect_all (GtkFileChooser *chooser); + GSList * gtk_file_chooser_get_filenames (GtkFileChooser *chooser); + gboolean gtk_file_chooser_set_current_folder (GtkFileChooser *chooser, + gchar *filename); + gchar * gtk_file_chooser_get_current_folder (GtkFileChooser *chooser); + + + + + gchar * gtk_file_chooser_get_uri (GtkFileChooser *chooser); + gboolean gtk_file_chooser_set_uri (GtkFileChooser *chooser, + char *uri); + gboolean gtk_file_chooser_select_uri (GtkFileChooser *chooser, + char *uri); + void gtk_file_chooser_unselect_uri (GtkFileChooser *chooser, + char *uri); + GSList * gtk_file_chooser_get_uris (GtkFileChooser *chooser); + gboolean gtk_file_chooser_set_current_folder_uri (GtkFileChooser *chooser, + gchar *uri); + gchar * gtk_file_chooser_get_current_folder_uri (GtkFileChooser *chooser); + + + + void gtk_file_chooser_set_preview_widget (GtkFileChooser *chooser, + GtkWidget *preview_widget); + GtkWidget *gtk_file_chooser_get_preview_widget (GtkFileChooser *chooser); + void gtk_file_chooser_set_preview_widget_active (GtkFileChooser *chooser, + gboolean active); + gboolean gtk_file_chooser_get_preview_widget_active (GtkFileChooser *chooser); + void gtk_file_chooser_set_use_preview_label (GtkFileChooser *chooser, + gboolean use_label); + gboolean gtk_file_chooser_get_use_preview_label (GtkFileChooser *chooser); + + char *gtk_file_chooser_get_preview_filename (GtkFileChooser *chooser); + char *gtk_file_chooser_get_preview_uri (GtkFileChooser *chooser); + + + + void gtk_file_chooser_set_extra_widget (GtkFileChooser *chooser, + GtkWidget *extra_widget); + GtkWidget *gtk_file_chooser_get_extra_widget (GtkFileChooser *chooser); + + + + void gtk_file_chooser_add_filter (GtkFileChooser *chooser, + GtkFileFilter *filter); + void gtk_file_chooser_remove_filter (GtkFileChooser *chooser, + GtkFileFilter *filter); + GSList *gtk_file_chooser_list_filters (GtkFileChooser *chooser); + + + + void gtk_file_chooser_set_filter (GtkFileChooser *chooser, + GtkFileFilter *filter); + GtkFileFilter *gtk_file_chooser_get_filter (GtkFileChooser *chooser); + + + + gboolean gtk_file_chooser_add_shortcut_folder (GtkFileChooser *chooser, + char *folder, + GError **error); + gboolean gtk_file_chooser_remove_shortcut_folder (GtkFileChooser *chooser, + char *folder, + GError **error); + GSList *gtk_file_chooser_list_shortcut_folders (GtkFileChooser *chooser); + + gboolean gtk_file_chooser_add_shortcut_folder_uri (GtkFileChooser *chooser, + char *uri, + GError **error); + gboolean gtk_file_chooser_remove_shortcut_folder_uri (GtkFileChooser *chooser, + char *uri, + GError **error); + GSList *gtk_file_chooser_list_shortcut_folder_uris (GtkFileChooser *chooser); + + + + + alias _GtkFileChooserDialog GtkFileChooserDialog; + + alias _GtkFileChooserDialogClass GtkFileChooserDialogClass; + + + alias _GtkFileChooserDialogPrivate GtkFileChooserDialogPrivate; + alias void _GtkFileChooserDialogPrivate; + + + struct _GtkFileChooserDialogClass { + GtkDialogClass parent_class; + } + + struct _GtkFileChooserDialog { + GtkDialog parent_instance; + + GtkFileChooserDialogPrivate *priv; + } + + GType gtk_file_chooser_dialog_get_type (); + GtkWidget *gtk_file_chooser_dialog_new ( gchar *title, + GtkWindow *parent, + GtkFileChooserAction action, + gchar *first_button_text, + ...); + GtkWidget *gtk_file_chooser_dialog_new_with_backend ( gchar *title, + GtkWindow *parent, + GtkFileChooserAction action, + gchar *backend, + gchar *first_button_text, + ...); + + + + alias _GtkFileChooserWidget GtkFileChooserWidget; + + alias _GtkFileChooserWidgetClass GtkFileChooserWidgetClass; + + + alias _GtkFileChooserWidgetPrivate GtkFileChooserWidgetPrivate; + alias void _GtkFileChooserWidgetPrivate; + + + struct _GtkFileChooserWidgetClass { + GtkVBoxClass parent_class; + } + + struct _GtkFileChooserWidget { + GtkVBox parent_instance; + + GtkFileChooserWidgetPrivate *priv; + } + + GType gtk_file_chooser_widget_get_type (); + GtkWidget *gtk_file_chooser_widget_new (GtkFileChooserAction action); + GtkWidget *gtk_file_chooser_widget_new_with_backend (GtkFileChooserAction action, + gchar *backend); + + + alias _GtkFontButton GtkFontButton; + + alias _GtkFontButtonClass GtkFontButtonClass; + + alias _GtkFontButtonPrivate GtkFontButtonPrivate; + alias void _GtkFontButtonPrivate; + + + struct _GtkFontButton { + GtkButton button; + + + GtkFontButtonPrivate *priv; + } + + struct _GtkFontButtonClass { + GtkButtonClass parent_class; + + + void (* font_set) (GtkFontButton *gfp); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_font_button_get_type () ; + GtkWidget *gtk_font_button_new (); + GtkWidget *gtk_font_button_new_with_font ( gchar *fontname); + + gchar *gtk_font_button_get_title (GtkFontButton *font_button); + void gtk_font_button_set_title (GtkFontButton *font_button, + gchar *title); + gboolean gtk_font_button_get_use_font (GtkFontButton *font_button); + void gtk_font_button_set_use_font (GtkFontButton *font_button, + gboolean use_font); + gboolean gtk_font_button_get_use_size (GtkFontButton *font_button); + void gtk_font_button_set_use_size (GtkFontButton *font_button, + gboolean use_size); + gchar* gtk_font_button_get_font_name (GtkFontButton *font_button); + gboolean gtk_font_button_set_font_name (GtkFontButton *font_button, + gchar *fontname); + gboolean gtk_font_button_get_show_style (GtkFontButton *font_button); + void gtk_font_button_set_show_style (GtkFontButton *font_button, + gboolean show_style); + gboolean gtk_font_button_get_show_size (GtkFontButton *font_button); + void gtk_font_button_set_show_size (GtkFontButton *font_button, + gboolean show_size); + + + alias _GtkFontSelection GtkFontSelection; + + alias _GtkFontSelectionClass GtkFontSelectionClass; + + + alias _GtkFontSelectionDialog GtkFontSelectionDialog; + + alias _GtkFontSelectionDialogClass GtkFontSelectionDialogClass; + + + struct _GtkFontSelection { + GtkVBox parent_instance; + + GtkWidget *font_entry; + GtkWidget *family_list; + GtkWidget *font_style_entry; + GtkWidget *face_list; + GtkWidget *size_entry; + GtkWidget *size_list; + GtkWidget *pixels_button; + GtkWidget *points_button; + GtkWidget *filter_button; + GtkWidget *preview_entry; + + PangoFontFamily *family; + PangoFontFace *face; + + gint size; + + GdkFont *font; + + + } + + struct _GtkFontSelectionClass { + GtkVBoxClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + struct _GtkFontSelectionDialog { + GtkDialog parent_instance; + + + GtkWidget *fontsel; + + GtkWidget *main_vbox; + GtkWidget *action_area; + + GtkWidget *ok_button; + GtkWidget *apply_button; + GtkWidget *cancel_button; + + + + + + + gint dialog_width; + gboolean auto_resize; + } + + struct _GtkFontSelectionDialogClass { + GtkDialogClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + GType gtk_font_selection_get_type () ; + GtkWidget* gtk_font_selection_new (); + gchar* gtk_font_selection_get_font_name (GtkFontSelection *fontsel); + + + GdkFont* gtk_font_selection_get_font (GtkFontSelection *fontsel); + + + gboolean gtk_font_selection_set_font_name (GtkFontSelection *fontsel, + gchar *fontname); + gchar* gtk_font_selection_get_preview_text (GtkFontSelection *fontsel); + void gtk_font_selection_set_preview_text (GtkFontSelection *fontsel, + gchar *text); + + + + + + + + GType gtk_font_selection_dialog_get_type () ; + GtkWidget* gtk_font_selection_dialog_new ( gchar *title); + + + + + + + gchar* gtk_font_selection_dialog_get_font_name (GtkFontSelectionDialog *fsd); + + + + + + GdkFont* gtk_font_selection_dialog_get_font (GtkFontSelectionDialog *fsd); + + + + + + + gboolean gtk_font_selection_dialog_set_font_name (GtkFontSelectionDialog *fsd, + gchar *fontname); + + + + gchar* gtk_font_selection_dialog_get_preview_text (GtkFontSelectionDialog *fsd); + + + + void gtk_font_selection_dialog_set_preview_text (GtkFontSelectionDialog *fsd, + gchar *text); + + alias _GtkGammaCurve GtkGammaCurve; + + alias _GtkGammaCurveClass GtkGammaCurveClass; + + + + struct _GtkGammaCurve { + GtkVBox vbox; + + GtkWidget *table; + GtkWidget *curve; + GtkWidget *button[5]; + + gfloat gamma; + GtkWidget *gamma_dialog; + GtkWidget *gamma_text; + } + + struct _GtkGammaCurveClass { + GtkVBoxClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_gamma_curve_get_type () ; + GtkWidget* gtk_gamma_curve_new (); + GdkGC* gtk_gc_get (gint depth, + GdkColormap *colormap, + GdkGCValues *values, + GdkGCValuesMask values_mask); + void gtk_gc_release (GdkGC *gc); + alias _GtkHandleBox GtkHandleBox; + + alias _GtkHandleBoxClass GtkHandleBoxClass; + + + struct _GtkHandleBox { + GtkBin bin; + + GdkWindow *bin_window; + GdkWindow *float_window; + GtkShadowType shadow_type; + guint handle_position; + guint float_window_mapped; + guint child_detached; + guint in_drag; + guint shrink_on_detach; + + int snap_edge; + + + + gint deskoff_x, deskoff_y; + + GtkAllocation attach_allocation; + GtkAllocation float_allocation; + } + + struct _GtkHandleBoxClass { + GtkBinClass parent_class; + + void (*child_attached) (GtkHandleBox *handle_box, + GtkWidget *child); + void (*child_detached) (GtkHandleBox *handle_box, + GtkWidget *child); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_handle_box_get_type () ; + GtkWidget* gtk_handle_box_new (); + void gtk_handle_box_set_shadow_type (GtkHandleBox *handle_box, + GtkShadowType type); + GtkShadowType gtk_handle_box_get_shadow_type (GtkHandleBox *handle_box); + void gtk_handle_box_set_handle_position (GtkHandleBox *handle_box, + GtkPositionType position); + GtkPositionType gtk_handle_box_get_handle_position(GtkHandleBox *handle_box); + void gtk_handle_box_set_snap_edge (GtkHandleBox *handle_box, + GtkPositionType edge); + GtkPositionType gtk_handle_box_get_snap_edge (GtkHandleBox *handle_box); + alias _GtkHButtonBox GtkHButtonBox; + + alias _GtkHButtonBoxClass GtkHButtonBoxClass; + + + struct _GtkHButtonBox { + GtkButtonBox button_box; + } + + struct _GtkHButtonBoxClass { + GtkButtonBoxClass parent_class; + } + + + GType gtk_hbutton_box_get_type () ; + GtkWidget* gtk_hbutton_box_new (); + + + + + gint gtk_hbutton_box_get_spacing_default (); + GtkButtonBoxStyle gtk_hbutton_box_get_layout_default (); + + void gtk_hbutton_box_set_spacing_default (gint spacing); + void gtk_hbutton_box_set_layout_default (GtkButtonBoxStyle layout); + + alias _GtkPaned GtkPaned; + + alias _GtkPanedClass GtkPanedClass; + + alias _GtkPanedPrivate GtkPanedPrivate; + alias void _GtkPanedPrivate; + + + struct _GtkPaned { + GtkContainer container; + + GtkWidget *child1; + GtkWidget *child2; + + GdkWindow *handle; + GdkGC *xor_gc; + GdkCursorType cursor_type; + + + GdkRectangle handle_pos; + + gint child1_size; + gint last_allocation; + gint min_position; + gint max_position; + + guint position_set; + guint in_drag; + guint child1_shrink; + guint child1_resize; + guint child2_shrink; + guint child2_resize; + guint orientation; + guint in_recursion; + guint handle_prelit; + + GtkWidget *last_child1_focus; + GtkWidget *last_child2_focus; + GtkPanedPrivate *priv; + + gint drag_pos; + gint original_position; + } + + struct _GtkPanedClass { + GtkContainerClass parent_class; + + gboolean (* cycle_child_focus) (GtkPaned *paned, + gboolean reverse); + gboolean (* toggle_handle_focus) (GtkPaned *paned); + gboolean (* move_handle) (GtkPaned *paned, + GtkScrollType scroll); + gboolean (* cycle_handle_focus) (GtkPaned *paned, + gboolean reverse); + gboolean (* accept_position) (GtkPaned *paned); + gboolean (* cancel_position) (GtkPaned *paned); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_paned_get_type () ; + void gtk_paned_add1 (GtkPaned *paned, + GtkWidget *child); + void gtk_paned_add2 (GtkPaned *paned, + GtkWidget *child); + void gtk_paned_pack1 (GtkPaned *paned, + GtkWidget *child, + gboolean resize, + gboolean shrink); + void gtk_paned_pack2 (GtkPaned *paned, + GtkWidget *child, + gboolean resize, + gboolean shrink); + gint gtk_paned_get_position (GtkPaned *paned); + void gtk_paned_set_position (GtkPaned *paned, + gint position); + + GtkWidget *gtk_paned_get_child1 (GtkPaned *paned); + GtkWidget *gtk_paned_get_child2 (GtkPaned *paned); + + + + void gtk_paned_compute_position (GtkPaned *paned, + gint allocation, + gint child1_req, + gint child2_req); + alias _GtkHPaned GtkHPaned; + + alias _GtkHPanedClass GtkHPanedClass; + + + struct _GtkHPaned { + GtkPaned paned; + } + + struct _GtkHPanedClass { + GtkPanedClass parent_class; + } + + GType gtk_hpaned_get_type () ; + GtkWidget *gtk_hpaned_new (); + alias _GtkRuler GtkRuler; + + alias _GtkRulerClass GtkRulerClass; + + alias _GtkRulerMetric GtkRulerMetric; + + + + + + struct _GtkRuler { + GtkWidget widget; + + GdkPixmap *backing_store; + GdkGC *non_gr_exp_gc; + GtkRulerMetric *metric; + gint xsrc, ysrc; + gint slider_size; + + + gdouble lower; + + gdouble upper; + + gdouble position; + + gdouble max_size; + } + + struct _GtkRulerClass { + GtkWidgetClass parent_class; + + void (* draw_ticks) (GtkRuler *ruler); + void (* draw_pos) (GtkRuler *ruler); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + struct _GtkRulerMetric { + gchar *metric_name; + gchar *abbrev; + + + gdouble pixels_per_unit; + gdouble ruler_scale[10]; + gint subdivide[5]; + } + + + GType gtk_ruler_get_type () ; + void gtk_ruler_set_metric (GtkRuler *ruler, + GtkMetricType metric); + void gtk_ruler_set_range (GtkRuler *ruler, + gdouble lower, + gdouble upper, + gdouble position, + gdouble max_size); + void gtk_ruler_draw_ticks (GtkRuler *ruler); + void gtk_ruler_draw_pos (GtkRuler *ruler); + + GtkMetricType gtk_ruler_get_metric (GtkRuler *ruler); + void gtk_ruler_get_range (GtkRuler *ruler, + gdouble *lower, + gdouble *upper, + gdouble *position, + gdouble *max_size); + alias _GtkHRuler GtkHRuler; + + alias _GtkHRulerClass GtkHRulerClass; + + + struct _GtkHRuler { + GtkRuler ruler; + } + + struct _GtkHRulerClass { + GtkRulerClass parent_class; + } + + + GType gtk_hruler_get_type () ; + GtkWidget* gtk_hruler_new (); + alias _GtkScale GtkScale; + + alias _GtkScaleClass GtkScaleClass; + + + struct _GtkScale { + GtkRange range; + + gint digits; + guint draw_value; + guint value_pos; + } + + struct _GtkScaleClass { + GtkRangeClass parent_class; + + gchar* (* format_value) (GtkScale *scale, + gdouble value); + + void (* draw_value) (GtkScale *scale); + + void (* get_layout_offsets) (GtkScale *scale, + gint *x, + gint *y); + + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_scale_get_type () ; + + void gtk_scale_set_digits (GtkScale *scale, + gint digits); + gint gtk_scale_get_digits (GtkScale *scale); + void gtk_scale_set_draw_value (GtkScale *scale, + gboolean draw_value); + gboolean gtk_scale_get_draw_value (GtkScale *scale); + void gtk_scale_set_value_pos (GtkScale *scale, + GtkPositionType pos); + GtkPositionType gtk_scale_get_value_pos (GtkScale *scale); + + PangoLayout *gtk_scale_get_layout (GtkScale *scale); + void gtk_scale_get_layout_offsets (GtkScale *scale, + gint *x, + gint *y); + void _gtk_scale_clear_layout (GtkScale *scale); + + void _gtk_scale_get_value_size (GtkScale *scale, + gint *width, + gint *height); + gchar *_gtk_scale_format_value (GtkScale *scale, + gdouble value); + alias _GtkHScale GtkHScale; + + alias _GtkHScaleClass GtkHScaleClass; + + + struct _GtkHScale { + GtkScale scale; + } + + struct _GtkHScaleClass { + GtkScaleClass parent_class; + } + + + GType gtk_hscale_get_type () ; + GtkWidget* gtk_hscale_new (GtkAdjustment *adjustment); + GtkWidget* gtk_hscale_new_with_range (gdouble min, + gdouble max, + gdouble step); + + alias _GtkSeparator GtkSeparator; + + alias _GtkSeparatorClass GtkSeparatorClass; + + + struct _GtkSeparator { + GtkWidget widget; + } + + struct _GtkSeparatorClass { + GtkWidgetClass parent_class; + } + + + GType gtk_separator_get_type () ; + alias _GtkHSeparator GtkHSeparator; + + alias _GtkHSeparatorClass GtkHSeparatorClass; + + + struct _GtkHSeparator { + GtkSeparator separator; + } + + struct _GtkHSeparatorClass { + GtkSeparatorClass parent_class; + } + + + GType gtk_hseparator_get_type () ; + GtkWidget* gtk_hseparator_new (); + alias _GtkIconFactoryClass GtkIconFactoryClass; + + struct _GtkIconFactory { + GObject parent_instance; + + GHashTable *icons; + } + + struct _GtkIconFactoryClass { + GObjectClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_icon_factory_get_type (); + GtkIconFactory* gtk_icon_factory_new (); + void gtk_icon_factory_add (GtkIconFactory *factory, + gchar *stock_id, + GtkIconSet *icon_set); + GtkIconSet* gtk_icon_factory_lookup (GtkIconFactory *factory, + gchar *stock_id); + + + + void gtk_icon_factory_add_default (GtkIconFactory *factory); + void gtk_icon_factory_remove_default (GtkIconFactory *factory); + GtkIconSet* gtk_icon_factory_lookup_default ( gchar *stock_id); + gboolean gtk_icon_size_lookup (GtkIconSize size, + gint *width, + gint *height); + + gboolean gtk_icon_size_lookup_for_settings (GtkSettings *settings, + GtkIconSize size, + gint *width, + gint *height); + + GtkIconSize gtk_icon_size_register ( gchar *name, + gint width, + gint height); + void gtk_icon_size_register_alias ( gchar *Alias, + GtkIconSize target); + GtkIconSize gtk_icon_size_from_name ( gchar *name); + gchar* gtk_icon_size_get_name (GtkIconSize size); + + + + GType gtk_icon_set_get_type (); + GtkIconSet* gtk_icon_set_new (); + GtkIconSet* gtk_icon_set_new_from_pixbuf (GdkPixbuf *pixbuf); + + GtkIconSet* gtk_icon_set_ref (GtkIconSet *icon_set); + void gtk_icon_set_unref (GtkIconSet *icon_set); + GtkIconSet* gtk_icon_set_copy (GtkIconSet *icon_set); + + + + + GdkPixbuf* gtk_icon_set_render_icon (GtkIconSet *icon_set, + GtkStyle *style, + GtkTextDirection direction, + GtkStateType state, + GtkIconSize size, + GtkWidget *widget, + char *detail); + + + void gtk_icon_set_add_source (GtkIconSet *icon_set, + GtkIconSource *source); + + void gtk_icon_set_get_sizes (GtkIconSet *icon_set, + GtkIconSize **sizes, + gint *n_sizes); + + GType gtk_icon_source_get_type (); + GtkIconSource* gtk_icon_source_new (); + GtkIconSource* gtk_icon_source_copy ( GtkIconSource *source); + void gtk_icon_source_free (GtkIconSource *source); + + void gtk_icon_source_set_filename (GtkIconSource *source, + gchar *filename); + void gtk_icon_source_set_icon_name (GtkIconSource *source, + gchar *icon_name); + void gtk_icon_source_set_pixbuf (GtkIconSource *source, + GdkPixbuf *pixbuf); + + gchar* gtk_icon_source_get_filename ( GtkIconSource *source); + gchar* gtk_icon_source_get_icon_name ( GtkIconSource *source); + GdkPixbuf* gtk_icon_source_get_pixbuf ( GtkIconSource *source); + + void gtk_icon_source_set_direction_wildcarded (GtkIconSource *source, + gboolean setting); + void gtk_icon_source_set_state_wildcarded (GtkIconSource *source, + gboolean setting); + void gtk_icon_source_set_size_wildcarded (GtkIconSource *source, + gboolean setting); + gboolean gtk_icon_source_get_size_wildcarded ( GtkIconSource *source); + gboolean gtk_icon_source_get_state_wildcarded ( GtkIconSource *source); + gboolean gtk_icon_source_get_direction_wildcarded ( GtkIconSource *source); + void gtk_icon_source_set_direction (GtkIconSource *source, + GtkTextDirection direction); + void gtk_icon_source_set_state (GtkIconSource *source, + GtkStateType state); + void gtk_icon_source_set_size (GtkIconSource *source, + GtkIconSize size); + GtkTextDirection gtk_icon_source_get_direction ( GtkIconSource *source); + GtkStateType gtk_icon_source_get_state ( GtkIconSource *source); + GtkIconSize gtk_icon_source_get_size ( GtkIconSource *source); + + + + void _gtk_icon_set_invalidate_caches (); + GSList* _gtk_icon_factory_list_ids (); + + alias _GtkIconInfo GtkIconInfo; + alias void _GtkIconInfo; + + alias _GtkIconTheme GtkIconTheme; + + alias _GtkIconThemeClass GtkIconThemeClass; + + alias _GtkIconThemePrivate GtkIconThemePrivate; + alias void _GtkIconThemePrivate; + + + struct _GtkIconTheme { + + GObject parent_instance; + + GtkIconThemePrivate *priv; + } + + struct _GtkIconThemeClass { + GObjectClass parent_class; + + void (* changed) (GtkIconTheme *icon_theme); + } + enum GtkIconLookupFlags { + GTK_ICON_LOOKUP_NO_SVG = 1 << 0, + GTK_ICON_LOOKUP_FORCE_SVG = 1 << 1, + GTK_ICON_LOOKUP_USE_BUILTIN = 1 << 2 + }; + + enum GtkIconThemeError { + GTK_ICON_THEME_NOT_FOUND, + GTK_ICON_THEME_FAILED + }; + + + GQuark gtk_icon_theme_error_quark () ; + + GType gtk_icon_theme_get_type () ; + + GtkIconTheme *gtk_icon_theme_new (); + GtkIconTheme *gtk_icon_theme_get_default (); + GtkIconTheme *gtk_icon_theme_get_for_screen (GdkScreen *screen); + void gtk_icon_theme_set_screen (GtkIconTheme *icon_theme, + GdkScreen *screen); + + void gtk_icon_theme_set_search_path (GtkIconTheme *icon_theme, + gchar *path[], + gint n_elements); + void gtk_icon_theme_get_search_path (GtkIconTheme *icon_theme, + gchar **path[], + gint *n_elements); + void gtk_icon_theme_append_search_path (GtkIconTheme *icon_theme, + gchar *path); + void gtk_icon_theme_prepend_search_path (GtkIconTheme *icon_theme, + gchar *path); + + void gtk_icon_theme_set_custom_theme (GtkIconTheme *icon_theme, + gchar *theme_name); + + gboolean gtk_icon_theme_has_icon (GtkIconTheme *icon_theme, + gchar *icon_name); + GtkIconInfo * gtk_icon_theme_lookup_icon (GtkIconTheme *icon_theme, + gchar *icon_name, + gint size, + GtkIconLookupFlags flags); + GdkPixbuf * gtk_icon_theme_load_icon (GtkIconTheme *icon_theme, + gchar *icon_name, + gint size, + GtkIconLookupFlags flags, + GError **error); + + GList * gtk_icon_theme_list_icons (GtkIconTheme *icon_theme, + gchar *context); + char * gtk_icon_theme_get_example_icon_name (GtkIconTheme *icon_theme); + + gboolean gtk_icon_theme_rescan_if_needed (GtkIconTheme *icon_theme); + + void gtk_icon_theme_add_builtin_icon ( gchar *icon_name, + gint size, + GdkPixbuf *pixbuf); + + GType gtk_icon_info_get_type (); + GtkIconInfo *gtk_icon_info_copy (GtkIconInfo *icon_info); + void gtk_icon_info_free (GtkIconInfo *icon_info); + + gint gtk_icon_info_get_base_size (GtkIconInfo *icon_info); + gchar *gtk_icon_info_get_filename (GtkIconInfo *icon_info); + GdkPixbuf * gtk_icon_info_get_builtin_pixbuf (GtkIconInfo *icon_info); + GdkPixbuf * gtk_icon_info_load_icon (GtkIconInfo *icon_info, + GError **error); + + void gtk_icon_info_set_raw_coordinates (GtkIconInfo *icon_info, + gboolean raw_coordinates); + + gboolean gtk_icon_info_get_embedded_rect (GtkIconInfo *icon_info, + GdkRectangle *rectangle); + gboolean gtk_icon_info_get_attach_points (GtkIconInfo *icon_info, + GdkPoint **points, + gint *n_points); + gchar *gtk_icon_info_get_display_name (GtkIconInfo *icon_info); + + + alias _GtkImage GtkImage; + + alias _GtkImageClass GtkImageClass; + + + alias _GtkImagePixmapData GtkImagePixmapData; + + alias _GtkImageImageData GtkImageImageData; + + alias _GtkImagePixbufData GtkImagePixbufData; + + alias _GtkImageStockData GtkImageStockData; + + alias _GtkImageIconSetData GtkImageIconSetData; + + alias _GtkImageAnimationData GtkImageAnimationData; + + + struct _GtkImagePixmapData { + GdkPixmap *pixmap; + } + + struct _GtkImageImageData { + GdkImage *image; + } + + struct _GtkImagePixbufData { + GdkPixbuf *pixbuf; + } + + struct _GtkImageStockData { + gchar *stock_id; + } + + struct _GtkImageIconSetData { + GtkIconSet *icon_set; + } + + struct _GtkImageAnimationData { + GdkPixbufAnimation *anim; + GdkPixbufAnimationIter *iter; + guint frame_timeout; + } + + enum GtkImageType { + GTK_IMAGE_EMPTY, + GTK_IMAGE_PIXMAP, + GTK_IMAGE_IMAGE, + GTK_IMAGE_PIXBUF, + GTK_IMAGE_STOCK, + GTK_IMAGE_ICON_SET, + GTK_IMAGE_ANIMATION + }; + + + struct _GtkImage { + GtkMisc misc; + + GtkImageType storage_type; + + union data_union + { + GtkImagePixmapData pixmap; + GtkImageImageData image; + GtkImagePixbufData pixbuf; + GtkImageStockData stock; + GtkImageIconSetData icon_set; + GtkImageAnimationData anim; + } + data_union data; + + + GdkBitmap *mask; + + + GtkIconSize icon_size; + } + + struct _GtkImageClass { + GtkMiscClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_image_get_type () ; + + GtkWidget* gtk_image_new (); + GtkWidget* gtk_image_new_from_pixmap (GdkPixmap *pixmap, + GdkBitmap *mask); + GtkWidget* gtk_image_new_from_image (GdkImage *image, + GdkBitmap *mask); + GtkWidget* gtk_image_new_from_file ( gchar *filename); + GtkWidget* gtk_image_new_from_pixbuf (GdkPixbuf *pixbuf); + GtkWidget* gtk_image_new_from_stock ( gchar *stock_id, + GtkIconSize size); + GtkWidget* gtk_image_new_from_icon_set (GtkIconSet *icon_set, + GtkIconSize size); + GtkWidget* gtk_image_new_from_animation (GdkPixbufAnimation *animation); + + void gtk_image_set_from_pixmap (GtkImage *image, + GdkPixmap *pixmap, + GdkBitmap *mask); + void gtk_image_set_from_image (GtkImage *image, + GdkImage *gdk_image, + GdkBitmap *mask); + void gtk_image_set_from_file (GtkImage *image, + gchar *filename); + void gtk_image_set_from_pixbuf (GtkImage *image, + GdkPixbuf *pixbuf); + void gtk_image_set_from_stock (GtkImage *image, + gchar *stock_id, + GtkIconSize size); + void gtk_image_set_from_icon_set (GtkImage *image, + GtkIconSet *icon_set, + GtkIconSize size); + void gtk_image_set_from_animation (GtkImage *image, + GdkPixbufAnimation *animation); + + GtkImageType gtk_image_get_storage_type (GtkImage *image); + + void gtk_image_get_pixmap (GtkImage *image, + GdkPixmap **pixmap, + GdkBitmap **mask); + void gtk_image_get_image (GtkImage *image, + GdkImage **gdk_image, + GdkBitmap **mask); + GdkPixbuf* gtk_image_get_pixbuf (GtkImage *image); + void gtk_image_get_stock (GtkImage *image, + gchar **stock_id, + GtkIconSize *size); + void gtk_image_get_icon_set (GtkImage *image, + GtkIconSet **icon_set, + GtkIconSize *size); + GdkPixbufAnimation* gtk_image_get_animation (GtkImage *image); + + + + + + void gtk_image_set (GtkImage *image, + GdkImage *val, + GdkBitmap *mask); + void gtk_image_get (GtkImage *image, + GdkImage **val, + GdkBitmap **mask); + alias _GtkImageMenuItem GtkImageMenuItem; + + alias _GtkImageMenuItemClass GtkImageMenuItemClass; + + + struct _GtkImageMenuItem { + GtkMenuItem menu_item; + + + GtkWidget *image; + } + + struct _GtkImageMenuItemClass { + GtkMenuItemClass parent_class; + } + + + GType gtk_image_menu_item_get_type () ; + GtkWidget* gtk_image_menu_item_new (); + GtkWidget* gtk_image_menu_item_new_with_label ( gchar *label); + GtkWidget* gtk_image_menu_item_new_with_mnemonic ( gchar *label); + GtkWidget* gtk_image_menu_item_new_from_stock ( gchar *stock_id, + GtkAccelGroup *accel_group); + void gtk_image_menu_item_set_image (GtkImageMenuItem *image_menu_item, + GtkWidget *image); + GtkWidget* gtk_image_menu_item_get_image (GtkImageMenuItem *image_menu_item); + + alias _GtkIMContextSimple GtkIMContextSimple; + + alias _GtkIMContextSimpleClass GtkIMContextSimpleClass; + + + + + struct _GtkIMContextSimple { + GtkIMContext object; + + GSList *tables; + + guint compose_buffer[7 + 1]; + gunichar tentative_match; + gint tentative_match_len; + + guint in_hex_sequence; + } + + struct _GtkIMContextSimpleClass { + GtkIMContextClass parent_class; + } + + GType gtk_im_context_simple_get_type () ; + GtkIMContext *gtk_im_context_simple_new (); + + void gtk_im_context_simple_add_table (GtkIMContextSimple *context_simple, + guint16 *data, + gint max_seq_len, + gint n_seqs); + alias _GtkIMMulticontext GtkIMMulticontext; + + alias _GtkIMMulticontextClass GtkIMMulticontextClass; + + alias _GtkIMMulticontextPrivate GtkIMMulticontextPrivate; + alias void _GtkIMMulticontextPrivate; + + + struct _GtkIMMulticontext { + GtkIMContext object; + + GtkIMContext *slave; + + GtkIMMulticontextPrivate *priv; + + gchar *context_id; + } + + struct _GtkIMMulticontextClass { + GtkIMContextClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_im_multicontext_get_type () ; + GtkIMContext *gtk_im_multicontext_new (); + + void gtk_im_multicontext_append_menuitems (GtkIMMulticontext *context, + GtkMenuShell *menushell); + alias _GtkInputDialog GtkInputDialog; + + alias _GtkInputDialogClass GtkInputDialogClass; + + + struct _GtkInputDialog { + GtkDialog dialog; + + GtkWidget *axis_list; + GtkWidget *axis_listbox; + GtkWidget *mode_optionmenu; + + GtkWidget *close_button; + GtkWidget *save_button; + + GtkWidget *axis_items[GdkAxisUse.GDK_AXIS_LAST]; + GdkDevice *current_device; + + GtkWidget *keys_list; + GtkWidget *keys_listbox; + } + + struct _GtkInputDialogClass { + GtkDialogClass parent_class; + + void (* enable_device) (GtkInputDialog *inputd, + GdkDevice *device); + void (* disable_device) (GtkInputDialog *inputd, + GdkDevice *device); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_input_dialog_get_type () ; + GtkWidget* gtk_input_dialog_new (); + + alias _GtkInvisible GtkInvisible; + + alias _GtkInvisibleClass GtkInvisibleClass; + + + struct _GtkInvisible { + GtkWidget widget; + gboolean has_user_ref_count; + GdkScreen *screen; + } + + struct _GtkInvisibleClass { + GtkWidgetClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_invisible_get_type () ; + + GtkWidget* gtk_invisible_new (); + GtkWidget* gtk_invisible_new_for_screen (GdkScreen *screen); + void gtk_invisible_set_screen (GtkInvisible *invisible, + GdkScreen *screen); + GdkScreen* gtk_invisible_get_screen (GtkInvisible *invisible); + + + + + + alias _GtkLayout GtkLayout; + + alias _GtkLayoutClass GtkLayoutClass; + + + struct _GtkLayout { + GtkContainer container; + + GList *children; + + guint width; + guint height; + + GtkAdjustment *hadjustment; + GtkAdjustment *vadjustment; + + + GdkWindow *bin_window; + + + GdkVisibilityState visibility; + gint scroll_x; + gint scroll_y; + + guint freeze_count; + } + + struct _GtkLayoutClass { + GtkContainerClass parent_class; + + void (*set_scroll_adjustments) (GtkLayout *layout, + GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_layout_get_type () ; + GtkWidget* gtk_layout_new (GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); + void gtk_layout_put (GtkLayout *layout, + GtkWidget *child_widget, + gint x, + gint y); + + void gtk_layout_move (GtkLayout *layout, + GtkWidget *child_widget, + gint x, + gint y); + + void gtk_layout_set_size (GtkLayout *layout, + guint width, + guint height); + void gtk_layout_get_size (GtkLayout *layout, + guint *width, + guint *height); + + GtkAdjustment* gtk_layout_get_hadjustment (GtkLayout *layout); + GtkAdjustment* gtk_layout_get_vadjustment (GtkLayout *layout); + void gtk_layout_set_hadjustment (GtkLayout *layout, + GtkAdjustment *adjustment); + void gtk_layout_set_vadjustment (GtkLayout *layout, + GtkAdjustment *adjustment); + void gtk_layout_freeze (GtkLayout *layout); + void gtk_layout_thaw (GtkLayout *layout); + alias _GtkListItem GtkListItem; + + alias _GtkListItemClass GtkListItemClass; + + + struct _GtkListItem { + GtkItem item; + } + + struct _GtkListItemClass { + GtkItemClass parent_class; + + void (*toggle_focus_row) (GtkListItem *list_item); + void (*select_all) (GtkListItem *list_item); + void (*unselect_all) (GtkListItem *list_item); + void (*undo_selection) (GtkListItem *list_item); + void (*start_selection) (GtkListItem *list_item); + void (*end_selection) (GtkListItem *list_item); + void (*extend_selection) (GtkListItem *list_item, + GtkScrollType scroll_type, + gfloat position, + gboolean auto_start_selection); + void (*scroll_horizontal) (GtkListItem *list_item, + GtkScrollType scroll_type, + gfloat position); + void (*scroll_vertical) (GtkListItem *list_item, + GtkScrollType scroll_type, + gfloat position); + void (*toggle_add_mode) (GtkListItem *list_item); + } + + + GtkType gtk_list_item_get_type () ; + GtkWidget* gtk_list_item_new (); + GtkWidget* gtk_list_item_new_with_label ( gchar *label); + void gtk_list_item_select (GtkListItem *list_item); + void gtk_list_item_deselect (GtkListItem *list_item); + alias _GtkList GtkList; + + alias _GtkListClass GtkListClass; + + + struct _GtkList { + GtkContainer container; + + GList *children; + GList *selection; + + GList *undo_selection; + GList *undo_unselection; + + GtkWidget *last_focus_child; + GtkWidget *undo_focus_child; + + guint htimer; + guint vtimer; + + gint anchor; + gint drag_pos; + GtkStateType anchor_state; + + guint selection_mode; + guint drag_selection; + guint add_mode; + } + + struct _GtkListClass { + GtkContainerClass parent_class; + + void (* selection_changed) (GtkList *list); + void (* select_child) (GtkList *list, + GtkWidget *child); + void (* unselect_child) (GtkList *list, + GtkWidget *child); + } + + + GtkType gtk_list_get_type () ; + GtkWidget* gtk_list_new (); + void gtk_list_insert_items (GtkList *list, + GList *items, + gint position); + void gtk_list_append_items (GtkList *list, + GList *items); + void gtk_list_prepend_items (GtkList *list, + GList *items); + void gtk_list_remove_items (GtkList *list, + GList *items); + void gtk_list_remove_items_no_unref (GtkList *list, + GList *items); + void gtk_list_clear_items (GtkList *list, + gint start, + gint end); + void gtk_list_select_item (GtkList *list, + gint item); + void gtk_list_unselect_item (GtkList *list, + gint item); + void gtk_list_select_child (GtkList *list, + GtkWidget *child); + void gtk_list_unselect_child (GtkList *list, + GtkWidget *child); + gint gtk_list_child_position (GtkList *list, + GtkWidget *child); + void gtk_list_set_selection_mode (GtkList *list, + GtkSelectionMode mode); + + void gtk_list_extend_selection (GtkList *list, + GtkScrollType scroll_type, + gfloat position, + gboolean auto_start_selection); + void gtk_list_start_selection (GtkList *list); + void gtk_list_end_selection (GtkList *list); + void gtk_list_select_all (GtkList *list); + void gtk_list_unselect_all (GtkList *list); + void gtk_list_scroll_horizontal (GtkList *list, + GtkScrollType scroll_type, + gfloat position); + void gtk_list_scroll_vertical (GtkList *list, + GtkScrollType scroll_type, + gfloat position); + void gtk_list_toggle_add_mode (GtkList *list); + void gtk_list_toggle_focus_row (GtkList *list); + void gtk_list_toggle_row (GtkList *list, + GtkWidget *item); + void gtk_list_undo_selection (GtkList *list); + void gtk_list_end_drag_selection (GtkList *list); + + alias void (*GtkModuleInitFunc) (gint *argc, + gchar ***argv); + alias void (*GtkModuleDisplayInitFunc) (GdkDisplay *display); + alias gint (*GtkKeySnoopFunc) (GtkWidget *grab_widget, + GdkEventKey *event, + gpointer func_data); + guint gtk_major_version; + guint gtk_minor_version; + guint gtk_micro_version; + guint gtk_binary_age; + guint gtk_interface_age; + gchar* gtk_check_version (guint required_major, + guint required_minor, + guint required_micro); + + + + + + gboolean gtk_parse_args (int *argc, + char ***argv); + + void gtk_init (int *argc, + char ***argv); + + gboolean gtk_init_check (int *argc, + char ***argv); + void gtk_exit (gint error_code); + + + void gtk_disable_setlocale (); + gchar * gtk_set_locale (); + PangoLanguage *gtk_get_default_language (); + gboolean gtk_events_pending (); + + + + + + void gtk_main_do_event (GdkEvent *event); + + void gtk_main (); + guint gtk_main_level (); + void gtk_main_quit (); + gboolean gtk_main_iteration (); + + gboolean gtk_main_iteration_do (gboolean blocking); + + gboolean gtk_true () ; + gboolean gtk_false () ; + + void gtk_grab_add (GtkWidget *widget); + GtkWidget* gtk_grab_get_current (); + void gtk_grab_remove (GtkWidget *widget); + + void gtk_init_add (GtkFunction Function, + gpointer data); + void gtk_quit_add_destroy (guint main_level, + GtkObject *object); + guint gtk_quit_add (guint main_level, + GtkFunction Function, + gpointer data); + guint gtk_quit_add_full (guint main_level, + GtkFunction Function, + GtkCallbackMarshal marshal, + gpointer data, + GtkDestroyNotify destroy); + void gtk_quit_remove (guint quit_handler_id); + void gtk_quit_remove_by_data (gpointer data); + + guint gtk_timeout_add (guint32 interval, + GtkFunction Function, + gpointer data); + guint gtk_timeout_add_full (guint32 interval, + GtkFunction Function, + GtkCallbackMarshal marshal, + gpointer data, + GtkDestroyNotify destroy); + void gtk_timeout_remove (guint timeout_handler_id); + + guint gtk_idle_add (GtkFunction Function, + gpointer data); + guint gtk_idle_add_priority (gint priority, + GtkFunction Function, + gpointer data); + guint gtk_idle_add_full (gint priority, + GtkFunction Function, + GtkCallbackMarshal marshal, + gpointer data, + GtkDestroyNotify destroy); + void gtk_idle_remove (guint idle_handler_id); + void gtk_idle_remove_by_data (gpointer data); + guint gtk_input_add_full (gint source, + GdkInputCondition condition, + GdkInputFunction Function, + GtkCallbackMarshal marshal, + gpointer data, + GtkDestroyNotify destroy); + void gtk_input_remove (guint input_handler_id); + + + guint gtk_key_snooper_install (GtkKeySnoopFunc snooper, + gpointer func_data); + void gtk_key_snooper_remove (guint snooper_handler_id); + + GdkEvent* gtk_get_current_event (); + guint32 gtk_get_current_event_time (); + gboolean gtk_get_current_event_state (GdkModifierType *state); + + GtkWidget* gtk_get_event_widget (GdkEvent *event); + + + + + void gtk_propagate_event (GtkWidget *widget, + GdkEvent *event); + + gboolean _gtk_boolean_handled_accumulator (GSignalInvocationHint *ihint, + GValue *return_accu, + GValue *handler_return, + gpointer dummy); + + gchar * _gtk_find_module ( gchar *name, + gchar *type); + gchar **_gtk_get_module_path ( gchar *type); + + gchar *_gtk_get_lc_ctype (); + + alias _GtkMenuBar GtkMenuBar; + + alias _GtkMenuBarClass GtkMenuBarClass; + + + struct _GtkMenuBar { + GtkMenuShell menu_shell; + } + + struct _GtkMenuBarClass { + GtkMenuShellClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_menu_bar_get_type () ; + GtkWidget* gtk_menu_bar_new (); + void _gtk_menu_bar_cycle_focus (GtkMenuBar *menubar, + GtkDirectionType dir); + + + enum GtkMessageType { + GTK_MESSAGE_INFO, + GTK_MESSAGE_WARNING, + GTK_MESSAGE_QUESTION, + GTK_MESSAGE_ERROR + }; + + + enum GtkButtonsType { + GTK_BUTTONS_NONE, + GTK_BUTTONS_OK, + GTK_BUTTONS_CLOSE, + GTK_BUTTONS_CANCEL, + GTK_BUTTONS_YES_NO, + GTK_BUTTONS_OK_CANCEL + }; + + alias _GtkMessageDialog GtkMessageDialog; + + alias _GtkMessageDialogClass GtkMessageDialogClass; + + + struct _GtkMessageDialog { + + + GtkDialog parent_instance; + + GtkWidget *image; + GtkWidget *label; + } + + struct _GtkMessageDialogClass { + GtkDialogClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_message_dialog_get_type (); + + GtkWidget* gtk_message_dialog_new (GtkWindow *parent, + GtkDialogFlags flags, + GtkMessageType type, + GtkButtonsType buttons, + gchar *message_format, + ...) ; + + GtkWidget* gtk_message_dialog_new_with_markup (GtkWindow *parent, + GtkDialogFlags flags, + GtkMessageType type, + GtkButtonsType buttons, + gchar *message_format, + ...) ; + + + void gtk_message_dialog_set_markup (GtkMessageDialog *message_dialog, + gchar *str); + + enum GtkNotebookTab { + GTK_NOTEBOOK_TAB_FIRST, + GTK_NOTEBOOK_TAB_LAST + }; + + + alias _GtkNotebook GtkNotebook; + + alias _GtkNotebookClass GtkNotebookClass; + + alias _GtkNotebookPage GtkNotebookPage; + alias void _GtkNotebookPage; + + + struct _GtkNotebook { + GtkContainer container; + + GtkNotebookPage *cur_page; + GList *children; + GList *first_tab; + GList *focus_tab; + + GtkWidget *menu; + GdkWindow *event_window; + + guint32 timer; + + guint16 tab_hborder; + guint16 tab_vborder; + + guint show_tabs; + guint homogeneous; + guint show_border; + guint tab_pos; + guint scrollable; + guint in_child; + guint click_child; + guint button; + guint need_timer; + guint child_has_focus; + guint have_visible_child; + guint focus_out; + + guint has_before_previous; + guint has_before_next; + guint has_after_previous; + guint has_after_next; + } + + struct _GtkNotebookClass { + GtkContainerClass parent_class; + + void (* switch_page) (GtkNotebook *notebook, + GtkNotebookPage *page, + guint page_num); + + + gboolean (* select_page) (GtkNotebook *notebook, + gboolean move_focus); + gboolean (* focus_tab) (GtkNotebook *notebook, + GtkNotebookTab type); + void (* change_current_page) (GtkNotebook *notebook, + gint offset); + void (* move_focus_out) (GtkNotebook *notebook, + GtkDirectionType direction); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + + + + GType gtk_notebook_get_type () ; + GtkWidget * gtk_notebook_new (); + gint gtk_notebook_append_page (GtkNotebook *notebook, + GtkWidget *child, + GtkWidget *tab_label); + gint gtk_notebook_append_page_menu (GtkNotebook *notebook, + GtkWidget *child, + GtkWidget *tab_label, + GtkWidget *menu_label); + gint gtk_notebook_prepend_page (GtkNotebook *notebook, + GtkWidget *child, + GtkWidget *tab_label); + gint gtk_notebook_prepend_page_menu (GtkNotebook *notebook, + GtkWidget *child, + GtkWidget *tab_label, + GtkWidget *menu_label); + gint gtk_notebook_insert_page (GtkNotebook *notebook, + GtkWidget *child, + GtkWidget *tab_label, + gint position); + gint gtk_notebook_insert_page_menu (GtkNotebook *notebook, + GtkWidget *child, + GtkWidget *tab_label, + GtkWidget *menu_label, + gint position); + void gtk_notebook_remove_page (GtkNotebook *notebook, + gint page_num); + + + + + + gint gtk_notebook_get_current_page (GtkNotebook *notebook); + GtkWidget* gtk_notebook_get_nth_page (GtkNotebook *notebook, + gint page_num); + gint gtk_notebook_get_n_pages (GtkNotebook *notebook); + gint gtk_notebook_page_num (GtkNotebook *notebook, + GtkWidget *child); + void gtk_notebook_set_current_page (GtkNotebook *notebook, + gint page_num); + void gtk_notebook_next_page (GtkNotebook *notebook); + void gtk_notebook_prev_page (GtkNotebook *notebook); + + + + + + void gtk_notebook_set_show_border (GtkNotebook *notebook, + gboolean show_border); + gboolean gtk_notebook_get_show_border (GtkNotebook *notebook); + void gtk_notebook_set_show_tabs (GtkNotebook *notebook, + gboolean show_tabs); + gboolean gtk_notebook_get_show_tabs (GtkNotebook *notebook); + void gtk_notebook_set_tab_pos (GtkNotebook *notebook, + GtkPositionType pos); + GtkPositionType gtk_notebook_get_tab_pos (GtkNotebook *notebook); + + + void gtk_notebook_set_homogeneous_tabs (GtkNotebook *notebook, + gboolean homogeneous); + void gtk_notebook_set_tab_border (GtkNotebook *notebook, + guint border_width); + void gtk_notebook_set_tab_hborder (GtkNotebook *notebook, + guint tab_hborder); + void gtk_notebook_set_tab_vborder (GtkNotebook *notebook, + guint tab_vborder); + + + void gtk_notebook_set_scrollable (GtkNotebook *notebook, + gboolean scrollable); + gboolean gtk_notebook_get_scrollable (GtkNotebook *notebook); + + + + + + void gtk_notebook_popup_enable (GtkNotebook *notebook); + void gtk_notebook_popup_disable (GtkNotebook *notebook); + + + + + + GtkWidget * gtk_notebook_get_tab_label (GtkNotebook *notebook, + GtkWidget *child); + void gtk_notebook_set_tab_label (GtkNotebook *notebook, + GtkWidget *child, + GtkWidget *tab_label); + void gtk_notebook_set_tab_label_text (GtkNotebook *notebook, + GtkWidget *child, + gchar *tab_text); + gchar *gtk_notebook_get_tab_label_text (GtkNotebook *notebook, + GtkWidget *child); + GtkWidget * gtk_notebook_get_menu_label (GtkNotebook *notebook, + GtkWidget *child); + void gtk_notebook_set_menu_label (GtkNotebook *notebook, + GtkWidget *child, + GtkWidget *menu_label); + void gtk_notebook_set_menu_label_text (GtkNotebook *notebook, + GtkWidget *child, + gchar *menu_text); + gchar *gtk_notebook_get_menu_label_text (GtkNotebook *notebook, + GtkWidget *child); + void gtk_notebook_query_tab_label_packing (GtkNotebook *notebook, + GtkWidget *child, + gboolean *expand, + gboolean *fill, + GtkPackType *pack_type); + void gtk_notebook_set_tab_label_packing (GtkNotebook *notebook, + GtkWidget *child, + gboolean expand, + gboolean fill, + GtkPackType pack_type); + void gtk_notebook_reorder_child (GtkNotebook *notebook, + GtkWidget *child, + gint position); + + alias _GtkOldEditable GtkOldEditable; + + alias _GtkOldEditableClass GtkOldEditableClass; + + + alias void (*GtkTextFunction) (GtkOldEditable *editable, guint32 time_); + + struct _GtkOldEditable { + GtkWidget widget; + + + guint current_pos; + + guint selection_start_pos; + guint selection_end_pos; + guint has_selection; + + + guint editable; + guint visible; + + gchar *clipboard_text; + } + + struct _GtkOldEditableClass { + GtkWidgetClass parent_class; + + + void (* activate) (GtkOldEditable *editable); + void (* set_editable) (GtkOldEditable *editable, + gboolean is_editable); + void (* move_cursor) (GtkOldEditable *editable, + gint x, + gint y); + void (* move_word) (GtkOldEditable *editable, + gint n); + void (* move_page) (GtkOldEditable *editable, + gint x, + gint y); + void (* move_to_row) (GtkOldEditable *editable, + gint row); + void (* move_to_column) (GtkOldEditable *editable, + gint row); + void (* kill_char) (GtkOldEditable *editable, + gint direction); + void (* kill_word) (GtkOldEditable *editable, + gint direction); + void (* kill_line) (GtkOldEditable *editable, + gint direction); + void (* cut_clipboard) (GtkOldEditable *editable); + void (* copy_clipboard) (GtkOldEditable *editable); + void (* paste_clipboard) (GtkOldEditable *editable); + + + + + + + void (* update_text) (GtkOldEditable *editable, + gint start_pos, + gint end_pos); + gchar* (* get_chars) (GtkOldEditable *editable, + gint start_pos, + gint end_pos); + void (* set_selection)(GtkOldEditable *editable, + gint start_pos, + gint end_pos); + void (* set_position) (GtkOldEditable *editable, + gint position); + } + + GtkType gtk_old_editable_get_type () ; + void gtk_old_editable_claim_selection (GtkOldEditable *old_editable, + gboolean claim, + guint32 time_); + void gtk_old_editable_changed (GtkOldEditable *old_editable); + alias _GtkOptionMenu GtkOptionMenu; + + alias _GtkOptionMenuClass GtkOptionMenuClass; + + + struct _GtkOptionMenu { + GtkButton button; + + GtkWidget *menu; + GtkWidget *menu_item; + + guint16 width; + guint16 height; + } + + struct _GtkOptionMenuClass { + GtkButtonClass parent_class; + + void (*changed) (GtkOptionMenu *option_menu); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_option_menu_get_type () ; + GtkWidget* gtk_option_menu_new (); + GtkWidget* gtk_option_menu_get_menu (GtkOptionMenu *option_menu); + void gtk_option_menu_set_menu (GtkOptionMenu *option_menu, + GtkWidget *menu); + void gtk_option_menu_remove_menu (GtkOptionMenu *option_menu); + gint gtk_option_menu_get_history (GtkOptionMenu *option_menu); + void gtk_option_menu_set_history (GtkOptionMenu *option_menu, + guint index_); + + alias _GtkPixmap GtkPixmap; + + alias _GtkPixmapClass GtkPixmapClass; + + + struct _GtkPixmap { + GtkMisc misc; + + GdkPixmap *pixmap; + GdkBitmap *mask; + + GdkPixmap *pixmap_insensitive; + guint build_insensitive; + } + + struct _GtkPixmapClass { + GtkMiscClass parent_class; + } + + + GtkType gtk_pixmap_get_type () ; + GtkWidget* gtk_pixmap_new (GdkPixmap *pixmap, + GdkBitmap *mask); + void gtk_pixmap_set (GtkPixmap *pixmap, + GdkPixmap *val, + GdkBitmap *mask); + void gtk_pixmap_get (GtkPixmap *pixmap, + GdkPixmap **val, + GdkBitmap **mask); + + void gtk_pixmap_set_build_insensitive (GtkPixmap *pixmap, + gboolean build); + alias _GtkSocket GtkSocket; + + alias _GtkSocketClass GtkSocketClass; + + + struct _GtkSocket { + GtkContainer container; + + guint16 request_width; + guint16 request_height; + guint16 current_width; + guint16 current_height; + + GdkWindow *plug_window; + GtkWidget *plug_widget; + + gshort xembed_version; + guint same_app; + guint focus_in; + guint have_size; + guint need_map; + guint is_mapped; + guint active; + + GtkAccelGroup *accel_group; + GtkWidget *toplevel; + } + + struct _GtkSocketClass { + GtkContainerClass parent_class; + + void (*plug_added) (GtkSocket *socket_); + gboolean (*plug_removed) (GtkSocket *socket_); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_socket_get_type () ; + GtkWidget* gtk_socket_new (); + + void gtk_socket_add_id (GtkSocket *socket_, + GdkNativeWindow window_id); + GdkNativeWindow gtk_socket_get_id (GtkSocket *socket_); + + + void gtk_socket_steal (GtkSocket *socket_, + GdkNativeWindow wid); + alias _GtkPlug GtkPlug; + + alias _GtkPlugClass GtkPlugClass; + + + + struct _GtkPlug { + GtkWindow window; + + GdkWindow *socket_window; + GtkWidget *modality_window; + GtkWindowGroup *modality_group; + GHashTable *grabbed_keys; + + guint same_app; + } + + struct _GtkPlugClass { + GtkWindowClass parent_class; + + void (*embedded) (GtkPlug *plug); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_plug_get_type () ; + + + void gtk_plug_ruct (GtkPlug *plug, + GdkNativeWindow socket_id); + GtkWidget* gtk_plug_new (GdkNativeWindow socket_id); + + + void gtk_plug_ruct_for_display (GtkPlug *plug, + GdkDisplay *display, + GdkNativeWindow socket_id); + GtkWidget* gtk_plug_new_for_display (GdkDisplay *display, + GdkNativeWindow socket_id); + + GdkNativeWindow gtk_plug_get_id (GtkPlug *plug); + + void _gtk_plug_add_to_socket (GtkPlug *plug, + GtkSocket *socket_); + void _gtk_plug_remove_from_socket (GtkPlug *plug, + GtkSocket *socket_); + alias _GtkPreview GtkPreview; + + alias _GtkPreviewInfo GtkPreviewInfo; + + alias _GtkDitherInfo GtkDitherInfo; + + alias _GtkPreviewClass GtkPreviewClass; + + + struct _GtkPreview { + GtkWidget widget; + + guchar *buffer; + guint16 buffer_width; + guint16 buffer_height; + + guint16 bpp; + guint16 rowstride; + + GdkRgbDither dither; + + guint type; + guint expand; + } + + struct _GtkPreviewInfo { + guchar *lookup; + + gdouble gamma; + } + + union _GtkDitherInfo { + gushort s[2]; + guchar c[4]; + } + + struct _GtkPreviewClass { + GtkWidgetClass parent_class; + + GtkPreviewInfo info; + + } + + + GtkType gtk_preview_get_type () ; + void gtk_preview_uninit (); + GtkWidget* gtk_preview_new (GtkPreviewType type); + void gtk_preview_size (GtkPreview *preview, + gint width, + gint height); + void gtk_preview_put (GtkPreview *preview, + GdkWindow *window, + GdkGC *gc, + gint srcx, + gint srcy, + gint destx, + gint desty, + gint width, + gint height); + void gtk_preview_draw_row (GtkPreview *preview, + guchar *data, + gint x, + gint y, + gint w); + void gtk_preview_set_expand (GtkPreview *preview, + gboolean expand); + + void gtk_preview_set_gamma (double gamma_); + void gtk_preview_set_color_cube (guint nred_shades, + guint ngreen_shades, + guint nblue_shades, + guint ngray_shades); + void gtk_preview_set_install_cmap (gint install_cmap); + void gtk_preview_set_reserved (gint nreserved); + void gtk_preview_set_dither (GtkPreview *preview, + GdkRgbDither dither); + + GdkVisual* gtk_preview_get_visual (); + GdkColormap* gtk_preview_get_cmap (); + + GtkPreviewInfo* gtk_preview_get_info (); + + + + + + + void gtk_preview_reset (); + alias _GtkProgress GtkProgress; + + alias _GtkProgressClass GtkProgressClass; + + + + struct _GtkProgress { + GtkWidget widget; + + GtkAdjustment *adjustment; + GdkPixmap *offscreen_pixmap; + gchar *format; + gfloat x_align; + gfloat y_align; + + guint show_text; + guint activity_mode; + guint use_text_format; + } + + struct _GtkProgressClass { + GtkWidgetClass parent_class; + + void (* paint) (GtkProgress *progress); + void (* update) (GtkProgress *progress); + void (* act_mode_enter) (GtkProgress *progress); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + + + + + + GType gtk_progress_get_type () ; + void gtk_progress_set_show_text (GtkProgress *progress, + gboolean show_text); + void gtk_progress_set_text_alignment (GtkProgress *progress, + gfloat x_align, + gfloat y_align); + void gtk_progress_set_format_string (GtkProgress *progress, + gchar *format); + void gtk_progress_set_adjustment (GtkProgress *progress, + GtkAdjustment *adjustment); + void gtk_progress_configure (GtkProgress *progress, + gdouble value, + gdouble min, + gdouble max); + void gtk_progress_set_percentage (GtkProgress *progress, + gdouble percentage); + void gtk_progress_set_value (GtkProgress *progress, + gdouble value); + gdouble gtk_progress_get_value (GtkProgress *progress); + void gtk_progress_set_activity_mode (GtkProgress *progress, + gboolean activity_mode); + gchar* gtk_progress_get_current_text (GtkProgress *progress); + gchar* gtk_progress_get_text_from_value (GtkProgress *progress, + gdouble value); + gdouble gtk_progress_get_current_percentage (GtkProgress *progress); + gdouble gtk_progress_get_percentage_from_value (GtkProgress *progress, + gdouble value); + alias _GtkProgressBar GtkProgressBar; + + alias _GtkProgressBarClass GtkProgressBarClass; + + + enum GtkProgressBarStyle { + GTK_PROGRESS_CONTINUOUS, + GTK_PROGRESS_DISCRETE + }; + + + enum GtkProgressBarOrientation { + GTK_PROGRESS_LEFT_TO_RIGHT, + GTK_PROGRESS_RIGHT_TO_LEFT, + GTK_PROGRESS_BOTTOM_TO_TOP, + GTK_PROGRESS_TOP_TO_BOTTOM + }; + + + struct _GtkProgressBar { + GtkProgress progress; + + GtkProgressBarStyle bar_style; + GtkProgressBarOrientation orientation; + + guint blocks; + gint in_block; + + gint activity_pos; + guint activity_step; + guint activity_blocks; + + gdouble pulse_fraction; + + guint activity_dir; + } + + struct _GtkProgressBarClass { + GtkProgressClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_progress_bar_get_type () ; + GtkWidget* gtk_progress_bar_new (); + void gtk_progress_bar_pulse (GtkProgressBar *pbar); + void gtk_progress_bar_set_text (GtkProgressBar *pbar, + gchar *text); + void gtk_progress_bar_set_fraction (GtkProgressBar *pbar, + gdouble fraction); + + void gtk_progress_bar_set_pulse_step (GtkProgressBar *pbar, + gdouble fraction); + void gtk_progress_bar_set_orientation (GtkProgressBar *pbar, + GtkProgressBarOrientation orientation); + + gchar* gtk_progress_bar_get_text (GtkProgressBar *pbar); + gdouble gtk_progress_bar_get_fraction (GtkProgressBar *pbar); + gdouble gtk_progress_bar_get_pulse_step (GtkProgressBar *pbar); + + GtkProgressBarOrientation gtk_progress_bar_get_orientation (GtkProgressBar *pbar); + + + + + + GtkWidget* gtk_progress_bar_new_with_adjustment (GtkAdjustment *adjustment); + void gtk_progress_bar_set_bar_style (GtkProgressBar *pbar, + GtkProgressBarStyle style); + void gtk_progress_bar_set_discrete_blocks (GtkProgressBar *pbar, + guint blocks); + + + + + void gtk_progress_bar_set_activity_step (GtkProgressBar *pbar, + guint step); + void gtk_progress_bar_set_activity_blocks (GtkProgressBar *pbar, + guint blocks); + void gtk_progress_bar_update (GtkProgressBar *pbar, + gdouble percentage); + + alias _GtkToggleAction GtkToggleAction; + + alias _GtkToggleActionPrivate GtkToggleActionPrivate; + alias void _GtkToggleActionPrivate; + + alias _GtkToggleActionClass GtkToggleActionClass; + + + struct _GtkToggleAction { + GtkAction parent; + + + + GtkToggleActionPrivate *private_data; + } + + struct _GtkToggleActionClass { + GtkActionClass parent_class; + + void (* toggled) (GtkToggleAction *action); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_toggle_action_get_type (); + GtkToggleAction *gtk_toggle_action_new ( gchar *name, + gchar *label, + gchar *tooltip, + gchar *stock_id); + void gtk_toggle_action_toggled (GtkToggleAction *action); + void gtk_toggle_action_set_active (GtkToggleAction *action, + gboolean is_active); + gboolean gtk_toggle_action_get_active (GtkToggleAction *action); + void gtk_toggle_action_set_draw_as_radio (GtkToggleAction *action, + gboolean draw_as_radio); + gboolean gtk_toggle_action_get_draw_as_radio (GtkToggleAction *action); + + + + + + alias _GtkRadioAction GtkRadioAction; + + alias _GtkRadioActionPrivate GtkRadioActionPrivate; + alias void _GtkRadioActionPrivate; + + alias _GtkRadioActionClass GtkRadioActionClass; + + + struct _GtkRadioAction { + GtkToggleAction parent; + + + + GtkRadioActionPrivate *private_data; + } + + struct _GtkRadioActionClass { + GtkToggleActionClass parent_class; + + void (* changed) (GtkRadioAction *action, GtkRadioAction *current); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_radio_action_get_type (); + GtkRadioAction *gtk_radio_action_new ( gchar *name, + gchar *label, + gchar *tooltip, + gchar *stock_id, + gint value); + GSList *gtk_radio_action_get_group (GtkRadioAction *action); + void gtk_radio_action_set_group (GtkRadioAction *action, + GSList *group); + gint gtk_radio_action_get_current_value (GtkRadioAction *action); + + + + alias _GtkRadioButton GtkRadioButton; + + alias _GtkRadioButtonClass GtkRadioButtonClass; + + + struct _GtkRadioButton { + GtkCheckButton check_button; + + GSList *group; + } + + struct _GtkRadioButtonClass { + GtkCheckButtonClass parent_class; + + + void (*group_changed) (GtkRadioButton *radio_button); + + + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_radio_button_get_type () ; + + GtkWidget* gtk_radio_button_new (GSList *group); + GtkWidget* gtk_radio_button_new_from_widget (GtkRadioButton *group); + GtkWidget* gtk_radio_button_new_with_label (GSList *group, + gchar *label); + GtkWidget* gtk_radio_button_new_with_label_from_widget (GtkRadioButton *group, + gchar *label); + GtkWidget* gtk_radio_button_new_with_mnemonic (GSList *group, + gchar *label); + GtkWidget* gtk_radio_button_new_with_mnemonic_from_widget (GtkRadioButton *group, + gchar *label); + GSList* gtk_radio_button_get_group (GtkRadioButton *radio_button); + void gtk_radio_button_set_group (GtkRadioButton *radio_button, + GSList *group); + + alias _GtkRadioMenuItem GtkRadioMenuItem; + + alias _GtkRadioMenuItemClass GtkRadioMenuItemClass; + + + struct _GtkRadioMenuItem { + GtkCheckMenuItem check_menu_item; + + GSList *group; + } + + struct _GtkRadioMenuItemClass { + GtkCheckMenuItemClass parent_class; + + + void (*group_changed) (GtkRadioMenuItem *radio_menu_item); + + + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_radio_menu_item_get_type () ; + + GtkWidget* gtk_radio_menu_item_new (GSList *group); + GtkWidget* gtk_radio_menu_item_new_with_label (GSList *group, + gchar *label); + GtkWidget* gtk_radio_menu_item_new_with_mnemonic (GSList *group, + gchar *label); + GtkWidget* gtk_radio_menu_item_new_from_widget (GtkRadioMenuItem *group); + GtkWidget *gtk_radio_menu_item_new_with_mnemonic_from_widget (GtkRadioMenuItem *group, + gchar *label); + GtkWidget *gtk_radio_menu_item_new_with_label_from_widget (GtkRadioMenuItem *group, + gchar *label); + GSList* gtk_radio_menu_item_get_group (GtkRadioMenuItem *radio_menu_item); + void gtk_radio_menu_item_set_group (GtkRadioMenuItem *radio_menu_item, + GSList *group); + + + + + + + alias _GtkTooltips GtkTooltips; + + alias _GtkTooltipsClass GtkTooltipsClass; + + alias _GtkTooltipsData GtkTooltipsData; + + + struct _GtkTooltipsData { + GtkTooltips *tooltips; + GtkWidget *widget; + gchar *tip_text; + gchar *tip_private; + } + + struct _GtkTooltips { + GtkObject parent_instance; + + GtkWidget *tip_window; + GtkWidget *tip_label; + GtkTooltipsData *active_tips_data; + GList *tips_data_list; + + guint delay; + guint enabled; + guint have_grab; + guint use_sticky_delay; + gint timer_tag; + GTimeVal last_popdown; + } + + struct _GtkTooltipsClass { + GtkObjectClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_tooltips_get_type () ; + GtkTooltips* gtk_tooltips_new (); + + void gtk_tooltips_enable (GtkTooltips *tooltips); + void gtk_tooltips_disable (GtkTooltips *tooltips); + + void gtk_tooltips_set_delay (GtkTooltips *tooltips, + guint delay); + + void gtk_tooltips_set_tip (GtkTooltips *tooltips, + GtkWidget *widget, + gchar *tip_text, + gchar *tip_private); + GtkTooltipsData* gtk_tooltips_data_get (GtkWidget *widget); + void gtk_tooltips_force_window (GtkTooltips *tooltips); + + + void _gtk_tooltips_toggle_keyboard_mode (GtkWidget *widget); + + gboolean gtk_tooltips_get_info_from_tip_window (GtkWindow *tip_window, + GtkTooltips **tooltips, + GtkWidget **current_widget); + + + + alias _GtkToolItem GtkToolItem; + + alias _GtkToolItemClass GtkToolItemClass; + + alias _GtkToolItemPrivate GtkToolItemPrivate; + alias void _GtkToolItemPrivate; + + + struct _GtkToolItem { + GtkBin parent; + + + GtkToolItemPrivate *priv; + } + + struct _GtkToolItemClass { + GtkBinClass parent_class; + + + gboolean (* create_menu_proxy) (GtkToolItem *tool_item); + void (* toolbar_reconfigured) (GtkToolItem *tool_item); + gboolean (* set_tooltip) (GtkToolItem *tool_item, + GtkTooltips *tooltips, + gchar *tip_text, + gchar *tip_private); + + + void (* _gtk_reserved1) (); + void (* _gtk_reserved2) (); + void (* _gtk_reserved3) (); + void (* _gtk_reserved4) (); + } + + GType gtk_tool_item_get_type (); + GtkToolItem *gtk_tool_item_new (); + + void gtk_tool_item_set_homogeneous (GtkToolItem *tool_item, + gboolean homogeneous); + gboolean gtk_tool_item_get_homogeneous (GtkToolItem *tool_item); + + void gtk_tool_item_set_expand (GtkToolItem *tool_item, + gboolean expand); + gboolean gtk_tool_item_get_expand (GtkToolItem *tool_item); + + void gtk_tool_item_set_tooltip (GtkToolItem *tool_item, + GtkTooltips *tooltips, + gchar *tip_text, + gchar *tip_private); + + void gtk_tool_item_set_use_drag_window (GtkToolItem *toolitem, + gboolean use_drag_window); + gboolean gtk_tool_item_get_use_drag_window (GtkToolItem *toolitem); + + void gtk_tool_item_set_visible_horizontal (GtkToolItem *toolitem, + gboolean visible_horizontal); + gboolean gtk_tool_item_get_visible_horizontal (GtkToolItem *toolitem); + + void gtk_tool_item_set_visible_vertical (GtkToolItem *toolitem, + gboolean visible_vertical); + gboolean gtk_tool_item_get_visible_vertical (GtkToolItem *toolitem); + + gboolean gtk_tool_item_get_is_important (GtkToolItem *tool_item); + void gtk_tool_item_set_is_important (GtkToolItem *tool_item, + gboolean is_important); + + GtkIconSize gtk_tool_item_get_icon_size (GtkToolItem *tool_item); + GtkOrientation gtk_tool_item_get_orientation (GtkToolItem *tool_item); + GtkToolbarStyle gtk_tool_item_get_toolbar_style (GtkToolItem *tool_item); + GtkReliefStyle gtk_tool_item_get_relief_style (GtkToolItem *tool_item); + + GtkWidget * gtk_tool_item_retrieve_proxy_menu_item (GtkToolItem *tool_item); + GtkWidget * gtk_tool_item_get_proxy_menu_item (GtkToolItem *tool_item, + gchar *menu_item_id); + void gtk_tool_item_set_proxy_menu_item (GtkToolItem *tool_item, + gchar *menu_item_id, + GtkWidget *menu_item); + + + void _gtk_tool_item_toolbar_reconfigured (GtkToolItem *tool_item); + + + + + alias _GtkToolButton GtkToolButton; + + alias _GtkToolButtonClass GtkToolButtonClass; + + alias _GtkToolButtonPrivate GtkToolButtonPrivate; + alias void _GtkToolButtonPrivate; + + + struct _GtkToolButton { + GtkToolItem parent; + + + GtkToolButtonPrivate *priv; + } + + struct _GtkToolButtonClass { + GtkToolItemClass parent_class; + + GType button_type; + + + void (* clicked) (GtkToolButton *tool_item); + + + void (* _gtk_reserved1) (); + void (* _gtk_reserved2) (); + void (* _gtk_reserved3) (); + void (* _gtk_reserved4) (); + } + + GType gtk_tool_button_get_type (); + GtkToolItem *gtk_tool_button_new (GtkWidget *icon_widget, + gchar *label); + GtkToolItem *gtk_tool_button_new_from_stock ( gchar *stock_id); + + void gtk_tool_button_set_label (GtkToolButton *button, + gchar *label); + gchar *gtk_tool_button_get_label (GtkToolButton *button); + void gtk_tool_button_set_use_underline (GtkToolButton *button, + gboolean use_underline); + gboolean gtk_tool_button_get_use_underline (GtkToolButton *button); + void gtk_tool_button_set_stock_id (GtkToolButton *button, + gchar *stock_id); + gchar *gtk_tool_button_get_stock_id (GtkToolButton *button); + void gtk_tool_button_set_icon_widget (GtkToolButton *button, + GtkWidget *icon_widget); + GtkWidget * gtk_tool_button_get_icon_widget (GtkToolButton *button); + void gtk_tool_button_set_label_widget (GtkToolButton *button, + GtkWidget *label_widget); + GtkWidget * gtk_tool_button_get_label_widget (GtkToolButton *button); + + + + GtkWidget *_gtk_tool_button_get_button (GtkToolButton *button); + + + + + alias _GtkToggleToolButton GtkToggleToolButton; + + alias _GtkToggleToolButtonClass GtkToggleToolButtonClass; + + alias _GtkToggleToolButtonPrivate GtkToggleToolButtonPrivate; + alias void _GtkToggleToolButtonPrivate; + + + struct _GtkToggleToolButton { + GtkToolButton parent; + + + GtkToggleToolButtonPrivate *priv; + } + + struct _GtkToggleToolButtonClass { + GtkToolButtonClass parent_class; + + + void (* toggled) (GtkToggleToolButton *button); + + + void (* _gtk_reserved1) (); + void (* _gtk_reserved2) (); + void (* _gtk_reserved3) (); + void (* _gtk_reserved4) (); + } + + GType gtk_toggle_tool_button_get_type () ; + GtkToolItem *gtk_toggle_tool_button_new (); + GtkToolItem *gtk_toggle_tool_button_new_from_stock ( gchar *stock_id); + + void gtk_toggle_tool_button_set_active (GtkToggleToolButton *button, + gboolean is_active); + gboolean gtk_toggle_tool_button_get_active (GtkToggleToolButton *button); + + + + + alias _GtkRadioToolButton GtkRadioToolButton; + + alias _GtkRadioToolButtonClass GtkRadioToolButtonClass; + + + struct _GtkRadioToolButton { + GtkToggleToolButton parent; + } + + struct _GtkRadioToolButtonClass { + GtkToggleToolButtonClass parent_class; + + + void (* _gtk_reserved1) (); + void (* _gtk_reserved2) (); + void (* _gtk_reserved3) (); + void (* _gtk_reserved4) (); + } + + GType gtk_radio_tool_button_get_type () ; + + GtkToolItem *gtk_radio_tool_button_new (GSList *group); + GtkToolItem *gtk_radio_tool_button_new_from_stock (GSList *group, + gchar *stock_id); + GtkToolItem *gtk_radio_tool_button_new_from_widget (GtkRadioToolButton *group); + GtkToolItem *gtk_radio_tool_button_new_with_stock_from_widget (GtkRadioToolButton *group, + gchar *stock_id); + GSList * gtk_radio_tool_button_get_group (GtkRadioToolButton *button); + void gtk_radio_tool_button_set_group (GtkRadioToolButton *button, + GSList *group); + + + + + + + + alias _GtkViewport GtkViewport; + + alias _GtkViewportClass GtkViewportClass; + + + struct _GtkViewport { + GtkBin bin; + + GtkShadowType shadow_type; + GdkWindow *view_window; + GdkWindow *bin_window; + GtkAdjustment *hadjustment; + GtkAdjustment *vadjustment; + } + + struct _GtkViewportClass { + GtkBinClass parent_class; + + void (*set_scroll_adjustments) (GtkViewport *viewport, + GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); + } + + + GType gtk_viewport_get_type () ; + GtkWidget* gtk_viewport_new (GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); + GtkAdjustment* gtk_viewport_get_hadjustment (GtkViewport *viewport); + GtkAdjustment* gtk_viewport_get_vadjustment (GtkViewport *viewport); + void gtk_viewport_set_hadjustment (GtkViewport *viewport, + GtkAdjustment *adjustment); + void gtk_viewport_set_vadjustment (GtkViewport *viewport, + GtkAdjustment *adjustment); + void gtk_viewport_set_shadow_type (GtkViewport *viewport, + GtkShadowType type); + GtkShadowType gtk_viewport_get_shadow_type (GtkViewport *viewport); + alias _GtkScrolledWindow GtkScrolledWindow; + + alias _GtkScrolledWindowClass GtkScrolledWindowClass; + + + struct _GtkScrolledWindow { + GtkBin container; + + GtkWidget *hscrollbar; + GtkWidget *vscrollbar; + + guint hscrollbar_policy; + guint vscrollbar_policy; + guint hscrollbar_visible; + guint vscrollbar_visible; + guint window_placement; + guint focus_out; + + guint16 shadow_type; + } + + struct _GtkScrolledWindowClass { + GtkBinClass parent_class; + + gint scrollbar_spacing; + void (*scroll_child) (GtkScrolledWindow *scrolled_window, + GtkScrollType scroll, + gboolean horizontal); + + void (* move_focus_out) (GtkScrolledWindow *scrolled_window, + GtkDirectionType direction); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_scrolled_window_get_type () ; + GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); + void gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window, + GtkAdjustment *hadjustment); + void gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window, + GtkAdjustment *hadjustment); + GtkAdjustment* gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window); + GtkAdjustment* gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window); + void gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window, + GtkPolicyType hscrollbar_policy, + GtkPolicyType vscrollbar_policy); + void gtk_scrolled_window_get_policy (GtkScrolledWindow *scrolled_window, + GtkPolicyType *hscrollbar_policy, + GtkPolicyType *vscrollbar_policy); + void gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window, + GtkCornerType window_placement); + GtkCornerType gtk_scrolled_window_get_placement (GtkScrolledWindow *scrolled_window); + void gtk_scrolled_window_set_shadow_type (GtkScrolledWindow *scrolled_window, + GtkShadowType type); + GtkShadowType gtk_scrolled_window_get_shadow_type (GtkScrolledWindow *scrolled_window); + void gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window, + GtkWidget *child); + + gint _gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow *scrolled_window); + + + alias _GtkSeparatorMenuItem GtkSeparatorMenuItem; + + alias _GtkSeparatorMenuItemClass GtkSeparatorMenuItemClass; + + + struct _GtkSeparatorMenuItem { + GtkMenuItem menu_item; + } + + struct _GtkSeparatorMenuItemClass { + GtkMenuItemClass parent_class; + } + + + GType gtk_separator_menu_item_get_type () ; + GtkWidget* gtk_separator_menu_item_new (); + + alias _GtkSeparatorToolItem GtkSeparatorToolItem; + + alias _GtkSeparatorToolItemClass GtkSeparatorToolItemClass; + + alias _GtkSeparatorToolItemPrivate GtkSeparatorToolItemPrivate; + alias void _GtkSeparatorToolItemPrivate; + + + struct _GtkSeparatorToolItem { + GtkToolItem parent; + + + GtkSeparatorToolItemPrivate *priv; + } + + struct _GtkSeparatorToolItemClass { + GtkToolItemClass parent_class; + + + void (* _gtk_reserved1) (); + void (* _gtk_reserved2) (); + void (* _gtk_reserved3) (); + void (* _gtk_reserved4) (); + } + + GType gtk_separator_tool_item_get_type () ; + GtkToolItem *gtk_separator_tool_item_new (); + + gboolean gtk_separator_tool_item_get_draw (GtkSeparatorToolItem *item); + void gtk_separator_tool_item_set_draw (GtkSeparatorToolItem *item, + gboolean draw); + + + + + alias _GtkSizeGroup GtkSizeGroup; + + alias _GtkSizeGroupClass GtkSizeGroupClass; + + + struct _GtkSizeGroup { + GObject parent_instance; + + GSList *widgets; + + guint8 mode; + + guint have_width; + guint have_height; + + GtkRequisition requisition; + } + + struct _GtkSizeGroupClass { + GObjectClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + enum GtkSizeGroupMode { + GTK_SIZE_GROUP_NONE, + GTK_SIZE_GROUP_HORIZONTAL, + GTK_SIZE_GROUP_VERTICAL, + GTK_SIZE_GROUP_BOTH + }; + + + GType gtk_size_group_get_type () ; + + GtkSizeGroup * gtk_size_group_new (GtkSizeGroupMode mode); + void gtk_size_group_set_mode (GtkSizeGroup *size_group, + GtkSizeGroupMode mode); + GtkSizeGroupMode gtk_size_group_get_mode (GtkSizeGroup *size_group); + void gtk_size_group_add_widget (GtkSizeGroup *size_group, + GtkWidget *widget); + void gtk_size_group_remove_widget (GtkSizeGroup *size_group, + GtkWidget *widget); + + + void _gtk_size_group_get_child_requisition (GtkWidget *widget, + GtkRequisition *requisition); + void _gtk_size_group_compute_requisition (GtkWidget *widget, + GtkRequisition *requisition); + void _gtk_size_group_queue_resize (GtkWidget *widget); + + enum GtkSpinButtonUpdatePolicy { + GTK_UPDATE_ALWAYS, + GTK_UPDATE_IF_VALID + }; + + + enum GtkSpinType { + GTK_SPIN_STEP_FORWARD, + GTK_SPIN_STEP_BACKWARD, + GTK_SPIN_PAGE_FORWARD, + GTK_SPIN_PAGE_BACKWARD, + GTK_SPIN_HOME, + GTK_SPIN_END, + GTK_SPIN_USER_DEFINED + }; + + + + alias _GtkSpinButton GtkSpinButton; + + alias _GtkSpinButtonClass GtkSpinButtonClass; + + + + struct _GtkSpinButton { + GtkEntry entry; + + GtkAdjustment *adjustment; + + GdkWindow *panel; + + guint32 timer; + + gdouble climb_rate; + gdouble timer_step; + + GtkSpinButtonUpdatePolicy update_policy; + + guint in_child; + guint click_child; + guint button; + guint need_timer; + guint timer_calls; + guint digits; + guint numeric; + guint wrap; + guint snap_to_ticks; + } + + struct _GtkSpinButtonClass { + GtkEntryClass parent_class; + + gint (*input) (GtkSpinButton *spin_button, + gdouble *new_value); + gint (*output) (GtkSpinButton *spin_button); + void (*value_changed) (GtkSpinButton *spin_button); + + + void (*change_value) (GtkSpinButton *spin_button, + GtkScrollType scroll); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_spin_button_get_type () ; + + void gtk_spin_button_configure (GtkSpinButton *spin_button, + GtkAdjustment *adjustment, + gdouble climb_rate, + guint digits); + + GtkWidget* gtk_spin_button_new (GtkAdjustment *adjustment, + gdouble climb_rate, + guint digits); + + GtkWidget* gtk_spin_button_new_with_range (gdouble min, + gdouble max, + gdouble step); + + void gtk_spin_button_set_adjustment (GtkSpinButton *spin_button, + GtkAdjustment *adjustment); + + GtkAdjustment* gtk_spin_button_get_adjustment (GtkSpinButton *spin_button); + + void gtk_spin_button_set_digits (GtkSpinButton *spin_button, + guint digits); + guint gtk_spin_button_get_digits (GtkSpinButton *spin_button); + + void gtk_spin_button_set_increments (GtkSpinButton *spin_button, + gdouble step, + gdouble page); + void gtk_spin_button_get_increments (GtkSpinButton *spin_button, + gdouble *step, + gdouble *page); + + void gtk_spin_button_set_range (GtkSpinButton *spin_button, + gdouble min, + gdouble max); + void gtk_spin_button_get_range (GtkSpinButton *spin_button, + gdouble *min, + gdouble *max); + + gdouble gtk_spin_button_get_value (GtkSpinButton *spin_button); + + gint gtk_spin_button_get_value_as_int (GtkSpinButton *spin_button); + + void gtk_spin_button_set_value (GtkSpinButton *spin_button, + gdouble value); + + void gtk_spin_button_set_update_policy (GtkSpinButton *spin_button, + GtkSpinButtonUpdatePolicy policy); + GtkSpinButtonUpdatePolicy gtk_spin_button_get_update_policy (GtkSpinButton *spin_button); + + void gtk_spin_button_set_numeric (GtkSpinButton *spin_button, + gboolean numeric); + gboolean gtk_spin_button_get_numeric (GtkSpinButton *spin_button); + + void gtk_spin_button_spin (GtkSpinButton *spin_button, + GtkSpinType direction, + gdouble increment); + + void gtk_spin_button_set_wrap (GtkSpinButton *spin_button, + gboolean wrap); + gboolean gtk_spin_button_get_wrap (GtkSpinButton *spin_button); + + void gtk_spin_button_set_snap_to_ticks (GtkSpinButton *spin_button, + gboolean snap_to_ticks); + gboolean gtk_spin_button_get_snap_to_ticks (GtkSpinButton *spin_button); + void gtk_spin_button_update (GtkSpinButton *spin_button); + alias _GtkStatusbar GtkStatusbar; + + alias _GtkStatusbarClass GtkStatusbarClass; + + + struct _GtkStatusbar { + GtkHBox parent_widget; + + GtkWidget *frame; + GtkWidget *label; + + GSList *messages; + GSList *keys; + + guint seq_context_id; + guint seq_message_id; + + GdkWindow *grip_window; + + guint has_resize_grip; + } + + struct _GtkStatusbarClass { + GtkHBoxClass parent_class; + + GMemChunk *messages_mem_chunk; + + void (*text_pushed) (GtkStatusbar *statusbar, + guint context_id, + gchar *text); + void (*text_popped) (GtkStatusbar *statusbar, + guint context_id, + gchar *text); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_statusbar_get_type () ; + GtkWidget* gtk_statusbar_new (); + + + + guint gtk_statusbar_get_context_id (GtkStatusbar *statusbar, + gchar *context_description); + + guint gtk_statusbar_push (GtkStatusbar *statusbar, + guint context_id, + gchar *text); + void gtk_statusbar_pop (GtkStatusbar *statusbar, + guint context_id); + void gtk_statusbar_remove (GtkStatusbar *statusbar, + guint context_id, + guint message_id); + + void gtk_statusbar_set_has_resize_grip (GtkStatusbar *statusbar, + gboolean setting); + gboolean gtk_statusbar_get_has_resize_grip (GtkStatusbar *statusbar); + alias _GtkStockItem GtkStockItem; + + + struct _GtkStockItem { + gchar *stock_id; + gchar *label; + GdkModifierType modifier; + guint keyval; + gchar *translation_domain; + } + + void gtk_stock_add ( GtkStockItem *items, + guint n_items); + void gtk_stock_add_static ( GtkStockItem *items, + guint n_items); + gboolean gtk_stock_lookup ( gchar *stock_id, + GtkStockItem *item); + + + + + GSList* gtk_stock_list_ids (); + + GtkStockItem *gtk_stock_item_copy ( GtkStockItem *item); + void gtk_stock_item_free (GtkStockItem *item); + + alias _GtkTable GtkTable; + + alias _GtkTableClass GtkTableClass; + + alias _GtkTableChild GtkTableChild; + + alias _GtkTableRowCol GtkTableRowCol; + + + struct _GtkTable { + GtkContainer container; + + GList *children; + GtkTableRowCol *rows; + GtkTableRowCol *cols; + guint16 nrows; + guint16 ncols; + guint16 column_spacing; + guint16 row_spacing; + guint homogeneous; + } + + struct _GtkTableClass { + GtkContainerClass parent_class; + } + + struct _GtkTableChild { + GtkWidget *widget; + guint16 left_attach; + guint16 right_attach; + guint16 top_attach; + guint16 bottom_attach; + guint16 xpadding; + guint16 ypadding; + guint xexpand; + guint yexpand; + guint xshrink; + guint yshrink; + guint xfill; + guint yfill; + } + + struct _GtkTableRowCol { + guint16 requisition; + guint16 allocation; + guint16 spacing; + guint need_expand; + guint need_shrink; + guint expand; + guint shrink; + guint empty; + } + + + GType gtk_table_get_type () ; + GtkWidget* gtk_table_new (guint rows, + guint columns, + gboolean homogeneous); + void gtk_table_resize (GtkTable *table, + guint rows, + guint columns); + void gtk_table_attach (GtkTable *table, + GtkWidget *child, + guint left_attach, + guint right_attach, + guint top_attach, + guint bottom_attach, + GtkAttachOptions xoptions, + GtkAttachOptions yoptions, + guint xpadding, + guint ypadding); + void gtk_table_attach_defaults (GtkTable *table, + GtkWidget *widget, + guint left_attach, + guint right_attach, + guint top_attach, + guint bottom_attach); + void gtk_table_set_row_spacing (GtkTable *table, + guint row, + guint spacing); + guint gtk_table_get_row_spacing (GtkTable *table, + guint row); + void gtk_table_set_col_spacing (GtkTable *table, + guint column, + guint spacing); + guint gtk_table_get_col_spacing (GtkTable *table, + guint column); + void gtk_table_set_row_spacings (GtkTable *table, + guint spacing); + guint gtk_table_get_default_row_spacing (GtkTable *table); + void gtk_table_set_col_spacings (GtkTable *table, + guint spacing); + guint gtk_table_get_default_col_spacing (GtkTable *table); + void gtk_table_set_homogeneous (GtkTable *table, + gboolean homogeneous); + gboolean gtk_table_get_homogeneous (GtkTable *table); + alias _GtkTearoffMenuItem GtkTearoffMenuItem; + + alias _GtkTearoffMenuItemClass GtkTearoffMenuItemClass; + + + struct _GtkTearoffMenuItem { + GtkMenuItem menu_item; + + guint torn_off; + } + + struct _GtkTearoffMenuItemClass { + GtkMenuItemClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_tearoff_menu_item_get_type () ; + GtkWidget* gtk_tearoff_menu_item_new (); + + + + alias _GtkTextIter GtkTextIter; + + alias _GtkTextTagTable GtkTextTagTable; + + + alias _GtkTextAttributes GtkTextAttributes; + + alias _GtkTextTag GtkTextTag; + + alias _GtkTextTagClass GtkTextTagClass; + + + struct _GtkTextTag { + GObject parent_instance; + + GtkTextTagTable *table; + + char *name; + + + + int priority; + GtkTextAttributes *values; + + + + + guint bg_color_set; + guint bg_stipple_set; + guint fg_color_set; + guint scale_set; + guint fg_stipple_set; + guint justification_set; + guint left_margin_set; + guint indent_set; + guint rise_set; + guint strikethrough_set; + guint right_margin_set; + guint pixels_above_lines_set; + guint pixels_below_lines_set; + guint pixels_inside_wrap_set; + guint tabs_set; + guint underline_set; + guint wrap_mode_set; + guint bg_full_height_set; + guint invisible_set; + guint editable_set; + guint language_set; + guint pad1; + guint pad2; + guint pad3; + } + + struct _GtkTextTagClass { + GObjectClass parent_class; + + gboolean (* event) (GtkTextTag *tag, + GObject *event_object, + GdkEvent *event, + GtkTextIter *iter); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_text_tag_get_type () ; + GtkTextTag *gtk_text_tag_new ( gchar *name); + gint gtk_text_tag_get_priority (GtkTextTag *tag); + void gtk_text_tag_set_priority (GtkTextTag *tag, + gint priority); + gboolean gtk_text_tag_event (GtkTextTag *tag, + GObject *event_object, + GdkEvent *event, + GtkTextIter *iter); + + + + + + alias _GtkTextAppearance GtkTextAppearance; + + + struct _GtkTextAppearance { + + GdkColor bg_color; + GdkColor fg_color; + GdkBitmap *bg_stipple; + GdkBitmap *fg_stipple; + + + gint rise; + + + + + + gpointer padding1; + + + guint underline; + guint strikethrough; + + + + + + + guint draw_bg; + + + + + + guint inside_selection; + guint is_text; + + + guint pad1; + guint pad2; + guint pad3; + guint pad4; + } + + struct _GtkTextAttributes { + + guint refcount; + + + GtkTextAppearance appearance; + + GtkJustification justification; + GtkTextDirection direction; + + + PangoFontDescription *font; + + gdouble font_scale; + + gint left_margin; + + gint indent; + + gint right_margin; + + gint pixels_above_lines; + + gint pixels_below_lines; + + gint pixels_inside_wrap; + + PangoTabArray *tabs; + + GtkWrapMode wrap_mode; + + + + + PangoLanguage *language; + + + + + + gpointer padding1; + + + + guint invisible; + + + + + guint bg_full_height; + + + guint editable; + + + guint realized; + + + guint pad1; + guint pad2; + guint pad3; + guint pad4; + } + + GtkTextAttributes* gtk_text_attributes_new (); + GtkTextAttributes* gtk_text_attributes_copy (GtkTextAttributes *src); + void gtk_text_attributes_copy_values (GtkTextAttributes *src, + GtkTextAttributes *dest); + void gtk_text_attributes_unref (GtkTextAttributes *values); + void gtk_text_attributes_ref (GtkTextAttributes *values); + + GType gtk_text_attributes_get_type (); + + + + + + + + alias void (* GtkTextTagTableForeach) (GtkTextTag *tag, gpointer data); + alias _GtkTextTagTableClass GtkTextTagTableClass; + + + struct _GtkTextTagTable { + GObject parent_instance; + + GHashTable *hash; + GSList *anonymous; + gint anon_count; + + GSList *buffers; + } + + struct _GtkTextTagTableClass { + GObjectClass parent_class; + + void (* tag_changed) (GtkTextTagTable *table, GtkTextTag *tag, gboolean size_changed); + void (* tag_added) (GtkTextTagTable *table, GtkTextTag *tag); + void (* tag_removed) (GtkTextTagTable *table, GtkTextTag *tag); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_text_tag_table_get_type () ; + + GtkTextTagTable *gtk_text_tag_table_new (); + void gtk_text_tag_table_add (GtkTextTagTable *table, + GtkTextTag *tag); + void gtk_text_tag_table_remove (GtkTextTagTable *table, + GtkTextTag *tag); + GtkTextTag *gtk_text_tag_table_lookup (GtkTextTagTable *table, + gchar *name); + void gtk_text_tag_table_foreach (GtkTextTagTable *table, + GtkTextTagTableForeach func, + gpointer data); + gint gtk_text_tag_table_get_size (GtkTextTagTable *table); + + + + + + void _gtk_text_tag_table_add_buffer (GtkTextTagTable *table, + gpointer buffer); + void _gtk_text_tag_table_remove_buffer (GtkTextTagTable *table, + gpointer buffer); + alias _GtkTextChildAnchor GtkTextChildAnchor; + + alias _GtkTextChildAnchorClass GtkTextChildAnchorClass; + + struct _GtkTextChildAnchor { + GObject parent_instance; + + gpointer segment; + } + + struct _GtkTextChildAnchorClass { + GObjectClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_text_child_anchor_get_type () ; + + GtkTextChildAnchor* gtk_text_child_anchor_new (); + + GList* gtk_text_child_anchor_get_widgets (GtkTextChildAnchor *anchor); + gboolean gtk_text_child_anchor_get_deleted (GtkTextChildAnchor *anchor); + + + + + + enum GtkTextSearchFlags { + GTK_TEXT_SEARCH_VISIBLE_ONLY = 1 << 0, + GTK_TEXT_SEARCH_TEXT_ONLY = 1 << 1 + + }; + + + + + + + + + alias _GtkTextBuffer GtkTextBuffer; + + + + + struct _GtkTextIter { + + + + + + gpointer dummy1; + gpointer dummy2; + gint dummy3; + gint dummy4; + gint dummy5; + gint dummy6; + gint dummy7; + gint dummy8; + gpointer dummy9; + gpointer dummy10; + gint dummy11; + gint dummy12; + + gint dummy13; + gpointer dummy14; + } + + + + + GtkTextBuffer *gtk_text_iter_get_buffer ( GtkTextIter *iter); + + + + + + GtkTextIter *gtk_text_iter_copy ( GtkTextIter *iter); + void gtk_text_iter_free (GtkTextIter *iter); + + GType gtk_text_iter_get_type (); + + + + + + gint gtk_text_iter_get_offset ( GtkTextIter *iter); + gint gtk_text_iter_get_line ( GtkTextIter *iter); + gint gtk_text_iter_get_line_offset ( GtkTextIter *iter); + gint gtk_text_iter_get_line_index ( GtkTextIter *iter); + + gint gtk_text_iter_get_visible_line_offset ( GtkTextIter *iter); + gint gtk_text_iter_get_visible_line_index ( GtkTextIter *iter); + + + + + + gunichar gtk_text_iter_get_char ( GtkTextIter *iter); + + + + + gchar *gtk_text_iter_get_slice ( GtkTextIter *start, + GtkTextIter *end); + + + gchar *gtk_text_iter_get_text ( GtkTextIter *start, + GtkTextIter *end); + + gchar *gtk_text_iter_get_visible_slice ( GtkTextIter *start, + GtkTextIter *end); + gchar *gtk_text_iter_get_visible_text ( GtkTextIter *start, + GtkTextIter *end); + + GdkPixbuf* gtk_text_iter_get_pixbuf ( GtkTextIter *iter); + GSList * gtk_text_iter_get_marks ( GtkTextIter *iter); + + GtkTextChildAnchor* gtk_text_iter_get_child_anchor ( GtkTextIter *iter); + + + + + GSList *gtk_text_iter_get_toggled_tags ( GtkTextIter *iter, + gboolean toggled_on); + + gboolean gtk_text_iter_begins_tag ( GtkTextIter *iter, + GtkTextTag *tag); + + gboolean gtk_text_iter_ends_tag ( GtkTextIter *iter, + GtkTextTag *tag); + + gboolean gtk_text_iter_toggles_tag ( GtkTextIter *iter, + GtkTextTag *tag); + + gboolean gtk_text_iter_has_tag ( GtkTextIter *iter, + GtkTextTag *tag); + GSList *gtk_text_iter_get_tags ( GtkTextIter *iter); + + gboolean gtk_text_iter_editable ( GtkTextIter *iter, + gboolean default_setting); + gboolean gtk_text_iter_can_insert ( GtkTextIter *iter, + gboolean default_editability); + + gboolean gtk_text_iter_starts_word ( GtkTextIter *iter); + gboolean gtk_text_iter_ends_word ( GtkTextIter *iter); + gboolean gtk_text_iter_inside_word ( GtkTextIter *iter); + gboolean gtk_text_iter_starts_sentence ( GtkTextIter *iter); + gboolean gtk_text_iter_ends_sentence ( GtkTextIter *iter); + gboolean gtk_text_iter_inside_sentence ( GtkTextIter *iter); + gboolean gtk_text_iter_starts_line ( GtkTextIter *iter); + gboolean gtk_text_iter_ends_line ( GtkTextIter *iter); + gboolean gtk_text_iter_is_cursor_position ( GtkTextIter *iter); + + gint gtk_text_iter_get_chars_in_line ( GtkTextIter *iter); + gint gtk_text_iter_get_bytes_in_line ( GtkTextIter *iter); + + gboolean gtk_text_iter_get_attributes ( GtkTextIter *iter, + GtkTextAttributes *values); + PangoLanguage* gtk_text_iter_get_language ( GtkTextIter *iter); + gboolean gtk_text_iter_is_end ( GtkTextIter *iter); + gboolean gtk_text_iter_is_start ( GtkTextIter *iter); + + + + + + gboolean gtk_text_iter_forward_char (GtkTextIter *iter); + gboolean gtk_text_iter_backward_char (GtkTextIter *iter); + gboolean gtk_text_iter_forward_chars (GtkTextIter *iter, + gint count); + gboolean gtk_text_iter_backward_chars (GtkTextIter *iter, + gint count); + gboolean gtk_text_iter_forward_line (GtkTextIter *iter); + gboolean gtk_text_iter_backward_line (GtkTextIter *iter); + gboolean gtk_text_iter_forward_lines (GtkTextIter *iter, + gint count); + gboolean gtk_text_iter_backward_lines (GtkTextIter *iter, + gint count); + gboolean gtk_text_iter_forward_word_end (GtkTextIter *iter); + gboolean gtk_text_iter_backward_word_start (GtkTextIter *iter); + gboolean gtk_text_iter_forward_word_ends (GtkTextIter *iter, + gint count); + gboolean gtk_text_iter_backward_word_starts (GtkTextIter *iter, + gint count); + + gboolean gtk_text_iter_forward_visible_word_end (GtkTextIter *iter); + gboolean gtk_text_iter_backward_visible_word_start (GtkTextIter *iter); + gboolean gtk_text_iter_forward_visible_word_ends (GtkTextIter *iter, + gint count); + gboolean gtk_text_iter_backward_visible_word_starts (GtkTextIter *iter, + gint count); + + gboolean gtk_text_iter_forward_sentence_end (GtkTextIter *iter); + gboolean gtk_text_iter_backward_sentence_start (GtkTextIter *iter); + gboolean gtk_text_iter_forward_sentence_ends (GtkTextIter *iter, + gint count); + gboolean gtk_text_iter_backward_sentence_starts (GtkTextIter *iter, + gint count); + + + + + + gboolean gtk_text_iter_forward_cursor_position (GtkTextIter *iter); + gboolean gtk_text_iter_backward_cursor_position (GtkTextIter *iter); + gboolean gtk_text_iter_forward_cursor_positions (GtkTextIter *iter, + gint count); + gboolean gtk_text_iter_backward_cursor_positions (GtkTextIter *iter, + gint count); + + gboolean gtk_text_iter_forward_visible_cursor_position (GtkTextIter *iter); + gboolean gtk_text_iter_backward_visible_cursor_position (GtkTextIter *iter); + gboolean gtk_text_iter_forward_visible_cursor_positions (GtkTextIter *iter, + gint count); + gboolean gtk_text_iter_backward_visible_cursor_positions (GtkTextIter *iter, + gint count); + + + void gtk_text_iter_set_offset (GtkTextIter *iter, + gint char_offset); + void gtk_text_iter_set_line (GtkTextIter *iter, + gint line_number); + void gtk_text_iter_set_line_offset (GtkTextIter *iter, + gint char_on_line); + void gtk_text_iter_set_line_index (GtkTextIter *iter, + gint byte_on_line); + void gtk_text_iter_forward_to_end (GtkTextIter *iter); + gboolean gtk_text_iter_forward_to_line_end (GtkTextIter *iter); + + void gtk_text_iter_set_visible_line_offset (GtkTextIter *iter, + gint char_on_line); + void gtk_text_iter_set_visible_line_index (GtkTextIter *iter, + gint byte_on_line); + + + + + + gboolean gtk_text_iter_forward_to_tag_toggle (GtkTextIter *iter, + GtkTextTag *tag); + + gboolean gtk_text_iter_backward_to_tag_toggle (GtkTextIter *iter, + GtkTextTag *tag); + + alias gboolean (* GtkTextCharPredicate) (gunichar ch, gpointer user_data); + + gboolean gtk_text_iter_forward_find_char (GtkTextIter *iter, + GtkTextCharPredicate pred, + gpointer user_data, + GtkTextIter *limit); + gboolean gtk_text_iter_backward_find_char (GtkTextIter *iter, + GtkTextCharPredicate pred, + gpointer user_data, + GtkTextIter *limit); + + gboolean gtk_text_iter_forward_search ( GtkTextIter *iter, + gchar *str, + GtkTextSearchFlags flags, + GtkTextIter *match_start, + GtkTextIter *match_end, + GtkTextIter *limit); + + gboolean gtk_text_iter_backward_search ( GtkTextIter *iter, + gchar *str, + GtkTextSearchFlags flags, + GtkTextIter *match_start, + GtkTextIter *match_end, + GtkTextIter *limit); + + + + + + gboolean gtk_text_iter_equal ( GtkTextIter *lhs, + GtkTextIter *rhs); + gint gtk_text_iter_compare ( GtkTextIter *lhs, + GtkTextIter *rhs); + gboolean gtk_text_iter_in_range ( GtkTextIter *iter, + GtkTextIter *start, + GtkTextIter *end); + + + void gtk_text_iter_order (GtkTextIter *first, + GtkTextIter *second); + alias _GtkTextMark GtkTextMark; + + alias _GtkTextMarkClass GtkTextMarkClass; + + struct _GtkTextMark { + GObject parent_instance; + + gpointer segment; + } + + struct _GtkTextMarkClass { + GObjectClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + GType gtk_text_mark_get_type () ; + + void gtk_text_mark_set_visible (GtkTextMark *mark, + gboolean setting); + gboolean gtk_text_mark_get_visible (GtkTextMark *mark); + + gchar* gtk_text_mark_get_name (GtkTextMark *mark); + gboolean gtk_text_mark_get_deleted (GtkTextMark *mark); + GtkTextBuffer* gtk_text_mark_get_buffer (GtkTextMark *mark); + gboolean gtk_text_mark_get_left_gravity (GtkTextMark *mark); + alias _GtkTextBTree GtkTextBTree; + alias void _GtkTextBTree; + + + alias _GtkTextLogAttrCache GtkTextLogAttrCache; + alias void _GtkTextLogAttrCache; + + alias _GtkTextBufferClass GtkTextBufferClass; + + + struct _GtkTextBuffer { + GObject parent_instance; + + GtkTextTagTable *tag_table; + GtkTextBTree *btree; + + GSList *clipboard_contents_buffers; + GSList *selection_clipboards; + + GtkTextLogAttrCache *log_attr_cache; + + guint user_action_count; + + + guint modified; + } + + struct _GtkTextBufferClass { + GObjectClass parent_class; + + void (* insert_text) (GtkTextBuffer *buffer, + GtkTextIter *pos, + gchar *text, + gint length); + + void (* insert_pixbuf) (GtkTextBuffer *buffer, + GtkTextIter *pos, + GdkPixbuf *pixbuf); + + void (* insert_child_anchor) (GtkTextBuffer *buffer, + GtkTextIter *pos, + GtkTextChildAnchor *anchor); + + void (* delete_range) (GtkTextBuffer *buffer, + GtkTextIter *start, + GtkTextIter *end); + + + + + void (* changed) (GtkTextBuffer *buffer); + + + + void (* modified_changed) (GtkTextBuffer *buffer); + + + void (* mark_set) (GtkTextBuffer *buffer, + GtkTextIter *location, + GtkTextMark *mark); + + void (* mark_deleted) (GtkTextBuffer *buffer, + GtkTextMark *mark); + + void (* apply_tag) (GtkTextBuffer *buffer, + GtkTextTag *tag, + GtkTextIter *start_char, + GtkTextIter *end_char); + + void (* remove_tag) (GtkTextBuffer *buffer, + GtkTextTag *tag, + GtkTextIter *start_char, + GtkTextIter *end_char); + + + void (* begin_user_action) (GtkTextBuffer *buffer); + void (* end_user_action) (GtkTextBuffer *buffer); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + void (*_gtk_reserved5) (); + void (*_gtk_reserved6) (); + } + + GType gtk_text_buffer_get_type () ; + + + + + GtkTextBuffer *gtk_text_buffer_new (GtkTextTagTable *table); + gint gtk_text_buffer_get_line_count (GtkTextBuffer *buffer); + gint gtk_text_buffer_get_char_count (GtkTextBuffer *buffer); + + + GtkTextTagTable* gtk_text_buffer_get_tag_table (GtkTextBuffer *buffer); + + + void gtk_text_buffer_set_text (GtkTextBuffer *buffer, + gchar *text, + gint len); + + + void gtk_text_buffer_insert (GtkTextBuffer *buffer, + GtkTextIter *iter, + gchar *text, + gint len); + void gtk_text_buffer_insert_at_cursor (GtkTextBuffer *buffer, + gchar *text, + gint len); + + gboolean gtk_text_buffer_insert_interactive (GtkTextBuffer *buffer, + GtkTextIter *iter, + gchar *text, + gint len, + gboolean default_editable); + gboolean gtk_text_buffer_insert_interactive_at_cursor (GtkTextBuffer *buffer, + gchar *text, + gint len, + gboolean default_editable); + + void gtk_text_buffer_insert_range (GtkTextBuffer *buffer, + GtkTextIter *iter, + GtkTextIter *start, + GtkTextIter *end); + gboolean gtk_text_buffer_insert_range_interactive (GtkTextBuffer *buffer, + GtkTextIter *iter, + GtkTextIter *start, + GtkTextIter *end, + gboolean default_editable); + + void gtk_text_buffer_insert_with_tags (GtkTextBuffer *buffer, + GtkTextIter *iter, + gchar *text, + gint len, + GtkTextTag *first_tag, + ...); + + void gtk_text_buffer_insert_with_tags_by_name (GtkTextBuffer *buffer, + GtkTextIter *iter, + gchar *text, + gint len, + gchar *first_tag_name, + ...); + + + void gtk_text_buffer_delete (GtkTextBuffer *buffer, + GtkTextIter *start, + GtkTextIter *end); + gboolean gtk_text_buffer_delete_interactive (GtkTextBuffer *buffer, + GtkTextIter *start_iter, + GtkTextIter *end_iter, + gboolean default_editable); + + + + + gchar *gtk_text_buffer_get_text (GtkTextBuffer *buffer, + GtkTextIter *start, + GtkTextIter *end, + gboolean include_hidden_chars); + + gchar *gtk_text_buffer_get_slice (GtkTextBuffer *buffer, + GtkTextIter *start, + GtkTextIter *end, + gboolean include_hidden_chars); + + + void gtk_text_buffer_insert_pixbuf (GtkTextBuffer *buffer, + GtkTextIter *iter, + GdkPixbuf *pixbuf); + + + void gtk_text_buffer_insert_child_anchor (GtkTextBuffer *buffer, + GtkTextIter *iter, + GtkTextChildAnchor *anchor); + + + GtkTextChildAnchor *gtk_text_buffer_create_child_anchor (GtkTextBuffer *buffer, + GtkTextIter *iter); + + + GtkTextMark *gtk_text_buffer_create_mark (GtkTextBuffer *buffer, + gchar *mark_name, + GtkTextIter *where, + gboolean left_gravity); + void gtk_text_buffer_move_mark (GtkTextBuffer *buffer, + GtkTextMark *mark, + GtkTextIter *where); + void gtk_text_buffer_delete_mark (GtkTextBuffer *buffer, + GtkTextMark *mark); + GtkTextMark* gtk_text_buffer_get_mark (GtkTextBuffer *buffer, + gchar *name); + + void gtk_text_buffer_move_mark_by_name (GtkTextBuffer *buffer, + gchar *name, + GtkTextIter *where); + void gtk_text_buffer_delete_mark_by_name (GtkTextBuffer *buffer, + gchar *name); + + GtkTextMark* gtk_text_buffer_get_insert (GtkTextBuffer *buffer); + GtkTextMark* gtk_text_buffer_get_selection_bound (GtkTextBuffer *buffer); + + + void gtk_text_buffer_place_cursor (GtkTextBuffer *buffer, + GtkTextIter *where); + void gtk_text_buffer_select_range (GtkTextBuffer *buffer, + GtkTextIter *ins, + GtkTextIter *bound); + + + + + void gtk_text_buffer_apply_tag (GtkTextBuffer *buffer, + GtkTextTag *tag, + GtkTextIter *start, + GtkTextIter *end); + void gtk_text_buffer_remove_tag (GtkTextBuffer *buffer, + GtkTextTag *tag, + GtkTextIter *start, + GtkTextIter *end); + void gtk_text_buffer_apply_tag_by_name (GtkTextBuffer *buffer, + gchar *name, + GtkTextIter *start, + GtkTextIter *end); + void gtk_text_buffer_remove_tag_by_name (GtkTextBuffer *buffer, + gchar *name, + GtkTextIter *start, + GtkTextIter *end); + void gtk_text_buffer_remove_all_tags (GtkTextBuffer *buffer, + GtkTextIter *start, + GtkTextIter *end); + + + + + + GtkTextTag *gtk_text_buffer_create_tag (GtkTextBuffer *buffer, + gchar *tag_name, + gchar *first_property_name, + ...); + + + + + void gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer *buffer, + GtkTextIter *iter, + gint line_number, + gint char_offset); + void gtk_text_buffer_get_iter_at_line_index (GtkTextBuffer *buffer, + GtkTextIter *iter, + gint line_number, + gint byte_index); + void gtk_text_buffer_get_iter_at_offset (GtkTextBuffer *buffer, + GtkTextIter *iter, + gint char_offset); + void gtk_text_buffer_get_iter_at_line (GtkTextBuffer *buffer, + GtkTextIter *iter, + gint line_number); + void gtk_text_buffer_get_start_iter (GtkTextBuffer *buffer, + GtkTextIter *iter); + void gtk_text_buffer_get_end_iter (GtkTextBuffer *buffer, + GtkTextIter *iter); + void gtk_text_buffer_get_bounds (GtkTextBuffer *buffer, + GtkTextIter *start, + GtkTextIter *end); + void gtk_text_buffer_get_iter_at_mark (GtkTextBuffer *buffer, + GtkTextIter *iter, + GtkTextMark *mark); + + void gtk_text_buffer_get_iter_at_child_anchor (GtkTextBuffer *buffer, + GtkTextIter *iter, + GtkTextChildAnchor *anchor); + gboolean gtk_text_buffer_get_modified (GtkTextBuffer *buffer); + void gtk_text_buffer_set_modified (GtkTextBuffer *buffer, + gboolean setting); + + void gtk_text_buffer_add_selection_clipboard (GtkTextBuffer *buffer, + GtkClipboard *clipboard); + void gtk_text_buffer_remove_selection_clipboard (GtkTextBuffer *buffer, + GtkClipboard *clipboard); + + void gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer, + GtkClipboard *clipboard, + gboolean default_editable); + void gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer, + GtkClipboard *clipboard); + void gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer, + GtkClipboard *clipboard, + GtkTextIter *override_location, + gboolean default_editable); + + gboolean gtk_text_buffer_get_selection_bounds (GtkTextBuffer *buffer, + GtkTextIter *start, + GtkTextIter *end); + gboolean gtk_text_buffer_delete_selection (GtkTextBuffer *buffer, + gboolean interactive, + gboolean default_editable); + + + void gtk_text_buffer_begin_user_action (GtkTextBuffer *buffer); + void gtk_text_buffer_end_user_action (GtkTextBuffer *buffer); + + + void _gtk_text_buffer_spew (GtkTextBuffer *buffer); + + GtkTextBTree* _gtk_text_buffer_get_btree (GtkTextBuffer *buffer); + + PangoLogAttr* _gtk_text_buffer_get_line_log_attrs (GtkTextBuffer *buffer, + GtkTextIter *anywhere_in_line, + gint *char_len); + + void _gtk_text_buffer_notify_will_remove_tag (GtkTextBuffer *buffer, + GtkTextTag *tag); + enum GtkTextWindowType { + GTK_TEXT_WINDOW_PRIVATE, + GTK_TEXT_WINDOW_WIDGET, + GTK_TEXT_WINDOW_TEXT, + GTK_TEXT_WINDOW_LEFT, + GTK_TEXT_WINDOW_RIGHT, + GTK_TEXT_WINDOW_TOP, + GTK_TEXT_WINDOW_BOTTOM + }; + + + + + alias _GtkTextView GtkTextView; + + alias _GtkTextViewClass GtkTextViewClass; + + + + alias _GtkTextWindow GtkTextWindow; + alias void _GtkTextWindow; + + alias _GtkTextPendingScroll GtkTextPendingScroll; + alias void _GtkTextPendingScroll; + + + struct _GtkTextView { + GtkContainer parent_instance; + + void *layout; + GtkTextBuffer *buffer; + + guint selection_drag_handler; + guint scroll_timeout; + + + gint pixels_above_lines; + gint pixels_below_lines; + gint pixels_inside_wrap; + GtkWrapMode wrap_mode; + GtkJustification justify; + gint left_margin; + gint right_margin; + gint indent; + PangoTabArray *tabs; + guint editable; + + + + guint overwrite_mode; + guint cursor_visible; + + + guint need_im_reset; + + guint accepts_tab; + + + guint reserved; + + + + + guint onscreen_validated; + + guint mouse_cursor_obscured; + + GtkTextWindow *text_window; + GtkTextWindow *left_window; + GtkTextWindow *right_window; + GtkTextWindow *top_window; + GtkTextWindow *bottom_window; + + GtkAdjustment *hadjustment; + GtkAdjustment *vadjustment; + + gint xoffset; + gint yoffset; + gint width; + gint height; + gint virtual_cursor_x; + gint virtual_cursor_y; + + GtkTextMark *first_para_mark; + gint first_para_pixels; + + GtkTextMark *dnd_mark; + guint blink_timeout; + + guint first_validate_idle; + guint incremental_validate_idle; + + GtkIMContext *im_context; + GtkWidget *popup_menu; + + gint drag_start_x; + gint drag_start_y; + + GSList *children; + + GtkTextPendingScroll *pending_scroll; + + gint pending_place_cursor_button; + } + + struct _GtkTextViewClass { + GtkContainerClass parent_class; + + void (* set_scroll_adjustments) (GtkTextView *text_view, + GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); + + void (* populate_popup) (GtkTextView *text_view, + GtkMenu *menu); + + + + + void (* move_cursor) (GtkTextView *text_view, + GtkMovementStep step, + gint count, + gboolean extend_selection); + + + + + + void (* page_horizontally) (GtkTextView *text_view, + gint count, + gboolean extend_selection); + + + void (* set_anchor) (GtkTextView *text_view); + + + void (* insert_at_cursor) (GtkTextView *text_view, + gchar *str); + void (* delete_from_cursor) (GtkTextView *text_view, + GtkDeleteType type, + gint count); + + + void (* cut_clipboard) (GtkTextView *text_view); + void (* copy_clipboard) (GtkTextView *text_view); + void (* paste_clipboard) (GtkTextView *text_view); + + void (* toggle_overwrite) (GtkTextView *text_view); + + + void (* move_focus) (GtkTextView *text_view, + GtkDirectionType direction); + + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + void (*_gtk_reserved5) (); + void (*_gtk_reserved6) (); + void (*_gtk_reserved7) (); + void (*_gtk_reserved8) (); + } + + GType gtk_text_view_get_type () ; + GtkWidget * gtk_text_view_new (); + GtkWidget * gtk_text_view_new_with_buffer (GtkTextBuffer *buffer); + void gtk_text_view_set_buffer (GtkTextView *text_view, + GtkTextBuffer *buffer); + GtkTextBuffer *gtk_text_view_get_buffer (GtkTextView *text_view); + gboolean gtk_text_view_scroll_to_iter (GtkTextView *text_view, + GtkTextIter *iter, + gdouble within_margin, + gboolean use_align, + gdouble xalign, + gdouble yalign); + void gtk_text_view_scroll_to_mark (GtkTextView *text_view, + GtkTextMark *mark, + gdouble within_margin, + gboolean use_align, + gdouble xalign, + gdouble yalign); + void gtk_text_view_scroll_mark_onscreen (GtkTextView *text_view, + GtkTextMark *mark); + gboolean gtk_text_view_move_mark_onscreen (GtkTextView *text_view, + GtkTextMark *mark); + gboolean gtk_text_view_place_cursor_onscreen (GtkTextView *text_view); + + void gtk_text_view_get_visible_rect (GtkTextView *text_view, + GdkRectangle *visible_rect); + void gtk_text_view_set_cursor_visible (GtkTextView *text_view, + gboolean setting); + gboolean gtk_text_view_get_cursor_visible (GtkTextView *text_view); + + void gtk_text_view_get_iter_location (GtkTextView *text_view, + GtkTextIter *iter, + GdkRectangle *location); + void gtk_text_view_get_iter_at_location (GtkTextView *text_view, + GtkTextIter *iter, + gint x, + gint y); + void gtk_text_view_get_line_yrange (GtkTextView *text_view, + GtkTextIter *iter, + gint *y, + gint *height); + + void gtk_text_view_get_line_at_y (GtkTextView *text_view, + GtkTextIter *target_iter, + gint y, + gint *line_top); + + void gtk_text_view_buffer_to_window_coords (GtkTextView *text_view, + GtkTextWindowType win, + gint buffer_x, + gint buffer_y, + gint *window_x, + gint *window_y); + void gtk_text_view_window_to_buffer_coords (GtkTextView *text_view, + GtkTextWindowType win, + gint window_x, + gint window_y, + gint *buffer_x, + gint *buffer_y); + + GdkWindow* gtk_text_view_get_window (GtkTextView *text_view, + GtkTextWindowType win); + GtkTextWindowType gtk_text_view_get_window_type (GtkTextView *text_view, + GdkWindow *window); + + void gtk_text_view_set_border_window_size (GtkTextView *text_view, + GtkTextWindowType type, + gint size); + gint gtk_text_view_get_border_window_size (GtkTextView *text_view, + GtkTextWindowType type); + + gboolean gtk_text_view_forward_display_line (GtkTextView *text_view, + GtkTextIter *iter); + gboolean gtk_text_view_backward_display_line (GtkTextView *text_view, + GtkTextIter *iter); + gboolean gtk_text_view_forward_display_line_end (GtkTextView *text_view, + GtkTextIter *iter); + gboolean gtk_text_view_backward_display_line_start (GtkTextView *text_view, + GtkTextIter *iter); + gboolean gtk_text_view_starts_display_line (GtkTextView *text_view, + GtkTextIter *iter); + gboolean gtk_text_view_move_visually (GtkTextView *text_view, + GtkTextIter *iter, + gint count); + + + void gtk_text_view_add_child_at_anchor (GtkTextView *text_view, + GtkWidget *child, + GtkTextChildAnchor *anchor); + + void gtk_text_view_add_child_in_window (GtkTextView *text_view, + GtkWidget *child, + GtkTextWindowType which_window, + + gint xpos, + gint ypos); + + void gtk_text_view_move_child (GtkTextView *text_view, + GtkWidget *child, + + gint xpos, + gint ypos); + + + + void gtk_text_view_set_wrap_mode (GtkTextView *text_view, + GtkWrapMode wrap_mode); + GtkWrapMode gtk_text_view_get_wrap_mode (GtkTextView *text_view); + void gtk_text_view_set_editable (GtkTextView *text_view, + gboolean setting); + gboolean gtk_text_view_get_editable (GtkTextView *text_view); + void gtk_text_view_set_overwrite (GtkTextView *text_view, + gboolean overwrite); + gboolean gtk_text_view_get_overwrite (GtkTextView *text_view); + void gtk_text_view_set_accepts_tab (GtkTextView *text_view, + gboolean accepts_tab); + gboolean gtk_text_view_get_accepts_tab (GtkTextView *text_view); + void gtk_text_view_set_pixels_above_lines (GtkTextView *text_view, + gint pixels_above_lines); + gint gtk_text_view_get_pixels_above_lines (GtkTextView *text_view); + void gtk_text_view_set_pixels_below_lines (GtkTextView *text_view, + gint pixels_below_lines); + gint gtk_text_view_get_pixels_below_lines (GtkTextView *text_view); + void gtk_text_view_set_pixels_inside_wrap (GtkTextView *text_view, + gint pixels_inside_wrap); + gint gtk_text_view_get_pixels_inside_wrap (GtkTextView *text_view); + void gtk_text_view_set_justification (GtkTextView *text_view, + GtkJustification justification); + GtkJustification gtk_text_view_get_justification (GtkTextView *text_view); + void gtk_text_view_set_left_margin (GtkTextView *text_view, + gint left_margin); + gint gtk_text_view_get_left_margin (GtkTextView *text_view); + void gtk_text_view_set_right_margin (GtkTextView *text_view, + gint right_margin); + gint gtk_text_view_get_right_margin (GtkTextView *text_view); + void gtk_text_view_set_indent (GtkTextView *text_view, + gint indent); + gint gtk_text_view_get_indent (GtkTextView *text_view); + void gtk_text_view_set_tabs (GtkTextView *text_view, + PangoTabArray *tabs); + PangoTabArray* gtk_text_view_get_tabs (GtkTextView *text_view); + + + GtkTextAttributes* gtk_text_view_get_default_attributes (GtkTextView *text_view); + alias _GtkTipsQuery GtkTipsQuery; + + alias _GtkTipsQueryClass GtkTipsQueryClass; + + + + + struct _GtkTipsQuery { + GtkLabel label; + + guint emit_always; + guint in_query; + gchar *label_inactive; + gchar *label_no_tip; + + GtkWidget *caller; + GtkWidget *last_crossed; + + GdkCursor *query_cursor; + } + + struct _GtkTipsQueryClass { + GtkLabelClass parent_class; + + void (*start_query) (GtkTipsQuery *tips_query); + void (*stop_query) (GtkTipsQuery *tips_query); + void (*widget_entered) (GtkTipsQuery *tips_query, + GtkWidget *widget, + gchar *tip_text, + gchar *tip_private); + gint (*widget_selected) (GtkTipsQuery *tips_query, + GtkWidget *widget, + gchar *tip_text, + gchar *tip_private, + GdkEventButton *event); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + + GtkType gtk_tips_query_get_type () ; + GtkWidget* gtk_tips_query_new (); + void gtk_tips_query_start_query (GtkTipsQuery *tips_query); + void gtk_tips_query_stop_query (GtkTipsQuery *tips_query); + void gtk_tips_query_set_caller (GtkTipsQuery *tips_query, + GtkWidget *caller); + void gtk_tips_query_set_labels (GtkTipsQuery *tips_query, + gchar *label_inactive, + gchar *label_no_tip); + + + + + + + + + enum GtkToolbarChildType { + GTK_TOOLBAR_CHILD_SPACE, + GTK_TOOLBAR_CHILD_BUTTON, + GTK_TOOLBAR_CHILD_TOGGLEBUTTON, + GTK_TOOLBAR_CHILD_RADIOBUTTON, + GTK_TOOLBAR_CHILD_WIDGET + }; + + + alias _GtkToolbarChild GtkToolbarChild; + + + struct _GtkToolbarChild { + GtkToolbarChildType type; + GtkWidget *widget; + GtkWidget *icon; + GtkWidget *label; + } + + + + enum GtkToolbarSpaceStyle { + GTK_TOOLBAR_SPACE_EMPTY, + GTK_TOOLBAR_SPACE_LINE + }; + + + alias _GtkToolbar GtkToolbar; + + alias _GtkToolbarClass GtkToolbarClass; + + alias _GtkToolbarPrivate GtkToolbarPrivate; + alias void _GtkToolbarPrivate; + + + struct _GtkToolbar { + GtkContainer container; + + + gint num_children; + GList *children; + GtkOrientation orientation; + GtkToolbarStyle style; + GtkIconSize icon_size; + + GtkTooltips *tooltips; + + + gint button_maxw; + gint button_maxh; + + guint style_set_connection; + guint icon_size_connection; + + guint style_set; + guint icon_size_set; + } + + struct _GtkToolbarClass { + GtkContainerClass parent_class; + + + void (* orientation_changed) (GtkToolbar *toolbar, + GtkOrientation orientation); + void (* style_changed) (GtkToolbar *toolbar, + GtkToolbarStyle style); + gboolean (* popup_context_menu) (GtkToolbar *toolbar, + gint x, + gint y, + gint button_number); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + } + + GType gtk_toolbar_get_type () ; + GtkWidget* gtk_toolbar_new (); + void gtk_toolbar_insert (GtkToolbar *toolbar, + GtkToolItem *item, + gint pos); + gint gtk_toolbar_get_item_index (GtkToolbar *toolbar, + GtkToolItem *item); + gint gtk_toolbar_get_n_items (GtkToolbar *toolbar); + GtkToolItem * gtk_toolbar_get_nth_item (GtkToolbar *toolbar, + gint n); + gboolean gtk_toolbar_get_show_arrow (GtkToolbar *toolbar); + void gtk_toolbar_set_show_arrow (GtkToolbar *toolbar, + gboolean show_arrow); + GtkOrientation gtk_toolbar_get_orientation (GtkToolbar *toolbar); + void gtk_toolbar_set_orientation (GtkToolbar *toolbar, + GtkOrientation orientation); + gboolean gtk_toolbar_get_tooltips (GtkToolbar *toolbar); + void gtk_toolbar_set_tooltips (GtkToolbar *toolbar, + gboolean enable); + GtkToolbarStyle gtk_toolbar_get_style (GtkToolbar *toolbar); + void gtk_toolbar_set_style (GtkToolbar *toolbar, + GtkToolbarStyle style); + void gtk_toolbar_unset_style (GtkToolbar *toolbar); + GtkIconSize gtk_toolbar_get_icon_size (GtkToolbar *toolbar); + GtkReliefStyle gtk_toolbar_get_relief_style (GtkToolbar *toolbar); + gint gtk_toolbar_get_drop_index (GtkToolbar *toolbar, + gint x, + gint y); + void gtk_toolbar_set_drop_highlight_item (GtkToolbar *toolbar, + GtkToolItem *tool_item, + gint index_); + + + gchar * _gtk_toolbar_elide_underscores ( gchar *original); + void _gtk_toolbar_paint_space_line (GtkWidget *widget, + GtkToolbar *toolbar, + GdkRectangle *area, + GtkAllocation *allocation); + gint _gtk_toolbar_get_default_space_size (); + + + + + + void gtk_toolbar_set_icon_size (GtkToolbar *toolbar, + GtkIconSize icon_size); + void gtk_toolbar_unset_icon_size (GtkToolbar *toolbar); + + + GtkWidget* gtk_toolbar_append_item (GtkToolbar *toolbar, + char *text, + char *tooltip_text, + char *tooltip_private_text, + GtkWidget *icon, + GtkSignalFunc callback, + gpointer user_data); + GtkWidget* gtk_toolbar_prepend_item (GtkToolbar *toolbar, + char *text, + char *tooltip_text, + char *tooltip_private_text, + GtkWidget *icon, + GtkSignalFunc callback, + gpointer user_data); + GtkWidget* gtk_toolbar_insert_item (GtkToolbar *toolbar, + char *text, + char *tooltip_text, + char *tooltip_private_text, + GtkWidget *icon, + GtkSignalFunc callback, + gpointer user_data, + gint position); + + + GtkWidget* gtk_toolbar_insert_stock (GtkToolbar *toolbar, + gchar *stock_id, + char *tooltip_text, + char *tooltip_private_text, + GtkSignalFunc callback, + gpointer user_data, + gint position); + + + void gtk_toolbar_append_space (GtkToolbar *toolbar); + void gtk_toolbar_prepend_space (GtkToolbar *toolbar); + void gtk_toolbar_insert_space (GtkToolbar *toolbar, + gint position); + void gtk_toolbar_remove_space (GtkToolbar *toolbar, + gint position); + + GtkWidget* gtk_toolbar_append_element (GtkToolbar *toolbar, + GtkToolbarChildType type, + GtkWidget *widget, + char *text, + char *tooltip_text, + char *tooltip_private_text, + GtkWidget *icon, + GtkSignalFunc callback, + gpointer user_data); + + GtkWidget* gtk_toolbar_prepend_element (GtkToolbar *toolbar, + GtkToolbarChildType type, + GtkWidget *widget, + char *text, + char *tooltip_text, + char *tooltip_private_text, + GtkWidget *icon, + GtkSignalFunc callback, + gpointer user_data); + + GtkWidget* gtk_toolbar_insert_element (GtkToolbar *toolbar, + GtkToolbarChildType type, + GtkWidget *widget, + char *text, + char *tooltip_text, + char *tooltip_private_text, + GtkWidget *icon, + GtkSignalFunc callback, + gpointer user_data, + gint position); + + + void gtk_toolbar_append_widget (GtkToolbar *toolbar, + GtkWidget *widget, + char *tooltip_text, + char *tooltip_private_text); + void gtk_toolbar_prepend_widget (GtkToolbar *toolbar, + GtkWidget *widget, + char *tooltip_text, + char *tooltip_private_text); + void gtk_toolbar_insert_widget (GtkToolbar *toolbar, + GtkWidget *widget, + char *tooltip_text, + char *tooltip_private_text, + gint position); + + + + + + + + + + alias _GtkTreeDragSource GtkTreeDragSource; + alias void _GtkTreeDragSource; + + alias _GtkTreeDragSourceIface GtkTreeDragSourceIface; + + + struct _GtkTreeDragSourceIface { + GTypeInterface g_iface; + + + + gboolean (* row_draggable) (GtkTreeDragSource *drag_source, + GtkTreePath *path); + + gboolean (* drag_data_get) (GtkTreeDragSource *drag_source, + GtkTreePath *path, + GtkSelectionData *selection_data); + + gboolean (* drag_data_delete) (GtkTreeDragSource *drag_source, + GtkTreePath *path); + } + + GType gtk_tree_drag_source_get_type () ; + + + gboolean gtk_tree_drag_source_row_draggable (GtkTreeDragSource *drag_source, + GtkTreePath *path); + + + gboolean gtk_tree_drag_source_drag_data_delete (GtkTreeDragSource *drag_source, + GtkTreePath *path); + + + + + gboolean gtk_tree_drag_source_drag_data_get (GtkTreeDragSource *drag_source, + GtkTreePath *path, + GtkSelectionData *selection_data); + + + + + + + alias _GtkTreeDragDest GtkTreeDragDest; + alias void _GtkTreeDragDest; + + alias _GtkTreeDragDestIface GtkTreeDragDestIface; + + + struct _GtkTreeDragDestIface { + GTypeInterface g_iface; + + + + gboolean (* drag_data_received) (GtkTreeDragDest *drag_dest, + GtkTreePath *dest, + GtkSelectionData *selection_data); + + gboolean (* row_drop_possible) (GtkTreeDragDest *drag_dest, + GtkTreePath *dest_path, + GtkSelectionData *selection_data); + } + + GType gtk_tree_drag_dest_get_type () ; + + + + + gboolean gtk_tree_drag_dest_drag_data_received (GtkTreeDragDest *drag_dest, + GtkTreePath *dest, + GtkSelectionData *selection_data); + + + + gboolean gtk_tree_drag_dest_row_drop_possible (GtkTreeDragDest *drag_dest, + GtkTreePath *dest_path, + GtkSelectionData *selection_data); + + + + + + gboolean gtk_tree_set_row_drag_data (GtkSelectionData *selection_data, + GtkTreeModel *tree_model, + GtkTreePath *path); + gboolean gtk_tree_get_row_drag_data (GtkSelectionData *selection_data, + GtkTreeModel **tree_model, + GtkTreePath **path); + + + + alias _GtkTreeModelSort GtkTreeModelSort; + + alias _GtkTreeModelSortClass GtkTreeModelSortClass; + + + struct _GtkTreeModelSort { + GObject parent; + + + gpointer root; + gint stamp; + guint child_flags; + GtkTreeModel *child_model; + gint zero_ref_count; + + + GList *sort_list; + gint sort_column_id; + GtkSortType order; + + + GtkTreeIterCompareFunc default_sort_func; + gpointer default_sort_data; + GtkDestroyNotify default_sort_destroy; + + + guint changed_id; + guint inserted_id; + guint has_child_toggled_id; + guint deleted_id; + guint reordered_id; + } + + struct _GtkTreeModelSortClass { + GObjectClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_tree_model_sort_get_type () ; + GtkTreeModel *gtk_tree_model_sort_new_with_model (GtkTreeModel *child_model); + + GtkTreeModel *gtk_tree_model_sort_get_model (GtkTreeModelSort *tree_model); + GtkTreePath *gtk_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sort, + GtkTreePath *child_path); + void gtk_tree_model_sort_convert_child_iter_to_iter (GtkTreeModelSort *tree_model_sort, + GtkTreeIter *sort_iter, + GtkTreeIter *child_iter); + GtkTreePath *gtk_tree_model_sort_convert_path_to_child_path (GtkTreeModelSort *tree_model_sort, + GtkTreePath *sorted_path); + void gtk_tree_model_sort_convert_iter_to_child_iter (GtkTreeModelSort *tree_model_sort, + GtkTreeIter *child_iter, + GtkTreeIter *sorted_iter); + void gtk_tree_model_sort_reset_default_sort_func (GtkTreeModelSort *tree_model_sort); + void gtk_tree_model_sort_clear_cache (GtkTreeModelSort *tree_model_sort); + gboolean gtk_tree_model_sort_iter_is_valid (GtkTreeModelSort *tree_model_sort, + GtkTreeIter *iter); + + + + alias gboolean (* GtkTreeSelectionFunc) (GtkTreeSelection *selection, + GtkTreeModel *model, + GtkTreePath *path, + gboolean path_currently_selected, + gpointer data); + alias void (* GtkTreeSelectionForeachFunc) (GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + gpointer data); + + struct _GtkTreeSelection { + GObject parent; + + + + GtkTreeView *tree_view; + GtkSelectionMode type; + GtkTreeSelectionFunc user_func; + gpointer user_data; + GtkDestroyNotify destroy; + } + + struct _GtkTreeSelectionClass { + GObjectClass parent_class; + + void (* changed) (GtkTreeSelection *selection); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_tree_selection_get_type (); + + void gtk_tree_selection_set_mode (GtkTreeSelection *selection, + GtkSelectionMode type); + GtkSelectionMode gtk_tree_selection_get_mode (GtkTreeSelection *selection); + void gtk_tree_selection_set_select_function (GtkTreeSelection *selection, + GtkTreeSelectionFunc func, + gpointer data, + GtkDestroyNotify destroy); + gpointer gtk_tree_selection_get_user_data (GtkTreeSelection *selection); + GtkTreeView* gtk_tree_selection_get_tree_view (GtkTreeSelection *selection); + + + + gboolean gtk_tree_selection_get_selected (GtkTreeSelection *selection, + GtkTreeModel **model, + GtkTreeIter *iter); + GList * gtk_tree_selection_get_selected_rows (GtkTreeSelection *selection, + GtkTreeModel **model); + gint gtk_tree_selection_count_selected_rows (GtkTreeSelection *selection); + void gtk_tree_selection_selected_foreach (GtkTreeSelection *selection, + GtkTreeSelectionForeachFunc func, + gpointer data); + void gtk_tree_selection_select_path (GtkTreeSelection *selection, + GtkTreePath *path); + void gtk_tree_selection_unselect_path (GtkTreeSelection *selection, + GtkTreePath *path); + void gtk_tree_selection_select_iter (GtkTreeSelection *selection, + GtkTreeIter *iter); + void gtk_tree_selection_unselect_iter (GtkTreeSelection *selection, + GtkTreeIter *iter); + gboolean gtk_tree_selection_path_is_selected (GtkTreeSelection *selection, + GtkTreePath *path); + gboolean gtk_tree_selection_iter_is_selected (GtkTreeSelection *selection, + GtkTreeIter *iter); + void gtk_tree_selection_select_all (GtkTreeSelection *selection); + void gtk_tree_selection_unselect_all (GtkTreeSelection *selection); + void gtk_tree_selection_select_range (GtkTreeSelection *selection, + GtkTreePath *start_path, + GtkTreePath *end_path); + void gtk_tree_selection_unselect_range (GtkTreeSelection *selection, + GtkTreePath *start_path, + GtkTreePath *end_path); + alias _GtkTreeStore GtkTreeStore; + + alias _GtkTreeStoreClass GtkTreeStoreClass; + + + struct _GtkTreeStore { + GObject parent; + + gint stamp; + gpointer root; + gpointer last; + gint n_columns; + gint sort_column_id; + GList *sort_list; + GtkSortType order; + GType *column_headers; + GtkTreeIterCompareFunc default_sort_func; + gpointer default_sort_data; + GtkDestroyNotify default_sort_destroy; + guint columns_dirty; + } + + struct _GtkTreeStoreClass { + GObjectClass parent_class; + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + + GType gtk_tree_store_get_type (); + GtkTreeStore *gtk_tree_store_new (gint n_columns, + ...); + GtkTreeStore *gtk_tree_store_newv (gint n_columns, + GType *types); + void gtk_tree_store_set_column_types (GtkTreeStore *tree_store, + gint n_columns, + GType *types); + + + + void gtk_tree_store_set_value (GtkTreeStore *tree_store, + GtkTreeIter *iter, + gint column, + GValue *value); + void gtk_tree_store_set (GtkTreeStore *tree_store, + GtkTreeIter *iter, + ...); + void gtk_tree_store_set_valist (GtkTreeStore *tree_store, + GtkTreeIter *iter, + va_list var_args); + gboolean gtk_tree_store_remove (GtkTreeStore *tree_store, + GtkTreeIter *iter); + void gtk_tree_store_insert (GtkTreeStore *tree_store, + GtkTreeIter *iter, + GtkTreeIter *parent, + gint position); + void gtk_tree_store_insert_before (GtkTreeStore *tree_store, + GtkTreeIter *iter, + GtkTreeIter *parent, + GtkTreeIter *sibling); + void gtk_tree_store_insert_after (GtkTreeStore *tree_store, + GtkTreeIter *iter, + GtkTreeIter *parent, + GtkTreeIter *sibling); + void gtk_tree_store_prepend (GtkTreeStore *tree_store, + GtkTreeIter *iter, + GtkTreeIter *parent); + void gtk_tree_store_append (GtkTreeStore *tree_store, + GtkTreeIter *iter, + GtkTreeIter *parent); + gboolean gtk_tree_store_is_ancestor (GtkTreeStore *tree_store, + GtkTreeIter *iter, + GtkTreeIter *descendant); + gint gtk_tree_store_iter_depth (GtkTreeStore *tree_store, + GtkTreeIter *iter); + void gtk_tree_store_clear (GtkTreeStore *tree_store); + gboolean gtk_tree_store_iter_is_valid (GtkTreeStore *tree_store, + GtkTreeIter *iter); + void gtk_tree_store_reorder (GtkTreeStore *tree_store, + GtkTreeIter *parent, + gint *new_order); + void gtk_tree_store_swap (GtkTreeStore *tree_store, + GtkTreeIter *a, + GtkTreeIter *b); + void gtk_tree_store_move_before (GtkTreeStore *tree_store, + GtkTreeIter *iter, + GtkTreeIter *position); + void gtk_tree_store_move_after (GtkTreeStore *tree_store, + GtkTreeIter *iter, + GtkTreeIter *position); + + + + + alias _GtkUIManager GtkUIManager; + + alias _GtkUIManagerClass GtkUIManagerClass; + + alias _GtkUIManagerPrivate GtkUIManagerPrivate; + alias void _GtkUIManagerPrivate; + + + + struct _GtkUIManager { + GObject parent; + + + + GtkUIManagerPrivate *private_data; + } + + struct _GtkUIManagerClass { + GObjectClass parent_class; + + + void (* add_widget) (GtkUIManager *merge, + GtkWidget *widget); + void (* actions_changed) (GtkUIManager *merge); + void (* connect_proxy) (GtkUIManager *merge, + GtkAction *action, + GtkWidget *proxy); + void (* disconnect_proxy) (GtkUIManager *merge, + GtkAction *action, + GtkWidget *proxy); + void (* pre_activate) (GtkUIManager *merge, + GtkAction *action); + void (* post_activate) (GtkUIManager *merge, + GtkAction *action); + + + void (*_gtk_reserved1) (); + void (*_gtk_reserved2) (); + void (*_gtk_reserved3) (); + void (*_gtk_reserved4) (); + } + + enum GtkUIManagerItemType { + GTK_UI_MANAGER_AUTO = 0, + GTK_UI_MANAGER_MENUBAR = 1 << 0, + GTK_UI_MANAGER_MENU = 1 << 1, + GTK_UI_MANAGER_TOOLBAR = 1 << 2, + GTK_UI_MANAGER_PLACEHOLDER = 1 << 3, + GTK_UI_MANAGER_POPUP = 1 << 4, + GTK_UI_MANAGER_MENUITEM = 1 << 5, + GTK_UI_MANAGER_TOOLITEM = 1 << 6, + GTK_UI_MANAGER_SEPARATOR = 1 << 7, + GTK_UI_MANAGER_ACCELERATOR = 1 << 8 + }; + + + GType gtk_ui_manager_get_type (); + GtkUIManager *gtk_ui_manager_new (); + void gtk_ui_manager_set_add_tearoffs (GtkUIManager *self, + gboolean add_tearoffs); + gboolean gtk_ui_manager_get_add_tearoffs (GtkUIManager *self); + void gtk_ui_manager_insert_action_group (GtkUIManager *self, + GtkActionGroup *action_group, + gint pos); + void gtk_ui_manager_remove_action_group (GtkUIManager *self, + GtkActionGroup *action_group); + GList *gtk_ui_manager_get_action_groups (GtkUIManager *self); + GtkAccelGroup *gtk_ui_manager_get_accel_group (GtkUIManager *self); + GtkWidget *gtk_ui_manager_get_widget (GtkUIManager *self, + gchar *path); + GSList *gtk_ui_manager_get_toplevels (GtkUIManager *self, + GtkUIManagerItemType types); + GtkAction *gtk_ui_manager_get_action (GtkUIManager *self, + gchar *path); + guint gtk_ui_manager_add_ui_from_string (GtkUIManager *self, + gchar *buffer, + gssize length, + GError **error); + guint gtk_ui_manager_add_ui_from_file (GtkUIManager *self, + gchar *filename, + GError **error); + void gtk_ui_manager_add_ui (GtkUIManager *self, + guint merge_id, + gchar *path, + gchar *name, + gchar *action, + GtkUIManagerItemType type, + gboolean top); + void gtk_ui_manager_remove_ui (GtkUIManager *self, + guint merge_id); + gchar *gtk_ui_manager_get_ui (GtkUIManager *self); + void gtk_ui_manager_ensure_update (GtkUIManager *self); + guint gtk_ui_manager_new_merge_id (GtkUIManager *self); + + + alias _GtkVButtonBox GtkVButtonBox; + + alias _GtkVButtonBoxClass GtkVButtonBoxClass; + + + struct _GtkVButtonBox { + GtkButtonBox button_box; + } + + struct _GtkVButtonBoxClass { + GtkButtonBoxClass parent_class; + } + + + GType gtk_vbutton_box_get_type () ; + GtkWidget *gtk_vbutton_box_new (); + + + + + gint gtk_vbutton_box_get_spacing_default (); + void gtk_vbutton_box_set_spacing_default (gint spacing); + + GtkButtonBoxStyle gtk_vbutton_box_get_layout_default (); + void gtk_vbutton_box_set_layout_default (GtkButtonBoxStyle layout); + + + alias _GtkVPaned GtkVPaned; + + alias _GtkVPanedClass GtkVPanedClass; + + + struct _GtkVPaned { + GtkPaned paned; + } + + struct _GtkVPanedClass { + GtkPanedClass parent_class; + } + + GType gtk_vpaned_get_type () ; + GtkWidget *gtk_vpaned_new (); + alias _GtkVRuler GtkVRuler; + + alias _GtkVRulerClass GtkVRulerClass; + + + struct _GtkVRuler { + GtkRuler ruler; + } + + struct _GtkVRulerClass { + GtkRulerClass parent_class; + } + + + GType gtk_vruler_get_type () ; + GtkWidget* gtk_vruler_new (); + alias _GtkVScale GtkVScale; + + alias _GtkVScaleClass GtkVScaleClass; + + + struct _GtkVScale { + GtkScale scale; + } + + struct _GtkVScaleClass { + GtkScaleClass parent_class; + } + + + GType gtk_vscale_get_type () ; + GtkWidget* gtk_vscale_new (GtkAdjustment *adjustment); + GtkWidget* gtk_vscale_new_with_range (gdouble min, + gdouble max, + gdouble step); + + alias _GtkVSeparator GtkVSeparator; + + alias _GtkVSeparatorClass GtkVSeparatorClass; + + + struct _GtkVSeparator { + GtkSeparator separator; + } + + struct _GtkVSeparatorClass { + GtkSeparatorClass parent_class; + } + + + GType gtk_vseparator_get_type (); + GtkWidget* gtk_vseparator_new (); + +} diff --git a/samples/minwin_gtk/minwin/gtk_peers.d b/samples/minwin_gtk/minwin/gtk_peers.d new file mode 100644 index 0000000..2dd5da5 --- /dev/null +++ b/samples/minwin_gtk/minwin/gtk_peers.d @@ -0,0 +1,152 @@ +/* MinWin GTK Container Peer + * + * A MinWinGtkPeer is a GTK container that calls delegates to handle + * size requests and allocation. These delegates are usually filled + * by MinWin layout managers. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.gtk_peers; + +private import minwin.gtk; + +private GtkContainerClass* parent_cls = null; +private GType container_type = 0; + +alias void delegate(GtkWidget *widget,GtkRequisition *requisition) SizeRequestDel; +alias void delegate(GtkWidget *widget,GtkAllocation *allocation) SizeAllocateDel; +struct MinWinGtkPeer { + GtkContainer parent; + GList* children; + SizeRequestDel sizeRequest; + SizeAllocateDel sizeAllocate; +} +struct MinWinGtkPeerClass { + GtkContainerClass parent; +} + +extern (C) +GType MinWinGtkPeer_get_type() { + if (container_type == 0) { + static GTypeInfo info; + info.class_size = MinWinGtkPeerClass.sizeof; + info.class_init = cast(GClassInitFunc)&MinWinGtkPeer_class_init; + info.instance_size = MinWinGtkPeer.sizeof; + info.instance_init = cast(GInstanceInitFunc)&MinWinGtkPeer_init; + container_type = g_type_register_static(gtk_container_get_type(), + "MinWinGtkPeer",&info, cast(GTypeFlags)0); + } + return container_type; +} + +extern (C) +void MinWinGtkPeer_class_init(MinWinGtkPeerClass* cls,gpointer p) { + GtkWidgetClass* wcls = cast(GtkWidgetClass*) cls; + GtkContainerClass* ccls = cast(GtkContainerClass*) cls; + + parent_cls = cast(GtkContainerClass*)g_type_class_peek_parent (cls); + wcls.realize = &MinWinGtkPeer_realize; + wcls.size_request = &MinWinGtkPeer_size_request; + wcls.size_allocate = &MinWinGtkPeer_size_allocate; + ccls.add = &MinWinGtkPeer_add; + ccls.remove = &MinWinGtkPeer_remove; + ccls.forall = &MinWinGtkPeer_forall; + ccls.child_type = &MinWinGtkPeer_child_type; +} + +extern (C) +GType MinWinGtkPeer_child_type(GtkContainer* container) { + return gtk_widget_get_type(); +} + +extern (C) +void MinWinGtkPeer_init(MinWinGtkPeer* c) { + GtkObject* obj = cast(GtkObject*)c; + obj.flags = GtkWidgetFlags.GTK_NO_WINDOW; + c.children = null; + c.sizeRequest = null; + c.sizeAllocate = null; +} + +extern (C) +GtkWidget* MinWinGtkPeer_new() { + return cast(GtkWidget*)g_object_new(MinWinGtkPeer_get_type(), null); +} + +extern (C) +void MinWinGtkPeer_add(GtkContainer* c,GtkWidget* widget) { + MinWinGtkPeer* mwc = cast(MinWinGtkPeer*)c; + GtkWidget* child = widget; + gtk_widget_set_parent(widget,cast(GtkWidget*)(c)); + mwc.children = g_list_append(mwc.children, child); +} + +extern (C) +void MinWinGtkPeer_realize(GtkWidget *widget) { + GtkWidgetClass* wcls = cast(GtkWidgetClass*)parent_cls; + wcls.realize(widget); +} + +extern (C) +void MinWinGtkPeer_size_request(GtkWidget* w,GtkRequisition* req) { + MinWinGtkPeer* c = cast(MinWinGtkPeer*) w; + req.width = 0; + req.height = 0; + if (c.sizeRequest !is null) { + c.sizeRequest(w,req); + } +} + +extern (C) +void MinWinGtkPeer_size_allocate(GtkWidget* w, GtkAllocation* a){ + MinWinGtkPeer* c = cast(MinWinGtkPeer*) w; + w.allocation = *a; + if (c.sizeAllocate !is null) { + c.sizeAllocate(w,a); + } +} + +extern (C) +void MinWinGtkPeer_remove(GtkContainer* container,GtkWidget* widget) { + MinWinGtkPeer *c; + GtkWidget *child; + GList *children; + + c = cast(MinWinGtkPeer*)(container); + + children = c.children; + while (children) { + child = cast(GtkWidget*)children.data; + + if (child is widget) { + gtk_widget_unparent (widget); + c.children = g_list_remove_link (c.children, children); + g_list_free (children); + break; + } + + children = children.next; + } +} + +extern (C) +void MinWinGtkPeer_forall (GtkContainer *container, + gboolean include_internals, + GtkCallback callback, + gpointer callback_data) { + MinWinGtkPeer *c; + GtkWidget *child; + GList *children; + c = cast(MinWinGtkPeer*)(container); + + children = c.children; + while (children) { + child = cast(GtkWidget*)children.data; + children = children.next; + + callback(child, callback_data); + } +} diff --git a/samples/minwin_gtk/minwin/icon.d b/samples/minwin_gtk/minwin/icon.d new file mode 100644 index 0000000..0411aee --- /dev/null +++ b/samples/minwin_gtk/minwin/icon.d @@ -0,0 +1,87 @@ +/* MinWin Icon class + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.icon; + +private { + import minwin.component; + import minwin.image; +} + +version (MinWin32) { + private import minwin.mswindows; + private import minwin.app; + + alias HICON IconPeer; +/* + struct IconData { + ICONINFO iconinfo; + void bitmap(Bitmap bm) { + iconinfo.hbmColor = bm.peer; + } + void mask(Bitmap mask) { + iconinfo.hbmMask = bm.peer; + } + } +*/ + class Icon { + IconPeer peer; + + this(char[] iconName) { + if (useWfuncs) + peer = LoadIconW(gApp.hInstance, toUTF16z(iconName)); + else + peer = LoadIconA(gApp.hInstance, toMBSz(iconName)); + hasPeer = OWNS_PEER; + } +/* + this(IconData* info) { + info.iconinfo.fIcon = true; + peer = CreateIconIndirect(&info.iconinfo); + hasPeer = OWNS_PEER; + } +*/ +/* + this(Bitmap bitmap, Bitmap mask = null) { + ICONINFO iinfo; + iinfo.fIcon = true; + iinfo.hbmColor = bitmap.peer; + if (mask) + iinfo.hbmMask = mask.peer; + peer = CreateIconIndirect(&iinfo); + hasPeer = OWNS_PEER; + } +*/ + this(IconPeer p) { + peer = p; + hasPeer = FOREIGN_PEER; + } + + ~this() { + dispose(); + } + void dispose() { + disposePeer(); + } + + // Peer management + int hasPeer; + void disposePeer() { + if (hasPeer == OWNS_PEER) + DeleteObject(peer); + hasPeer = NO_PEER; + } + } + +} else version (GTK) { + + private import minwin.gtk; + private import minwin.app; + // peer is pixbuf + class Icon{} + +} diff --git a/samples/minwin_gtk/minwin/image.d b/samples/minwin_gtk/minwin/image.d new file mode 100644 index 0000000..6454765 --- /dev/null +++ b/samples/minwin_gtk/minwin/image.d @@ -0,0 +1,76 @@ +/* MinWin Image class + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.image; + +public import minwin.component; + +private { + import minwin.app; + import minwin.paint; +} + +version (MinWin32) { + private import minwin.mswindows; + + alias HBITMAP ImagePeer; + + class Image { + int width,height; + ImagePeer peer; + + this(ImagePeer bm) { + peer = bm; + hasPeer = FOREIGN_PEER; + } + + void getBits() { + // call GetDIBits. make sure bitmap isn't selected in memGC + getGContext(); + // GetDIBits(memGC.peer,sdf); + } + + GContext getGContext() { + GContext gc = newGContext(); + gc.peer = CreateCompatibleDC(null); // hmm. null is for screen + sysAssert(gc.peer !is null, "Failed to create compatible DC for image"); + gc.hasPeer = OWNS_PEER; + SelectObject(gc.peer,peer); + return gc; + } + + mixin SimplePeerMixin!(); + + } +} else version (GTK) { + + private import minwin.window; + private import minwin.gtk; + + // alias GdkPixbuf* ImagePeer; + alias GdkPixmap* ImagePeer; + + class Image { + int width,height; + ImagePeer peer; + + this(ImagePeer bm) { + peer = bm; + hasPeer = FOREIGN_PEER; + } + + GContext getGContext() { + GContext gc = newGContext(); + gc.drawable = peer; + gc.peer = gdk_gc_new(gc.drawable); + gc.hasPeer = OWNS_PEER; + return gc; + } + + mixin SimplePeerMixin!(); + } +} diff --git a/samples/minwin_gtk/minwin/label.d b/samples/minwin_gtk/minwin/label.d new file mode 100644 index 0000000..3488b69 --- /dev/null +++ b/samples/minwin_gtk/minwin/label.d @@ -0,0 +1,109 @@ +/* MinWin Label class + * + * Static text label + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.label; + +public import minwin.component; + +private { + import minwin.app; + import minwin.window; + import minwin.peerimpl; + import std.string; + import minwin.logging; +} + +version (MinWin32) { + + private import minwin.mswindows; + + template LabelPrefSizeImpl() { + Point preferredSize() { + HDC dc = GetDC(peer); + sysAssert(dc !is null, "Failed to get label DC in preferredSize"); + SIZE s; + try { + Font f = standardFont(StandardFont.Gui); + HFONT oldfont = SelectObject(dc,f.peer); + sysAssert(oldfont !is null, "Failed to get Label font in preferredSize"); + BOOL ok = GetTextExtentPoint32X(dc,text_data,text_data.length,&s); + SelectObject(dc,oldfont); + sysAssert(ok != false, "Failed to get font extents in preferredSize"); + } finally { + ReleaseDC(peer,dc); + } + POINT p; + p.x = s.cx; + p.y = s.cy; + if (userPreferredWidth > 0) + p.x = userPreferredWidth; + if (userPreferredHeight > 0) + p.y = userPreferredHeight; + return toPoint(p); + } + } + + class Label : WindowChild { + private char[] text_data; + this(Component parent, char[] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + peer = CreateWindowX("STATIC",text, + SS_LEFTNOWORDWRAP | WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,gApp.hInstance,null); + sysAssert(peer !is null, "Failed to create peer Label"); + this.name = name; + text_data = text; + Font f = standardFont(StandardFont.Gui); + SendMessageA(peer,WM_SETFONT,cast(WPARAM)f.peer,0); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + } + char[] text() {return text_data;} + void text(char[] c) { + text_data = c; + SendMessageX(peer,WM_SETTEXT,0,c); + } + mixin LabelPrefSizeImpl!(); + mixin WindowChildImpl!(); + } + +} else version (GTK) { + + private import minwin.gtk; + private import std.c.string; + + class Label : WindowChild { + this(Component parent, char[] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + char* str = toStringz(text); + peer = gtk_label_new(str); + gtk_container_add(cast(GtkContainer*)parentp,peer); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + gtk_widget_realize(peer); + visible = true; + } + + mixin WindowChildImpl!(); + + char[] text() { + char* str = gtk_label_get_text(cast(GtkLabel*)peer); + if (str is null) + return ""; + else + return str[0..strlen(str)].dup; + } + + void text(char[] c) { + gtk_label_set_text(cast(GtkLabel*)peer,toStringz(c)); + } + } +} diff --git a/samples/minwin_gtk/minwin/layout.d b/samples/minwin_gtk/minwin/layout.d new file mode 100644 index 0000000..ff08f8d --- /dev/null +++ b/samples/minwin_gtk/minwin/layout.d @@ -0,0 +1,471 @@ +/* MinWin Layout management + * + * Defines a LayoutManager interface and some layout managers + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.layout; + +public import minwin.component; + +private import minwin.logging; + +interface LayoutManager { + + // layout children of c. Can reuse cached information from previous + // preferredSize() or layout() calls in which case the layout + // manager should only be used for a single component. + void layout(Component c); + + // compute preferred layout size. Does not reuse cached information. + Point preferredSize(Component c); + + // clear cache if present + void reset(); +} + +/***************** Flow Layout *********************/ +enum Dir { + Horizontal, // left to right, then right to left + Vertical // top to bottom, then bottom to top +} + +class FlowLayout : LayoutManager { + Dir dir; + + int flowGap; // gap between items along flow direction + int flowReverse = 1000; // number of items to lay out before + // flipping to the other side + double endGap = 0.0; // gap at ends of layout, values <= 1 are + // percentage of space + + int sideGap; // gap between largest item and side + bool sideStretch; // true means items are stretched to fit to side + + int prefWidth; + int prefHeight; + + this(Dir dir = Dir.Vertical) { + this.dir = dir; + prefWidth = -1; + prefHeight = -1; + } + + void layout(Component c) { + Rect r; + if (c.child is null) return; + version(LOG) log.printf("laying out %x\n",c); + c.getLayoutBounds(r); + version(LOG) log.writefln("layout got bounds %d %d %d %d", + r.left,r.top,r.width,r.height); + int width = r.width; + int height = r.height; + if (prefWidth < 0) { + Point s = preferredSize(c); + prefWidth = s.x; + prefHeight = s.y; + } + int actEndGap = cast(int)endGap; // actual end gap in pixels + int actFlowGap = flowGap; + int x = r.left; + int y = r.top; + int left = x; + int top = y; + int bottom = r.bottom; + int right = r.right; + if (dir == Dir.Vertical) { + if (endGap <= 1.0) + actEndGap = cast(int)(endGap*(height - prefHeight)/2); + y += actEndGap; + } else { + if (endGap <= 1.0) + actEndGap = cast(int)(endGap*(width - prefWidth)/2); + x += actEndGap; + } + int n = 0; + bool isVisible = c.visible(); + foreach (Component ch; c ) { + int w, h; + version(LOG) log.printf("doing flow layout for child %x\n",ch); + if (n == flowReverse) { + if (dir == Dir.Vertical) + y = top + height - actEndGap; + else + x = left + width - actEndGap; + actFlowGap = -actFlowGap; + } + if (ch.parentOwnsLayout) { + Point s = ch.preferredSize(); + w = s.x; + h = s.y; + version(LOG) log.printf(" got flow child size for %x\n",ch); + if (dir == Dir.Vertical) { + if (n != 0 && n < flowReverse) y += flowGap; // what about first item? + if (n >= flowReverse) y -= h; + int x1 = x, w1 = width; + if (!sideStretch && (w < width)) { + x1 = x+(width-w)/2; + w1 = w; + } + r.LTWH(x1,y,w1,h); + if ((r.top > bottom || r.bottom < top) && ch.parentOwnsVisibility) { + version(LOG)log.printf("layout setting visible off on %x %d %d\n", + ch,r.bottom,height); + ch.visible = false; + } else { + version(LOG)log.writefln("about to set bounds on child %s", + ch.classinfo.name); + ch.setBounds(r); + version(LOG)log.printf("layout checking for visible on %x\n",ch); + if (ch.parentOwnsVisibility && isVisible) { + version(LOG)log.printf("layout setting visible on %x\n",ch); + ch.visible = true; + } + ch.layout(false); + } + if (n < flowReverse) y += h; + } else { + if (n < flowReverse) x += flowGap; + if (n >= flowReverse) x -= w; + int y1 = y, h1 = height; + if (!sideStretch && (h < height)) { + y1 = y+(height-h)/2; + h1 = h; + } + r.LTWH(x,y1,w,h1); + if ((r.left > right || r.right < left) && ch.parentOwnsVisibility) { + version(LOG)log.printf("layout setting visible off on %x\n",ch); + ch.visible = false; + } else { + ch.setBounds(r); + if (ch.parentOwnsVisibility && isVisible) + ch.visible = true; + ch.layout(false); + } + if (n < flowReverse) x += w; + } + } + ++n; + } + version(LOG) log.printf(" done laying out %x\n",c); + } + + Point preferredSize(Component c) { + version(LOG) log.printf("preferred size for %x\n",c); + int width = 0; + int height = 0; + foreach (Component ch; c ) { + int w, h; + if (ch.parentOwnsLayout) { + Point s = ch.preferredSize; + w = s.x; + h = s.y; + if (dir == Dir.Vertical) { + height += flowGap; + width = width < w ? w : width; + height += h; + } else { + width += flowGap; + height = height < h ? h : height; + width += w; + } + } + } + if (dir == Dir.Vertical) { + height += 2*cast(int)endGap; + width += 2*sideGap; + } else { + width += 2*cast(int)endGap; + height += 2*sideGap; + } + prefWidth = width; + prefHeight = height; + version(LOG) log.printf(" done preferred size for %x %d %d\n",c,width,height); + return XY(width,height); + } + + void reset() { + prefWidth = -1; + prefHeight = -1; + } +} + +/***************** Table Layout *********************/ + +// A TableLayout first computes the sum of all the preferred +// sizes of the rows and columns and then divides up the remaining +// space according to the user-supplied distribution. If the +// preferred sizes are greater then the available space the +// preferred sizes are shrunk by the user-supplied distribution to fit +class TableLayout : LayoutManager { + + double[] rowScales; + double[] colScales; + int gap; + + bool cache; + double[] prows; // preferred row heights + double[] pcols; // preferred column widths + + double[] arows; // actual row heights + double[] acols; // actual column widths + + // constructs a TableLayout with given scales. The scale + // arrays are duplicated. + this(double[] colScales, double[] rowScales, int gap = 0) { + this.rowScales = rowScales.dup; + this.colScales = colScales.dup; + this.gap = gap; + reset(); + } + + void reset() { + prows.length = rowScales.length; + pcols.length = colScales.length; + prows[] = 0; + pcols[] = 0; + arows.length = rowScales.length; + acols.length = colScales.length; + cache = false; + } + + void layout(Component comp) { + int r,c; + int pref_width, pref_height; + if (comp.child is null) return; + version(LOG) log.printf("laying out %x\n",comp); + if (!cache) + fillPreferredData(comp); + computePreferredSize(comp,pref_width,pref_height); + Rect b,pb; + version(LOG) log.printf("about to get bounds of comp %x\n",comp); + comp.getLayoutBounds(pb); + version(LOG) log.writefln("layout got bounds %d %d %d %d", + pb.left,pb.top,pb.width,pb.height); + int width = pb.width; + int height = pb.height; + + // distribute extra space or trim to fit in given space + int extra_width = width - pref_width; + int extra_height = height - pref_height; + version(LOG) log.writefln("extra %d %d \n",extra_width,extra_height); + foreach(int n, double x; prows) { + arows[n] = x + rowScales[n]*extra_height; + version(LOG) log.writefln("rows[n] %g",arows[n]); + } + double total = 0; + foreach(int n, double x; arows) { + total += x; + arows[n] = cast(int)total; + } + foreach(int n, double x; pcols) { + acols[n] = x + colScales[n]*extra_width; + version(LOG) log.writefln("cols[n] %g",acols[n]); + } + total = 0; + foreach(int n, double x; acols) { + total += x; + acols[n] = cast(int)total; + } + int x,y; + c = 0; + r = 0; + foreach (Component ch; comp ) { + if (ch.parentOwnsLayout) { + int nx = cast(int)acols[c]; + int ny = cast(int)arows[r]; + version(LOG) log.writefln("nx ny %d %d",nx,ny); + b.LTRB(pb.left+x,pb.top+y,nx,ny); + x = nx; + version(LOG) log.printf("setting bounds of %x during layout for %x\n",ch,comp); + ch.setBounds(b); + version(LOG) log.printf("child layout %x during layout for %x\n",ch,comp); + ch.layout(false); + if (++c >= colScales.length) { + c = 0; + x = 0; + y = ny; + if (++r >= rowScales.length) + break; // just stop if too many children + } + } + } + version(LOG) log.printf(" done laying out %x\n",comp); + } + + Point preferredSize(Component comp) { + int width,height; + version(LOG) log.printf("preferred size for %x\n",comp); + fillPreferredData(comp); + computePreferredSize(comp,width,height); + version(LOG) log.printf(" done preferred size for %x\n",comp); + return XY(width,height); + } + + private void fillPreferredData(Component comp) { + int r,c; + prows[] = 0; + pcols[] = 0; + foreach (Component ch; comp ) { + int w, h; + if (ch.parentOwnsLayout) { + Point s = ch.preferredSize; + w = s.x; + h = s.y; + version(LOG) log.writefln("pref size %d %d",w,h); + prows[r] = prows[r]>h ? prows[r] : h; + pcols[c] = pcols[c]>w ? pcols[c] : w; + version(LOG) log.writefln("row col %g %g",prows[r],pcols[c]); + if (++c >= colScales.length) { + c = 0; + if (++r >= rowScales.length) + break; // just stop if too many children + } + } + } + cache = true; + } + + private void computePreferredSize(Component comp, + inout int width, + inout int height) { + double total = 0; + foreach(double x; pcols) { total += x; } + width = cast(int)total; + total = 0; + foreach(double x; prows) { total += x; } + height = cast(int)total; + } +} + +/***************** Border Layout *********************/ + +/* + + --------------- + | N | + |-------------| + | | | | + |W | C | E| + | | | | + |-------------| + | S | + --------------- + +*/ + +enum Loc { + North, South, East, West, Center +} + +class BorderLayout : LayoutManager { + Component[Loc.max+1] location; // user fills this in + + void layout(Component c) { + Rect r; + if (c.child is null) return; + c.getLayoutBounds(r); + version(LOG) log.writefln("layout got bounds %d %d %d %d", + r.left,r.top,r.width,r.height); + int width = r.width; + int height = r.height; + int west,east,north,south; + int dummy; + if (location[Loc.North]) + north = location[Loc.North].preferredSize().y; + if (location[Loc.South]) + south = location[Loc.South].preferredSize().y; + if (location[Loc.East]) + east = location[Loc.East].preferredSize().x; + if (location[Loc.West]) + west = location[Loc.West].preferredSize().x; + Rect cr; + int x0 = r.left; + int y0 = r.top; + // TODO: visible off if not enough space + if (location[Loc.North]) { + cr.LTWH(x0,y0,r.width,north); + location[Loc.North].setBounds(cr); + } + if (location[Loc.South]) { + cr.LTWH(x0,y0+r.height-south,r.width,south); + location[Loc.South].setBounds(cr); + } + if (location[Loc.West]) { + cr.LTWH(x0,y0+north,west,r.height-south-north); + location[Loc.West].setBounds(cr); + } + if (location[Loc.East]) { + cr.LTWH(x0+r.width-east,y0+north,east,r.height-south-north); + location[Loc.East].setBounds(cr); + } + if (location[Loc.Center]) { + cr.LTWH(x0+west,y0+north,width-east-west,height-south-north); + location[Loc.Center].setBounds(cr); + } + } + + Point preferredSize(Component c) { + int width = 0; + int height = 0; + int west,east,north,south,centerWidth,centerHeight; + int dummy; + Point center; + Point eastPt; + Point westPt; + if (location[Loc.North]) + north = location[Loc.North].preferredSize().y; + if (location[Loc.South]) + south = location[Loc.South].preferredSize().y; + if (location[Loc.East]) + eastPt = location[Loc.East].preferredSize(); + if (location[Loc.West]) + westPt = location[Loc.West].preferredSize(); + if (location[Loc.Center]) + center = location[Loc.Center].preferredSize; + east = eastPt.x; + west = westPt.x; + int maxy = eastPt.y>westPt.y?eastPt.y:westPt.y; + maxy = maxy>center.y?maxy:center.y; + width = east + west + center.x; + height = north + south + maxy; + version(LOG)log.writefln("BorderLayout preferred size %d %d",width,height); + return XY(width,height); + } + + void reset() { } +} + +unittest { + // simple component for testing layout + class Foo : Component { + Rect bounds; + this(Component parent) { + if (parent) + parent.addChild(this); + } + void disposePeer(){} + PeerForAdd getPeerForAdd() {return parent.getPeerForAdd();} + void getPeerOffset(inout int x, inout int y) {} + void getBounds(inout Rect r) { r = bounds; } + void setBounds(inout Rect r) { + bounds = r; + childLayoutDirty = true; + } + void size(Point s) { + bounds.LTWH(bounds.left,bounds.top,s.x,s.y); + childLayoutDirty = true; + } + void visible(bool vis) { } + bool visible() { return true; } + void repaint() { } + } + Foo a = new Foo(null); + Foo c1 = new Foo(a); + Foo c2 = new Foo(a); + Foo c3 = new Foo(a); + +} diff --git a/samples/minwin_gtk/minwin/listbox.d b/samples/minwin_gtk/minwin/listbox.d new file mode 100644 index 0000000..5d5c3c7 --- /dev/null +++ b/samples/minwin_gtk/minwin/listbox.d @@ -0,0 +1,140 @@ +/* MinWin ListBox class + * + * Display a list of items to choose from. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.listbox; + +// TODO: multi-select + +public import minwin.component; + +private { + import minwin.app; + import minwin.window; + import minwin.peerimpl; + import std.string; + import minwin.logging; +} + +version (MinWin32) { + + private import minwin.mswindows; + + class ListBox : WindowChild { + + this(Component parent, char[][] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + HINSTANCE hInst = GetModuleHandleA(null); + peer = CreateWindowA("LISTBOX","", + WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,hInst,null); + sysAssert(peer !is null, "Failed to create peer ListBox"); + foreach (char[] s; text) { + SendMessageX(peer,LB_ADDSTRING,0,s); + } + Font f = standardFont(StandardFont.Gui); + SendMessageA(peer,WM_SETFONT,cast(WPARAM)f.peer,0); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + } + mixin WindowChildImpl!(); + Point preferredSize() { + // width = SendMessageA(peer,CB_GETDROPPEDWIDTH,0,0); + int height = SendMessageA(peer,LB_GETITEMHEIGHT,cast(WPARAM)-1,0)* + SendMessageA(peer,LB_GETCOUNT,0,0); + int width = 75; + return XY(width,height); + } + // -1 for custom text + int selection() { + return SendMessageA(peer,LB_GETCURSEL,0,0); + } + void selection(int n) { + SendMessageA(peer,LB_SETCURSEL,n,0); + version (LOG) log.writefln("number of item is %d", + SendMessageA(peer,CB_GETCOUNT,0,0)); + } + } + +} else version (GTK) { + + private import minwin.gtk; + private import std.c.string; + + class ListBox : WindowChild { + + this(Component parent, char[][] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + GType the_type = g_type_fundamental(16); // means string + GtkListStore* model = gtk_list_store_newv(1,&the_type); + GtkTreeIter iter; + foreach (char[] s; text) { + gtk_list_store_append(model,&iter); + int[3] args; + args[0] = 0; + args[1] = cast(int)toStringz(s); + args[2] = -1; + gtk_list_store_set_valist(model,&iter,&args); + } + peer = gtk_tree_view_new_with_model(cast(GtkTreeModel*)model); + g_object_unref(cast(GObject*)model); + gtk_container_add(cast(GtkContainer*)parentp,peer); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + gtk_widget_realize(peer); + visible = true; + gtk_tree_view_columns_autosize(cast(GtkTreeView*)peer); + gtk_tree_view_expand_all(cast(GtkTreeView*)peer); + GList* objs = gtk_tree_view_get_columns(cast(GtkTreeView*)peer); + // printf("len %d\n",g_list_length(objs)); + // printf("cols %d\n",gtk_tree_model_get_n_columns(cast(GtkTreeModel*)model)); + g_list_free(objs); + } + + // -1 for custom text + int selection() { + // GtkComboBox* box = cast(GtkComboBox*)peer; + // return gtk_combo_box_get_active(box); + return 0; + } + void selection(int n) { + // GtkComboBox* box = cast(GtkComboBox*)peer; + // gtk_combo_box_set_active(box,n); + } + + char[] text() { + char* str; + GtkTreeView* list = cast(GtkTreeView*)peer; + GtkTreeModel* model = gtk_tree_view_get_model(list); + GtkTreeIter iter; + if (gtk_tree_model_get_iter_first(model,&iter)) { + int n = selection(); + GValue* val; + while (n--) { + gtk_tree_model_iter_next(model,&iter); + } + gtk_tree_model_get_value(model,&iter,0,val); + str = *(cast(char**)val); + g_value_unset(val); + } + if (str is null) + return ""; + else + return str[0..strlen(str)].dup; + } + + void text(char[] s) { + assert(false); + } + + mixin WindowChildImpl!(); + } +} diff --git a/samples/minwin_gtk/minwin/logging.d b/samples/minwin_gtk/minwin/logging.d new file mode 100644 index 0000000..f1bb4d8 --- /dev/null +++ b/samples/minwin_gtk/minwin/logging.d @@ -0,0 +1,19 @@ +module minwin.logging; + +public import std.stream; + +//version=StdOutLog; + +version (LOG) { + Stream log; + version (StdOutLog) { + static this() { + log = stdout; + } + } else { + static this() { + log = new BufferedFile("log.txt",FileMode.OutNew); + } + } +} + diff --git a/samples/minwin_gtk/minwin/menu.d b/samples/minwin_gtk/minwin/menu.d new file mode 100644 index 0000000..fd65c02 --- /dev/null +++ b/samples/minwin_gtk/minwin/menu.d @@ -0,0 +1,128 @@ + +module minwin.menu; + +public import minwin.window; + +private { + import minwin.app; + import std.string; +} + +// todo: disposePeer? + +version (MinWin32) { + private import minwin.mswindows; + + alias HMENU MenuPeer; + alias HMENU MenuBarPeer; + + class MenuBar { + MenuBarPeer peer; + char[] name; + Window owner; + Menu[] menus; + + this(Window parent, char[] name = "") { + peer = CreateMenu(); + BOOL ok = SetMenu(parent.peer,peer); // destroy old menu? + sysAssert(ok != false, "Failed to set menu"); + owner = parent; + owner.menubar = this; + this.name = name; + } + } + + class Menu { + MenuPeer peer; + char[] name; + MenuBar parentBar; + + this(inout MenuBar bar, char[] label, char[] name = "") { + this.name = name; + parentBar = bar; + peer = CreateMenu(); + BOOL ok = AppendMenuX(bar.peer,MF_POPUP,cast(void*)peer,label); + sysAssert(ok != false, "Failed to append to menubar"); + bar.menus ~= this; + ok = DrawMenuBar(bar.owner.peer); + sysAssert(ok != false, "Failed to draw menu bar"); + } + void addSeparator() { + BOOL ok = AppendMenuA(peer,MF_SEPARATOR,null,null); + sysAssert(ok != false, "Failed to append separator to menu"); + } + void add(char[] name, int cmd) { + BOOL ok = AppendMenuX(peer,MF_STRING,cast(void*)(cmd),name); + sysAssert(ok != false, "Failed to append to menu"); + } + } +} else version (GTK) { + + private import minwin.gtk; + + alias GtkWidget* MenuPeer; + alias GtkWidget* MenuBarPeer; + + class MenuBar { + MenuBarPeer peer; + char[] name; + Window owner; + Menu[] menus; + + this(Window parent, char[] name = "") { + this.name = name; + peer = gtk_menu_bar_new(); + GtkContainer* p = cast(GtkContainer*)parent.getPeerForAdd(); + gtk_container_add(p,peer); + gtk_widget_show(peer); + owner = parent; + owner.menubar = this; + } + } + + class Menu { + MenuPeer peer; + char[] name; + MenuBar parentBar; + GtkWidget* trigger; + + this(inout MenuBar bar, char[] label, char[] name = "") { + this.name = name; + parentBar = bar; + char* cname = toStringz(label); + peer = gtk_menu_new(); + trigger = gtk_menu_item_new_with_label(cname); + gtk_menu_item_set_submenu(cast(GtkMenuItem*)trigger,peer); + gtk_menu_shell_append(cast(GtkMenuShell*)bar.peer,trigger); + gtk_widget_show(trigger); + bar.menus ~= this; + } + + void addSeparator() { + GtkWidget* item = gtk_separator_menu_item_new(); + gtk_menu_shell_append(cast(GtkMenuShell*)peer,item); + gtk_widget_show(item); + } + + void add(char[] name, int cmd) { + char* cname = toStringz(name); + GtkWidget* item = gtk_menu_item_new_with_label(cname); + gtk_menu_shell_append(cast(GtkMenuShell*)peer,item); + g_object_set_data(cast(GObject*)item,"MinWinItemCommand", + cast(gpointer)cmd); + g_signal_connect_data(item,"activate", + cast(GCallback)&mw_menuitem_callback, + cast(gpointer)parentBar.owner, + null,cast(GConnectFlags)0); + gtk_widget_show(item); + } + } + extern (C) + void mw_menuitem_callback(GtkWidget* w, gpointer ud) { + Window x = cast(Window)ud; + if (x) { + int cmd = cast(int)g_object_get_data(cast(GObject*)w,"MinWinItemCommand"); + x.doCommand(cmd); + } + } +} diff --git a/samples/minwin_gtk/minwin/mswindows.d b/samples/minwin_gtk/minwin/mswindows.d new file mode 100644 index 0000000..9b312e4 --- /dev/null +++ b/samples/minwin_gtk/minwin/mswindows.d @@ -0,0 +1,609 @@ +/* + * Windows API not covered by std.c.windows.windows + */ + +module minwin.mswindows; + +public import std.c.windows.windows; +package import std.windows.charset; +package import std.utf; + +extern (Windows): +export BOOL PostMessageA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); +export BOOL SendMessageA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); +export BOOL SendMessageW(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); +export UINT SetTimer(HWND hWnd, uint id,uint time, TIMERPROC proc); +export BOOL KillTimer(HWND hWnd, uint id); +export BOOL IsWindowVisible (HWND hWnd); +export BOOL IsWindowEnabled (HWND hWnd); +export BOOL IsWindow (HWND hWnd); +export BOOL EnableWindow (HWND hWnd, BOOL enable); +export BOOL BringWindowToTop (HWND hWnd); +export BOOL DestroyWindow (HWND hWnd); +export BOOL MoveWindow (HWND hWnd, int x, int y, int w, int h, byte bRepaint); +export int SetWindowLongA (HWND hWnd, int nIndex, int dwNewLong); +export int GetWindowLongA (HWND hWnd, int nIndex); +export int GetWindowTextA (HWND hWnd, LPTSTR str, int count); +export int GetWindowTextW (HWND hWnd, LPWSTR str, int count); +export BOOL SetWindowTextA (HWND hWnd, LPTSTR str); +export BOOL SetWindowTextW (HWND hWnd, LPWSTR str); +export ushort GetKeyState(int key); +export ATOM RegisterClassExA(WNDCLASSEXA *lpWndClass); +export BOOL GetTextExtentPoint32A(HDC dc, LPCSTR str, int len, SIZE* s); +export BOOL GetTextExtentPoint32W(HDC dc, LPWSTR str, int len, SIZE* s); +export BOOL IsDialogMessageA(HWND hWnd, PMSG msg); +export int LoadStringA(HINSTANCE inst, LPSTR id, LPTSTR buf, int siz); +export int LoadStringW(HINSTANCE inst, LPWSTR id, LPWSTR buf, int siz); +export int MessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType); +export int GetSystemMetrics(int nIndex); + +/* +struct INITCOMMONCONTROLSEX { + DWORD dwSize; + DWORD dwICC; +} +export void InitCommonControls(); +export BOOL InitCommonControlsEx(INITCOMMONCONTROLSEX*); +*/ +export DWORD GetSysColor(int); + +const uint WM_PAINTICON = 0x0026; +const uint WM_ICONERASEBKGND = 0x0027; +const uint WM_NEXTDLGCTL = 0x0028; +const uint WM_SPOOLERSTATUS = 0x002A; +const uint WM_DRAWITEM = 0x002B; +const uint WM_MEASUREITEM = 0x002C; +const uint WM_DELETEITEM = 0x002D; +const uint WM_VKEYTOITEM = 0x002E; +const uint WM_CHARTOITEM = 0x002F; +const uint WM_SETFONT = 0x0030; +const uint WM_GETFONT = 0x0031; +const uint WM_SETHOTKEY = 0x0032; +const uint WM_GETHOTKEY = 0x0033; +const uint WM_QUERYDRAGICON = 0x0037; +const uint WM_COMPAREITEM = 0x0039; + +const uint WM_SIZING= 0x0214; +const uint WM_CAPTURECHANGED= 0x0215; +const uint WM_MOVING= 0x0216; +const uint WM_POWERBROADCAST= 0x0218; +const uint WM_DEVICECHANGE= 0x0219; + +const uint DS_MODALFRAME = 0x80; +const uint ICON_SMALL = 0; +const uint ICON_BIG = 1; + +export BOOL GdiFlush(); + +struct SIZE { + int cx; + int cy; +} +alias SIZE* PSIZE; + +const uint SBM_SETPOS =0x00E0; +const uint SBM_GETPOS =0x00E1; +const uint SBM_SETRANGE =0x00E2; +const uint SBM_SETRANGEREDRAW =0x00E6; +const uint SBM_GETRANGE =0x00E3; +const uint SBM_ENABLE_ARROWS =0x00E4; +const uint SBM_SETSCROLLINFO =0x00E9; +const uint SBM_GETSCROLLINFO =0x00EA; +const uint SIF_RANGE =0x0001; +const uint SIF_PAGE =0x0002; +const uint SIF_POS =0x0004; +const uint SIF_DISABLENOSCROLL =0x0008; +const uint SIF_TRACKPOS =0x0010; +const uint SIF_ALL =(SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS); +const uint SW_SCROLLCHILDREN =0x0001; +const uint SW_INVALIDATE =0x0002; +const uint SW_ERASE =0x0004; + +struct SCROLLINFO { + UINT cbSize; + UINT fMask; + int nMin; + int nMax; + UINT nPage; + int nPos; + int nTrackPos; +} +export int SetScrollInfo(HWND, int, SCROLLINFO*, BOOL); +export BOOL GetScrollInfo(HWND, int, SCROLLINFO*); + + +struct ICONINFO { + BOOL fIcon; + DWORD xHotspot; + DWORD yHotspot; + HBITMAP hbmMask; + HBITMAP hbmColor; +} +alias ICONINFO* PICONINFO; +export HICON CreateIconIndirect(PICONINFO piconinfo); +export HBITMAP CreateCompatibleBitmap(HDC hdc,int width,int height); +export COLORREF GetPixel(HDC hdc,int x,int y); +export HBRUSH CreateSolidBrush(COLORREF c); +export BOOL BitBlt(HDC dest,int x,int y,int width,int height, + HDC src,int xsrc,int ysrc, DWORD op); +//alias HANDLE HBRUSH; +export HANDLE LoadImageA(HINSTANCE hInstance, LPCSTR lpName,UINT utype, + int cx, int cy, UINT load); +export HANDLE LoadImageW(HINSTANCE hInstance, LPCWSTR lpName,UINT utype, + int cx, int cy, UINT load); +enum { IMAGE_BITMAP, IMAGE_CURSOR, IMAGE_ICON }; + +const uint GW_HWNDFIRST = 0; +const uint GW_HWNDLAST = 1; +const uint GW_HWNDNEXT = 2; +const uint GW_HWNDPREV = 3; +const uint GW_OWNER = 4; +const uint GW_CHILD = 5; +const uint GW_MAX = 5; + +const int GWL_USERDATA = -21; + +export HWND GetWindow (HWND hWnd, int dir); + +const uint MF_INSERT =0x00000000L; +const uint MF_CHANGE =0x00000080L; +const uint MF_APPEND =0x00000100L; +const uint MF_DELETE =0x00000200L; +const uint MF_REMOVE =0x00001000L; +const uint MF_BYCOMMAND =0x00000000L; +const uint MF_BYPOSITION =0x00000400L; +const uint MF_SEPARATOR =0x00000800L; +const uint MF_ENABLED =0x00000000L; +const uint MF_GRAYED =0x00000001L; +const uint MF_DISABLED =0x00000002L; +const uint MF_UNCHECKED =0x00000000L; +const uint MF_CHECKED =0x00000008L; +const uint MF_USECHECKBITMAPS =0x00000200L; +const uint MF_STRING =0x00000000L; +const uint MF_BITMAP =0x00000004L; +const uint MF_OWNERDRAW =0x00000100L; +const uint MF_POPUP =0x00000010L; +const uint MF_MENUBARBREAK =0x00000020L; +const uint MF_MENUBREAK =0x00000040L; +const uint MF_UNHILITE =0x00000000L; +const uint MF_HILITE =0x00000080L; +const uint MF_SYSMENU =0x00002000L; +const uint MF_HELP =0x00004000L; +const uint MF_MOUSESELECT =0x00008000L; + +export HMENU CreateMenu(); +export BOOL DrawMenuBar(HWND win); +export BOOL SetMenu(HWND win, HMENU menu); +export BOOL AppendMenuA(HMENU menu, uint flags, void*item, char* str); +export BOOL AppendMenuW(HMENU menu, uint flags, void*item, wchar* str); + +// 32 bit version +void* SetWindowLongPtr (HWND hWnd, int nIndex, void* dwNewLong) { + return cast(void*)SetWindowLongA(hWnd,nIndex,cast(int)dwNewLong); +} +void* GetWindowLongPtr (HWND hWnd, int nIndex) { + return cast(void*)GetWindowLongA(hWnd,nIndex); +} + +/* CombineRgn() Styles */ +enum { + RGN_AND = 1, + RGN_OR = 2, + RGN_XOR = 3, + RGN_DIFF = 4, + RGN_COPY = 5 +} + +export BOOL EqualRgn(HRGN a, HRGN b); +export BOOL RectInRegion(HRGN r, RECT *); +export BOOL PtInRegion(HRGN r, int x, int y); +export int OffsetRgn(HRGN r, int x, int y); +export HRGN CreatePolygonRgn(POINT *p, int n, int rule); +export HRGN CreateRectRgnIndirect(RECT *r); +export HRGN CreateEllipticRgnIndirect(RECT *r); +export HRGN CreateRoundRectRgn(int a, int b, int c, int d, int e, int f); +export int CombineRgn(HRGN r, HRGN a, HRGN b, int n); +export int GetRgnBox(HRGN r, LPRECT p); +export BOOL PaintRgn(HDC dc, HRGN r); +struct RGNDATAHEADER { + DWORD dwSize; + DWORD iType; + DWORD nCount; + DWORD nRgnSize; + RECT rcBound; +} +struct RGNDATA { + RGNDATAHEADER rdh; + char Buffer[1]; +} +struct XFORM { + FLOAT eM11; + FLOAT eM12; + FLOAT eM21; + FLOAT eM22; + FLOAT eDx; + FLOAT eDy; +} +export DWORD GetRegionData(HRGN h, DWORD s, RGNDATA* data); +export HRGN ExtCreateRegion(XFORM *t, DWORD s, RGNDATA *data); + +export int FillRect(HDC hDC,RECT *lprc,HBRUSH hbr); +export int FrameRect(HDC hDC,RECT *lprc,HBRUSH hbr); +export BOOL InvertRect(HDC hDC,RECT *lprc); +export BOOL IntersectRect(LPRECT lprcDst,RECT *lprcSrc1,RECT *lprcSrc2); +export BOOL UnionRect(LPRECT lprcDst,RECT *lprcSrc1,RECT *lprcSrc2); +export BOOL SubtractRect(LPRECT lprcDst,RECT *lprcSrc1,RECT *lprcSrc2); +export BOOL OffsetRect(LPRECT lprc,int dx,int dy); +export BOOL IsRectEmpty(RECT *lprc); +export BOOL EqualRect(RECT *lprc1,RECT *lprc2); +export BOOL PtInRect(RECT *lprc,POINT pt); + +/* PolyFill() Modes */ +enum { + ALTERNATE = 1, + WINDING = 2 +} +export int SetPolyFillMode(HDC hdc, int m); +export int GetPolyFillMode(HDC hdc); + +/* + * Combo Box messages + */ +const uint CB_GETEDITSEL =0x0140; +const uint CB_LIMITTEXT =0x0141; +const uint CB_SETEDITSEL =0x0142; +const uint CB_ADDSTRING =0x0143; +const uint CB_DELETESTRING =0x0144; +const uint CB_DIR =0x0145; +const uint CB_GETCOUNT =0x0146; +const uint CB_GETCURSEL =0x0147; +const uint CB_GETLBTEXT =0x0148; +const uint CB_GETLBTEXTLEN =0x0149; +const uint CB_INSERTSTRING =0x014A; +const uint CB_RESETCONTENT =0x014B; +const uint CB_FINDSTRING =0x014C; +const uint CB_SELECTSTRING =0x014D; +const uint CB_SETCURSEL =0x014E; +const uint CB_SHOWDROPDOWN =0x014F; +const uint CB_GETITEMDATA =0x0150; +const uint CB_SETITEMDATA =0x0151; +const uint CB_GETDROPPEDCONTROLRECT =0x0152; +const uint CB_SETITEMHEIGHT =0x0153; +const uint CB_GETITEMHEIGHT =0x0154; +const uint CB_SETEXTENDEDUI =0x0155; +const uint CB_GETEXTENDEDUI =0x0156; +const uint CB_GETDROPPEDSTATE =0x0157; +const uint CB_FINDSTRINGEXACT =0x0158; +const uint CB_SETLOCALE =0x0159; +const uint CB_GETLOCALE =0x015A; +const uint CB_GETTOPINDEX =0x015b; +const uint CB_SETTOPINDEX =0x015c; +const uint CB_GETHORIZONTALEXTENT =0x015d; +const uint CB_SETHORIZONTALEXTENT =0x015e; +const uint CB_GETDROPPEDWIDTH =0x015f; +const uint CB_SETDROPPEDWIDTH =0x0160; +const uint CB_INITSTORAGE =0x0161; +const uint CBN_SELCHANGE =1; +const uint CBN_DBLCLK =2; +const uint CBN_SETFOCUS =3; +const uint CBN_KILLFOCUS =4; +const uint CBN_EDITCHANGE =5; +const uint CBN_EDITUPDATE =6; +const uint CBN_DROPDOWN =7; +const uint CBN_CLOSEUP =8; +const uint CBN_SELENDOK =9; +const uint CBN_SELENDCANCEL =10; + +/* + * Combo Box styles + */ +const uint CBS_SIMPLE =0x0001L; +const uint CBS_DROPDOWN =0x0002L; +const uint CBS_DROPDOWNLIST =0x0003L; +const uint CBS_OWNERDRAWFIXED =0x0010L; +const uint CBS_OWNERDRAWVARIABLE =0x0020L; +const uint CBS_AUTOHSCROLL =0x0040L; +const uint CBS_OEMCONVERT =0x0080L; +const uint CBS_SORT =0x0100L; +const uint CBS_HASSTRINGS =0x0200L; +const uint CBS_NOINTEGRALHEIGHT =0x0400L; +const uint CBS_DISABLENOSCROLL =0x0800L; +const uint CBS_UPPERCASE =0x2000L; +const uint CBS_LOWERCASE =0x4000L; + +/* + * Listbox messages + */ +const uint LB_ADDSTRING =0x0180; +const uint LB_INSERTSTRING =0x0181; +const uint LB_DELETESTRING =0x0182; +const uint LB_SELITEMRANGEEX =0x0183; +const uint LB_RESETCONTENT =0x0184; +const uint LB_SETSEL =0x0185; +const uint LB_SETCURSEL =0x0186; +const uint LB_GETSEL =0x0187; +const uint LB_GETCURSEL =0x0188; +const uint LB_GETTEXT =0x0189; +const uint LB_GETTEXTLEN =0x018A; +const uint LB_GETCOUNT =0x018B; +const uint LB_SELECTSTRING =0x018C; +const uint LB_DIR =0x018D; +const uint LB_GETTOPINDEX =0x018E; +const uint LB_FINDSTRING =0x018F; +const uint LB_GETSELCOUNT =0x0190; +const uint LB_GETSELITEMS =0x0191; +const uint LB_SETTABSTOPS =0x0192; +const uint LB_GETHORIZONTALEXTENT =0x0193; +const uint LB_SETHORIZONTALEXTENT =0x0194; +const uint LB_SETCOLUMNWIDTH =0x0195; +const uint LB_ADDFILE =0x0196; +const uint LB_SETTOPINDEX =0x0197; +const uint LB_GETITEMRECT =0x0198; +const uint LB_GETITEMDATA =0x0199; +const uint LB_SETITEMDATA =0x019A; +const uint LB_SELITEMRANGE =0x019B; +const uint LB_SETANCHORINDEX =0x019C; +const uint LB_GETANCHORINDEX =0x019D; +const uint LB_SETCARETINDEX =0x019E; +const uint LB_GETCARETINDEX =0x019F; +const uint LB_SETITEMHEIGHT =0x01A0; +const uint LB_GETITEMHEIGHT =0x01A1; +const uint LB_FINDSTRINGEXACT =0x01A2; +const uint LB_SETLOCALE =0x01A5; +const uint LB_GETLOCALE =0x01A6; +const uint LB_SETCOUNT =0x01A7; +const uint LB_INITSTORAGE =0x01A8; +const uint LB_ITEMFROMPOINT =0x01A9; + + +/* + * Listbox Styles + */ +const uint LBS_NOTIFY =0x0001L; +const uint LBS_SORT =0x0002L; +const uint LBS_NOREDRAW =0x0004L; +const uint LBS_MULTIPLESEL =0x0008L; +const uint LBS_OWNERDRAWFIXED =0x0010L; +const uint LBS_OWNERDRAWVARIABLE =0x0020L; +const uint LBS_HASSTRINGS =0x0040L; +const uint LBS_USETABSTOPS =0x0080L; +const uint LBS_NOINTEGRALHEIGHT =0x0100L; +const uint LBS_MULTICOLUMN =0x0200L; +const uint LBS_WANTKEYBOARDINPUT =0x0400L; +const uint LBS_EXTENDEDSEL =0x0800L; +const uint LBS_DISABLENOSCROLL =0x1000L; +const uint LBS_NODATA =0x2000L; +const uint LBS_NOSEL =0x4000L; +const uint LBS_STANDARD =(LBS_NOTIFY | LBS_SORT | WS_VSCROLL | WS_BORDER); + +const uint OFN_READONLY =0x00000001; +const uint OFN_OVERWRITEPROMPT =0x00000002; +const uint OFN_HIDEREADONLY =0x00000004; +const uint OFN_NOCHANGEDIR =0x00000008; +const uint OFN_SHOWHELP =0x00000010; +const uint OFN_ENABLEHOOK =0x00000020; +const uint OFN_ENABLETEMPLATE =0x00000040; +const uint OFN_ENABLETEMPLATEHANDLE =0x00000080; +const uint OFN_NOVALIDATE =0x00000100; +const uint OFN_ALLOWMULTISELECT =0x00000200; +const uint OFN_EXTENSIONDIFFERENT =0x00000400; +const uint OFN_PATHMUSTEXIST =0x00000800; +const uint OFN_FILEMUSTEXIST =0x00001000; +const uint OFN_CREATEPROMPT =0x00002000; +const uint OFN_SHAREAWARE =0x00004000; +const uint OFN_NOREADONLYRETURN =0x00008000; +const uint OFN_NOTESTFILECREATE =0x00010000; +const uint OFN_NONETWORKBUTTON =0x00020000; +const uint OFN_NOLONGNAMES =0x00040000; +const uint OFN_EXPLORER =0x00080000; +const uint OFN_NODEREFERENCELINKS =0x00100000; +const uint OFN_LONGNAMES =0x00200000; + +const uint SBS_HORZ =0x0000; +const uint SBS_VERT =0x0001; +const uint SBS_TOPALIGN =0x0002; +const uint SBS_LEFTALIGN =0x0002; +const uint SBS_BOTTOMALIGN =0x0004; +const uint SBS_RIGHTALIGN =0x0004; +const uint SBS_SIZEBOXTOPLEFTALIGN =0x0002; +const uint SBS_SIZEBOXBOTTOMRIGHTALIGN =0x0004; +const uint SBS_SIZEBOX =0x0008; + +export HWND CreateWindowExW( + DWORD dwExStyle, + LPWSTR lpClassName, + LPWSTR lpWindowName, + DWORD dwStyle, + int X, + int Y, + int nWidth, + int nHeight, + HWND hWndParent , + HMENU hMenu, + HINSTANCE hInstance, + LPVOID lpParam); + + +HWND CreateWindowW( + LPWSTR lpClassName, + LPWSTR lpWindowName, + DWORD dwStyle, + int X, + int Y, + int nWidth, + int nHeight, + HWND hWndParent , + HMENU hMenu, + HINSTANCE hInstance, + LPVOID lpParam) +{ + return CreateWindowExW(0, lpClassName, lpWindowName, dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); +} + +// PIXELFORMATDESCRIPTOR stuff +const uint PFD_TYPE_RGBA = 0; +const uint PFD_TYPE_COLORINDEX = 1; +const uint PFD_MAIN_PLANE = 0; +const uint PFD_OVERLAY_PLANE = 1; +const uint PFD_DOUBLEBUFFER = 1; +const uint PFD_STEREO = 2; +const uint PFD_DRAW_TO_WINDOW = 4; +const uint PFD_DRAW_TO_BITMAP = 8; +const uint PFD_SUPPORT_GDI = 16; +const uint PFD_SUPPORT_OPENGL = 32; +const uint PFD_GENERIC_FORMAT = 64; +const uint PFD_NEED_PALETTE = 128; +const uint PFD_NEED_SYSTEM_PALETTE = 0x00000100; +const uint PFD_SWAP_EXCHANGE = 0x00000200; +const uint PFD_SWAP_COPY = 0x00000400; +const uint PFD_SWAP_LAYER_BUFFERS = 0x00000800; +const uint PFD_GENERIC_ACCELERATED = 0x00001000; +const uint PFD_DEPTH_DONTCARE = 0x20000000; +const uint PFD_DOUBLEBUFFER_DONTCARE = 0x40000000; +const uint PFD_STEREO_DONTCARE = 0x80000000; + +export int ChoosePixelFormat(HDC hdc, PIXELFORMATDESCRIPTOR* ppfd); +export int DescribePixelFormat(HDC hdc, int iPixelFormat, UINT nBytes, PIXELFORMATDESCRIPTOR* ppfd); + +alias HANDLE HGLRC; + +const int WGL_SWAP_MAIN_PLANE = 1; +//int wglUseFontOutlinesW(HDC, uint, uint, uint, float, float, int, _GLYPHMETRICSFLOAT *); +//int wglUseFontOutlinesA(HDC, uint, uint, uint, float, float, int, _GLYPHMETRICSFLOAT *); +//int wglUseFontBitmapsW(HDC, uint, uint, uint); +//int wglUseFontBitmapsA(HDC, uint, uint, uint); +//int wglSetLayerPaletteEntries(HDC, int, int, int, uint*); +//int wglRealizeLayerPalette(HDC, int, int); +//int wglGetLayerPaletteEntries(HDC, int, int, int, uint*); +//int wglDescribeLayerPlane(HDC*, int, int, uint, LAYERPLANEDESCRIPTOR *); +//HGLRC wglCreateLayerContext(HDC, int); +export int wglSwapLayerBuffers(HDC, uint); +export int wglShareLists(HGLRC, HGLRC); +export int wglMakeCurrent(HDC, HGLRC); +export void* wglGetProcAddress(char*); +export HDC wglGetCurrentDC(); +export HGLRC wglGetCurrentContext(); +export int wglDeleteContext(HGLRC); +export HGLRC wglCreateContext(HDC); +export int wglCopyContext(HGLRC, HGLRC, uint); + +export BOOL SwapBuffers(HDC); + +const int SM_CXBORDER = 5; +const int SM_CYBORDER = 5; +const int SM_CXFIXEDFRAME = 7; +const int SM_CYFIXEDFRAME = 8; +const int SM_CXEDGE = 45; +const int SM_CYEDGE= 46; +const int SM_CXMENUCHECK = 71; +const int SM_CYMENUCHECK = 72; + +// +// these wrappers makes windows unicode look alot better and avoids excessive code duplication +package +{ + HWND CreateWindowX( + char[] lpClassName, + char[] lpWindowName, + DWORD dwStyle, + int X, + int Y, + int nWidth, + int nHeight, + HWND hWndParent , + HMENU hMenu, + HINSTANCE hInstance, + LPVOID lpParam) + { + if (useWfuncs) + return CreateWindowExW(0, toUTF16z(lpClassName), toUTF16z(lpWindowName), dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); + else + return CreateWindowExA(0, toMBSz(lpClassName), toMBSz(lpWindowName), dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam); + } + + BOOL SendMessageX(HWND hWnd, UINT msg, WPARAM wParam, char[] lParam) + { + if (useWfuncs) + return SendMessageW(hWnd, msg, wParam, cast(LPARAM)toUTF16z(lParam)); + else + return SendMessageW(hWnd, msg, wParam, cast(LPARAM)toMBSz(lParam)); + } + + int MessageBoxX(HWND hWnd, char[] lpText, char[] lpCaption, UINT uType) + { + if (useWfuncs) + return MessageBoxW(hWnd, toUTF16z(lpText), toUTF16z(lpCaption), uType); + else + return MessageBoxA(hWnd, toMBSz(lpText), toMBSz(lpCaption), uType); + } + + BOOL GetTextExtentPoint32X(HDC dc, char[] str, int len, SIZE* s) + { + if (useWfuncs) { + wchar[] wstr = toUTF16(str); + return GetTextExtentPoint32W(dc, wstr.ptr, wstr.length, s); + } else { + size_t al; + char* ansi = toMBSzl(str, al); + return GetTextExtentPoint32A(dc, ansi, al, s); + } + } + + BOOL AppendMenuX(HMENU menu, uint flags, void*item, char[] str) + { + if (useWfuncs) + return AppendMenuW(menu, flags, item, toUTF16z(str)); + else + return AppendMenuA(menu, flags, item, toMBSz(str)); + } +} + +/****************************************** + * Converts the UTF-8 string s into a null-terminated string in a Windows + * 8-bit character set. + * + * Params: + * s = UTF-8 string to convert. + * reslen = the number of bytes in the resulting buffer + * (not including the null terminator) will be place here. + * codePage = is the number of the target codepage, or + * 0 - ANSI, + * 1 - OEM, + * 2 - Mac + * + * Authors: + * yaneurao, Walter Bright, Stewart Gordon + */ +private import std.windows.syserror; +char* toMBSzl(char[] s, out size_t reslen, uint codePage = 0) +{ + // Only need to do this if any chars have the high bit set + foreach (char c; s) + { + if (c >= 0x80) + { + char[] result; + int readLen; + wchar* ws = std.utf.toUTF16z(s); + result.length = WideCharToMultiByte(codePage, 0, ws, -1, null, 0, + null, null); + + if (result.length) + { + readLen = WideCharToMultiByte(codePage, 0, ws, -1, result.ptr, + result.length, null, null); + } + + if (!readLen || readLen != result.length) + { + throw new Exception("Couldn't convert string: " ~ + sysErrorString(GetLastError())); + } + + reslen = result.length ? result.length-1 : 0; + return result.ptr; + } + } + reslen = s.length; + return std.string.toStringz(s); +} diff --git a/samples/minwin_gtk/minwin/multidg.d b/samples/minwin_gtk/minwin/multidg.d new file mode 100644 index 0000000..aa22805 --- /dev/null +++ b/samples/minwin_gtk/minwin/multidg.d @@ -0,0 +1,155 @@ +/* MultiDelegate: add, remove and fire multiple delegates + * + * A multi-delegate is similar to a C# multicast delegate. + * It has array copy semantics so assignment will copy the + * length and data pointer but modification could allocate + * a distinct copy. Delegates in a multi-delegate are fired + * in the order they were added. + * + * A MultiBoolDelegate is a multi-delegates where each + * delegate returns a bool and the result of executing + * the MultiBoolDelegate is the or'ed value of all the bools. + * + * To append to a multi-delegate use ~= + * To remove a delegate from a multi-delegate use remove() + * To fire all the delegates in order use opCall: multidg() + * To test if the multi-delegate is empty use isEmpty() + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.multidg; + +template DelegateMixin() { + + // Append dg to the end of the multi-delegate. + // If dg is null nothing changes. + void opCatAssign(Callback dg) { + if (dg is null) return; + bool found = false; + int len = dgs.length; + int n = len-1; + while (n >= 0 && dgs[n] is null) + --n; + if (n < len-1) + dgs[n+1] = dg; + else + dgs ~= dg; + } + + // Remove the first occurance of dg from the multi-delegate. + // If dg is not in the multi-delegate nothing changes. + void remove(Callback dg) { + if (dgs.length == 0) return; + bool found = false; + for (int n=0 ; n < dgs.length-1; ++n) { + if (!found && dgs[n] is dg) found = true; + if (found) dgs[n] = dgs[n+1]; + if (dgs[n] is null) break; + } + if (found || dgs[length-1] is dg) + dgs[length-1] = null; + } + + bool isEmpty() { + if (dgs.length == 0) + return true; + else if (dgs[0] is null) + return true; + else + return false; + } + + // the array of delegate with possible trailing nulls + Callback[] dgs; +} + +// MultiDelegate with variadic args +struct MultiDelegate(T...) +{ + alias void delegate(T) Callback; + mixin DelegateMixin!(); + void opCall(T args) { + foreach( Callback dg; dgs) { + if (dg is null) break; + dg(args); + } + } +} + +// MultiBoolDelegate with variadic args +struct MultiBoolDelegate(T...) { + alias bool delegate(T) Callback; + mixin DelegateMixin!(); + bool opCall(T args) { + bool result = false; + foreach( Callback dg; dgs) { + if (dg is null) break; + result |= dg(args); + } + return result; + } +} + +unittest { + /** Example class illustrating multi-delegates based on Qt's example at + * http://doc.trolltech.com/3.3/signalsandslots.html + * + */ + class Foo { + MultiDelegate!(int) valueChanged; + private int val; + int value() { + return val; + } + void value(int v) { + if (val != v) { + val = v; + valueChanged(v); + } + } + MultiBoolDelegate!(int,double) boolDelegate; + private int val2; + int value2() { + return val2; + } + void value2(int v) { + if (val2 != v && !boolDelegate(v,2.0*v)) { + val2 = v; + } + } + } + + Foo a = new Foo; + Foo b = new Foo; + Foo c = new Foo; + a.valueChanged ~= &b.value; + assert( a.value == 0 ); + assert( b.value == 0 ); + b.value = 11; + assert( a.value == 0 ); + assert( b.value == 11 ); + a.value = 79; + assert( a.value == 79 ); + assert( b.value == 79 ); + a.valueChanged ~= &c.value; + a.value = 80; + assert( a.value == 80 ); + assert( b.value == 80 ); + assert( c.value == 80 ); + a.valueChanged.remove(&b.value); + a.value = 100; + assert( a.value == 100 ); + assert( b.value == 80 ); + assert( c.value == 100 ); + + a.boolDelegate ~= delegate bool(int x,double y) { + return (y > 10.0); + }; + a.value2 = 2; + assert( a.value2 == 2 ); + a.value2 = 20; + assert( a.value2 == 2 ); +} diff --git a/samples/minwin_gtk/minwin/paint.d b/samples/minwin_gtk/minwin/paint.d new file mode 100644 index 0000000..bbe2a33 --- /dev/null +++ b/samples/minwin_gtk/minwin/paint.d @@ -0,0 +1,605 @@ +/* MinWin Paint module + * + * An GContext is a simple 2D drawing API similar to a Windows DC + * and an X11 Graphics Context. A GXContext is a more advanced + * painting API that is similar to GDI+ or Quartz. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.paint; + +public { + import minwin.geometry; + import minwin.peer; +} + +private { + import minwin.app; + import minwin.image; + import minwin.logging; +} + +// TODO: gdi+ +// maybe also add a template paint context with coordinates in non-int + +GContext newGContext() { + GContext gc = GContext.freeList; + if (gc) { + GContext.freeList = GContext.freeList.next; + } else { + gc = new GContext; + } + return gc; +} + +enum PenStyle { + Solid = 0, + Dash = 1, /* ------- */ + Dot = 2, /* ....... */ + DashDot = 3 /* _._._._ */ + // todo: None? +} + +enum LineJoin { + Round, + Bevel, + Miter +} + +enum PaintMode { + Copy, Invert, And, Or, Xor +} + +version (GTK) + version = SharedPenBrushImpl; + +version (SharedPenBrushImpl) { + + struct PenData { + uint width; + Color color; + PenStyle style; + LineJoin join; + + } + + class Pen { + PenData data; + this(PenData* data) { + this.data = *data; + } + this(Color color) { + data.color = color; + } + void dispose(){} + } + + class Brush { + Color color; + this(Color color) { + this.color = color; + } + } +} + +version (MinWin32) { + private import minwin.mswindows; + + public import minwin.font; + + alias HDC GContextPeer; + + class GXContext { } // GDI+ + + alias HPEN PenPeer; + alias HBRUSH BrushPeer; + + private DWORD paintModeToNative(PaintMode mode) { + DWORD nmode; + switch (mode) { + case PaintMode.Copy: nmode = SRCCOPY; break; + case PaintMode.Invert: nmode = NOTSRCCOPY; break; + case PaintMode.And: nmode = SRCAND; break; + case PaintMode.Or: nmode = SRCPAINT; break; + case PaintMode.Xor: nmode = SRCINVERT; break; + default: assert(0); + } + return nmode; + } + + struct PenData { + LOGPEN native; + void width(uint w) { + native.lopnWidth = XY(w,w).native; + } + void color(Color c) { + native.lopnColor = c.native; + } + void style(PenStyle s) { + native.lopnStyle = s; + } + void lineJoin(LineJoin j) { + } + } + + class Pen { + PenPeer peer; + + mixin SimplePeerMixin!(); + this(PenData* data) { + peer = CreatePenIndirect(&data.native); + sysAssert(peer !is null, "Failed to create pen"); + hasPeer = OWNS_PEER; + } + this(Color color) { + PenData pd; + pd.color = color; + this(&pd); + } + this(PenPeer peer) { + this.peer = peer; + hasPeer = FOREIGN_PEER; + } + } + + class Brush { + BrushPeer peer; + + mixin SimplePeerMixin!(); + this(Color color) { + peer = CreateSolidBrush(color.native); + sysAssert(peer !is null, "Failed to create brush"); + hasPeer = OWNS_PEER; + } + this(BrushPeer peer) { + this.peer = peer; + hasPeer = FOREIGN_PEER; + } + } + + class GContext { + GContextPeer peer; + GContext next; // free list link + static GContext freeList; + bool release; + HWND hwnd; // companion hwnd used if release is true + Font font; + FontPeer origFont; // stores font in used before setFont is called + Pen pen; + PenPeer origPen; + Brush brush; + BrushPeer origBrush; + Region cliprgn; + PAINTSTRUCT paintstruct; + + ~this() { + disposePeer(); + } + int hasPeer; + void dispose() { + disposePeer(); + next = freeList; + freeList = this; + } + void disposePeer() { + pen = null; + font = null; + origFont = origPen = origBrush = null; + brush = null; + cliprgn = null; + if (hasPeer == OWNS_PEER) { + if (release) + ReleaseDC(hwnd,peer); + else { + BOOL ok = DeleteDC(peer); + sysAssert(ok != false, "Failed to delete DC"); + } + } + } + + Rect updateRect() { + return toRect(paintstruct.rcPaint); + } + + Font setFont(Font f) { + Font oldFont = font; + font = f; + if (f is null) { + SelectObject(peer, cast(HGDIOBJ) origFont); + } else if (oldFont is null) { + origFont = cast(FontPeer)SelectObject(peer, cast(HGDIOBJ) font.peer); + } else { + SelectObject(peer, cast(HGDIOBJ) font.peer); + } + return oldFont; + } + + void getFontMetrics(inout FontMetrics f) { + BOOL ok = GetTextMetricsA(peer,&f.native); + sysAssert(ok != false, "Failed to get font metrics"); + } + + Pen setPen(Pen p) { + Pen oldPen = pen; + pen = p; + if (p is null) { + SelectObject(peer, cast(HGDIOBJ) origPen); + } else if (oldPen is null) { + origPen = cast(PenPeer)SelectObject(peer, cast(HGDIOBJ) pen.peer); + } else { + SelectObject(peer, cast(HGDIOBJ) pen.peer); + } + return oldPen; + } + + Brush setBrush(Brush p) { + Brush oldBrush = brush; + brush = p; + if (p is null) { + SelectObject(peer, cast(HGDIOBJ) origBrush); + } else if (oldBrush is null) { + origBrush = cast(BrushPeer)SelectObject(peer, cast(HGDIOBJ) brush.peer); + } else { + SelectObject(peer, cast(HGDIOBJ) brush.peer); + } + return oldBrush; + } + + void getClip(Region rgn) { + int res = GetClipRgn(peer,rgn.peer); + sysAssert(res != -1, "Failed to get clip region"); + } + + // in postscript could mean intersect with current clip region + void setClip(Region rgn) { + int res = SelectClipRgn(peer,rgn.peer); + sysAssert(res != 0, "Failed to set clip region"); + } + + // pen must be set + void drawRect(inout Rect r) { + // TODO: move in by pen width + BOOL ok = MoveToEx(peer,r.left,r.top,null); + sysAssert(ok != false, "Failed to draw rect"); + LineTo(peer,r.left,r.bottom-1); + LineTo(peer,r.right-1,r.bottom-1); + LineTo(peer,r.right-1,r.top); + LineTo(peer,r.left,r.top); + } + + // brush must be set + void fillRect(inout Rect r) { + sysAssert(brush !is null, "Brush must be set for fillRect"); + int ok = FillRect(peer,&r.native,brush.peer); + sysAssert(ok != false, "Failed to fill rect"); + } + + void drawText(int x, int y, char[] str) { + BOOL ok; + if (useWfuncs) { + wchar[] buf = toUTF16(str); + ok = TextOutW(peer, x, y, buf.ptr, buf.length); + } + else { + auto buf = toMBSz(str); + ok = TextOutA(peer, x, y, buf, std.c.string.strlen(buf)); + } + sysAssert(ok != false, "Failed to draw text"); + } + void drawLine(int x1, int y1, int x2, int y2) { + BOOL ok = MoveToEx(peer,x1,y1,null); + sysAssert(ok != false, "Failed to draw line"); + LineTo(peer,x2,y2); + } + void drawPolyline(Point[] pts) { + if (pts.length > 1) { + BOOL ok = MoveToEx(peer,pts[0].x,pts[0].y,null); + sysAssert(ok != false, "Failed to draw polyline"); + for (int n=1; n < pts.length; ++n) { + LineTo(peer,pts[n].x,pts[n].y); + } + } + } + void drawPolygon(Point[] pts) { + if (pts.length > 1) { + BOOL ok = MoveToEx(peer,pts[0].x,pts[0].y,null); + sysAssert(ok != false, "Failed to draw polygon"); + for (int n=1; n < pts.length; ++n) { + LineTo(peer,pts[n].x,pts[n].y); + } + LineTo(peer,pts[0].x,pts[0].y); + } + } + void drawBezier(Point[] pts) { +// PolyBezier(peer,pts.ptr,pts.length); + } + void fillPolygon(Point[] pts) { + //? + } + void fillRegion(Region rgn) { + sysAssert(brush !is null, "Brush must be set for fillRect"); +// FillRgn(peer,rgn,brush); + } + void drawRegion(Region rgn) { + BOOL ok = PaintRgn(peer,rgn.peer); + sysAssert(ok != false, "Failed to draw region"); + } + + void drawImage(Image im, int x, int y, PaintMode mode = PaintMode.Copy) { + HDC memDC = CreateCompatibleDC(peer); + sysAssert(memDC !is null, "Failed to create compatible DC in drawImage"); + HANDLE res = SelectObject(memDC,im.peer); + sysAssert(res !is null, "Failed to select bitmap in drawImage"); + version(LOG)log.writefln("drawing image %x %d %d", + im,im.width,im.height); + DWORD nmode = paintModeToNative(mode); + BOOL ok = BitBlt(peer,x,y,im.width,im.height,memDC,0,0,nmode); + sysAssert(ok != false, "Failed to BitBlt drawImage"); + version(LOG)log.writefln(" result %d",cast(int)res); + ok = DeleteDC(memDC); + sysAssert(ok != false, "Failed to delete compatible DC in drawImage"); + } + + void stretchImage(Image im, int x, int y, + int w, int h, PaintMode mode = PaintMode.Copy) { + HDC memDC = CreateCompatibleDC(peer); + sysAssert(memDC !is null, "Failed to create compatible DC in stretchImage"); + SelectObject(memDC,im.peer); + DWORD nmode = paintModeToNative(mode); + BOOL ok = StretchBlt(peer,x,y,w,h,memDC,0,0,im.width,im.height,nmode); + sysAssert(ok != false, "Failed to StretchBlt in stretchImage"); + DeleteDC(memDC); + } + + void drawSubImage(Image im, int x, int y, + int sx, int sy, int sw, int sh, + PaintMode mode = PaintMode.Copy) { + HDC memDC = CreateCompatibleDC(peer); + sysAssert(memDC !is null, "Failed to create compatible DC in drawSubImage"); + SelectObject(memDC,im.peer); + DWORD nmode = paintModeToNative(mode); + BOOL ok = BitBlt(peer,x,y,sw,sh,memDC,sx,sx,nmode); + sysAssert(ok != false, "Failed to BitBlt in drawSubImage"); + DeleteDC(memDC); + } + + void stretchSubImage(Image im, int x, int y, int w, int h, + int sx, int sy, int sw, int sh, + PaintMode mode = PaintMode.Copy) { + HDC memDC = CreateCompatibleDC(peer); + sysAssert(memDC !is null, "Failed to create compatible DC in stretchSubImage"); + SelectObject(memDC,im.peer); + DWORD nmode = paintModeToNative(mode); + BOOL ok = StretchBlt(peer,x,y,w,h,memDC,sx,sy,sw,sh,nmode); + sysAssert(ok != false, "Failed to StretchBlt in stretchSubImage"); + DeleteDC(memDC); + } + + void flush() { + GdiFlush(); + } + } + +} else version (GTK) { + + private import minwin.gtk; + + public import minwin.font; + + private GdkFunction paintModeToNative(PaintMode mode) { + GdkFunction nmode; + switch (mode) { + case PaintMode.Copy: nmode = GdkFunction.GDK_COPY; break; + case PaintMode.Invert: nmode = GdkFunction.GDK_COPY_INVERT; break; + case PaintMode.And: nmode = GdkFunction.GDK_AND; break; + case PaintMode.Or: nmode = GdkFunction.GDK_OR; break; + case PaintMode.Xor: nmode = GdkFunction.GDK_XOR; break; + default: assert(0); + } + return nmode; + } + + alias GdkGC* GContextPeer; + + class GXContext { } // not impl in GDK + + class GContext { + GContextPeer peer; + GContext next; // free list link + static GContext freeList; + GdkDrawable* drawable; + PangoLayout* layout; + Font font; + Pen pen; + Brush brush; + bool penActive; + GdkEventExpose* paintEvent; + + ~this() { + disposePeer(); + } + int hasPeer; + void dispose() { + disposePeer(); + next = freeList; + freeList = this; + } + void disposePeer() { + pen = null; + font = null; + brush = null; + penActive = false; + if (hasPeer == OWNS_PEER) { + g_object_unref(cast(GObject*)peer); + // g_object_unref(cast(GObject*)layout); + } + } + + Rect updateRect() { + Rect r; + if (paintEvent) + r = toRect(paintEvent.area); + return r; + } + + Font setFont(Font f) { + Font oldFont = font; +// if (oldFont is null) +// oldFont = DefaultFont; + font = f; + if (font) + pango_layout_set_font_description(layout,font.peer); + return oldFont; + } + + void getFontMetrics(inout FontMetrics f) { + PangoContext* c = pango_layout_get_context(layout); + PangoFontMetrics* data = pango_context_get_metrics(c,font.peer,null); + f.ascent = pango_font_metrics_get_ascent(data); + f.descent = pango_font_metrics_get_descent(data); + // f.leading = f.descent; + f.leading = 0; + f.size = f.ascent+f.descent; + f.maxWidth = pango_font_metrics_get_approximate_char_width(data)/PANGO_SCALE; + f.size /= PANGO_SCALE; + f.ascent /= PANGO_SCALE; + f.descent /= PANGO_SCALE; + f.leading /= PANGO_SCALE; + pango_font_metrics_unref(data); + } + + private void setForeground(Color rgb) { + GdkColor c; + c.red = Color.rescale(rgb.red,ubyte.max,ushort.max); + c.green = Color.rescale(rgb.green,ubyte.max,ushort.max); + c.blue = Color.rescale(rgb.blue,ubyte.max,ushort.max); + gdk_gc_set_rgb_fg_color(peer,&c); + } + + Pen setPen(Pen p) { + Pen oldPen = pen; + pen = p; + if (p !is null) { + GdkLineStyle style = GdkLineStyle.GDK_LINE_SOLID; + if (p.data.style != PenStyle.Solid) { + style = GdkLineStyle.GDK_LINE_ON_OFF_DASH; + gdk_gc_set_dashes(peer,0,dashlist[style-1].ptr, + dashlist[style-1].length); + } + gdk_gc_set_line_attributes(peer,p.data.width,style, + GdkCapStyle.GDK_CAP_BUTT, + cast(GdkJoinStyle)p.data.join); + setForeground(p.data.color); + penActive = true; + } + return oldPen; + } + + Brush setBrush(Brush p) { + Brush oldBrush = brush; + brush = p; + if (brush) { + setForeground(brush.color); + penActive = false; + } + return oldBrush; + } + + void drawRect(inout Rect r) { + if (pen && !penActive) { + setForeground(pen.data.color); + penActive = true; + } + gdk_draw_rectangle(drawable,peer,false, + r.left,r.top,r.width-1,r.height-1); + } + + // brush must be set + void fillRect(inout Rect r) { + if (brush && penActive) { + setForeground(brush.color); + penActive = false; + } + gdk_draw_rectangle(drawable,peer,true, + r.left,r.top,r.width,r.height); + } + + private static { + byte[][3] dashlist; + byte[2] dashed = [6,6]; + byte[2] dotted = [4,2]; + byte[4] dashdotted = [4,6,4,2]; + } + static this() { + dashlist[0] = dashed; + dashlist[1] = dotted; + dashlist[2] = dashdotted; + } + + void drawLine(int x1, int y1, int x2, int y2) { + gdk_draw_line(drawable, peer, x1,y1,x2,y2); + } + + void drawPolyline(Point[] pts) { + gdk_draw_lines(drawable, peer, cast(GdkPoint*)pts.ptr, pts.length); + } + + void drawPolygon(Point[] pts) { + gdk_draw_polygon(drawable, peer, false, cast(GdkPoint*)pts.ptr, pts.length); + } + + void fillPolygon(Point[] pts) { + gdk_draw_polygon(drawable, peer, true, cast(GdkPoint*)pts.ptr, pts.length); + } + + void drawText(int x, int y, char[] str) { + pango_layout_set_text(layout,str.ptr,str.length); + gdk_draw_layout(drawable,peer,x,y,layout); + } + + void drawImage(Image im, int x, int y, PaintMode mode = PaintMode.Copy) { + GdkGCValues vals; + gdk_gc_get_values(peer,&vals); + gdk_gc_set_function(peer,paintModeToNative(mode)); + gdk_draw_drawable(drawable,peer,im.peer,0,0,x,y,-1,-1); + gdk_gc_set_function(peer,vals.Function); + } + + void drawSubImage(Image im, int x, int y, + int sx, int sy, int sw, int sh, + PaintMode mode = PaintMode.Copy) { + GdkGCValues vals; + gdk_gc_get_values(peer,&vals); + gdk_gc_set_function(peer,paintModeToNative(mode)); + gdk_draw_drawable(drawable,peer,im.peer,sx,sy,x,y,sw,sh); + gdk_gc_set_function(peer,vals.Function); + } + + void stretchImage(Image im, int x, int y, int w, int h, + PaintMode mode = PaintMode.Copy) { + // TODO + GdkGCValues vals; + gdk_gc_get_values(peer,&vals); + gdk_gc_set_function(peer,paintModeToNative(mode)); + gdk_draw_drawable(drawable,peer,im.peer,0,0,x,y,-1,-1); + gdk_gc_set_function(peer,vals.Function); + } + + void stretchSubImage(Image im, int x, int y, int w, int h, + int sx, int sy, int sw, int sh, + PaintMode mode = PaintMode.Copy) { + // TODO + GdkGCValues vals; + gdk_gc_get_values(peer,&vals); + gdk_gc_set_function(peer,paintModeToNative(mode)); + gdk_draw_drawable(drawable,peer,im.peer,sx,sy,x,y,sw,sh); + gdk_gc_set_function(peer,vals.Function); + } + + void flush() { gdk_flush(); } + + } +} diff --git a/samples/minwin_gtk/minwin/peer.d b/samples/minwin_gtk/minwin/peer.d new file mode 100644 index 0000000..d09a242 --- /dev/null +++ b/samples/minwin_gtk/minwin/peer.d @@ -0,0 +1,54 @@ +/* MinWin Peer module + * + * Mixin templates to simplify peer management + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.peer; + +version (MinWin32) { + private import minwin.mswindows; + alias HWND PeerForAdd; + alias PeerForAdd WindowChildPeer; +} else version (GTK) { + private import minwin.gtk; + alias GtkWidget* PeerForAdd; + alias PeerForAdd WindowChildPeer; +} + +// possible values for hasPeer property +enum { + NO_PEER, // object has no peer + FOREIGN_PEER, // peer is not owned by object + OWNS_PEER // object owns peer +} + +template PeerMixin() { + ~this() { + disposePeer(); + } + int hasPeer; +} + +template SimplePeerMixin() { + ~this() { + disposePeer(); + } + int hasPeer; + void dispose() { disposePeer(); } + void disposePeer() { + if (hasPeer == OWNS_PEER) { + version (MinWin32) { + int ok = DeleteObject(peer); + sysAssert(ok != false, "Failed to dispose peer Font"); + } else version (GTK) { + g_object_unref(cast(GObject*)peer); + } + } + hasPeer = NO_PEER; + } +} + diff --git a/samples/minwin_gtk/minwin/peerimpl.d b/samples/minwin_gtk/minwin/peerimpl.d new file mode 100644 index 0000000..53ac1f4 --- /dev/null +++ b/samples/minwin_gtk/minwin/peerimpl.d @@ -0,0 +1,265 @@ +/* MinWin PeerImpl module + * + * Mixin template to implement heavyweight peer for window children. + * Plus PeerWrapper to insert peer children into the MinWin tree. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.peerimpl; + +private { + import minwin.app; + import minwin.component; + import minwin.window; + import std.string; + import minwin.logging; +} + + +version (MinWin32) { + public import minwin.paint; + private import minwin.mswindows; + + template WindowChildImpl() { + + WindowChildPeer peer; + PeerForAdd getPeerForAdd() { return peer; } + WindowChildPeer getPeer() { return peer;} + + void disposePeer(){ + if (hasPeer == OWNS_PEER && parent is null) { + int ok = DeleteObject(peer); + sysAssert(ok != false, "Failed to dispose peer child"); + } + hasPeer = NO_PEER; + } + + void visible(bool vis) { + ShowWindow(peer,vis ? SW_SHOW : SW_HIDE); // ignore bool result + } + bool visible() { + return IsWindowVisible(peer) != 0; + } + + void enabled(bool b) { + EnableWindow(peer, b); + } + bool enabled() { + return IsWindowEnabled(peer) == TRUE; + } + + void requestFocus() { + HWND old = SetFocus(peer); + sysAssert(old !is null, "Failed to requestFocus"); + } + + // gets window bounds that encose the entire widget in parent coordinates + void getBounds(inout Rect r) { + Rect r2; + BOOL ok = GetWindowRect(peer,&r2.native); + sysAssert(ok != false, "Failed to get window bounds"); + int x,y; + parent.getPeerOffset(x,y); + r2.LTWH(r2.left+x,r2.top+y,r2.width,r2.height); + r = r2; + } + + void setBounds(inout Rect r) { + Rect r2,r3 = r; + getBounds(r2); + int x,y; + parent.getPeerOffset(x,y); + r3.LTWH(r3.left+x,r3.top+y,r3.width,r3.height); + BOOL ok = MoveWindow(peer,r3.left,r3.top,r3.width,r3.height,true); + sysAssert(ok != false, "Failed to move window in setBounds"); + if (r2 != r) + childLayoutDirty = true; + } + + alias Component.size size; + void size(Point s) { + Rect r2; + BOOL ok = GetWindowRect(peer,&r2.native); + sysAssert(ok != false, "Failed to get window rect in size"); + ok = MoveWindow(peer,r2.left,r2.top,s.x,s.y,true); + sysAssert(ok != false, "Failed to move window in size"); + if (r2.width != s.x || r2.height != s.y) + childLayoutDirty = true; + } + + void repaint() { + BOOL ok = InvalidateRect(peer,null,clearBackgroundOnPaint); + sysAssert(ok != false, "Failed to invalidate rect in repaint"); + } + + GContext getGContext() { + GContext gc = newGContext(); + gc.peer = GetDC(peer); + sysAssert(gc.peer !is null, "Failed to get DC in getGContext"); + gc.hasPeer = OWNS_PEER; + return gc; + } + } + + // Get the Component object associated with the given peer. + // The peer is accessed from the Component using the peer property. + WindowChild peerToWindowChild(WindowChildPeer peer) { + return cast(WindowChild)cast(void*)GetWindowLongA(peer,GWL_USERDATA); + } + // Associate c with the peer. On Windows this overwrites the + // window UserData. + void setWindowChildPeer(Component c, WindowChildPeer peer,int peerState) { + SetWindowLongA(peer,GWL_USERDATA,cast(int)cast(void*)c); + c.hasPeer = peerState; + // TODO investigate if we need a destroy callback to clear hasPeer + } + +} else version(GTK) { + + private import minwin.gtk; + + extern (C) + gint mw_exposechild_callback(GtkWidget w, GdkEventExpose*ev, + gpointer ud) { + Component win = cast(Component) ud; + if (win) { + win.layout(true); + } + return 0; + } + + template WindowChildImpl() { + + WindowChildPeer peer; + + PeerForAdd getPeerForAdd() { return peer; } + WindowChildPeer getPeer() { return peer;} + + void disposePeer() { + if (hasPeer == OWNS_PEER && parent is null) + gtk_widget_destroy(peer); + hasPeer = NO_PEER; + } + + void visible(bool vis) { + if (vis) { + gtk_widget_show(peer); + } else { + gtk_widget_hide(peer); + } + } + + bool visible() { + GtkObject* obj = cast(GtkObject*)peer; + return ((obj.flags & GtkWidgetFlags.GTK_VISIBLE) != 0); + } + + void enabled(bool b) { + gtk_widget_set_sensitive(peer,cast(int)b); + } + bool enabled() { + GtkObject* obj = cast(GtkObject*)peer; + return ((obj.flags & GtkWidgetFlags.GTK_SENSITIVE) != 0); + } + + override void requestFocus() { + GtkObject* obj = cast(GtkObject*)peer; + + // printf("%d\n", cast(int)((obj.flags & GtkWidgetFlags.GTK_CAN_FOCUS) != 0)); + gtk_widget_grab_focus(peer); + } + + void getBounds(inout Rect r) { + int x,y,x2,y2,w,h,depth; + parent.getPeerOffset(x,y); + // gdk_window_get_geometry(peer.window,&x2,&y2,&w,&h,&depth); + Rect r2 = toRect(peer.allocation); + r.LTWH(r2.left+x,r2.top+y,r2.width,r2.height); + // version(LOG) log.writefln("get bounds got %d %d %d %d", + // x2+x,y2+y,w,h); + } + + void setBounds(inout Rect r) { + version(LOG) log.writefln("setBounds %d %d %d %d", + r.left,r.top,r.width,r.height); + + int x,y; + parent.getPeerOffset(x,y); + Rect r2 = r; + r2.left = r2.left+x; + r2.top = r2.top+y; + + gtk_widget_size_allocate(peer,&r2.native); + /* + int x2,y2,w,h,depth; + gdk_window_get_geometry(peer.window,&x2,&y2,&w,&h,&depth); + r.LTWH(x2+x,y2+y,w,h); + version(LOG) log.writefln("after set bounds got %d %d %d %d", + x2,y2,w,h); + if (r2.width != r.width || r2.height != r.height) + */ + childLayoutDirty = true; + } + + alias Component.size size; + void size(Point s) { + Rect r; + getBounds(r); + r.LTWH(r.left,r.top,s.x,s.y); + setBounds(r); + } + + Point preferredSize() { + GtkRequisition req; + gtk_widget_size_request(peer,&req); + int width = req.width; + int height = req.height; + if (userPreferredWidth > 0) + width = userPreferredWidth; + if (userPreferredHeight > 0) + height = userPreferredHeight; + return XY(width,height); + } + + // mark as needing a repaint and post event to event queue + void repaint() { + Rect r; + getBounds(r); + gdk_window_invalidate_rect(peer.window,&r.native,true); + } + } + + WindowChild peerToWindowChild(WindowChildPeer peer) { + gpointer ptr = g_object_get_data(cast(GObject*)peer,"MinWinUserData"); + return cast(WindowChild)ptr; + } + void setWindowChildPeer(Component c, WindowChildPeer peer,int peerState) { + g_object_set_data(cast(GObject*)peer,"MinWinUserData",cast(gpointer)peer); + g_signal_connect_data(peer,"destroy", + cast(GCallback)&mw_wcdestroy_callback, + cast(gpointer)c, + null,GConnectFlags.G_CONNECT_AFTER); + c.hasPeer = peerState; + } + extern (C) + void mw_wcdestroy_callback(GtkObject w, gpointer ud) { + Component wc = cast(Component) ud; + if (wc && (wc.hasPeer == OWNS_PEER)) { + wc.hasPeer = NO_PEER; + } + } +} + +// assumes the peer has already been parented to the result of +// parent.getPeerForAdd +class PeerWrapper : WindowChild { + this(Component parent, WindowChildPeer peer) { + this.peer = peer; + setWindowChildPeer(this,peer,FOREIGN_PEER); + parent.addChild(this); + } + mixin WindowChildImpl!(); +} diff --git a/samples/minwin_gtk/minwin/readme.txt b/samples/minwin_gtk/minwin/readme.txt new file mode 100644 index 0000000..c7c44dc --- /dev/null +++ b/samples/minwin_gtk/minwin/readme.txt @@ -0,0 +1,9 @@ +MinWin originally written by Ben Hinkle. + +Updated on 20060520 by Christopher E. Miller. +My changes are donated to the MinWin project. + +Updated on 20061128 by Tomas L. Olsen. +It should now compile using DMD 0.175. + +http://www.dprogramming.com/minwin.php diff --git a/samples/minwin_gtk/minwin/samples/CMakeLists.txt b/samples/minwin_gtk/minwin/samples/CMakeLists.txt new file mode 100644 index 0000000..4316ad6 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/CMakeLists.txt @@ -0,0 +1,37 @@ +SET(CMAKE_FIND_LIBRARY_PREFIXES "") +SET(CMAKE_FIND_LIBRARY_SUFFIXES ".so") + +FIND_PACKAGE (GTK2) + +IF (GTK2_FOUND) + INCLUDE_DIRECTORIES (${minwin_gtk_SOURCE_DIR} ${GTK2_INCLUDE_DIRS}) + LINK_DIRECTORIES (${minwin_gtk_SOURCE_DIR} ${GTK2_LIBRARY_DIRS}) + + ADD_EXECUTABLE (sample sample.d) + TARGET_LINK_LIBRARIES (sample minwin_gtk) + + ADD_EXECUTABLE (layout layout.d) + TARGET_LINK_LIBRARIES (layout minwin_gtk) + + ADD_EXECUTABLE (topgroup topgroup.d) + TARGET_LINK_LIBRARIES (topgroup minwin_gtk) + + ADD_EXECUTABLE (widgets widgets.d) + TARGET_LINK_LIBRARIES (widgets minwin_gtk) + + ADD_EXECUTABLE (menus menus.d) + TARGET_LINK_LIBRARIES (menus minwin_gtk) + + ADD_EXECUTABLE (painting painting.d) + TARGET_LINK_LIBRARIES (painting minwin_gtk) + + ADD_EXECUTABLE (sdialog sdialog.d) + TARGET_LINK_LIBRARIES (sdialog minwin_gtk) + + ADD_EXECUTABLE (sdialog2 sdialog2.d) + TARGET_LINK_LIBRARIES (sdialog2 minwin_gtk) + + ADD_EXECUTABLE (idle idle.d) + TARGET_LINK_LIBRARIES (idle minwin_gtk) + +ENDIF (GTK2_FOUND) \ No newline at end of file diff --git a/samples/minwin_gtk/minwin/samples/idle.d b/samples/minwin_gtk/minwin/samples/idle.d new file mode 100644 index 0000000..744a614 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/idle.d @@ -0,0 +1,40 @@ +/* Sample MinWin application: idle processing + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.samples.idle; + +import minwin.all; +import std.random; +import std.string; +import std.utf; + +extern (C) +int MinWinMain(Application* app) { + Window win = new Window("Idle processing"); + char[] text = "Idle processing..."; + char[] cur = ""; + win.quitOnDestroy = true; + win.paintDelegate ~= delegate void(Component source, GContext gc) { + auto Font font = new Font("",14,FontWeight.Bold); + Font oldfont = gc.setFont(font); + gc.drawText(100,100,text); + gc.setFont(oldfont); + }; + win.keyDelegate ~= delegate void(Component source, KeyEvent* event) { + if (event.id == KeyPressedEvent) { + char[4] buf; + cur = toUTF8(buf,event.keyCode).dup; + } + }; + app.idleTime = 1000; // every second + app.idleDelegate ~= delegate void() { + text = cur ~ " " ~ toString(rand()); + win.repaint(); + }; + win.visible = true; + return app.enterEventLoop(); +} diff --git a/samples/minwin_gtk/minwin/samples/layout.d b/samples/minwin_gtk/minwin/samples/layout.d new file mode 100644 index 0000000..bf8a21c --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/layout.d @@ -0,0 +1,84 @@ +/* Sample MinWin application: layout and groups + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.samples.layout; + +import minwin.all; +import std.random; +import std.string; + +extern (C) +int MinWinMain(Application* app) { + + Window win = new Window("Layout Sample"); + char[] text = "Click the Random number button"; + win.quitOnDestroy = true; + + // set table layout + static double[3] yy = [.3, .2, .5]; + static double[2] xx = [.5,.5]; + win.layoutMgr = new TableLayout(xx,yy); + + // define some buttons to put in the table + Button b1 = new Button(win,"Random number"); + Button b2 = new Button(win,"hide groups"); + Button b3 = new Button(win,"hide layout"); + + // define a group to put in the table + Group g = new Group(win); + FlowLayout flow = new FlowLayout(); + flow.sideStretch = true; + g.layoutMgr = flow; + Button sub1 = new Button(g,"click random"); + Button sub2 = new Button(g,"sub2"); + + // make a sub-group of g + Group g2 = new Group(g); + flow = new FlowLayout(Dir.Horizontal); + flow.flowReverse = 1; + g2.layoutMgr = flow; + Button sub3 = new Button(g2,"sub3"); + Button sub4 = new Button(g2,"sub4"); + Button sub5 = new Button(g2,"sub5"); + + Button b4 = new Button(win,"b3"); + + // define actions + b1.actionDelegate ~= delegate void(Component source) { + sub1.text = toString(rand()); + }; + b2.actionDelegate ~= delegate void(Component source) { + g.visible = !g.visible; + }; + b3.actionDelegate ~= delegate void(Component source) { + // remove from layout computations + g.parentOwnsLayout = !g.parentOwnsLayout; + }; + + win.pack(); + win.visible = true; + + Window win2 = new Window("Border Layout Sample"); + win2.quitOnDestroy = true; + BorderLayout bl = new BorderLayout(); + Button w2b1 = new Button(win2,"north"); + bl.location[Loc.North] = w2b1; + Button w2b2 = new Button(win2,"south"); + bl.location[Loc.South] = w2b2; + Button w2b3 = new Button(win2,"east"); + bl.location[Loc.East] = w2b3; + Button w2b4 = new Button(win2,"west"); + bl.location[Loc.West] = w2b4; + Button w2b5 = new Button(win2,"center"); + bl.location[Loc.Center] = w2b5; + win2.layoutMgr = bl; + + win2.pack(); + win2.visible = true; + + return app.enterEventLoop(); +} diff --git a/samples/minwin_gtk/minwin/samples/linux.mak b/samples/minwin_gtk/minwin/samples/linux.mak new file mode 100644 index 0000000..f445245 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/linux.mak @@ -0,0 +1,23 @@ + +# To build the samples type "make -f win32.mak" + +#VER = Motif +#LIB = libminwin_motif.a +#XLIBS = -L-L/usr/X11R6/lib -L-lXm -L-lXt -L-lX11 -L-lImlib + +VER = GTK +LIB = libminwin_gtk.a +XLIBS = -L-L/usr/X11R6/lib -L-lgtk-x11-2.0 -L-lX11 + +DMD = dmd + +TARGETS= sample layout topgroup \ + widgets menus painting sdialog sdialog2 idle + +targets : $(TARGETS) + +% : %.d + $(DMD) -g ../$(LIB) -I../.. $(XLIBS) -version=$(VER) -of$@ $< -version=LOG + +clean: + - rm *.o $(TARGETS) diff --git a/samples/minwin_gtk/minwin/samples/menus.d b/samples/minwin_gtk/minwin/samples/menus.d new file mode 100644 index 0000000..c0fa075 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/menus.d @@ -0,0 +1,61 @@ +/* Sample MinWin application: Menus + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.samples.menus; + +import minwin.all; +import std.string; + +extern (C) +int MinWinMain(Application* app) { + Window win = new Window("Menu Sample"); + win.quitOnDestroy = true; + win.layoutMgr = new FlowLayout; + MenuBar mb = new MenuBar(win); + Menu file = new Menu(mb,"File"); + file.add("Open...",100); + file.addSeparator(); + file.add("Save...",234); + Menu edit = new Menu(mb,"Edit"); + edit.add("Hello",400); + edit.add("World",500); + char[] text = "select menu"; + win.commandDelegate ~= delegate void(Component source, int cmd) { + text = toString(cmd); + win.repaint(); + if (cmd == 100) { + // show open file dialog + FileDialogData data; + data.title = "Open File"; + if (openFileDialog(win,data)) { + text = "you selected " ~ data.result; + } + } else if (cmd == 234) { + // show save file dialog + FileFilter[2] filt; + filt[0].description = "Foo bar files"; + filt[0].extensions ~= "*.foo"; + filt[1].description = "All files"; + filt[1].extensions ~= "*"; + FileDialogData data; + data.title = "Save File"; + data.filter = filt; + if (saveFileDialog(win,data)) { + text = "you saved " ~ data.result; + } + } + }; + win.paintDelegate ~= delegate void(Component source, GContext gc) { + auto Font font = new Font("",12); + Font oldfont = gc.setFont(font); + gc.drawText(100,100,text); + gc.setFont(oldfont); + }; + + win.visible = true; + return app.enterEventLoop(); +} diff --git a/samples/minwin_gtk/minwin/samples/painting.d b/samples/minwin_gtk/minwin/samples/painting.d new file mode 100644 index 0000000..a6eec98 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/painting.d @@ -0,0 +1,81 @@ +/* Sample MinWin application: Graphics and painting + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.samples.painting; + +import minwin.all; + +extern (C) +int MinWinMain(Application* app) { + Window win = new Window("Painting Sample"); + win.quitOnDestroy = true; + + Image im = win.getCompatibleImage(100,150); + GContext gc = im.getGContext(); + + auto Pen p2 = new Pen(RGB(0,0,0)); + Pen oldPen = gc.setPen(p2); + Rect r = LTWH(0,0,100,150); + auto Brush b2 = new Brush(RGB(255,255,255)); + Brush oldBrush = gc.setBrush(b2); + gc.fillRect(r); + gc.drawRect(r); + gc.setBrush(oldBrush); + + PenData pd; + pd.width = 4; + pd.style = PenStyle.Solid; + pd.color = RGB(100,0,120); + auto Pen p = new Pen(&pd); + gc.setPen(p); + gc.drawLine(0,0,100,150); + gc.drawLine(100,0,0,150); + gc.drawLine(50,0,50,150); + gc.setPen(oldPen); + gc.dispose(); + + win.paintDelegate ~= delegate void(Component source, GContext pc) { + + auto Font font = new Font("", 20, FontWeight.Bold); + Font oldfont = pc.setFont(font); + pc.drawText(100,100,"testing"); + pc.setFont(oldfont); + + pc.drawLine(10,10,20,20); + pc.drawLine(30,10,35,50); + + static Point[3] pts = [{{40,10}}, {{45,50}}, {{50,30}}]; + pc.drawPolyline(pts); + + static Point[4] pts2 = [{{70,10}},{{75,50}},{{80,30}},{{90,10}}]; + pc.drawPolygon(pts2); + + static Point[4] pts3 = [{{100,10}},{{105,50}},{{110,30}},{{120,10}}]; + pc.fillPolygon(pts3); + + // try different line styles and colors + PenData pd; + pd.width = 4; + pd.color = RGB(100,200,0); + pd.style = PenStyle.Dash; + auto Pen p1 = new Pen(&pd); + Pen oldPen = pc.setPen(p1); + pc.drawLine(10,100,20,200); + + pd.color = RGB(0,200,200); + auto Pen p2 = new Pen(&pd); + pc.setPen(p2); + pc.drawLine(50,100,50,200); + + pc.setPen(oldPen); + + pc.drawImage(im,180,30); + }; + + win.visible = true; + return app.enterEventLoop(); +} diff --git a/samples/minwin_gtk/minwin/samples/sample.d b/samples/minwin_gtk/minwin/samples/sample.d new file mode 100644 index 0000000..b47a7e8 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/sample.d @@ -0,0 +1,67 @@ +/* Sample MinWin application to mimic winsamp.d + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ +module minwin.samples.sample; + +import minwin.all; +import minwin.logging; +import std.string; +version (Windows) { + import minwin.mswindows; +} + +extern (C) +int MinWinMain(Application* app) { + Window win = new Window("MinWin Sample"); + char[] text = "D Does Windows, Motif and GTK"; + win.quitOnDestroy = true; + win.paintDelegate ~= delegate void(Component source, GContext gc) { + FontData fd; + fd.size = 18; + fd.weight = FontWeight.Bold; + auto Font font = new Font(fd); + Font oldfont = gc.setFont(font); + gc.drawText(100,100,text); + gc.setFont(oldfont); + // Image im = win.loadCompatibleImage(44); + // gc.drawImage(im,200,200); + }; + + win.mouseDelegate ~= delegate void(Component source, MouseEvent* event) { + Point pt = event.point; + text = pt.toString ~ " " ~ toString(cast(int)event.id) ~ " " ~ toString(event.modifiers); + win.repaint(); + }; + + Button b = new Button(win,"Click me"); + Button b2 = new Button(win,"Don't click me"); + + // like winsamp.d place buttons by hand + Point s = b.preferredSize; + Rect r = LTWH(20,50,s.x,s.y); + b.setBounds(r); + s = b2.preferredSize; + r.LTWH(100,50,s.x,s.y); + b2.setBounds(r); + + // define actions to perform on button clicks + b.actionDelegate ~= delegate void(Component source) { + informationDialog(win, "Hello, world!", "Greeting"); + }; + b2.actionDelegate ~= delegate void(Component source) { + warningDialog(win, "You've been warned...", "Prepare to GP fault"); + *(cast(int*) null) = 666; + }; + + // show window + version (Windows) { + ShowWindow(win.peer,gApp.nCmdShow); + } else { + win.visible = true; + } + + return app.enterEventLoop(); +} diff --git a/samples/minwin_gtk/minwin/samples/sample.def b/samples/minwin_gtk/minwin/samples/sample.def new file mode 100644 index 0000000..71fd016 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/sample.def @@ -0,0 +1,2 @@ +EXETYPE NT +SUBSYSTEM WINDOWS,5.0 diff --git a/samples/minwin_gtk/minwin/samples/sample.exe.manifest b/samples/minwin_gtk/minwin/samples/sample.exe.manifest new file mode 100644 index 0000000..03098ea --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/sample.exe.manifest @@ -0,0 +1,23 @@ + + + +Sample MinWin application. + + + + + + + diff --git a/samples/minwin_gtk/minwin/samples/sample.rc b/samples/minwin_gtk/minwin/samples/sample.rc new file mode 100644 index 0000000..9451c7e --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/sample.rc @@ -0,0 +1,2 @@ +CREATEPROCESS_MANIFEST_RESOURCE_ID RT_MANIFEST "sample.exe.manifest" + diff --git a/samples/minwin_gtk/minwin/samples/sdialog.d b/samples/minwin_gtk/minwin/samples/sdialog.d new file mode 100644 index 0000000..ad63f15 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/sdialog.d @@ -0,0 +1,63 @@ +/* Sample dialog application with OOP style + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ +module minwin.samples.sdialog; + +import minwin.all; +import minwin.logging; + +class MyDialog : Dialog { + int result; + this(MyWindow win, char[] str) { + super(win,str); + layoutMgr = new FlowLayout; + Button clicked; + Button ok = new Button(this,"OK"); + Button cancel = new Button(this,"Cancel"); + CheckBox bb = new CheckBox(this,"this is a big check"); + CheckBox bb2 = new CheckBox(this,"this check"); + ok.actionDelegate ~= &okCallback; + cancel.actionDelegate ~= &cancelCallback; + pack(); + } + void okCallback(Component c) { + MyWindow win = cast(MyWindow)owner; + win.title = "you hit ok"; + result = 100; + visible = false; + } + void cancelCallback(Component c) { + MyWindow win = cast(MyWindow)owner; + win.title = "you hit cancel"; + result = 101; + visible = false; + } +} + +class MyWindow : Window { + this(char[] str) { + super(str); + layoutMgr = new FlowLayout; + Button but = new Button(this,"click me"); + but.actionDelegate ~= &doDialogCallback; + } + void doDialogCallback(Component c){doDialog();} + void doDialog() { + MyDialog dlg = new MyDialog(this,"hello"); + dlg.visible = true; + if (dlg.result == 0) { + title = "you destroyed the dialog"; + } + } +} + +extern (C) +int MinWinMain(Application* app) { + MyWindow win = new MyWindow("window"); + win.quitOnDestroy = true; + win.visible = true; + return app.enterEventLoop(); +} diff --git a/samples/minwin_gtk/minwin/samples/sdialog2.d b/samples/minwin_gtk/minwin/samples/sdialog2.d new file mode 100644 index 0000000..41ffa09 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/sdialog2.d @@ -0,0 +1,56 @@ +/* Sample dialog application with procedural style + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.samples.sdialog2; + +import minwin.all; + +const int OK = 100; +const int CANCEL = 101; +const char[] KEY = "result"; + +extern (C) +int MinWinMain(Application* app) { + Window win = new Window("window"); + win.quitOnDestroy = true; + win.layoutMgr = new FlowLayout; + Button but = new Button(win,"click me"); + but.actionDelegate ~= delegate void (Component c) { + Window w = cast(Window)c.parent; + Dialog dlg = new Dialog(w,"hit ok or cancel"); + dlg.layoutMgr = new FlowLayout; + Button ok = new Button(dlg,"OK"); + ok.cmd = OK; + Button cancel = new Button(dlg,"Cancel"); + cancel.cmd = CANCEL; + dlg.commandDelegate ~= delegate void(Component c, int cmd) { + Dialog dlg = cast(Dialog)c; + switch (cmd) { + case OK: + dlg.owner.title = "you hit ok"; + break; + case CANCEL: + dlg.owner.title = "you hit cancel"; + break; + default: assert(0); + } + // indicate a button was clicked + int* data = new int; + *data = cmd; + dlg.userdata[KEY] = data; + // end the dialog modality + dlg.visible = false; + }; + dlg.pack(); + dlg.visible = true; + if ((KEY in dlg.userdata) is null) { + w.title = "you destroyed the dialog"; + } + }; + win.visible = true; + return app.enterEventLoop(); +} diff --git a/samples/minwin_gtk/minwin/samples/topgroup.d b/samples/minwin_gtk/minwin/samples/topgroup.d new file mode 100644 index 0000000..e3c8ed0 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/topgroup.d @@ -0,0 +1,41 @@ +/* MinWin Sample: Groups of top-level windows + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.samples.topgroup; + +import minwin.all; + +extern (C) +int MinWinMain(Application* app) { + + Window win = new Window("Close window 2"); + win.cancelCloseDelegate ~= delegate bool(Component c) { + // we could pop up a confirm dialog but let's just say + // you can't destroy this window + return true; + }; + + Window win2 = new Window("Testing 2"); + win2.quitOnDestroy = true; + + Group g = new Group(null); + g ~= win; + g ~= win2; + + static double[2] x = [.5,.5]; + static double[1] y = [1]; + g.layoutMgr = new TableLayout(x,y); + + Rect r; + r.LTWH(100,100,600,300); + g.setBounds(r); + g.layout(false); + + g.visible = true; + + return app.enterEventLoop(); +} diff --git a/samples/minwin_gtk/minwin/samples/widgets.d b/samples/minwin_gtk/minwin/samples/widgets.d new file mode 100644 index 0000000..a845bd6 --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/widgets.d @@ -0,0 +1,80 @@ +/* Sample MinWin application: widgets + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.samples.widgets; + +import minwin.all; +import minwin.logging; +import std.utf; + +extern (C) +int MinWinMain(Application* app) { + Window win = new Window("Widgets"); + win.quitOnDestroy = true; + win.backgroundColor = systemBackgroundColor(); + win.layoutMgr = new FlowLayout; + + CheckBox b3 = new CheckBox(win,"check 1"); + CheckBox b4 = new CheckBox(win,"check 2"); + ToggleButton b5 = new ToggleButton(win,"toggle 1"); + + ToggleGroup g = new ToggleGroup; + GroupBox box = new GroupBox(win,"Group"); + box.layoutMgr = new FlowLayout; + RadioButton b1 = new RadioButton(box,"click me"); + RadioButton b2 = new RadioButton(box,"no, click me"); + g.addButton(b1); + g.addButton(b2); + g.select(0); + + Label lab = new Label(win,"This is a label"); + Text t1 = new Text(win,"single line"); + t1.userPreferredWidth = 60; + MultiLineText t2 = new MultiLineText(win,"multi line text area"); + t2.userPreferredSize(60,60); + + char[][] strs; + strs ~= "hello"; + strs ~= "world"; + strs ~= "bye"; + ComboBox combo = new ComboBox(win,strs); + combo.selection = 0; + + ListBox list = new ListBox(win,strs); + list.selection = 0; + list.userPreferredHeight = 60; + + Canvas p = new Canvas(win); + p.keyDelegate ~= delegate void(Component source, KeyEvent* event) { + if (event.id == KeyPressedEvent) { + char[4] buf; + win.title = "you hit the " ~ toUTF8(buf,event.keyChar) ~ " key"; + } + }; + p.paintDelegate ~= delegate void(Component source, GContext gc) { + assert(source !is null); + scope Brush b = new Brush(RGB(250,20,20)); + Brush oldBrush = gc.setBrush(b); + Rect r = LTWH(0,0,source.width(),source.height()); + gc.fillRect(r); + gc.setBrush(oldBrush); + }; + p.userPreferredSize(20,20); + + ScrollBar sb = new ScrollBar(win,Horizontal); + + ScrollPane sp = new ScrollPane(win); + MultiLineText t3 = new MultiLineText(sp,"This is a big text block that needs some scrolling maybe if we are lucky"); + t3.userPreferredSize(221,334); // make a large scrollable area + sp.userPreferredSize(100,100); + + win.pack(); + win.visible = true; + + p.requestFocus(); // on GTK must be made visible first + return app.enterEventLoop(); +} diff --git a/samples/minwin_gtk/minwin/samples/win32.mak b/samples/minwin_gtk/minwin/samples/win32.mak new file mode 100644 index 0000000..6763cdc --- /dev/null +++ b/samples/minwin_gtk/minwin/samples/win32.mak @@ -0,0 +1,14 @@ + +# To build the samples type "make -f win32.mak" + +DMD = dmd + +targets : sample.exe layout.exe topgroup.exe \ + widgets.exe menus.exe painting.exe sdialog.exe sdialog2.exe \ + idle.exe + +.d.exe : + $(DMD) sample.def comdlg32.lib gdi32.lib ..\minwin.lib ..\app.obj -I..\.. -of$@ $< -g -version=LOG + +clean: + - del *.obj *.exe diff --git a/samples/minwin_gtk/minwin/scroll.d b/samples/minwin_gtk/minwin/scroll.d new file mode 100644 index 0000000..732321f --- /dev/null +++ b/samples/minwin_gtk/minwin/scroll.d @@ -0,0 +1,319 @@ +/* MinWin Scroll classes + * + * ScrollBar and ScrollPane + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.scroll; + +public import minwin.component; + +private { + import minwin.app; + import minwin.window; + import minwin.peerimpl; + import std.string; + import minwin.logging; +} + +version (GTK) version = SharedScrollData; +version (SharedScrollData) { + struct ScrollData { + int min; + int max; + int increment; + int value; + } +} +enum ScrollMask { + Range = 1, Increment = 2, Value = 4 +} +const int Horizontal = 1; +const int Vertical = 2; + +version (MinWin32) { + + private import minwin.mswindows; + + alias SCROLLINFO ScrollData; + + class ScrollBar : WindowChild { + int orientation; + this(Component parent, int orientation, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + uint style = orientation==Horizontal?SBS_HORZ:SBS_VERT; + peer = CreateWindowA("SCROLLBAR","", + style | WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,gApp.hInstance,null); + sysAssert(peer !is null, "Failed to create peer scrollbar"); + this.name = name; + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + } + Point preferredSize() { + int width,height; + if (orientation == Vertical) { + height = 50; + width = 16; + } else { + height = 16; + width = 50; + } + if (userPreferredWidth > 0) + width = userPreferredWidth; + if (userPreferredHeight > 0) + height = userPreferredHeight; + return XY(width,height); + } + mixin WindowChildImpl!(); + + private uint windowsMask(uint mask) { + uint res = 0; + if (mask & ScrollMask.Range) + res |= SIF_RANGE; + if (mask & ScrollMask.Value) + res |= SIF_POS; + if (mask & ScrollMask.Increment) + res |= SIF_PAGE; + return res; + } + + void setData(inout ScrollData state, uint mask) { + state.cbSize = SCROLLINFO.sizeof; + state.fMask = windowsMask(mask); + SetScrollInfo(peer,SB_CTL,&state, false); + } + void getData(inout ScrollData state, uint mask) { + state.cbSize = SCROLLINFO.sizeof; + state.fMask = windowsMask(mask); + GetScrollInfo(peer,SB_CTL,&state); + } + int value() { + ScrollData state; + getData(state,ScrollMask.Value); + return state.nPos; + } + } + + class ScrollPane : WindowChild { + Point origin; + + // how to customize page size and steps and limits? need API to each scrollbar + + int hstep = 1; // given bounds of child this is how quickly to move through it + int vstep = 1; + + this(Component parent, int orientations = Horizontal | Vertical, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + int style; + if (orientations & Horizontal) style |= WS_HSCROLL; + if (orientations & Vertical) style |= WS_VSCROLL; + peer = CreateWindowA("MinWinScrollWindow","", + style | WS_CHILD | WS_VISIBLE, + 0,0,50,50,parentp, + cast(HMENU)0,gApp.hInstance,null); + this.name = name; + clearBackgroundOnPaint = false; + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + } + mixin WindowChildImpl!(); + + void layout(bool validateParent) { + if (parent && validateParent) + parent.layout(true); + if (childLayoutDirty && child) { + Point s = child.preferredSize; + Rect r = LTWH(origin.x,origin.y,s.x,s.y); + child.setBounds(r); + childLayoutDirty = false; + } + foreach( Component ch; this) { + ch.layout(false); + } + } + + int WindowProc(HWND hWnd, uint uMsg, WPARAM wParam, LPARAM lParam) { + version (LOG) log.printf(" in ScrollPane windowproc msg %d\n",uMsg); + bool doDefault = true; + if (uMsg == WM_HSCROLL) { + SCROLLINFO data; + data.cbSize = SCROLLINFO.sizeof; + data.fMask = SIF_ALL; + GetScrollInfo(hWnd, SB_HORZ, &data); + int cmd = LOWORD(wParam); + int oldPos = data.nPos; + if (cmd == SB_LINELEFT) data.nPos--; + if (cmd == SB_LINERIGHT) data.nPos++; + if (cmd == SB_PAGELEFT) data.nPos -= data.nPage; + if (cmd == SB_PAGERIGHT) data.nPos += data.nPage; + data.fMask = SIF_POS; + SetScrollInfo(hWnd, SB_HORZ, &data, true); + GetScrollInfo(hWnd, SB_HORZ, &data); + if (data.nPos != oldPos) { + int step = hstep*(oldPos-data.nPos); + ScrollWindowEx(hWnd,step,0,null,null,null,null,SW_INVALIDATE | SW_ERASE); + // ScrollWindow(hWnd,step,0,null,null); + if (child) { + WindowChild wc = cast(WindowChild)child; + MoveWindow(wc.getPeer,step,0,0,0,false); + UpdateWindow(wc.getPeer); + } + origin.XY(origin.x + step, origin.y); + } + doDefault = false; + } else if (uMsg == WM_VSCROLL) { + SCROLLINFO data; + data.cbSize = SCROLLINFO.sizeof; + data.fMask = SIF_ALL; + GetScrollInfo(hWnd, SB_VERT, &data); + int cmd = LOWORD(wParam); + int oldPos = data.nPos; + if (cmd == SB_LINEUP) data.nPos--; + if (cmd == SB_LINEDOWN) data.nPos++; + if (cmd == SB_PAGEUP) data.nPos -= data.nPage; + if (cmd == SB_PAGEDOWN) data.nPos += data.nPage; + data.fMask = SIF_POS; + SetScrollInfo(hWnd, SB_VERT, &data, true); + GetScrollInfo(hWnd, SB_VERT, &data); + if (data.nPos != oldPos) { + int step = vstep*(oldPos-data.nPos); + ScrollWindowEx(hWnd,0,step,null,null,null,null,SW_INVALIDATE | SW_ERASE); + // ScrollWindow(hWnd,0,step,null,null); + if (child) { + WindowChild wc = cast(WindowChild)child; + MoveWindow(wc.getPeer,0,step,0,0,false); + UpdateWindow(wc.getPeer); + } + origin.XY(origin.x, origin.y + step); + } + doDefault = false; + } + return doDefault; + } + } + + extern(Windows) int MinWinScrollWindowProc(HWND hWnd, uint uMsg, WPARAM wParam, LPARAM lParam) { + version(LOG) log.printf("in minwin scroll window proc hwnd %p %d %d %d\n",hWnd,uMsg,wParam,lParam); + bool doDefault = true; + ScrollPane pane = cast(ScrollPane)peerToWindowChild(hWnd); + version(LOG) log.printf("in minwin scroll window proc win %p\n",pane); + if (pane !is null) + doDefault = pane.WindowProc(hWnd,uMsg,wParam,lParam) != 0; + if (doDefault) + return DefWindowProcA(hWnd, uMsg, wParam, lParam); + else + return 0; + } + static this() { + HINSTANCE hInst = GetModuleHandleA(null); + WNDCLASSA wc; + wc.lpszClassName = "MinWinScrollWindow"; + wc.style = CS_CLASSDC | CS_HREDRAW | CS_VREDRAW; + wc.lpfnWndProc = &MinWinScrollWindowProc; + wc.hInstance = hInst; + wc.hIcon = LoadIconA(cast(HINSTANCE) null, IDI_APPLICATION); +// wc.hIconSm = DefaultWindowSmallIcon.peer; + wc.hCursor = LoadCursorA(cast(HINSTANCE) null, IDC_ARROW); + wc.hbrBackground = cast(HBRUSH) (COLOR_WINDOW + 1); // not +1 for default + wc.lpszMenuName = null; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + RegisterClassA(&wc); + } + +} else version (GTK) { + + private import minwin.gtk; + private import minwin.gtk_peers; + + class ScrollBar : WindowChild { + this(Component parent, int orientation, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + if (orientation == Horizontal) + peer = gtk_hscrollbar_new(null); + else + peer = gtk_vscrollbar_new(null); + gtk_container_add(cast(GtkContainer*)parentp,peer); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + gtk_widget_realize(peer); + visible = true; + } + + mixin WindowChildImpl!(); + + } + + class ScrollPane : WindowChild { + MinWinGtkPeer* content; + this(Component parent, int orientations = Horizontal | Vertical, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + peer = gtk_scrolled_window_new(null,null); + gtk_container_add(cast(GtkContainer*)parentp,peer); + GtkWidget* view = gtk_viewport_new(null,null); + gtk_container_add(cast(GtkContainer*)peer,view); + + // add our peer to hook into GTK size allocation algorithm + GtkWidget* wcontent = MinWinGtkPeer_new(); + content = cast(MinWinGtkPeer*)wcontent; + gtk_widget_set_sensitive(wcontent,true); + content.sizeRequest = >kRequest; + content.sizeAllocate = >kAllocate; + gtk_container_add(cast(GtkContainer*)view,wcontent); + + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + + // are all of these really needed? + gtk_widget_realize(wcontent); + gtk_widget_show(wcontent); + gtk_widget_realize(view); + gtk_widget_show(view); + gtk_widget_realize(peer); + visible = true; + } + + mixin WindowChildImpl!(); + + void layout(bool validateParent) { + if (parent && validateParent) + parent.layout(true); + childLayoutDirty = false; + } + + PeerForAdd getPeerForAdd() { + return cast(GtkWidget*)content; + } + + // callback from the GTK peer asking for preferred size + private void gtkRequest(GtkWidget *w, GtkRequisition* req) { + version(LOG)log.writefln("gtkRequest for scrollpane"); + Component ch = child; + if (ch is null) return; + Point s = ch.preferredSize; + req.width = s.x; + req.height = s.y; + version(LOG)log.writefln("done gtkRequest for scrollpane"); + } + + // callback from GTK peer telling us our position + private void gtkAllocate(GtkWidget *w, GtkAllocation* req) { + version(LOG)log.writefln("gtkAllocate for scrollpane"); + Component ch = child; + if (ch is null) return; + Rect r = toRect(*req); + ch.size = XY(r.width,r.height); + ch.layout(false); + childLayoutDirty = false; + version(LOG)log.writefln("done gtkAllocate for scrollpane"); + } + + } +} diff --git a/samples/minwin_gtk/minwin/text.d b/samples/minwin_gtk/minwin/text.d new file mode 100644 index 0000000..7ec6b91 --- /dev/null +++ b/samples/minwin_gtk/minwin/text.d @@ -0,0 +1,172 @@ +/* MinWin Text class + * + * A single or multi-line editable text area + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.text; + +public import minwin.component; + +private { + import minwin.app; + import minwin.window; + import minwin.peerimpl; + import std.string; + import std.c.string; + import minwin.logging; +} + +version (MinWin32) { + + private import minwin.mswindows; + + template TextPrefSizeImpl() { + Point preferredSize() { + HDC dc = GetDC(peer); + sysAssert(dc !is null, "Failed to get label DC in preferredSize"); + SIZE s; + try { + Font f = standardFont(StandardFont.Gui); + HFONT oldfont = SelectObject(dc,f.peer); + sysAssert(oldfont !is null, "Failed to get Text font in preferredSize"); + BOOL ok; + int len; + if (useWfuncs) { + wchar[128] buf; + len = SendMessageW(peer,WM_GETTEXT,cast(WPARAM)128,cast(LPARAM)buf.ptr); + ok = GetTextExtentPoint32W(dc,buf.ptr,len,&s); + } + else { + char[128] buf; + len = SendMessageA(peer,WM_GETTEXT,cast(WPARAM)128,cast(LPARAM)buf.ptr); + ok = GetTextExtentPoint32A(dc,buf.ptr,len,&s); + } + SelectObject(dc,oldfont); + sysAssert(ok != false, "Failed to get text extents in preferredSize"); + } finally { + ReleaseDC(peer,dc); + } + int width = s.cx; + int height = s.cy; + if (userPreferredWidth() > 0) + width = userPreferredWidth(); + if (userPreferredHeight() > 0) + height = userPreferredHeight(); + return XY(width,height); + } + } + + class Text : WindowChild { + this(Component parent, char[] text = "", char[] name = "") { + HINSTANCE hInst = GetModuleHandleA(null); + PeerForAdd parentp = parent.getPeerForAdd(); + peer = CreateWindowX("EDIT",text, + ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE, + 0,0,20,20,parentp, + cast(HMENU)0,hInst,null); + sysAssert(peer !is null, "Failed to create peer Text"); + this.name = name; + Font f = standardFont(StandardFont.Gui); + SendMessageA(peer,WM_SETFONT,cast(WPARAM)f.peer,0); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + version(LOG) log.writefln("done making text edit"); + } + mixin TextPrefSizeImpl!(); + mixin WindowChildImpl!(); + } + class MultiLineText : WindowChild { + this(Component parent, char[] text = "", char[] name = "") { + HINSTANCE hInst = GetModuleHandleA(null); + PeerForAdd parentp = parent.getPeerForAdd(); + peer = CreateWindowX("EDIT",text, + ES_MULTILINE | WS_CHILD | WS_VISIBLE, + 0,0,10,10,parentp, + cast(HMENU)0,hInst,null); + sysAssert(peer !is null, "Failed to create peer MultiLineText"); + this.name = name; + Font f = standardFont(StandardFont.Gui); + SendMessageA(peer,WM_SETFONT,cast(WPARAM)f.peer,0); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + } + mixin TextPrefSizeImpl!(); + mixin WindowChildImpl!(); + } + +} else version (GTK) { + + private import minwin.gtk; + + class Text : WindowChild { + this(Component parent, char[] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + char* str = toStringz(text); + peer = gtk_entry_new(); + gtk_entry_set_text(cast(GtkEntry*)peer,str); + gtk_container_add(cast(GtkContainer*)parentp,peer); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + gtk_widget_realize(peer); + visible = true; + } + + mixin WindowChildImpl!(); + + char[] text() { + char* str; + str = gtk_entry_get_text(cast(GtkEntry*)peer); + if (str is null) + return ""; + else + return str[0..strlen(str)].dup; + } + + void text(char[] c) { + char* str = toStringz(c); + gtk_entry_set_text(cast(GtkEntry*)peer,str); + } + } + + class MultiLineText : WindowChild { + this(Component parent, char[] text, char[] name = "") { + PeerForAdd parentp = parent.getPeerForAdd(); + this.name = name; + char* str = toStringz(text); + peer = gtk_text_view_new(); + GtkTextView* view = cast(GtkTextView*)peer; + GtkTextBuffer* buf = gtk_text_view_get_buffer(view); + gtk_text_buffer_set_text(buf,text.ptr,text.length); + gtk_text_view_set_wrap_mode(view,GtkWrapMode.GTK_WRAP_WORD); + gtk_container_add(cast(GtkContainer*)parentp,peer); + setWindowChildPeer(this,peer,OWNS_PEER); + parent.addChild(this); + gtk_widget_realize(peer); + visible = true; + } + + mixin WindowChildImpl!(); + + char[] text() { + char* str; + GtkTextBuffer* buffer =gtk_text_view_get_buffer(cast(GtkTextView*)peer); + // str = gtk_text_buffer_get_text(buffer,0); + assert(false); // TODO + if (str is null) + return ""; + else + return str[0..strlen(str)].dup; + } + + void text(char[] c) { + GtkTextView* view = cast(GtkTextView*)peer; + GtkTextBuffer* buf = gtk_text_view_get_buffer(view); + gtk_text_buffer_set_text(buf,c.ptr,c.length); + } + } +} diff --git a/samples/minwin_gtk/minwin/todo b/samples/minwin_gtk/minwin/todo new file mode 100644 index 0000000..30092a5 --- /dev/null +++ b/samples/minwin_gtk/minwin/todo @@ -0,0 +1,56 @@ +* clean up build response files: brf. It seems like comments are not +allowed so I'll put the comments here. On linux the build will fail since +it uses Windows commands for creating a library. If the build fails with +"lib not found" or something run +ar -r libminwin_gtk.a *.o +Get build from www.dsource.org and run with +build @gtk.brf or @win32.brf + +* x11 + - font/fontset/encoding + - window resizing/repaint DONE + +* mswindows + - A vs W for string inputs - convert to wchar (DONE except for save/openFileDialog) + +* events: key, mouse DONE (well, some mouse) +* event: window, focus, window-destroy etc etc +* canvas DONE +* framed panel DONE +* layout mgr DONE +* label DONE +* cursor control +* List widget +* group-component DONE +* images/offscreen rendering DONE +* GXContext extensions for gdi+ and fancy drawing +* color mgnt needed? just assume true-color on X DONE-true-color +* double-buffering +* abstract button DONE +* toggle/radio button DONE +* text widgets DONE +* selection/clipboard +* modal/nonmodal dialog DONE +* util dialog boxes DONE(file) +* screen access +* cmd line parsing +* printing (where supported) +* scroll pane/scroll bars DONE +* sash +* menus DONE(basic) +* context menus/popup menus +* layout min/max size and +* layout hide on overflow DONE + +requests: + window title getter DONE + custom window background color (not just white) DONE + get pen and font data from peers + test image, brush on gtk DONE + fillPolygon on Windows + +bugs: + dropdown on windows doesn't work + GroupBox doesn't let radio buttons switch + list on gtk is squished + border layout completely untested diff --git a/samples/minwin_gtk/minwin/unittest.d b/samples/minwin_gtk/minwin/unittest.d new file mode 100644 index 0000000..73b28a5 --- /dev/null +++ b/samples/minwin_gtk/minwin/unittest.d @@ -0,0 +1,17 @@ +/* MinWin unittest + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +import minwin.all; + +extern (C) +int MinWinMain(Application* app) { + Point p = XY(100,100); + Group g = new Group(null); + app.rsrc("100"); + return 0; +} + diff --git a/samples/minwin_gtk/minwin/win32.brf b/samples/minwin_gtk/minwin/win32.brf new file mode 100644 index 0000000..e7fe5a7 --- /dev/null +++ b/samples/minwin_gtk/minwin/win32.brf @@ -0,0 +1,9 @@ +all.d +logging.d +-version=MinWin32 +-allobj +-Tminwin.lib +-I.. +-lib +-g +-w diff --git a/samples/minwin_gtk/minwin/win32.mak b/samples/minwin_gtk/minwin/win32.mak new file mode 100644 index 0000000..60d6df0 --- /dev/null +++ b/samples/minwin_gtk/minwin/win32.mak @@ -0,0 +1,87 @@ + +# To build minwin.lib type "make -f win32.mak" +# The minwin.lib and object files will be created in the source directory. + +# flags to use building unittest.exe +DUNITFLAGS=-g -unittest -I.. + +# flags to use when building the minwi.lib library +#DLIBFLAGS=-O -release -I.. +DLIBFLAGS=-g -I.. + +DMD = dmd +LIB = lib + +targets : minwin + +#unittest : unittest.exe + +LIBNAME = minwin.lib + +minwin : $(LIBNAME) + +SRC = app.d \ + window.d \ + peerimpl.d \ + paint.d \ + font.d \ + logging.d \ + geometry.d \ + mswindows.d \ + multidg.d \ + component.d \ + button.d \ + menu.d \ + event.d \ + icon.d \ + dialog.d \ + group.d \ + image.d \ + peer.d \ + label.d \ + text.d \ + combo.d \ + listbox.d \ + canvas.d \ + scroll.d \ + layout.d + +OBJS = app.obj \ + window.obj \ + peerimpl.obj \ + paint.obj \ + font.obj \ + logging.obj \ + geometry.obj \ + mswindows.obj \ + multidg.obj \ + component.obj \ + button.obj \ + menu.obj \ + event.obj \ + icon.obj \ + dialog.obj \ + group.obj \ + image.obj \ + peer.obj \ + label.obj \ + text.obj \ + combo.obj \ + listbox.obj \ + canvas.obj \ + scroll.obj \ + layout.obj + +.d.obj : + $(DMD) -c $(DLIBFLAGS) -of$@ $< + +$(LIBNAME) : $(OBJS) $(SRC) + $(LIB) -c $@ $(OBJS) + +#unittest.exe : $(LIBNAME) $(SRC) +# $(DMD) $(DUNITFLAGS) unittest.d -ofunittest.exe $(SRC) + +clean: + - del *.obj + - del $(LIBNAME) + - del unittest.exe diff --git a/samples/minwin_gtk/minwin/window.d b/samples/minwin_gtk/minwin/window.d new file mode 100644 index 0000000..523121e --- /dev/null +++ b/samples/minwin_gtk/minwin/window.d @@ -0,0 +1,826 @@ +/* MinWin Window class + * + * An AbstractWindow is a top-level window. Concrete subclasses + * are Window and Dialog. + * + * Written by Ben Hinkle and released to the public domain, as + * explained at http://creativecommons.org/licenses/publicdomain + * Report comments and bugs at dsource: http://www.dsource.org/projects/minwin + */ + +module minwin.window; + +private { + import std.string; + import std.c.string; + import minwin.peerimpl; + import minwin.font; + import minwin.event; + import minwin.component; + import minwin.menu; + import minwin.app; + import minwin.paint; + import minwin.logging; + import minwin.icon; + import minwin.image; +} + +int DefaultWindowWidth = 400; +int DefaultWindowHeight = 300; +Icon DefaultWindowIcon; +Icon DefaultWindowSmallIcon; + +version (MinWin32) { + public import std.utf : toUTF16z, toUTF16, toUTF8; +} + +template CommonEventSourceImpl() { + version (MinWin32) { + HBRUSH backgroundPeer; + void repaintNow() { + UpdateWindow(peer); + } + + GContext getGContext() { + GContext gc = newGContext(); + gc.peer = GetDC(peer); + sysAssert(gc.peer !is null, "Failed to get DC in getGContext"); + gc.hasPeer = OWNS_PEER; + gc.release = true; + gc.hwnd = peer; + return gc; + } + + Image getCompatibleImage(int width, int height) { + HDC dc = GetDC(peer); + sysAssert(dc !is null, "Failed to get DC in getCompatibleImage"); + ImagePeer bm = CreateCompatibleBitmap(dc,width,height); + sysAssert(bm !is null, "Failed to create compatible bitmap"); + version(LOG) log.writefln("create bitmap %x",cast(int)bm); + Image res = new Image(bm); + res.width = width; + res.height = height; + res.hasPeer = OWNS_PEER; + ReleaseDC(peer,dc); + return res; + } + + Image loadCompatibleImage(char[] imageKey, char[] fmt = "bmp") { + // TODO: use fmt + ImagePeer bm; + if (useWfuncs) + bm = LoadImageW(gApp.hInstance,toUTF16z(imageKey),IMAGE_BITMAP,0,0,0); + else + bm = LoadImageA(gApp.hInstance,toMBSz(imageKey),IMAGE_BITMAP,0,0,0); + sysAssert(bm !is null, format("Failed to load image %s",imageKey)); + BITMAP bm_data; + int ok = GetObjectA(bm,bm_data.sizeof,&bm_data); + sysAssert(ok != false, "Failed to get bitmap data in loadCompatibleImage"); + version(LOG) log.writefln("create bitmap %x",cast(int)bm); + Image res = new Image(bm); + res.width = bm_data.bmWidth; + res.height = bm_data.bmHeight; + res.hasPeer = OWNS_PEER; + return res; + } + + } else version (GTK) { + void repaintNow(Event* paintEvent = null) { + layout(true); + if (!paintDelegate.isEmpty) { + GContext gc = getGContext(paintEvent); + paintDelegate(this,gc); + gc.dispose(); + } + } + } +} + +template CommonWindowImpl() { + static AbstractWindow[AbstractWindow] WindowList; + bool quitOnDestroy; + + void doCommand(int cmd) { + commandDelegate(this,cmd); + } + + MultiDelegate!(Component, GContext) paintDelegate; + MultiDelegate!(Component, GXContext) paintXDelegate; + MultiDelegate!(Component, int) commandDelegate; + MultiBoolDelegate!(Component) cancelCloseDelegate; // don't quit if bool is true + + // events + MultiDelegate!(Component, KeyEvent*) keyDelegate; + MultiDelegate!(Component, MouseEvent*) mouseDelegate; + MultiDelegate!(Component, WindowEvent*) windowDelegate; + + Point preferredSize() { + Point s; + if (layoutMgr) { + s = layoutMgr.preferredSize(this); + } else { + s.x = DefaultWindowWidth; + s.y = DefaultWindowHeight; + } + if (userPreferredWidth > 0) + s.x = userPreferredWidth; + if (userPreferredHeight > 0) + s.y = userPreferredHeight; + return s; + } +} + +version (MinWin32) { + + private import minwin.mswindows; + + alias HWND WindowPeer; + + const int MinWinWindowStyle = WS_OVERLAPPEDWINDOW; + + // Get the Window object associated with the given peer. + // The peer is accessed from the Window using the peer property. + AbstractWindow peerToWindow(WindowPeer peer) { + return cast(AbstractWindow)cast(void*)GetWindowLongA(peer,GWL_USERDATA); + } + // Associate c with the peer. This overwrites the window UserData. + void setWindowPeer(AbstractWindow c, WindowPeer peer, int peerState) { + SetWindowLongA(peer,GWL_USERDATA,cast(int)cast(void*)c); + c.hasPeer = peerState; + } + class AbstractWindow : Component { + WindowPeer peer; + MenuBar menubar; + + mixin CommonWindowImpl!(); + + void title(char[] str) { + BOOL ok; + if (useWfuncs) + ok = SetWindowTextW(peer,toUTF16z(str)); + else + ok = SetWindowTextA(peer,toMBSz(str)); + sysAssert(ok != false, "Failed to set window title"); + } + + char[] title() { + if (useWfuncs) { + wchar[64] res; + int len = GetWindowTextW(peer,res.ptr,res.length); + return toUTF8(res[0..len]); + } + else { + char[64] res; + int len = GetWindowTextA(peer,res.ptr,res.length); + return fromMBSz(res[0..len].ptr); + } + } + + PeerForAdd getPeerForAdd() { return peer; } + + void disposePeer() { + if (hasPeer == OWNS_PEER) { + BOOL ok = DestroyWindow(peer); + sysAssert(ok != false, "Failed to destroy window"); + } + hasPeer = NO_PEER; + //delete WindowList[this]; // remove global reference + WindowList.remove(this); // remove global reference + } + + void close() { + SendMessageA(peer,WM_CLOSE,0,0); + } + + void visible(bool vis) { + ShowWindow(peer,vis ? SW_SHOW : SW_HIDE); // ignore bool result + } + + bool visible() { + return IsWindowVisible(peer) != 0; + } + + void enabled(bool ena) { + EnableWindow(peer, ena); + } + bool enabled() { + return IsWindowEnabled(peer) == TRUE; + } + + void backgroundColor(Color c) { + version(LOG) log.writefln("making background %d %d %d", + cast(int)c.red, + cast(int)c.green, + cast(int)c.blue); + if (backgroundPeer) + DeleteObject(backgroundPeer); + backgroundPeer = CreateSolidBrush(c.native); + // use GetSysColorBrush? + } + + // returns client bounds in screen coordinates + void getBounds(inout Rect r) { + BOOL ok = GetClientRect(peer,&r.native); + sysAssert(ok != false, "Failed to get client rect"); + Point pt = XY(r.left,r.top); + ClientToScreen(peer,&pt.native); + int x,y; + if (parent) parent.getPeerOffset(x,y); + r.LTWH(pt.x+x,pt.y+y,r.width,r.height); + } + + // should be the same as AdjustWindowRect but it seems like + // that doesn't account for the title bar. + protected final void adjustBounds(inout Rect r) { + BOOL ok = AdjustWindowRect(&r.native,MinWinWindowStyle,menubar !is null); + sysAssert(ok != false, "Failed to adjust window bounds"); + } + + void setBounds(inout Rect r) { + Rect r2 = r; + adjustBounds(r2); + int x,y; + if (parent) parent.getPeerOffset(x,y); + BOOL ok = MoveWindow(peer,r2.left+x,r2.top+y,r2.width,r2.height,true); + sysAssert(ok != false, "Failed to move window in setBounds"); + childLayoutDirty = true; + } + + alias Component.size size; + void size(Point s) { + Rect r; + getBounds(r); + r.width = s.x; + r.height = s.y; + adjustBounds(r); + BOOL ok = MoveWindow(peer,r.left,r.top,r.width,r.height,true); + sysAssert(ok != false, "Failed to move window in size"); + childLayoutDirty = true; + } + + void toFront() { + BOOL ok = BringWindowToTop(peer); + sysAssert(ok != false, "Failed to bring window to front"); + } + + // mark as needing a repaint and post event to event queue + void repaint() { + InvalidateRect(peer,null,clearBackgroundOnPaint); + super.repaint(); + } + + void repaint(inout Rect r) { + InvalidateRect(peer,&r.native,clearBackgroundOnPaint); + } + + mixin CommonEventSourceImpl!(); + + int WindowProc(HWND hWnd, uint uMsg, WPARAM wParam, LPARAM lParam) { + //version (LOG) log.printf(" in windowproc msg %x LowW %x HiW %x L %x\n", + //uMsg,cast(int)LOWORD(wParam),cast(int)HIWORD(wParam),lParam); + bool doDefault = true; + if (uMsg <= WM_KEYLAST && uMsg >= WM_KEYFIRST) { + // version(LOG) log.writefln("got key event %d %d",uMsg,wParam); + keyDelegate(this, cast(KeyEvent*)&gApp.event); + } else if (uMsg <= WM_MOUSELAST && uMsg >= WM_MOUSEFIRST) { + mouseDelegate(this, cast(MouseEvent*)&gApp.event); + } else { + switch (uMsg) { + case WM_COMMAND: + // version (LOG) log.printf(" got command %x %x from %x\n", + // HIWORD(wParam),LOWORD(wParam),lParam); + Component c = peerToWindowChild(cast(HWND)lParam); + // version (LOG) log.printf(" got pointer %p\n",c); + if (c !is null) { + c.doCommand(wParam); + } else { + doCommand(LOWORD(wParam)); + } + break; + case WM_PAINT: + // version (LOG) log.writefln(" got paint"); + layout(true); + GContext gc = newGContext(); + gc.peer = BeginPaint(peer, &gc.paintstruct); + sysAssert(gc.peer !is null, "Failed to get DC in repaintNow"); + // version(LOG)log.writefln("Paint rect: %s",toRect(gc.paintstruct.rcPaint).toString); + gc.hasPeer = FOREIGN_PEER; // don't call DisposeDC + if (clearBackgroundOnPaint && backgroundPeer) { + Point s = super.size; + Rect r = LTWH(0,0,s.x,s.y); + // version(LOG)log.writefln("painting background %d %d",width,height); + FillRect(gc.peer,&r.native,backgroundPeer); + } + if (!paintDelegate.isEmpty) { + paintDelegate(this,gc); + } + EndPaint(peer, &gc.paintstruct); + gc.dispose(); + break; + /* + case CBN_DROPDOWN: + // TODO: doesn't work! + Rect r; + HWND ctrl = cast(HWND)lParam; + BOOL ok = GetWindowRect(ctrl,&r.native); + // sysAssert(ok != false, "Failed to get drop down bounds"); + + // BOOL ok = SendMessageA(ctrl,CB_GETDROPPEDCONTROLRECT,0,cast(LPARAM)&r); + // sysAssert(ok != false, "Failed to get drop down bounds"); + int height1 = SendMessageA(ctrl,CB_GETITEMHEIGHT,cast(WPARAM)-1,0); + int n = SendMessageA(ctrl,CB_GETITEMHEIGHT,cast(WPARAM)0,0); + version(LOG)log.writefln("got drop down command %d %d",height1,n); + // MoveWindow(peer,rectL(r),rectR(r),rectW(r),height1+n,false); + // MoveWindow(ctrl,rectL(r),rectR(r),rectW(r),rectH(r),false); + break; + */ + case WM_SIZE: + case WM_SIZING: + // version (LOG) log.writefln(" got size"); + childLayoutDirty = true; + if (!windowDelegate.isEmpty) { + WindowEvent event; + event.native.hwnd = hWnd; + event.native.wParam = wParam; + event.native.lParam = lParam; + event.native.message = uMsg; + windowDelegate(this, &event); + } + break; + case WM_MOVE: + case WM_MOVING: + // version (LOG) log.writefln(" got move"); + if (!windowDelegate.isEmpty) { + WindowEvent event; + event.native.hwnd = hWnd; + event.native.wParam = wParam; + event.native.lParam = lParam; + event.native.message = uMsg; + windowDelegate(this, &event); + } + break; + case WM_CLOSE: + version (LOG) log.writefln(" got close"); + doDefault = !cancelCloseDelegate(this); + break; + case WM_DESTROY: + version (LOG) log.writefln(" got destroy"); + hasPeer = NO_PEER; + if (quitOnDestroy) + gApp.exitEventLoop(); + break; + default: + // version (LOG) log.writefln(" got default"); + break; + } + } + return doDefault; + } + } + + class Window : AbstractWindow { + + this(char[] title = "", char[] name = "") { + peer = CreateWindowX("MinWinWindow", title, + MinWinWindowStyle, + CW_USEDEFAULT, CW_USEDEFAULT, + DefaultWindowWidth, DefaultWindowHeight, + HWND_DESKTOP, + cast(HMENU) null, gApp.hInstance, null); + sysAssert(peer !is null, "Failed to create peer Window"); + this.name = name; + setWindowPeer(this,peer,OWNS_PEER); + backgroundPeer = GetStockObject(WHITE_BRUSH); + WindowList[this] = this; // prevent garbage collection + } + + this(WindowPeer peer) { + setWindowPeer(this,peer,FOREIGN_PEER); + WindowList[this] = this; // prevent garbage collection + } + } + extern(Windows) + int MinWinWindowProc(HWND hWnd, uint uMsg, WPARAM wParam, LPARAM lParam) { + // version(LOG) log.printf("in minwin window proc hwnd %p\n",hWnd); + bool doDefault = true; + AbstractWindow win = cast(AbstractWindow)peerToWindow(hWnd); + // version(LOG) log.printf("in minwin window proc win %p\n",win); + if (win !is null) + doDefault = win.WindowProc(hWnd,uMsg,wParam,lParam) != 0; + if (doDefault) + return DefWindowProcA(hWnd, uMsg, wParam, lParam); + else + return 0; + } + static this() { + if (DefaultWindowIcon is null) { + IconPeer ip = LoadIconA(cast(HINSTANCE) null, IDI_APPLICATION); + DefaultWindowIcon = DefaultWindowSmallIcon = new Icon(ip); + } + HINSTANCE hInst = GetModuleHandleA(null); + WNDCLASSA wc; + wc.lpszClassName = "MinWinWindow"; + wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW; + wc.lpfnWndProc = &MinWinWindowProc; + wc.hInstance = hInst; + wc.hIcon = DefaultWindowIcon.peer; +// wc.hIconSm = DefaultWindowSmallIcon.peer; + wc.hCursor = LoadCursorA(cast(HINSTANCE) null, IDC_ARROW); + wc.hbrBackground = null; + // wc.hbrBackground = cast(HBRUSH) (COLOR_WINDOW + 1); // not +1 for default + wc.lpszMenuName = null; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + RegisterClassA(&wc); + } + +} else version (GTK) { + + private import minwin.gtk; + private import minwin.gtk_peers; + + alias GtkWindow* WindowPeer; + + class AbstractWindow : Component { + WindowPeer peer; + MinWinGtkPeer* content; + MenuBar menubar; + + mixin CommonWindowImpl!(); + + void title(char[] str) { + gtk_window_set_title(peer,toStringz(str)); + } + + char[] title() { + char* cstr = gtk_window_get_title(peer); + if (cstr is null) + return ""; + return cstr[0..strlen(cstr)].dup; + } + + // TODO + void backgroundColor(Color c) { + GtkWidget* wid = cast(GtkWidget*)peer; + GdkColor* nc = toNativeColor(c); + GtkStyle* style = gtk_widget_get_style(wid); + style.bg[GtkStateType.GTK_STATE_NORMAL] = *nc; + gtk_widget_set_style(wid,style); + } + + // callback from the GTK peer asking for preferred size + private void gtkRequest(GtkWidget *w, GtkRequisition* req) { + version(LOG)log.writefln("gtkRequest for toplevel window"); + if (layoutMgr) { + Point s = layoutMgr.preferredSize(this); + req.width = s.x; + req.height = s.y; + } else { + req.width = 0; + req.height = 0; + } + version(LOG)log.writefln("done gtkRequest for toplevel window"); + } + + // callback from GTK peer telling us our position + private void gtkAllocate(GtkWidget *w, GtkAllocation* req) { + version(LOG)log.writefln("gtkAllocate for toplevel window"); + Rect r = toRect(*req); + this.size = XY(r.width,r.height); + if (layoutMgr) { + layoutMgr.layout(this); + } + childLayoutDirty = false; + version(LOG)log.writefln("done gtkAllocate for toplevel window"); + } + + PeerForAdd getPeerForAdd() { return cast(GtkWidget*)content; } + + void disposePeer() { + if (hasPeer == OWNS_PEER) { + gtk_widget_destroy(cast(GtkWidget*)peer); + } + hasPeer = NO_PEER; + //delete WindowList[this]; // remove global reference + WindowList.remove(this); // remove global reference + } + + void close() { + if (!cancelCloseDelegate(this)) { + gtk_widget_destroy(cast(GtkWidget*)peer); + } + } + + void resizable(bool vis) { + gtk_window_set_resizable(peer,vis); + } + + bool resizable() { + return gtk_window_get_resizable(peer) != 0; + } + + void visible(bool vis) { + if (vis) { + gtk_widget_show(cast(GtkWidget*)peer); + } else { + gtk_widget_hide(cast(GtkWidget*)peer); + } + } + + bool visible() { + GtkObject* obj = cast(GtkObject*)peer; + return ((obj.flags & GtkWidgetFlags.GTK_VISIBLE) != 0); + } + + void enabled(bool b) { + gtk_widget_set_sensitive(cast(GtkWidget*)peer,cast(int)b); + } + bool enabled() { + GtkObject* obj = cast(GtkObject*)peer; + return ((obj.flags & GtkWidgetFlags.GTK_SENSITIVE) != 0); + } + + void getPeerOffset(inout int x, inout int y) { + x = 0; + y = 0; + if (menubar !is null) { + GtkRequisition req; + gtk_widget_size_request(menubar.peer,&req); + y = req.height; + } + } + + override void layout(bool validateParent) { + if (parent && validateParent) + parent.layout(true); + if (menubar !is null) { + positionMenuBar(); + } + if (childLayoutDirty) { + if (layoutMgr) + layoutMgr.layout(this); + childLayoutDirty = false; + } + foreach( Component ch; this) { + ch.layout(false); + } + } + + void positionMenuBar() { + Rect r; + getBounds(r); + MenuBarPeer w = menubar.peer; + GtkRequisition req; + gtk_widget_size_request(menubar.peer,&req); + r.height = req.height; + gtk_widget_size_allocate(w,&r.native); + } + + void getBounds(inout Rect r) { + int x,y; + r = toRect((cast(GtkWidget*)peer).allocation); + if (parent) parent.getPeerOffset(x,y); + r.left = r.left+x; + r.top = r.top+y; + } + + void setBounds(inout Rect r) { + int x,y; + if (parent) parent.getPeerOffset(x,y); + gtk_window_move(peer,r.left+x,r.top+y); + childLayoutDirty = true; + gtk_window_resize(peer,r.width,r.height); + } + + alias Component.size size; + void size(Point s) { + gtk_window_resize(peer,s.x,s.y); + } + + void toFront() { + gdk_window_raise((cast(GtkWidget*)peer).window); + } + + // mark as needing a repaint and post event to event queue + void repaint() { + Rect r; + GdkWindow* win = (cast(GtkWidget*)peer).window; + getBounds(r); + gdk_window_invalidate_rect(win,&r.native,1); + } + + void repaint(inout Rect r) { + GdkWindow* win = (cast(GtkWidget*)peer).window; + gdk_window_invalidate_rect(win,&r.native,1); + } + + mixin CommonEventSourceImpl!(); + + GContext getGContext(Event* paintEvent = null) { + GContext gc = newGContext(); + GtkWidget* widget = cast(GtkWidget*)content; + GdkWindow* gwin = widget.window; + gc.drawable = cast(GdkDrawable*)gwin; + gc.layout = gtk_widget_create_pango_layout(widget,""); + gc.peer = gdk_gc_new(gc.drawable); + gc.hasPeer = OWNS_PEER; + gc.paintEvent = cast(GdkEventExpose*)paintEvent; + return gc; + } + + Image getCompatibleImage(int width, int height) { + GtkWidget* widget = cast(GtkWidget*)content; + GdkDrawable* gwin = cast(GdkDrawable*)widget.window; + int depth = gdk_drawable_get_depth(gwin); + ImagePeer bm = gdk_pixmap_new(gwin,width,height,depth); + version(LOG) log.writefln("create bitmap %x",cast(int)bm); + Image res = new Image(bm); + res.width = width; + res.height = height; + res.hasPeer = OWNS_PEER; + return res; + } + + Image loadCompatibleImage(char[] imageKey, char[] fmt = "bmp") { + GtkWidget* widget = cast(GtkWidget*)content; + GdkDrawable* gwin = cast(GdkDrawable*)widget.window; + GError* err; + char[] fname = imageKey; + if (gApp.resourcePath.length > 0) { + fname = gApp.resourcePath ~ "/" ~ fname; + } + fname = fname ~ "." ~ fmt; + GdkPixbuf* pbuf = gdk_pixbuf_new_from_file(toStringz(fname),&err); + int width = gdk_pixbuf_get_width(pbuf); + int height = gdk_pixbuf_get_height(pbuf); + int depth = gdk_drawable_get_depth(gwin); + GdkColormap* cmap = gdk_drawable_get_colormap(gwin); + ImagePeer bm = gdk_pixmap_new(gwin,width,height,depth); + gdk_pixbuf_render_pixmap_and_mask_for_colormap(pbuf,cmap,&bm,null,0); + Image res = new Image(bm); + res.width = width; + res.height = height; + res.hasPeer = OWNS_PEER; + return res; + } + } + + class Window : AbstractWindow { + this(char[] title = "", char[] name = "") { + char* str = toStringz(title); + // TODO: application name vs window name?? + peer = cast(GtkWindow*)gtk_window_new(GtkWindowType.GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(peer,str); + gtk_window_set_default_size(peer,DefaultWindowWidth,DefaultWindowHeight); + backgroundColor = RGB(255,255,255); + this.name = name; + gtk_widget_add_events(cast(GtkWidget*)peer,GdkEventMask.GDK_KEY_PRESS_MASK | + GdkEventMask.GDK_KEY_RELEASE_MASK | + GdkEventMask.GDK_EXPOSURE_MASK | + GdkEventMask.GDK_STRUCTURE_MASK | + GdkEventMask.GDK_POINTER_MOTION_MASK | + GdkEventMask.GDK_BUTTON_PRESS_MASK | + GdkEventMask.GDK_BUTTON_RELEASE_MASK); + g_signal_connect_data(peer,"destroy", + cast(GCallback)&mw_destroy_callback, + cast(gpointer)this, + null,cast(GConnectFlags)0); + g_signal_connect_data(peer,"delete-event", + cast(GCallback)&mw_close_callback, + cast(gpointer)this, + null,cast(GConnectFlags)0); + g_signal_connect_data(peer,"configure-event", + cast(GCallback)&mw_notify_callback, + cast(gpointer)this, + null,cast(GConnectFlags)0); + setWindowPeer(this,peer,OWNS_PEER); + WindowList[this] = this; // prevent garbage collection + + GtkWidget* wcontent = MinWinGtkPeer_new(); + content = cast(MinWinGtkPeer*)wcontent; + gtk_widget_set_sensitive(wcontent,true); + content.sizeRequest = >kRequest; + content.sizeAllocate = >kAllocate; + gtk_container_add(cast(GtkContainer*)peer,wcontent); + g_signal_connect_data(peer,"expose-event", + cast(GCallback)&mw_expose_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + g_signal_connect_data(peer,"key-press-event", + cast(GCallback)&mw_key_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + g_signal_connect_data(peer,"key-release-event", + cast(GCallback)&mw_key_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + g_signal_connect_data(peer,"motion-notify-event", + cast(GCallback)&mw_win_mouse_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + g_signal_connect_data(peer,"button-press-event", + cast(GCallback)&mw_win_button_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + g_signal_connect_data(peer,"button-release-event", + cast(GCallback)&mw_win_button_callback, + cast(gpointer)this, + null,GConnectFlags.G_CONNECT_AFTER); + gtk_widget_realize(wcontent); + gtk_widget_show(wcontent); + } + + this(WindowPeer peer) { + setWindowPeer(this,peer,FOREIGN_PEER); + WindowList[this] = this; // prevent garbage collection + } + + } + + + // Get the Window object associated with the given peer. + // The peer is accessed from the Window using the peer property. + AbstractWindow peerToWindow(WindowPeer peer) { + gpointer ptr = g_object_get_data(cast(GObject*)peer,"MinWinUserData"); + return cast(AbstractWindow)ptr; + } + + // Associate c with the peer. This overwrites the window UserData. + void setWindowPeer(AbstractWindow c, WindowPeer peer, int peerState) { + g_object_set_data(cast(GObject*)peer,"MinWinUserData",cast(gpointer)peer); + c.hasPeer = peerState; + } + + extern (C) gboolean mw_expose_callback(GtkWidget* w, + GdkEventExpose* event, + gpointer ud) { + Window win = cast(Window) ud; + if (win) { + win.repaintNow(cast(Event*)event); + } + return false; + } + + extern (C) gboolean mw_key_callback(GtkWidget* w, + GdkEventKey* event, + gpointer ud) { + Window win = cast(Window) ud; + if (win && !win.keyDelegate.isEmpty) { + win.keyDelegate(win,cast(KeyEvent*)event); + } + return false; + } + + extern (C) gboolean mw_win_mouse_callback(GtkWidget* w, + GdkEventMotion* event, + gpointer ud) { + version(LOG)log.writefln("got mouse motion event"); + Window win = cast(Window) ud; + if (win && !win.mouseDelegate.isEmpty) { + // TODO this should be made into a GdkEventButton + win.mouseDelegate(win,cast(MouseEvent*)event); + } + return false; + } + + extern (C) gboolean mw_win_button_callback(GtkWidget* w, + GdkEventButton* event, + gpointer ud) { + Window win = cast(Window) ud; + if (win && !win.mouseDelegate.isEmpty) { + win.mouseDelegate(win,cast(MouseEvent*)event); + } + return false; + } + + extern (C) void mw_destroy_callback(GtkObject* w, gpointer ud) { + Window win = cast(Window) ud; + if (win) { + version(LOG)log.printf("mw_destroy_callback\n"); + win.hasPeer = NO_PEER; + if (win.quitOnDestroy) + gApp.exitEventLoop(); + if (win in Window.WindowList) { + //delete Window.WindowList[win]; + Window.WindowList.remove(win); + } + } + } + extern (C) void mw_close_callback(GtkWidget* w, GdkEvent* ev, gpointer ud) { + Window win = cast(Window) ud; + version(LOG)log.printf("mw_close_callback\n"); + if (win) + win.close(); + } + + extern (C) void mw_notify_callback(GtkWidget* w, GdkEvent* ev, gpointer ud) { + Window win = cast(Window) ud; + if (win && ev.type == GdkEventType.GDK_CONFIGURE) { + if (!win.windowDelegate.isEmpty) { + win.windowDelegate(win, cast(WindowEvent*)ev); + } + } + } + +} +