# # This file is part of gtkDS. # # gtkD is free software; you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation; either version 2.1 of the License, or # (at your option) any later version. # # gtkDS is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with gtkDS; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # ignoreEnum: GtkRcTokenType ignoreEnum: GtkSignalRunType ignoreEnum: GtkArgFlags structCode: GtkTextIter void* dummy1; void* dummy2; int dummy3; int dummy4; int dummy5; int dummy6; int dummy7; int dummy8; void* dummy9; void* dummy10; int dummy11; int dummy12; int dummy13; void* dummy14; structCode: end wrap: gtk addTypes: start public typedef extern(C) bool function (void*) GtkFunction; addTypes: end registerCode: start { char** argv = (new char*[args.length]).ptr; int argc = 0; foreach (char[] p; args) { argv[argc++] = cast(char*)p; } gtk_init(&argc,&argv); } registerCode: end jsPackage: Gtk ########################################################### ### Core Reference ######################################## ########################################################### #we have to register all the structs that are not defined anywhere?? = work out why later.. structWrapJS: GtkType #structures to output full details of. fullstruct: GtkTreeIter nostruct: GtkAccelKey nostruct: GtkTargetEntry nostruct: GtkTargetList nostruct: GtkIconFactory nostruct: GtkIconSet nostruct: GtkSettingsValue nostruct: GtkSelectionData nostruct: GtkBorder nostruct: GtkRequisition nostruct: GtkFileFilterInfo nostruct: GtkTooltipsData nostruct: GtkAllocation nostruct: GtkWidgetClass nostruct: GtkItemFactoryEntry nostruct: GtkNotebookPage #read file, but dont output anything.. file: gtk-Standard-Enumerations.html #class: StandardEnumerations #no output! outFile: file: gtk-General.html #struct: class: GtkD jsClass: Gtk ctype: static prefix: gtk_ noprefix: gtk_true noprefix: gtk_false noprefix: gtk_timeout_ noprefix: gtk_idle_ import: gdk.Event import: gtk.Widget import: gtk.ObjectGtk import: glib.Str import: gtk.bindinggtk import: gthread.Thread import: pango.PgLanguage import: glib.OptionGroup import: atk.bindingatktypes jsnocode: gtk_init #depreciated? jsnocode: gtk_input_add_full #jscode: gtk_init # char** argv = null; # int argc = 0; # gtk_init(&argc,&argv); # ret.putVundefined(); #jscode: end code: start /** * This initiates GtkD to supports multi threaded programs. * read full documantation at http://gtk.org/faq/#AEN482 * from the FAQ: * "There is a single global lock that you must acquire with * gdk_threads_enter() before making any GDK calls, * and release with gdk_threads_leave() afterwards throughout your code." * This is to be used on any call to GDK not executed from the main thread. */ public static void initMultiThread(char[][] args) { Thread.init(null); gdkThreadsInit(); init(args); } code: end outFile: GtkD file: gtk-General.html class: Timeout prefix: gtk_timeout_ outFile: Timeout #fixme - they are on my local box #copy: Timeout.d file: gtk-General.html class: Idle prefix: gtk_idle_ outFile: Idle #fixme - they are on my local box #copy: Idle.d file: gtk-Keyboard-Accelerators.html struct: GtkAccelGroup class: AccelGroup prefix: gtk_accel_group_ prefix: gtk_ import: glib.Str import: gdk.Gdk import: gobject.Closure import: gobject.ObjectG import: gtk.AccelGroup import: glib.ListSG outFile: AccelGroup file: gtk-Accelerator-Maps.html struct: GtkAccelMap class: AccelMap prefix: gtk_accel_map_ prefix: gtk_ import: glib.Str import: gdk.Gdk import: gtk.AccelMap outFile: AccelMap file: gtk-Clipboards.html struct: GtkClipboard class: Clipboard prefix: gtk_clipboard_ prefix: gtk_ import: glib.Str import: gtk.Clipboard import: gdk.Display import: gobject.ObjectG import: gdk.Pixbuf outFile: Clipboard file: gtk-Drag-and-Drop.html struct: GdkDragContext class: DragAndDrop prefix: gtk_drag_ prefix: gtk_ import: glib.Str import: gtk.Widget import: gdk.Window import: gdk.DragContext import: gdk.Event import: gdk.Colormap import: gdk.Pixmap import: gdk.Bitmap import: gdk.Pixbuf import: glib.Str outFile: DragAndDrop file: GtkIconTheme.html struct: GtkIconTheme class: IconTheme prefix: gtk_icon_theme_ noprefix: gtk_icon_info_ prefix: gtk_ import: glib.Str import: gtk.IconTheme import: gdk.Screen import: gtk.IconInfo import: gdk.Pixbuf import: glib.ListG outFile: IconTheme struct: GtkIconInfo class: IconInfo prefix: gtk_icon_info_ strictPrefix: Y import: glib.Str import: gtk.IconInfo import: gdk.Pixbuf outFile: IconInfo file: gtk-Stock-Items.html struct: GtkStockItem class: StockItem prefix: gtk_stock_ prefix: gtk_ import: glib.Str import: gtk.StockItem import: glib.ListSG outFile: StockItem file: gtk-Themeable-Stock-Images.html struct: GtkIconSource class: IconSource prefix: gtk_icon_ prefix: gtk_ import: glib.Str import: gdk.Pixbuf import: gtk.Style import: gtk.Widget import: gtk.Settings outFile: IconSource file: gtk-Resource-Files.html struct: GtkRcStyle class: RcStyle prefix: gtk_rc_ prefix: gtk_ #import: g.Scanner import: glib.Str import: gtk.Style import: gtk.Widget import: gtk.Settings import: gdk.Color #import: gtk.StateType #import: gtk.PathPriorityType import: gtk.RcStyle outFile: RcStyle file: GtkSettings.html struct: GtkSettings class: Settings prefix: gtk_settings_ prefix: gtk_ import: glib.Str import: gtk.Settings import: gdk.Screen import: glib.StringG import: gobject.Value outFile: Settings file: gtk-Bindings.html struct: GtkBindingSet class: BindingSet prefix: gtk_binding_set_ prefix: gtk_bindings_ prefix: gtk_ import: glib.Str import: gdk.Gdk import: gtk.BindingSet import: gtk.ObjectGtk import: glib.ListSG import: glib.Str; outFile: BindingSet file: gtk-Graphics-Contexts.html class: GCs prefix: gtk_gc_ prefix: gtk_ import: gdk.GC import: gdk.Colormap outFile: GCs file: GtkStyle.html struct: GtkStyle class: Style prefix: gtk_style_ prefix: gtk_ import: glib.Str import: gtk.Style import: gdk.Window import: gdk.Rectangle import: gdk.Pixbuf import: gtk.IconSource import: gtk.Widget import: gdk.Font import: gdk.Drawable outFile: Style file: gtk-Selections.html #struct: class: Selections prefix: gtk_ import: glib.Str import: gtk.Widget import: gdk.Display import: gdk.Pixbuf import: glib.Str outFile: Selections file: gtk-Feature-Test-Macros.html class: Version prefix: gtk_ import: glib.Str outFile: Version #depreciated #file: gtk-Signals.html #class: Signals #prefix: gtk_signal_ #prefix: gtk_ #import: glib.Str #outFile: Signals file: gtk-Types.html struct: GtkType class: Types prefix: gtk_type_ prefix: gtk_ import: glib.Str import: gobject.ObjectG outFile: Types ########################################################### ### Windows ############################################### ########################################################### file: GtkDialog.html struct: GtkDialog class: Dialog prefix: gtk_dialog_ prefix: gtk_ import: glib.Str import: gtk.Window import: gtk.Widget import: gdk.Screen #util only jsnocode: gtk_dialog_add_buttons jsnocode: gtk_dialog_new_with_buttons outFile: Dialog file: GtkInvisible.html struct: GtkInvisible class: Invisible prefix: gtk_invisible_ prefix: gtk_ import: gdk.Screen import: gtk.Widget outFile: Invisible file: GtkMessageDialog.html struct: GtkMessageDialog class: MessageDialog prefix: gtk_message_dialog_ prefix: gtk_ import: glib.Str import: gtk.Window nocode: gtk_message_dialog_new #dont support with_markup - you can use getMarkup() nocode: gtk_message_dialog_new_with_markup jssig: gtk_message_dialog_new Gtk.Windowparent ENUM GtkDialogFlagsflags ENUM GtkMessageTypetype ENUM GtkButtonsTypebuttons ENUM GtkDialogFlagsflags Stringmessage_format [String]message jssig: end jscode: gtk_message_dialog_new Wrapped_GtkWindow* _args_parent = cast(Wrapped_GtkWindow*) ((cast (dsWrapped_GtkWindow)(arglist[0].toObject())).getStruct()); Enum_GtkDialogFlags _args_flags = cast(Enum_GtkDialogFlags) (arglist[1].toInteger()); Enum_GtkMessageType _args_type = cast(Enum_GtkMessageType) (arglist[2].toInteger()); Enum_GtkButtonsType _args_buttons = cast(Enum_GtkButtonsType) (arglist[3].toInteger()); char[] _args_message_format = arglist[4].toString(); char[] _args_message = arglist.length > 4 ? arglist[5].toString() : ""; /* Wrapped_GtkMessageDialog* _ret = cast(Wrapped_GtkMessageDialog* ) gtk_message_dialog_new_with_markup ( _args_parent, _args_flags, _args_type, _args_buttons, std.string.toStringz(_args_message_format), std.string.toStringz(_args_message), // this should be null null ); */ Wrapped_GtkMessageDialog* _ret = cast(Wrapped_GtkMessageDialog* ) gtk_message_dialog_new( _args_parent is null ? null : _args_parent, _args_flags, _args_type, _args_buttons, std.string.toStringz(_args_message_format), std.string.toStringz(_args_message), // this should be null null ); ret.putVobject(new dsWrapped_GtkMessageDialog(_ret)); jscode: end outFile: MessageDialog file: GtkWindow.html struct: GtkWindow class: Window prefix: gtk_window_ prefix: gtk_ import: glib.Str import: gtk.AccelGroup import: gtk.Bin import: gtk.Widget import: gtk.Window import: gdk.Screen import: glib.ListG import: gdk.Pixbuf import: gtk.Window #there is a bug - it creates 2 versions of this? noprefix: gtk_window_set_role jssig: gtk_window_new Gtk.WindowType|Stringtype=Gtk.WindowType.TOPLEVEL|title jssig: end jscode: gtk_window_new // if type of arg is int.. Enum_GtkWindowType _arg_type = Enum_GtkWindowType.TOPLEVEL; if (arglist.length && (arglist[0].vtype == V_NUMBER)) { _arg_type = cast(Enum_GtkWindowType) (arglist[0].toInteger()); } Wrapped_GtkWindow* _ret = cast(Wrapped_GtkWindow* ) (gtk_window_new(_arg_type)); if (arglist.length && (arglist[0].vtype == V_STRING)) { char[] title = (arglist[0].toString()); gtk_window_set_title(_ret, std.string.toStringz(title)); } ret.putVobject(new dsWrapped_GtkWindow(_ret)); jscode: end outFile: Window file: GtkWindowGroup.html struct: GtkWindowGroup class: WindowGroup prefix: gtk_window_group_ prefix: gtk_ import: gtk.Window outFile: WindowGroup file: GtkAboutDialog.html struct: GtkAboutDialog class: AboutDialog prefix: gtk_about_dialog_ prefix: gtk_ import: glib.Str import: gdk.Pixbuf import: gtk.Window outFile: AboutDialog file: GtkAssistant.html struct: GtkAssistant class: Assistant prefix: gtk_assistant_ prefix: gtk_ import: glib.Str import: gdk.Pixbuf import: gtk.Widget outFile: Assistant ########################################################### ### Display Widgets ####################################### ########################################################### file: GtkAccelLabel.html struct: GtkAccelLabel class: AccelLabel prefix: gtk_accel_label_ prefix: gtk_ import: glib.Str import: gobject.Closure import: gtk.Widget import: gtk.Label outFile: AccelLabel file: GtkImage.html struct: GtkImage import: gtk.Misc class: Image prefix: gtk_image_ prefix: gtk import: glib.Str import: gdkpixbuf.PixbufAnimation import: gdkpixbuf.bindinggdkpixbuftypes #import: gtk.IconSet* #import: gtk.IconSize #import: gdk.ImageGdk* #import: gdk.Bitmap* import: gdk.Pixbuf #import: gdk.Pixmap* #import: gdk.PixbufAnimation #import: gtk.IconSet import: gdk.ImageGdk import: gdk.Bitmap import: gdk.Pixmap nocode: gtk_image_new_from_stock nocode: gtk_image_new_from_icon_name code: start // this will be an enum /** * Creates a GtkImage displaying a stock icon. Sample stock icon * names are GTK_STOCK_OPEN, GTK_STOCK_EXIT. Sample stock sizes * are GTK_ICON_SIZE_MENU, GTK_ICON_SIZE_SMALL_TOOLBAR. If the stock * icon name isn't known, the image will be empty. * You can register your own stock icon names, see * gtk_icon_factory_add_default() and gtk_icon_factory_add(). * stock_id: * a stock icon name * size: * a stock icon size * Returns: * a new GtkImage displaying the stock icon */ public this (StockID stockID, GtkIconSize size) { // GtkWidget* gtk_image_new_from_stock (const gchar *stock_id, GtkIconSize size); this(cast(GtkImage*)gtk_image_new_from_stock(StockDesc[stockID].ptr, size) ); } /** * Creates a GtkImage displaying an icon from the current icon theme. * If the icon name isn't known, a "broken image" icon will be * displayed instead. If the current icon theme is changed, the icon * will be updated appropriately. * icon_name: * an icon name * size: * a stock icon size * Returns: * a new GtkImage displaying the themed icon * Since 2.6 */ public this (char[] iconName, GtkIconSize size) { // GtkWidget* gtk_image_new_from_icon_name (const gchar *icon_name, GtkIconSize size); this(cast(GtkImage*)gtk_image_new_from_icon_name(Str.toStringz(iconName), size) ); } code: end outFile: Image file: GtkLabel.html struct: GtkLabel class: Label prefix: gtk_label_ prefix: gtk_ import: glib.Str import: gtk.Widget import: gtk.Misc nocode: gtk_label_new nocode: gtk_label_new_with_mnemonic outFile: Label #technically depreiciated - but it's used by progressbar (extended) file: GtkProgress.html struct: GtkProgress class: Progress prefix: gtk_progress_ noprefix: gtk_progress_ prefix: gtk_ import: glib.Str outFile: Progress file: GtkProgressBar.html struct: GtkProgressBar class: ProgressBar prefix: gtk_progress_bar_ prefix: gtk_ import: glib.Str import: pango.bindingpangotypes import: gtk.Adjustment outFile: ProgressBar file: GtkStatusbar.html struct: GtkStatusbar class: Statusbar import: glib.Str import: gtk.HBox prefix: gtk_statusbar_ prefix: gtk_ outFile: Statusbar ########################################################### ### Buttons and Toggles ################################### ########################################################### file: GtkButton.html struct: GtkButton class: Button prefix: gtk_button_ prefix: gtk_ import: glib.Str import: gtk.Widget import: gtk.Bin import: gtk.Image import: gtk.Button nocode: gtk_button_new_with_mnemonic nocode: gtk_button_new_with_label nocode: gtk_button_new_from_stock jssig: gtk_button_new [String]button_label jssig: end jscode: gtk_button_new Wrapped_GtkButton* _ret; if (!arglist.length) { _ret = cast(Wrapped_GtkButton* ) (gtk_button_new()); } else if (arglist[0].vtype == V_STRING){ _ret = cast(Wrapped_GtkButton* ) (gtk_button_new_with_label( std.string.toStringz(arglist[0].toString()) )); } else { //fixme. _ret = cast(Wrapped_GtkButton* ) (gtk_button_new()); } ret.putVobject(new dsWrapped_GtkButton(_ret)); jscode: end outFile: Button file: GtkCheckButton.html struct: GtkCheckButton class: CheckButton import: glib.Str import: gtk.Button import: glib.Str prefix: gtk_check_button_ prefix: gtk_ nocode: gtk_check_button_new_with_label nocode: gtk_check_button_new_with_mnemonic jssig: gtk_check_button_new [String]button_label jssig: end jscode: gtk_check_button_new Wrapped_GtkCheckButton* _ret; if (!arglist.length) { _ret = cast(Wrapped_GtkCheckButton* ) (gtk_check_button_new()); } else if (arglist[0].vtype == V_STRING){ _ret = cast(Wrapped_GtkCheckButton* ) (gtk_check_button_new_with_label( std.string.toStringz(arglist[0].toString()) )); } else { //fixme. _ret = cast(Wrapped_GtkCheckButton* ) (gtk_check_button_new()); } ret.putVobject(new dsWrapped_GtkCheckButton(_ret)); jscode: end outFile: CheckButton file: GtkRadioButton.html struct: GtkRadioButton class: RadioButton prefix: gtk_radio_button_ prefix: gtk_ import: glib.Str import: glib.ListSG nocode: gtk_radio_button_new_with_label nocode: gtk_radio_button_new_with_mnemonic nocode: gtk_radio_button_new_with_label_from_widget nocode: gtk_radio_button_new_with_mnemonic_from_widget jssig: gtk_radio_button_new [String]button_label jssig: end jscode: gtk_radio_button_new Wrapped_GSList* _arg_group = cast(Wrapped_GSList*) ((cast (dsWrapped_GSList)(arglist[0].toObject())).getStruct()); Wrapped_GtkRadioButton* _ret; if (!arglist.length < 2) { _ret = cast(Wrapped_GtkRadioButton* )(gtk_radio_button_new(_arg_group)); } else { _ret = cast(Wrapped_GtkRadioButton* ) (gtk_radio_button_new_with_label(_arg_group, std.string.toStringz(arglist[1].toString()) )); } ret.putVobject(new dsWrapped_GtkRadioButton(_ret)); jscode:end outFile: RadioButton file: GtkToggleButton.html struct: GtkToggleButton class: ToggleButton prefix: gtk_toggle_button_ prefix: gtk_ import: glib.Str nocode: gtk_toggle_button_new_with_label nocode: gtk_toggle_button_new_with_mnemonic jssig: gtk_toggle_button_new [String]button_label jssig: end jscode: gtk_toggle_button_new Wrapped_GtkToggleButton* _ret; if (!arglist.length) { _ret = cast(Wrapped_GtkToggleButton* ) gtk_toggle_button_new(); } else { _ret = cast(Wrapped_GtkToggleButton* ) gtk_toggle_button_new_with_label( std.string.toStringz(arglist[0].toString()) ); } ret.putVobject(new dsWrapped_GtkToggleButton(_ret)); jscode:end outFile: ToggleButton ########################################################### ### numeric/text Data Entry ############################### ########################################################### file: GtkEntry.html struct: GtkEntry class: Entry prefix: gtk_entry_ prefix: gtk_ import: glib.Str import: gtk.EntryCompletion jscode: gtk_entry_get_text Wrapped_GtkEntry* _arg_entry = cast(Wrapped_GtkEntry*) ((cast (Dobject) othis).getStruct()); char[] _ret = std.string.toString(gtk_entry_get_text(_arg_entry)).dup; ret.putVstring(_ret); jscode: end outFile: Entry file: GtkEntryCompletion.html struct: GtkEntryCompletion class: EntryCompletion prefix: gtk_entry_completion_ prefix: gtk_ import: glib.Str import: gtk.Widget import: gtk.TreeModel outFile: EntryCompletion file: GtkHScale.html struct: GtkHScale class: HScale prefix: gtk_hscale_ prefix: gtk_ import: gtk.Adjustment outFile: HScale file: GtkVScale.html struct: GtkVScale class: VScale prefix: gtk_vscale_ prefix: gtk_ import: gtk.Adjustment outFile: VScale file: GtkSpinButton.html struct: GtkSpinButton class: SpinButton prefix: gtk_spin_button_ prefix: gtk_ import: gtk.Widget import: gtk.Adjustment outFile: SpinButton file: GtkEditable.html struct: GtkEditable class: Editable prefix: gtk_editable_ prefix: gtk_ import: glib.Str outFile: Editable ########################################################### ### Multiline Text Editor ################################# ########################################################### file: gtk-GtkTextIter.html struct: GtkTextIter class: TextIter #nostruct: GtkTextIter prefix: gtk_text_iter_ prefix: gtk_ import: glib.Str import: gtk.TextBuffer import: gtk.TextIter import: gdk.Pixbuf import: glib.ListSG import: gtk.TextTag import: gtk.TextAttributes import: gtk.TextChildAnchor # this doesnt really exist! jscode: gtk_text_iter_new Wrapped_GtkTextIter* _ret = new Wrapped_GtkTextIter; ret.putVobject(new dsWrapped_GtkTextIter(_ret)); jscode: end outFile: TextIter file: GtkTextMark.html struct: GtkTextMark class: TextMark prefix: gtk_text_mark_ prefix: gtk_ import: glib.Str import: gtk.TextBuffer outFile: TextMark file: GtkTextBuffer.html struct: GtkTextBuffer class: TextBuffer prefix: gtk_text_buffer_ prefix: gtk_ import: glib.Str import: gtk.TextBuffer #import: gtk.TextMark #import: gtk.TextIter import: gdk.Rectangle import: gtk.Widget import: pango.PgTabArray import: gtk.TextAttributes import: gtk.TextTagTable import: gtk.TextIter import: gtk.TextTag import: gdk.Pixbuf import: gtk.TextChildAnchor import: gtk.TextMark import: gtk.Clipboard import: gdk.Bitmap import: std.stdarg jscode: gtk_text_buffer_get_bounds Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTextIter* _arg_start = new Wrapped_GtkTextIter; Wrapped_GtkTextIter* _arg_end = new Wrapped_GtkTextIter; gtk_text_buffer_get_bounds(_arg_buffer,_arg_start,_arg_end); auto _ret = new Darray(); _ret.Put(0, new dsWrapped_GtkTextIter(_arg_start),0); _ret.Put(1, new dsWrapped_GtkTextIter(_arg_end),0); ret.putVobject(_ret); jscode: end jscode: gtk_text_buffer_get_selection_bounds Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTextIter* _arg_start = new Wrapped_GtkTextIter; Wrapped_GtkTextIter* _arg_end = new Wrapped_GtkTextIter; // check if anything is selected. int len = cast(int) gtk_text_buffer_get_selection_bounds(_arg_buffer,null,null); if (!len) { ret.putVboolean(false); return null; } // now call it for real... len = cast(int) gtk_text_buffer_get_selection_bounds(_arg_buffer,_arg_start,_arg_end); auto _ret = new Darray(); _ret.Put(0, new dsWrapped_GtkTextIter(_arg_start),0); if (len > 0) { _ret.Put(1, new dsWrapped_GtkTextIter(_arg_end),0); } ret.putVobject(_ret); jscode: end jscode: gtk_text_buffer_get_iter_at_line_offset Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTextIter* _arg_iter = new Wrapped_GtkTextIter; int _arg_line_number = cast(int) (arglist[0].toInteger()); int _arg_char_offset = cast(int) (arglist[1].toInteger()); gtk_text_buffer_get_iter_at_line_offset(_arg_buffer,_arg_iter,_arg_line_number,_arg_char_offset); ret.putVobject(new dsWrapped_GtkTextIter(_arg_iter)); jscode: end jscode: gtk_text_buffer_get_iter_at_offset Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTextIter* _arg_iter = new Wrapped_GtkTextIter; int _arg_char_offset = cast(int) (arglist[0].toInteger()); gtk_text_buffer_get_iter_at_offset(_arg_buffer,_arg_iter,_arg_char_offset); ret.putVobject(new dsWrapped_GtkTextIter(_arg_iter)); jscode: end jscode: gtk_text_buffer_get_iter_at_line Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTextIter* _arg_iter = new Wrapped_GtkTextIter; int _arg_char_offset = cast(int) (arglist[0].toInteger()); gtk_text_buffer_get_iter_at_line(_arg_buffer,_arg_iter,_arg_char_offset); ret.putVobject(new dsWrapped_GtkTextIter(_arg_iter)); jscode: end jscode: dswrap_gtk_text_buffer_get_iter_at_line_index Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTextIter* _arg_iter = new Wrapped_GtkTextIter; int _arg_line_number = cast(int) (arglist[0].toInteger()); int _arg_char_offset = cast(int) (arglist[1].toInteger()); gtk_text_buffer_get_iter_at_line_index(_arg_buffer,_arg_iter,_arg_line_number,_arg_char_offset); ret.putVobject(new dsWrapped_GtkTextIter(_arg_iter)); jscode: end jscode: gtk_text_buffer_get_iter_at_mark Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTextIter* _arg_iter = new Wrapped_GtkTextIter; Wrapped_GtkTextMark* _arg_mark = cast(Wrapped_GtkTextMark*) (arglist[0].vtype == V_OBJECT ? arglist[0].toObject().getStruct() : null); gtk_text_buffer_get_iter_at_mark(_arg_buffer,_arg_iter,_arg_mark); ret.putVobject(new dsWrapped_GtkTextIter(_arg_iter)); jscode: end jscode: gtk_text_buffer_get_iter_at_child_anchor Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTextIter* _arg_iter = new Wrapped_GtkTextIter; Wrapped_GtkTextChildAnchor* _arg_anchor = cast(Wrapped_GtkTextChildAnchor*) (arglist[0].vtype == V_OBJECT ? arglist[0].toObject().getStruct() : null); gtk_text_buffer_get_iter_at_child_anchor(_arg_buffer,_arg_iter,_arg_anchor); ret.putVobject(new dsWrapped_GtkTextIter(_arg_iter)); jscode: end jscode: gtk_text_buffer_get_start_iter Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTextIter* _arg_iter = new Wrapped_GtkTextIter; gtk_text_buffer_get_start_iter(_arg_buffer,_arg_iter); ret.putVobject(new dsWrapped_GtkTextIter(_arg_iter)); jscode: end jscode: gtk_text_buffer_get_end_iter Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTextIter* _arg_iter = new Wrapped_GtkTextIter; gtk_text_buffer_get_end_iter(_arg_buffer,_arg_iter); ret.putVobject(new dsWrapped_GtkTextIter(_arg_iter)); jscode: end #nocode: gtk_text_buffer_set_text #nocode: gtk_text_buffer_insert_with_tags #nocode: gtk_text_buffer_insert_with_tags_by_name #nocode: gtk_text_buffer_create_tag jscode: gtk_text_buffer_set_text Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (dsWrapped_GtkTextBuffer)othis).getStruct()); char[] _arg_text = arglist[0].toString(); int _arg_len = cast(int) _arg_text.length; gtk_text_buffer_set_text(_arg_buffer,std.string.toStringz(_arg_text),_arg_len); ret.putVundefined(); jscode: end jscode: gtk_text_buffer_insert // skip = void gtk_text_buffer_insert(GtkTextBuffer* buffer, GtkTextIter* iter, gchar* text, gint len) Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (dsWrapped_GtkTextBuffer)othis).getStruct()); Wrapped_GtkTextIter* _arg_iter = cast(Wrapped_GtkTextIter*) ((cast (dsWrapped_GtkTextIter)arglist[0].toObject()).getStruct()); char[] _arg_text = arglist[1].toString(); int _arg_len = cast(int) _arg_text.length; gtk_text_buffer_insert(_arg_buffer, _arg_iter, std.string.toStringz(_arg_text), _arg_len); ret.putVundefined(); jscode: end jscode: gtk_text_buffer_insert_at_cursor Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (dsWrapped_GtkTextBuffer)othis).getStruct()); char[] _arg_text = arglist[0].toString(); int _arg_len = cast(int) _arg_text.length; gtk_text_buffer_insert_at_cursor(_arg_buffer,std.string.toStringz(_arg_text),_arg_len); ret.putVundefined(); jscode: end jscode: gtk_text_buffer_insert_interactive Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (dsWrapped_GtkTextBuffer)othis).getStruct()); Wrapped_GtkTextIter* _arg_iter = cast(Wrapped_GtkTextIter*) ((cast (dsWrapped_GtkTextIter)arglist[0].toObject()).getStruct()); char[] _arg_text = arglist[1].toString(); int _arg_len = cast(int) _arg_text.length; uint _arg_default_editable = arglist[1].toBoolean(); int _ret = cast(int) gtk_text_buffer_insert_interactive(_arg_buffer, _arg_iter, std.string.toStringz(_arg_text), _arg_len, _arg_default_editable); ret.putVnumber(_ret); jscode: end jscode: gtk_text_buffer_insert_interactive_at_cursor Wrapped_GtkTextBuffer* _arg_buffer = cast(Wrapped_GtkTextBuffer*) ((cast (dsWrapped_GtkTextBuffer)othis).getStruct()); char[] _arg_text = arglist[0].toString(); int _arg_len = cast(int) _arg_text.length; uint _arg_default_editable = arglist.length > 1 ? arglist[1].toBoolean() : 0; int _ret = cast(int) gtk_text_buffer_insert_interactive_at_cursor(_arg_buffer, std.string.toStringz(_arg_text), _arg_len, _arg_default_editable); ret.putVnumber(_ret); jscode: end code: start // how are we going to do this. public void insertWithTags(TextIter iter, char[] text, ... ) { for (int i = 0; (i<_arguments.length) && (_arguments[i] == typeid(TextTag)); i++) { TextTag tag = va_arg!(TextTag)(_argptr); // void gtk_text_buffer_insert_with_tags (GtkTextBuffer *buffer, GtkTextIter *iter, const gchar *text, gint len, GtkTextTag *first_tag, ...); gtk_text_buffer_insert_with_tags(gtkTextBuffer, (iter is null) ? null : iter.getTextIterStruct(), Str.toStringz(text), text.length, (tag is null) ? null : tag.getTextTagStruct(), null); } } public void insertWithTagsByName(TextIter iter, char[] text, ... ) { for (int i = 0; (i<_arguments.length) && (_arguments[i] == typeid(char[])); i++) { char[] tagName = va_arg!(char[])(_argptr); // void gtk_text_buffer_insert_with_tags_by_name (GtkTextBuffer *buffer, GtkTextIter *iter, const gchar *text, gint len, const gchar *first_tag_name, ...); gtk_text_buffer_insert_with_tags_by_name(gtkTextBuffer, (iter is null) ? null : iter.getTextIterStruct(), Str.toStringz(text), text.length, Str.toStringz(tagName), null); } } TextTag createTag(char[] tagName, char[] propertyName, int propertyValue, char[] propertyName1, char[] propertyValue1) { return new TextTag( gtk_text_buffer_create_tag(gtkTextBuffer, Str.toStringz(tagName), Str.toStringz(propertyName),propertyValue, Str.toStringz(propertyName1), Str.toStringz(propertyValue1), null) ); } TextTag createTag(char[] tagName, char[] propertyName, int propertyValue) { return new TextTag( gtk_text_buffer_create_tag(gtkTextBuffer, Str.toStringz(tagName), Str.toStringz(propertyName),propertyValue,null) ); } TextTag createTag(char[] tagName, char[] propertyName, double propertyValue) { return new TextTag( gtk_text_buffer_create_tag(gtkTextBuffer, Str.toStringz(tagName), Str.toStringz(propertyName),propertyValue,null) ); } TextTag createTag(char[] tagName, char[] propertyName, int propertyValue, char[] propertyName2, int propertyValue2) { return new TextTag( gtk_text_buffer_create_tag(gtkTextBuffer, Str.toStringz(tagName), Str.toStringz(propertyName), propertyValue, Str.toStringz(propertyName2), propertyValue2, null) ); } TextTag createTag(char[] tagName, char[] propertyName, int propertyValue, char[] propertyName2, int propertyValue2, char[] propertyName3, int propertyValue3, char[] propertyName4, int propertyValue4, char[] propertyName5, int propertyValue5) { return new TextTag( gtk_text_buffer_create_tag(gtkTextBuffer, Str.toStringz(tagName), Str.toStringz(propertyName), propertyValue, Str.toStringz(propertyName2), propertyValue2, Str.toStringz(propertyName3), propertyValue3, Str.toStringz(propertyName4), propertyValue4, Str.toStringz(propertyName5), propertyValue5, null) ); } TextTag createTag(char[] tagName, char[] propertyName, char[] propertyValue) { return new TextTag( gtk_text_buffer_create_tag(gtkTextBuffer, Str.toStringz(tagName), Str.toStringz(propertyName),Str.toStringz(propertyValue),null) ); } TextTag createTag(char[] tagName, char[] propertyName, Bitmap propertyValue) { return new TextTag( gtk_text_buffer_create_tag(gtkTextBuffer, Str.toStringz(tagName), Str.toStringz(propertyName),propertyValue.getBitmapStruct(),null) ); } TextTag createTag(char[] tagName, char[] propertyName, char[] propertyValue, char[] propertyName2, int propertyValue2) { return new TextTag( gtk_text_buffer_create_tag(gtkTextBuffer, Str.toStringz(tagName), Str.toStringz(propertyName), Str.toStringz(propertyValue), Str.toStringz(propertyName2), propertyValue2, null) ); } code: end outFile: TextBuffer file: GtkTextTag.html struct: GtkTextTag class: TextTag prefix: gtk_text_tag_ noprefix: gtk_text_attributes_ prefix: gtk_ import: glib.Str import: gobject.ObjectG import: gdk.Event import: gtk.TextIter outFile: TextTag struct: GtkTextAttributes class: TextAttributes prefix: gtk_text_attributes_ strictPrefix: Y import: gtk.TextAttributes outFile: TextAttributes file: GtkTextTagTable.html struct: GtkTextTagTable class: TextTagTable prefix: gtk_text_tag_ prefix: gtk_ import: glib.Str import: gtk.TextTagTable import: gtk.TextTag outFile: TextTagTable file: GtkTextView.html struct: GtkTextView class: TextView prefix: gtk_text_view_ prefix: gtk_ noprefix: gtk_text_child_anchor_ import: glib.Str import: gtk.TextBuffer import: gtk.TextMark import: gtk.TextIter import: gdk.Rectangle import: gtk.Widget import: pango.PgTabArray import: gtk.TextAttributes import: gdk.Window import: gtk.TextChildAnchor import: glib.ListG jscode: gtk_text_view_get_line_at_y // skip = void gtk_text_view_get_line_at_y( //GtkTextView* text_view, GtkTextIter* target_iter, gint y, gint* line_top) Wrapped_GtkTextView* _arg_text_view = cast(Wrapped_GtkTextView*) ((cast (dsWrapped_GtkTextView)othis).getStruct()); int _arg_y = cast(int) (arglist[0].toInteger()); Wrapped_GtkTextIter* arg_target_iter = new Wrapped_GtkTextIter; int window_x; int window_y; gtk_text_view_buffer_to_window_coords( _arg_text_view, Enum_GtkTextWindowType.TEXT, 0, _arg_y, &window_x, &window_y); Wrapped_GtkTextIter* iterEnd = new Wrapped_GtkTextIter; Wrapped_GtkTextBuffer* buffer = gtk_text_view_get_buffer(_arg_text_view); gtk_text_buffer_get_iter_at_offset(buffer, iterEnd, gtk_text_iter_get_offset(arg_target_iter) + gtk_text_iter_get_chars_in_line(arg_target_iter) ); char[] _ret = std.string.toString(gtk_text_buffer_get_text(buffer,arg_target_iter, iterEnd, false)); ret.putVstring(_ret); jscode: end outFile: TextView struct: GtkTextChildAnchor class: TextChildAnchor import: glib.Str prefix: gtk_text_child_anchor_ strictPrefix: Y outFile: TextChildAnchor ########################################################### ### Tree, List and Icon Grid Widgets ###################### ########################################################### file: GtkTreeModel.html struct: GtkTreeModel class: TreeModel prefix: gtk_tree_model_ noprefix: gtk_tree_row_reference_ noprefix: gtk_tree_path_ noprefix: gtk_tree_iter_ import: glib.Str #noprefix: gtk_ import: gtk.TreeIter import: gtk.TreePath import: gobject.Value interfaceCode: start /** * Get the value of a column as a char array. * this is the same calling getValue and get the string from the value object */ char[] getValueString(TreeIter iter, int column); /** * Get the value of a column as a char array. * this is the same calling getValue and get the int from the value object */ int getValueInt(TreeIter iter, int column); void setValue(TreeIter iter, int column, char[] value); void setValue(TreeIter iter, int column, int value); interfaceCode: end nocode: gtk_tree_model_get_iter code: start /** * Get the value of a column as a char array. * this is the same calling getValue and get the string from the value object */ char[] getValueString(TreeIter iter, int column) { Value value = new Value(); getValue(iter, column, value); return value.getString(); } /** * Get the value of a column as a char array. * this is the same calling getValue and get the int from the value object */ int getValueInt(TreeIter iter, int column) { Value value = new Value(); getValue(iter, column, value); return value.getInt(); } /** * Sets iter to a valid iterator pointing to path. * tree_model: * A GtkTreeModel. * iter: * The uninitialized GtkTreeIter. * path: * The GtkTreePath. * Returns: * TRUE, if iter was set. */ public int getIter(TreeIter iter, TreePath path) { // gboolean gtk_tree_model_get_iter (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path); iter.setModel(this); return gtk_tree_model_get_iter(gtkTreeModel, (iter is null) ? null : iter.getTreeIterStruct(), (path is null) ? null : path.getTreePathStruct()); } code: end outFile: TreeModel file: GtkTreeModel.html struct: GtkTreeIter class: TreeIter strictPrefix: Y prefix: gtk_tree_iter_ import: glib.Str import: gtk.TreeIter import: gtk.TreeModel import: gtk.TreePath import: gtk.TreeIterError import: gobject.Value; jscode: gtk_tree_iter_new Wrapped_GtkTreeIter* _ret = new Wrapped_GtkTreeIter; ret.putVobject(new dsWrapped_GtkTreeIter(_ret)); jscode: end code: start /** * this will be set only when the iter * is created from the model. */ GtkTreeModel *gtkTreeModel; public void setModel(GtkTreeModel *gtkTreeModel) { this.gtkTreeModel = gtkTreeModel; } public void setModel(TreeModel treeModel) { this.gtkTreeModel = treeModel.getTreeModelStruct(); } public this(TreeModel treeModel, TreePath treePath) { this(); setModel(treeModel); if ( gtk_tree_model_get_iter_from_string( treeModel.getTreeModelStruct(), getTreeIterStruct(), Str.toStringz(treePath.toString())) ) { // ??? } } /** * creates a new tree iteractor. * used TreeView.createIter and TreeView.append() to create iteractor for a tree or list */ this() { this(new GtkTreeIter); } /** * Get Value * @param iter * @param column * @param value */ void getValue(int column, Value value) { if ( gtkTreeModel is null ) { throw new TreeIterError("getValue","Tree model not set"); } gtk_tree_model_get_value(gtkTreeModel, gtkTreeIter, column, value.getValueStruct()); } /** * Get the value of a column as a string * @para column the column number * @return a string representing the value of the column */ char[] getValueString(int column) { if ( gtkTreeModel is null ) { throw new TreeIterError("getValueString","Tree model not set"); } Value value = new Value(); gtk_tree_model_get_value(gtkTreeModel, gtkTreeIter, column, value.getValueStruct()); //printf("TreeIter.getValuaString = %.*s\n", value.getString().toString()); return value.getString(); } /** * Get the value of a column as an int * @para column the column number * @return a string representing the value of the column */ int getValueInt(int column) { if ( gtkTreeModel is null ) { throw new TreeIterError("getValueInt", "Tree model not set"); } Value value = new Value(); gtk_tree_model_get_value(gtkTreeModel, gtkTreeIter, column, value.getValueStruct()); return value.getInt(); } TreePath getTreePath() { if ( gtkTreeModel is null ) { throw new TreeIterError("getTreePath","Tree model not set"); } return new TreePath(gtk_tree_model_get_path(gtkTreeModel, gtkTreeIter)); } /** * This return the path visible to the user. */ char[] getVisiblePath(char[] separator) { char[] vPath; if ( gtkTreeModel is null ) { throw new TreeIterError("getVisiblePath", "Tree model not set"); } vPath = getValueString(0); TreeIter parent = getParent(); while ( parent !is null ) { //printf("TreeIter.getVisiblePath parent = %.*s\n",parent.getValueString(0).toString()); vPath = parent.getValueString(0) ~ separator ~ vPath; parent = parent.getParent(); } //printf("TreeIter.getVisiblePath = %.*s\n", vPath.toString()); return vPath; } /** * Gets the parent of this iter * @param child * @return the parent iter or null if can't get parent or an error occured */ TreeIter getParent() { if ( gtkTreeModel is null ) { throw new TreeIterError("getParent", "Tree model not set"); } TreeIter parent = new TreeIter(); bool gotParent = gtk_tree_model_iter_parent(gtkTreeModel, parent.getTreeIterStruct(), gtkTreeIter) == 0 ? false : true; if ( !gotParent ) { return null; } parent.setModel(gtkTreeModel); return parent; } TreeIter getGrandParent() { if ( gtkTreeModel is null ) { throw new TreeIterError("getGrandParent", "Tree model not set"); } TreeIter grandParent = this; TreeIter parent = grandParent.getParent(); while ( parent !is null ) { grandParent = parent; parent = grandParent.getParent(); } return grandParent; } code: end outFile: TreeIter struct: GtkTreePath class: TreePath strictPrefix: Y prefix: gtk_tree_path_ #prefix: gtk_ import: glib.Str import: gtk.TreePath import: glib.Str nocode: gtk_tree_path_new nocode: gtk_tree_path_new_first code: start /** * Creates a new GtkTreePath. This structure refers to a row. * if firstRow is true this is the string representation of this path is "0" * Returns: * A newly created GtkTreePath. */ public this (bit firstRow=false) { if ( firstRow ) { // GtkTreePath* gtk_tree_path_new_first (void); this(cast(GtkTreePath*)gtk_tree_path_new_first() ); } else { // GtkTreePath* gtk_tree_path_new (void); this(cast(GtkTreePath*)gtk_tree_path_new() ); } } code: end outFile: TreePath struct: GtkTreeRowReference class: TreeRowReference strictPrefix: Y prefix: gtk_tree_row_reference_ #prefix: gtk_ import: gtk.TreeModel import: gtk.TreePath import: gobject.ObjectG #import: gtk.TreeRowReference import: gtk.TreeIter outFile: TreeRowReference file: class: TreeIterError extend: Error code: start /** * A TreeIter error. * thrown
* - trying to access a method that requires a tree model and the tree model was never set */ public this(char[] method, char[] message) { super("TreeIter."~method~" : "~message); } code: end outFile: TreeIterError file: GtkTreeSelection.html struct: GtkTreeSelection class: TreeSelection prefix: gtk_tree_selection_ prefix: gtk_ import: gtk.TreeView #import: gtk.TreeModel* import: gtk.TreeIter import: glib.ListG import: gtk.TreePath import: gtk.TreeModel import: gtk.TreeIter import: glib.bindingglib nocode: gtk_tree_selection_get_selected #nocode: gtk_tree_selection_get_selected_rows jscode: gtk_tree_selection_get_selected_rows Wrapped_GtkTreeSelection* _arg_selection = cast(Wrapped_GtkTreeSelection*) ((cast (Dobject)othis).getStruct()); Wrapped_GtkTreeModel* _arg_model = cast(Wrapped_GtkTreeModel*) (arglist[0].vtype == V_OBJECT ? arglist[0].toObject().getStruct() : null); //GtkTreeModel* m = model.getTreeModelStruct(); auto lst = gtk_tree_selection_get_selected_rows(_arg_selection, &_arg_model); Darray _ret = new Darray(); for ( int i=0 ; i< g_list_length(lst) ; i++ ) { Value *v = new Value; v.putVobject( cast(Dobject)new dsWrapped_GtkTreePath(cast(Wrapped_GtkTreePath*) g_list_nth_data(lst,i))); _ret.Put(i,v ,0); } ret.putVobject(_ret); jscode: end code: start /** * Sets iter to the currently selected node if selection is set to * GTK_SELECTION_SINGLE or GTK_SELECTION_BROWSE. iter may be NULL if you * just want to test if selection has any selected nodes. model is filled * with the current model as a convenience. This function will not work if you * use selection is GTK_SELECTION_MULTIPLE. * selection: * A GtkTreeSelection. * model: * A pointer to set to the GtkTreeModel, or NULL. * iter: * The GtkTreeIter, or NULL. * Returns: * TRUE, if there is a selected node. */ int getSelected(TreeModel model, TreeIter iter) { GtkTreeModel* m = model.getTreeModelStruct(); return gtk_tree_selection_get_selected(gtkTreeSelection, &m, iter.getTreeIterStruct())==0 ? false : true; } /** * Creates a list of path of all selected rows. Additionally, if you are * planning on modifying the model after calling this function, you may * want to convert the returned list into a list of GtkTreeRowReferences. * To do this, you can use gtk_tree_row_reference_new(). * To free the return value, use: * g_list_foreach (list, gtk_tree_path_free, NULL); * g_list_free (list); * selection: * A GtkTreeSelection. * model: * A pointer to set to the GtkTreeModel, or NULL. * Returns: * A GList containing a GtkTreePath for each selected row. * Since 2.2 */ TreePath[] getSelectedRows(TreeModel model) { //printf("getSelectedRows(model) 1\n"); GtkTreeModel* m = model.getTreeModelStruct(); //printf("getSelectedRows(model) 2\n"); ListG list = new ListG( gtk_tree_selection_get_selected_rows(gtkTreeSelection, &m) ); //printf("getSelectedRows(model) 3\n"); TreePath[] paths; //printf("getSelectedRows(model) 4 list.length() = %d\n",list.length()); for ( int i=0 ; i 0 ) { model.getIter(iter,paths[0]); } return iter; } TreeIter[] getSelectedIters() { TreeIter[] iters; TreeIter iter = new TreeIter(); TreeSelection selection = getSelection(); TreeModel model = getModel(); TreePath[] paths = selection.getSelectedRows(model); foreach ( TreePath p; selection.getSelectedRows(model) ) { //iters.length = iters.length+1; //iters[iters.length-1] = model.getIter(iter,p); // iters ~= model.getIter(iter,p); >>> compile error can only concatenate arrays ??? if ( model.getIter(iter,p) ) { iters ~= iter; iter = new TreeIter(); } } //printf("TreeView.getSelectedIters iters.lenght = %d\n", iters.length); return iters; } /** * Inserts a column and sets it's attributes * @param position * @param title * @param renderer * @param editable * @return number of columns including the new one */ gint insertEditableColumn(int position, char[] title, CellRenderer renderer, bit editable) { // OK, this is a trick because of my ignorance on how to pass variable argument lists if ( position < 0 ) { position = getColumns().length(); } int tot = gtk_tree_view_insert_column_with_attributes( gtkTreeView, position, Str.toStringz(title), renderer.getCellRendererStruct(), Str.toStringz("text"),position,//v1.getV(), Str.toStringz("editable"),2,0);//v.getV(),0); return tot; } code: end outFile: TreeView file: gtk-GtkTreeView-drag-and-drop.html struct: GtkTreeDragSource class: TreeDragSource prefix: gtk_tree_drag_ prefix: gtk_ import: gtk.TreePath #import: gtk.SelectionData #import: gtk.TreeDragDest import: gtk.TreeModel outFile: TreeDragSource file: GtkCellView.html struct: GtkCellView class: CellView prefix: gtk_cell_view_ prefix: gtk_ import: glib.Str import: gdk.Pixbuf import: gtk.TreeModel import: gtk.TreePath #import: gtk.Requisition import: gdk.Color import: glib.ListG nocode: gtk_cell_view_new_with_text nocode: gtk_cell_view_new_with_markup code: start /** * Creates a new GtkCellView widget, adds a GtkCellRendererText * to it, and makes its show text. * If markup is true the text can be marked up with the Pango text * markup language. * text: * the text to display in the cell view * Returns: * A newly created GtkCellView widget. * Since 2.6 */ public this (char[] text, bit markup=true) { if ( markup ) { // GtkWidget* gtk_cell_view_new_with_markup (const gchar *markup); this(cast(GtkCellView*)gtk_cell_view_new_with_markup(Str.toStringz(text)) ); } else { // GtkWidget* gtk_cell_view_new_with_text (const gchar *text); this(cast(GtkCellView*)gtk_cell_view_new_with_text(Str.toStringz(text)) ); } } code: end outFile: CellView file: GtkIconView.html struct: GtkIconView class: IconView prefix: gtk_icon_view_ prefix: gtk_ import: gtk.TreeModel import: gtk.TreePath #import: gtk.TreePath* #import: gtk.CellRenderer* import: gtk.CellRenderer import: glib.ListG #import: gtk.TargetEntry #import: gtk.IconViewDropPosition import: gdk.Pixmap outFile: IconView file: GtkTreeSortable.html struct: GtkTreeSortable class: TreeSortable prefix: gtk_tree_sortable_ prefix: gtk_ #import: gtk.SortType outFile: TreeSortable file: GtkTreeModelSort.html struct: GtkTreeModelSort class: TreeModelSort import: glib.Str prefix: gtk_tree_model_sort_ prefix: gtk_ import: gtk.TreeModel import: gtk.TreePath import: gtk.TreeIter outFile: TreeModelSort file: GtkTreeModelFilter.html struct: GtkTreeModelFilter class: TreeModelFilter prefix: gtk_tree_model_filter_ prefix: gtk_ import: gtk.TreeModel import: gtk.TreePath #import: gobject.Type import: gtk.TreeIter outFile: TreeModelFilter file: GtkCellLayout.html struct: GtkCellLayout class: CellLayoutT template: TStruct prefix: gtk_cell_layout_ prefix: gtk_ import: glib.Str import: gtk.CellRenderer import: glib.Str #interface: CellLayoutIF outFile: CellLayoutT file: GtkCellRenderer.html struct: GtkCellRenderer class: CellRenderer prefix: gtk_cell_renderer_ prefix: gtk_ import: glib.Str import: gtk.Widget import: gtk.ObjectGtk import: gdk.Rectangle import: gdk.Window import: gdk.Event import: gtk.CellEditable outFile: CellRenderer file: GtkCellEditable.html struct: GtkCellEditable class: CellEditable prefix: gtk_cell_editable_ prefix: gtk_ import: gdk.Event outFile: CellEditable file: GtkCellRendererCombo.html #struct: GtkCellRenderer #realStruct: GtkCellRendererCombo struct: GtkCellRendererCombo class: CellRendererCombo prefix: gtk_cell_renderer_combo_ prefix: gtk_ import: gtk.CellRenderer outFile: CellRendererCombo file: GtkCellRendererPixbuf.html #struct: GtkCellRenderer #realStruct: GtkCellRendererPixbuf struct: GtkCellRendererPixbuf class: CellRendererPixbuf prefix: gtk_cell_renderer_pixbuf_ prefix: gtk_ import: gtk.CellRenderer outFile: CellRendererPixbuf file: GtkCellRendererProgress.html #struct: GtkCellRenderer #realStruct: GtkCellRendererProgress struct: GtkCellRendererProgress class: CellRendererProgress prefix: gtk_cell_renderer_progress_ prefix: gtk_ import: gtk.CellRenderer outFile: CellRendererProgress file: GtkCellRendererText.html #struct: GtkCellRenderer #realStruct: GtkCellRendererText struct: GtkCellRendererText class: CellRendererText prefix: gtk_cell_renderer_text_ prefix: gtk_ import: glib.Str import: gtk.CellRenderer outFile: CellRendererText file: GtkCellRendererToggle.html #struct: GtkCellRenderer #realStruct: GtkCellRendererToggle struct: GtkCellRendererToggle class: CellRendererToggle prefix: gtk_cell_renderer_toggle_ prefix: gtk_ import: glib.Str import: gtk.CellRenderer outFile: CellRendererToggle file: GtkListStore.html struct: GtkListStore class: ListStore extend: GtkTreeModel prefix: gtk_list_store_ prefix: gtk_ import: gtk.TreeModel import: glib.Str import: gobject.Type import: gtk.TreeIter import: gobject.Value import: gobject.bindinggobject import: glib.Str nocode: gtk_list_store_set jscode: gtk_list_store_new // construct from Model if ((arglist.length == 1) && (arglist[0].vtype == V_OBJECT)) { Wrapped_GtkListStore* _ret = cast(Wrapped_GtkListStore* ) ((arglist[0].toObject()).getStruct()); ret.putVobject(new dsWrapped_GtkListStore(_ret)); return null; } Enum_GType[] types; for (int i=0;i < arglist.length; i++) { // check type is string? Enum_GType t = g_type_from_name(std.string.toStringz(arglist[i].toString())); types ~= t; std.stdio.writefln("ADDED type %d %s", cast(int) t, std.string.toString(g_type_name(t))); } Wrapped_GtkListStore* _ret = cast(Wrapped_GtkListStore* ) gtk_list_store_newv(types.length, cast(Enum_GType*)(types.ptr)); ret.putVobject(new dsWrapped_GtkListStore(_ret)); jscode:end jscode: gtk_list_store_set // iterm, key , value? Wrapped_GtkListStore* _arg_list_store = cast(Wrapped_GtkListStore*) (othis.getStruct()); Wrapped_GtkTreeIter* _arg_iter = cast(Wrapped_GtkTreeIter*) (arglist[0].toObject().getStruct()); int _arg_column = cast(int) arglist[1].toInteger(); Wrapped_GValue* _arg_value = cast(Wrapped_GValue*) dsWrapped_GValue.newFromValue(arglist[2]); gtk_list_store_set_value(_arg_list_store, _arg_iter, _arg_column, _arg_value); ret.putVundefined(); // ret.putVobject(new dsWrapped_GtkListStore(_ret)); jscode:end code: start /** * Non-vararg creation function. Used primarily by language bindings. * n_columns: * number of columns in the list store * types: * an array of GType types for the columns, from first to last * Returns: * a new GtkListStore */ public this (GType[] types) { // GtkListStore* gtk_list_store_newv (gint n_columns, GType *types); this(cast(GtkListStore*)gtk_list_store_newv(types.length, cast(GType*)(types.ptr)) ); } /** * Creates a top level iteractor. * I don't think lists have but the top level iteractor */ TreeIter createIter() { GtkTreeIter* iter = new GtkTreeIter; gtk_list_store_append(getListStoreStruct(), iter); return new TreeIter(iter); } /** * sets the values for one row * @param iter the row iteractor * @param columns an arrays with the columns to set * @param values an arrays with the values */ void set(TreeIter iter, int [] columns, char*[] values) { for ( int i=0 ; i 1 ? cast(Wrapped_GtkTreeIter*) ((cast (Dobject)(arglist[1].toObject())).getStruct()) : null; gtk_tree_store_append(_arg_tree_store,_arg_iter,_arg_parent); ret.putVundefined(); jscode:end code: start // todo!! public TreeIter prepend(TreeIter parent) { TreeIter iter = new TreeIter(); // void gtk_tree_store_prepend (GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent); gtk_tree_store_prepend(gtkTreeStore, iter.getTreeIterStruct(), (parent is null) ? null : parent.getTreeIterStruct()); return iter; } / code: end outFile: TreeStore ########################################################### ### Menus, Combo Box, Toolbar ############################# ########################################################### file: GtkComboBox.html struct: GtkComboBox class: ComboBox #implements: CellLayoutIF import: atk.ObjectAtk prefix: gtk_combo_box_ prefix: gtk_ import: glib.Str import: gtk.TreeModel import: gtk.TreeIter import: gtk.CellRenderer import: gtk.CellLayoutT jscode: gtk_combo_box_new Wrapped_GtkComboBox* _ret; if (arglist.length && arglist[0].toBoolean()) { _ret = cast(Wrapped_GtkComboBox* ) (gtk_combo_box_new_text()); } else { _ret = cast(Wrapped_GtkComboBox* ) (gtk_combo_box_new()); } if (!_ret) { ret.putVnull(); return null; } ret.putVobject(new dsWrapped_GtkComboBox(_ret)); jscode: end nocode: gtk_combo_box_new nocode: gtk_combo_box_new_text code: start private int count = 0; public int maxCount = 0; // add the CellLayout capabilities mixin CellLayoutT!(GtkComboBox); /** * Creates a new empty GtkComboBox. * If text is true then * constructs a new text combo box, which is a * GtkComboBox just displaying strings. If you use this function to create * a text combo box, you should only manipulate its data source with the * following convenience functions: gtk_combo_box_append_text(), * gtk_combo_box_insert_text(), gtk_combo_box_prepend_text() and * gtk_combo_box_remove_text(). * Returns: * A new GtkComboBox. * Since 2.4 */ public this (bit text=true) { if ( text ) { // GtkWidget* gtk_combo_box_new_text (void); this(cast(GtkComboBox*)gtk_combo_box_new_text() ); } else { // GtkWidget* gtk_combo_box_new (void); this(cast(GtkComboBox*)gtk_combo_box_new() ); } } public void setActiveText(char[] text, bool insert=false) { int currActive = getActive(); int active = 0; setActive(active); bool found = false; while ( !found && active==getActive) { found = text==getActiveText(); ++active; } if ( !found ) { if ( insert ) { appendText(text); setActive(active); } else { //setActive(currActive); setActive(-1); } } } int getIndex(char[] text) { TreeIter iter = new TreeIter(); TreeModel model = getModel(); iter.setModel(model); int index = 0; bit found = false; bit end = false; if ( model.getIterFirst(iter) ) { while ( !end && iter !is null && !found ) { found = iter.getValueString(0) == text; if ( !found ) { end = !model.iterNext(iter); ++index; } } } else { end = true; } return end ? -1 : index; } void prependOrReplaceText(char[] text) { int index = getIndex(text); if ( index > 0 ) { removeText(index); prependText(text); } else if ( index == -1 ) { prependText(text); } } code: end outFile: ComboBox file: GtkComboBoxEntry.html struct: GtkComboBoxEntry class: ComboBoxEntry prefix: gtk_combo_box_entry_ #noprefix: gtk_combo_box_entry_new_text #noprefix: gtk_combo_box_append_text #noprefix: gtk_combo_box_insert_text #noprefix: gtk_combo_box_prepend_text #noprefix: gtk_combo_box_remove_text import: gtk.TreeModel import: glib.Str import: gtk.CellRenderer #import: gtk.CellLayoutIF import: gtk.CellLayoutT nocode: gtk_combo_box_entry_new nocode: gtk_combo_box_entry_new_text code: start mixin CellLayoutT!(GtkComboBoxEntry); /** * Creates a new GtkComboBoxEntry which has a GtkEntry as child. After * construction, you should set a model using gtk_combo_box_set_model() and a * text_column * using gtk_combo_box_entry_set_text_column(). * Returns: * A new GtkComboBoxEntry. * Since 2.4 */ public this (bit text=true) { if ( text ) { // GtkWidget* gtk_combo_box_entry_new_text (void); this(cast(GtkComboBoxEntry*)gtk_combo_box_entry_new_text() ); } else { // GtkWidget* gtk_combo_box_entry_new (void); this(cast(GtkComboBoxEntry*)gtk_combo_box_entry_new() ); } } code: end outFile: ComboBoxEntry #struct: GtkComboBoxEntry #class: ComboBoxEntryText #filterIn: gtk_combo_box_entry_new_text #filterIn: gtk_combo_box_append_text #filterIn: gtk_combo_box_insert_text #filterIn: gtk_combo_box_prepend_text #filterIn: gtk_combo_box_remove_text #strictPrefix: Y #outFile: ComboBoxEntryText file: GtkMenu.html struct: GtkMenu class: Menu prefix: gtk_menu_ prefix: gtk_ import: glib.Str import: gtk.Widget import: gtk.MenuShell import: gdk.Screen import: gtk.AccelGroup import: glib.ListG import: gtk.MenuItem outFile: Menu file: GtkMenuBar.html struct: GtkMenuBar class: MenuBar prefix: gtk_menu_bar_ prefix: gtk_ import: gtk.Widget import: gtk.Menu; import: gtk.MenuItem; code: start code: end outFile: MenuBar file: GtkMenuItem.html struct: GtkMenuItem class: MenuItem prefix: gtk_menu_item_ prefix: gtk_ import: glib.Str import: gtk.Widget import: gtk.Item import: gtk.AccelGroup nocode: gtk_menu_item_activate nocode: gtk_menu_item_new_with_label nocode: gtk_menu_item_new_with_mnemonic # TODO create a method rename instead of replacing the entire code jscode: gtk_menu_item_new // no mnemonic suport yet! Wrapped_GtkMenuItem* _ret; if (arglist.length) { char[] _arg_label = arglist[0].toString(); _ret = cast(Wrapped_GtkMenuItem* ) (gtk_menu_item_new_with_label(std.string.toStringz(_arg_label))); } else { _ret = cast(Wrapped_GtkMenuItem* ) gtk_menu_item_new(); } ret.putVobject(new dsWrapped_GtkMenuItem(_ret)); jscode: end jscode: gtk_menu_item_new_with_mnemonic // no mnemonic suport yet! Wrapped_GtkMenuItem* _ret; char[] _arg_label = arglist[0].toString(); _ret = cast(Wrapped_GtkMenuItem* ) (gtk_menu_item_new_with_mnemonic(std.string.toStringz(_arg_label))); ret.putVobject(new dsWrapped_GtkMenuItem(_ret)); jscode: end code: start /** store the action code passed in by the applcation */ private char[] actionLabel; /** Gets the application set action code */ public char[] getActionName() { if ( actionLabel is null ) { actionLabel = ""; } return actionLabel; } /** * Creates a new Item associated with a "activate" delegate and with a action code * and optionally accelGroup */ public this(void delegate(MenuItem) dlg, char[] label, char[] action, bit mnemonic=true, AccelGroup accelGroup=null, char accelKey='\0', GdkModifierType modifierType=GdkModifierType.CONTROL_MASK, GtkAccelFlags accelFlags=GtkAccelFlags.VISIBLE ) { this(label, mnemonic); this.actionLabel = action; addOnActivate(dlg); if ( accelGroup !is null && accelKey != '\0' ) { addAccelerator("activate",accelGroup,accelKey,modifierType,accelFlags); } } /** * Creates a new Item associated with a "activate" delegate */ public this(void delegate(MenuItem) dlg, char[] label, bit mnemonic=true) { this(label, mnemonic); addOnActivate(dlg); } /** * Creates a new GtkMenuItem whose child is a GtkLabel. * If mnemonic is true the label * will be created using gtk_label_new_with_mnemonic(), so underscores * in label indicate the mnemonic for the menu item. * label: * the text for the label * Returns: * the newly created GtkMenuItem */ public this (char[] label, bit mnemonic=true) { if ( mnemonic ) { // GtkWidget* gtk_menu_item_new_with_mnemonic (const gchar *label); this(cast(GtkMenuItem*)gtk_menu_item_new_with_mnemonic(Str.toStringz(label)) ); } else { // GtkWidget* gtk_menu_item_new_with_label (const gchar *label); this(cast(GtkMenuItem*)gtk_menu_item_new_with_label(Str.toStringz(label)) ); } setName(label); } /** * Emits the "activate" signal on the given item * menu_item: * the menu item */ public void itemActivate() { // void gtk_menu_item_activate (GtkMenuItem *menu_item); gtk_menu_item_activate(gtkMenuItem); } code: end outFile: MenuItem file: GtkMenuShell.html struct: GtkMenuShell class: MenuShell prefix: gtk_menu_shell_ prefix: gtk_ import: gtk.Widget import: gtk.Container outFile: MenuShell file: GtkImageMenuItem.html struct: GtkImageMenuItem class: ImageMenuItem prefix: gtk_image_menu_item_ prefix: gtk_ import: glib.Str import: gtk.Widget import: gtk.AccelGroup nocode: gtk_image_menu_item_new_with_label nocode: gtk_image_menu_item_new_with_mnemonic code: start /** * Creates a new GtkImageMenuItem containing a label. * If mnemonic it true the label * will be created using gtk_label_new_with_mnemonic(), so underscores * in label indicate the mnemonic for the menu item. * label: * the text of the menu item. * Returns: * a new GtkImageMenuItem. */ public this (char[] label, bit mnemonic=true) { if ( mnemonic ) { // GtkWidget* gtk_image_menu_item_new_with_mnemonic (const gchar *label); this(cast(GtkImageMenuItem*)gtk_image_menu_item_new_with_mnemonic(Str.toStringz(label)) ); } else { // GtkWidget* gtk_image_menu_item_new_with_label (const gchar *label); this(cast(GtkImageMenuItem*)gtk_image_menu_item_new_with_label(Str.toStringz(label)) ); } } code: end outFile: ImageMenuItem file: GtkRadioMenuItem.html struct: GtkRadioMenuItem class: RadioMenuItem prefix: gtk_radio_menu_item_ prefix: gtk_ import: glib.Str import: glib.ListSG nocode: gtk_radio_menu_item_new_with_label nocode: gtk_radio_menu_item_new_with_mnemonic nocode: gtk_radio_menu_item_new_with_mnemonic_from_widget nocode: gtk_radio_menu_item_new_with_label_from_widget code: start /** * Creates a new GtkRadioMenuItem whose child is a simple GtkLabel. * The new GtkRadioMenuItem is added to the same group as group. * If mnemonic is true the label will be * created using gtk_label_new_with_mnemonic(), so underscores in label * indicate the mnemonic for the menu item. * group: * an existing GtkRadioMenuItem * label: * the text for the label * Returns: * The new GtkRadioMenuItem * Since 2.4 */ public this (RadioMenuItem radioMenuItem, char[] label, bit mnemonic=true) { if ( mnemonic ) { // GtkWidget* gtk_radio_menu_item_new_with_mnemonic_from_widget (GtkRadioMenuItem *group, const gchar *label); this(cast(GtkRadioMenuItem*)gtk_radio_menu_item_new_with_mnemonic_from_widget( radioMenuItem.getRadioMenuItemStruct(), Str.toStringz(label)) ); } else { // GtkWidget* gtk_radio_menu_item_new_with_label_from_widget (GtkRadioMenuItem *group, const gchar *label); this(cast(GtkRadioMenuItem*)gtk_radio_menu_item_new_with_label_from_widget( radioMenuItem.getRadioMenuItemStruct(), Str.toStringz(label)) ); } } /** * Creates a new GtkRadioMenuItem containing a label. T * The new GtkRadioMenuItem is added to the same group as group. * group: * An existing GtkRadioMenuItem * label: * the text of the button, with an underscore in front of the * mnemonic character * Returns: * The new GtkRadioMenuItem * Since 2.4 */ public this (char[] label) { } /** * Creates a new GtkRadioMenuItem whose child is a simple GtkLabel. * If mnemonic is true the label * will be created using gtk_label_new_with_mnemonic(), so underscores * in label indicate the mnemonic for the menu item. * group: * the group to which the radio menu item is to be attached * label: * the text for the label * Returns: * a new GtkRadioMenuItem */ public this (ListSG group, char[] label, bit mnemonic=true) { if ( mnemonic ) { // GtkWidget* gtk_radio_menu_item_new_with_mnemonic (GSList *group, const gchar *label); this(cast(GtkRadioMenuItem*)gtk_radio_menu_item_new_with_mnemonic( group is null ? null : group.getListSGStruct(), Str.toStringz(label)) ); } else { // GtkWidget* gtk_radio_menu_item_new_with_label (GSList *group, const gchar *label); this(cast(GtkRadioMenuItem*)gtk_radio_menu_item_new_with_label( group is null ? null : group.getListSGStruct(), Str.toStringz(label)) ); } } code: end outFile: RadioMenuItem file: GtkCheckMenuItem.html struct: GtkCheckMenuItem class: CheckMenuItem prefix: gtk_check_menu_item_ prefix: gtk_ import: glib.Str nocode: gtk_check_menu_item_new_with_label nocode: gtk_check_menu_item_new_with_mnemonic code: start /** * Creates a new GtkCheckMenuItem with a label. * If mnemonic it true the label * will be created using gtk_label_new_with_mnemonic(), so underscores * in label indicate the mnemonic for the menu item. * label: * the string to use for the label. * Returns: * a new GtkCheckMenuItem. */ public this (char[] label, bit mnemonic=true) { if ( mnemonic ) { // GtkWidget* gtk_check_menu_item_new_with_mnemonic (const gchar *label); this(cast(GtkCheckMenuItem*)gtk_check_menu_item_new_with_mnemonic(Str.toStringz(label)) ); } else { // GtkWidget* gtk_check_menu_item_new_with_label (const gchar *label); this(cast(GtkCheckMenuItem*)gtk_check_menu_item_new_with_label(Str.toStringz(label)) ); } } code: end outFile: CheckMenuItem file: GtkSeparatorMenuItem.html struct: GtkSeparatorMenuItem class: SeparatorMenuItem prefix: gtk_separator_menu_item_ prefix: gtk_ outFile: SeparatorMenuItem file: GtkTearoffMenuItem.html struct: GtkTearoffMenuItem class: TearoffMenuItem prefix: gtk_tearoff_menu_item_ prefix: gtk_ outFile: TearoffMenuItem file: GtkToolbar.html struct: GtkToolbar class: Toolbar prefix: gtk_toolbar_ prefix: gtk_ import: glib.Str import: gtk.Widget import: gtk.Button import: gtk.ToolItem nocode: gtk_toolbar_get_style #depreciated jsnocode: gtk_toolbar_append_element jsnocode: gtk_toolbar_append_item jsnocode: gtk_toolbar_insert_element jsnocode: gtk_toolbar_insert_item jsnocode: gtk_toolbar_insert_stock jsnocode: gtk_toolbar_prepend_element jsnocode: gtk_toolbar_prepend_item code: start /** * Retrieves whether the toolbar has text, icons, or both . See * gtk_toolbar_set_style(). * toolbar: * a GtkToolbar * Returns: * the current style of toolbar */ public GtkToolbarStyle toolbarGetStyle() { // GtkToolbarStyle gtk_toolbar_get_style (GtkToolbar *toolbar); return gtk_toolbar_get_style(gtkToolbar); } public void insert (ToolItem toolItem, int pos=-1) { gtk_toolbar_insert(gtkToolbar, toolItem.getToolItemStruct(), pos); } public Widget insertStock(StockID stockId, char[] tooltipText, char[] tooltipPrivateText, GtkSignalFunc callback, void* userData, int position) { return insertStock(getId(stockId), tooltipText, tooltipPrivateText, callback, userData, position); } public Widget insertStock(char[] stockId, char[] tooltipText, char[] tooltipPrivateText, int position) { return insertStock(stockId, tooltipText, tooltipPrivateText, null, null, position); } public Widget insertStock(StockID stockId, char[] tooltipText, char[] tooltipPrivateText, int position) { return insertStock(getId(stockId), tooltipText, tooltipPrivateText, null, null, position); } Button insertButton(StockID stockID, char[] tooltipText, char[] tooltipPrivateText, gint position) { Button button = new Button( cast(GtkButton*)gtk_toolbar_insert_stock( gtkToolbar, Str.toStringz(StockDesc[stockID]), Str.toStringz(tooltipText), Str.toStringz(tooltipPrivateText), null, null, position) ); return button; } code: end outFile: Toolbar file: GtkToolItem.html struct: GtkToolItem class: ToolItem prefix: gtk_tool_item_ prefix: gtk_ import: glib.Str import: gtk.Tooltips import: gtk.Bin import: gtk.Widget code: start /** * Sets this widget tooltip * @param tipText the tooltip * @param tipPrivate a private text */ void setTooltip(char[] tipText, char[] tipPrivate) { Tooltips tt = new Tooltips(); tt.setTip(this, tipText, tipPrivate); } code: end outFile: ToolItem file: GtkSeparatorToolItem.html struct: GtkSeparatorToolItem ctorStruct: GtkToolItem class: SeparatorToolItem prefix: gtk_separator_tool_item_ prefix: gtk_ import: gtk.ToolItem outFile: SeparatorToolItem file: GtkToolButton.html struct: GtkToolButton ctorStruct: GtkToolItem class: ToolButton prefix: gtk_tool_button_ prefix: gtk_ import: glib.Str import: gtk.ToolItem import: gtk.Widget jscode: gtk_tool_button_new Wrapped_GtkToolButton* _ret; if (arglist.length == 1 && arglist[0].vtype == V_STRING) { char* _stockId = std.string.toStringz(arglist[0].toString()); _ret = cast(Wrapped_GtkToolButton* ) (gtk_tool_button_new_from_stock(_stockId)); } else { Wrapped_GtkWidget* _arg_icon_widget = cast(Wrapped_GtkWidget*) (arglist[0].vtype == V_OBJECT ? arglist[0].toObject().getStruct() : null); char* _arg_label = arglist[1].vtype == V_NULL ? null : std.string.toStringz(arglist[1].toString()); _ret = cast(Wrapped_GtkToolButton* ) (gtk_tool_button_new(_arg_icon_widget,_arg_label)); } if (!_ret) { ret.putVnull(); return null; } ret.putVobject(new dsWrapped_GtkToolButton(_ret)); jscode: end code: start /** An arbitrary string to be used by the application */ private char[] action; public void setActionName(char[] action) { this.action = action.dup; } public char[] getActionName() { return action; } public this (StockID stockID) { this(StockDesc[stockID]); } code: end outFile: ToolButton file: GtkMenuToolButton.html struct: GtkMenuToolButton ctorStruct: GtkToolItem class: MenuToolButton prefix: gtk_menu_tool_button_ prefix: gtk_ import: glib.Str import: gtk.ToolItem import: gtk.Widget import: gtk.Tooltips import: gtk.Menu nocode: gtk_menu_tool_button_new nocode: gtk_menu_tool_button_new_from_stock nocode: gtk_menu_tool_button_get_menu jscode: gtk_menu_tool_button_new Wrapped_GtkMenuToolButton* _ret; if (arglist.length == 1 && arglist[0].vtype == V_STRING) { char* _stockId = std.string.toStringz(arglist[0].toString()); _ret = cast(Wrapped_GtkMenuToolButton* ) (gtk_menu_tool_button_new_from_stock(_stockId)); } else { Wrapped_GtkWidget* _arg_icon_widget = cast(Wrapped_GtkWidget*) (arglist[0].vtype == V_OBJECT ? arglist[0].toObject().getStruct() : null); char* _arg_label = arglist[1].vtype == V_NULL ? null : std.string.toStringz(arglist[1].toString()); _ret = cast(Wrapped_GtkMenuToolButton* ) (gtk_menu_tool_button_new(_arg_icon_widget,_arg_label)); } if (!_ret) { ret.putVnull(); return null; } ret.putVobject(new dsWrapped_GtkMenuToolButton(_ret)); jscode: end code: start /** * Creates a new GtkMenuToolButton using icon_widget as icon and * label as label. * icon_widget: * a widget that will be used as icon widget, or NULL * label: * a string that will be used as label, or NULL * Returns: * the new GtkMenuToolButton * Since 2.6 */ public this(Widget iconWidget, char[] label) { // GtkToolItem* gtk_menu_tool_button_new (GtkWidget *icon_widget, const gchar *label); this( cast(GtkMenuToolButton*)gtk_menu_tool_button_new( (iconWidget is null) ? null : iconWidget.getWidgetStruct(), Str.toStringz(label)) ); } /** * Creates a new GtkMenuToolButton. * The new GtkMenuToolButton will contain an icon and label from * the stock item indicated by stock_id. * stock_id: * the name of a stock item * Returns: * the new GtkMenuToolButton * Since 2.6 */ public this(StockID stockId) { // GtkToolItem* gtk_menu_tool_button_new_from_stock (const gchar *stock_id); this( cast(GtkMenuToolButton*)gtk_menu_tool_button_new_from_stock( Str.toStringz(StockDesc[stockId])) ); } /** * Gets the GtkMenu associated with GtkMenuToolButton. * button: * a GtkMenuToolButton * Returns: * the GtkMenu associated with GtkMenuToolButton * Since 2.6 */ public Menu getMenu() { // GtkWidget* gtk_menu_tool_button_get_menu (GtkMenuToolButton *button); return new Menu( cast(GtkMenu*)gtk_menu_tool_button_get_menu(gtkMenuToolButton) ); } /** * Sets the toolTip for the arrow * Params: * tipText = * tipPrivate = */ public void setArrowTooltip(char[] tipText, char[] tipPrivate) { Tooltips tooltips = new Tooltips(); gtk_menu_tool_button_set_arrow_tooltip( gtkMenuToolButton, (tooltips is null) ? null : tooltips.getTooltipsStruct(), Str.toStringz(tipText), Str.toStringz(tipPrivate) ); } code: end outFile: MenuToolButton file: GtkToggleToolButton.html struct: GtkToggleToolButton ctorStruct: GtkToolItem class: ToggleToolButton prefix: gtk_toggle_tool_button_ prefix: gtk_ import: glib.Str import: gtk.ToolItem outFile: ToggleToolButton file: GtkRadioToolButton.html struct: GtkRadioToolButton ctorStruct: GtkToolItem class: RadioToolButton prefix: gtk_radio_tool_button_ prefix: gtk_ import: glib.Str import: gtk.ToolItem import: glib.ListSG outFile: RadioToolButton ########################################################### ### Action-based menus and toolbars ####################### ########################################################### file: GtkUIManager.html struct: GtkUIManager class: UIManager prefix: gtk_ui_manager_ prefix: gtk_ import: glib.Str import: gtk.ActionGroup import: glib.ListG import: gtk.AccelGroup import: gtk.Widget import: glib.ListSG import: gtk.Action outFile: UIManager file: GtkActionGroup.html struct: GtkActionGroup class: ActionGroup prefix: gtk_action_group_ prefix: gtk_ import: glib.Str import: gtk.Action import: glib.ListG #util methods. noprefix: gtk_action_group_add_actions noprefix: gtk_action_group_add_radio_actions noprefix: gtk_action_group_add_toggle_actions outFile: ActionGroup file: GtkAction.html struct: GtkAction class: Action prefix: gtk_action_ prefix: gtk_ import: glib.Str import: gtk.Widget import: glib.ListSG import: gobject.Closure import: gtk.AccelGroup outFile: Action file: GtkToggleAction.html struct: GtkToggleAction class: ToggleAction prefix: gtk_toggle_action_ prefix: gtk_ import: glib.Str outFile: ToggleAction file: GtkRadioAction.html struct: GtkRadioAction class: RadioAction prefix: gtk_radio_action_ prefix: gtk_ import: glib.Str import: glib.ListSG outFile: RadioAction ########################################################### ### Selectors (File/Font/Color/Input Devices) ############ ########################################################### file: GtkColorButton.html struct: GtkColorButton class: ColorButton prefix: gtk_color_button_ prefix: gtk_ import: glib.Str import: gdk.Color outFile: ColorButton file: GtkColorSelection.html struct: GtkColorSelection class: ColorSelection prefix: gtk_color_selection_ prefix: gtk_ import: glib.Str import: gdk.Color outFile: ColorSelection file: GtkColorSelectionDialog.html struct: GtkColorSelectionDialog class: ColorSelectionDialog prefix: gtk_color_selection_dialog_ prefix: gtk_ import: glib.Str outFile: ColorSelectionDialog file: GtkFileSelection.html struct: GtkFileSelection class: FileSelection prefix: gtk_file_selection_ prefix: gtk_ import: glib.Str outFile: FileSelection file: GtkFileChooser.html struct: GtkFileChooser class: FileChooser prefix: gtk_file_chooser_ prefix: gtk_ import: glib.Str import: gtk.Window import: glib.ListSG import: gtk.Widget import: gtk.FileFilter outFile: FileChooser file: GtkFileChooserButton.html struct: GtkFileChooserButton class: FileChooserButton prefix: gtk_file_chooser_button_ prefix: gtk_ import: glib.Str import: gtk.Widget import: glib.ListSG; import: gtk.Widget; import: gtk.FileFilter; import: gtk.FileChooser; code: start private FileChooser fileChooser; public FileChooser getFileChooser() { if ( fileChooser is null ) { fileChooser = new FileChooser(cast(GtkFileChooser*)getFileChooserButtonStruct()); } return fileChooser; } code: end outFile: FileChooserButton file: GtkFileChooserDialog.html struct: GtkFileChooserDialog class: FileChooserDialog prefix: gtk_file_chooser_dialog_ prefix: gtk_ import: glib.Str import: gtk.Window import: glib.ListSG; import: gtk.Widget; import: gtk.FileFilter; import: gtk.FileChooser; import: glib.Str nocode: gtk_file_chooser_dialog_new nocode: gtk_file_chooser_dialog_new_with_backend code: start private FileChooser fileChooser; public FileChooser getFileChooser() { if ( fileChooser is null ) { fileChooser = new FileChooser(cast(GtkFileChooser*)getFileChooserDialogStruct()); } return fileChooser; } /** * Creates a new GtkFileChooserDialog. This function is analogous to * gtk_dialog_new_with_buttons(). * title: * Title of the dialog, or NULL * parent: * Transient parent of the dialog, or NULL * action: * Open or save mode for the dialog * first_button_text: * stock ID or text to go in the first button, or NULL * ...: * response ID for the first button, then additional (button, id) pairs, ending with NULL * Returns: * a new GtkFileChooserDialog * Since 2.4 */ this(char[] title, Window parent, FileChooserAction action, char[][] buttonsText=null, ResponseType[] responses=null) { if ( buttonsText is null ) { buttonsText ~= "OK"; buttonsText ~= "Cancel"; } if ( responses is null ) { responses ~= ResponseType.GTK_RESPONSE_OK; responses ~= ResponseType.GTK_RESPONSE_CANCEL; } this( cast(GtkFileChooserDialog*)gtk_file_chooser_dialog_new( Str.toStringz(title), parent.getWindowStruct(), action, null, 0)); addButtons(buttonsText, responses); } /** * Creates a new GtkFileChooserDialog with a specified backend. This is * especially useful if you use gtk_file_chooser_set_local_only() to allow * non-local files and you use a more expressive vfs, such as gnome-vfs, * to load files. * title: * Title of the dialog, or NULL * parent: * Transient parent of the dialog, or NULL * action: * Open or save mode for the dialog * backend: * The name of the specific filesystem backend to use. * first_button_text: * stock ID or text to go in the first button, or NULL * ...: * response ID for the first button, then additional (button, id) pairs, ending with NULL * Returns: * a new GtkFileChooserDialog * Since 2.4 * See Also * GtkFileChooser, GtkDialog */ public this (char[] title, Window parent, GtkFileChooserAction action, char[] backend, char[][] buttonsText=null, ResponseType[] responses=null) { // GtkWidget* gtk_file_chooser_dialog_new_with_backend (const gchar *title, GtkWindow *parent, GtkFileChooserAction action, const gchar *backend, const gchar *first_button_text, ...); this( cast(GtkFileChooserDialog*)gtk_file_chooser_dialog_new_with_backend( Str.toStringz(title), parent.getWindowStruct(), action, Str.toStringz(backend), null, 0 )); if ( buttonsText is null ) { buttonsText ~= "OK"; buttonsText ~= "Cancel"; } if ( responses is null ) { responses ~= ResponseType.GTK_RESPONSE_OK; responses ~= ResponseType.GTK_RESPONSE_CANCEL; } addButtons(buttonsText, responses); } // this(char[] title, Window parent, FileChooserAction action, StockID[] buttons=null, ResponseType[] responses=null) // { // if ( buttons is null ) // { // buttons ~= STOCK_OK; // buttons ~= STOCK_CANCEL; // } // if ( responses is null ) // { // responses ~= ResponseType.GTK_RESPONSE_OK; // responses ~= ResponseType.GTK_RESPONSE_CANCEL; // } // // this(gtk_file_chooser_dialog_new( // title.toStringz(), // parent.getWindowStruct(), // action, // null, // 0)); // addButtons(buttons, responses); // } code: end outFile: FileChooserDialog file: GtkFileChooserWidget.html struct: GtkFileChooserWidget class: FileChooserWidget prefix: gtk_file_chooser_widget_ prefix: gtk_ import: glib.Str import: glib.ListSG; import: gtk.Widget; import: gtk.FileFilter; import: gtk.FileChooser; code: start private FileChooser fileChooser; public FileChooser getFileChooser() { if ( fileChooser is null ) { fileChooser = new FileChooser(cast(GtkFileChooser*)getFileChooserWidgetStruct()); } return fileChooser; } code: end outFile: FileChooserWidget file: gtk-gtkfilefilter.html struct: GtkFileFilter class: FileFilter prefix: gtk_file_filter_ prefix: gtk_ import: glib.Str import: gtk.ObjectGtk outFile: FileFilter file: GtkFontButton.html struct: GtkFontButton class: FontButton prefix: gtk_font_button_ prefix: gtk_ import: glib.Str outFile: FontButton file: GtkFontSelection.html struct: GtkFontSelection class: FontSelection prefix: gtk_font_selection_ prefix: gtk_ import: glib.Str import: gdk.Font outFile: FontSelection file: GtkFontSelectionDialog.html struct: GtkFontSelectionDialog class: FontSelectionDialog prefix: gtk_font_selection_dialog_ prefix: gtk_ import: glib.Str import: gdk.Font outFile: FontSelectionDialog file: GtkInputDialog.html struct: GtkInputDialog class: InputDialog prefix: gtk_input_dialog_ prefix: gtk_ outFile: InputDialog ########################################################### ### Layout Containers ##################################### ########################################################### file: GtkAlignment.html struct: GtkAlignment class: Alignment prefix: gtk_alignment_ prefix: gtk_ import: gtk.Widget code: start public static Alignment center(Widget widget) { Alignment a = new Alignment(0.5, 0.5, 0, 0); a.add(widget); return a; } public static Alignment north(Widget widget) { Alignment a = new Alignment(0.5, 0.0, 0, 0); a.add(widget); return a; } public static Alignment south(Widget widget) { Alignment a = new Alignment(0.5, 1.0, 0, 0); a.add(widget); return a; } public static Alignment east(Widget widget) { Alignment a = new Alignment(1.0, 0.5, 0, 0); a.add(widget); return a; } public static Alignment west(Widget widget) { Alignment a = new Alignment(0.0, 0.5, 0, 0); a.add(widget); return a; } public static Alignment northWest(Widget widget) { Alignment a = new Alignment(0.0, 0.0, 0, 0); a.add(widget); return a; } public static Alignment southWest(Widget widget) { Alignment a = new Alignment(0.0, 0.5, 0, 0); a.add(widget); return a; } public static Alignment northEast(Widget widget) { Alignment a = new Alignment(1.0, 0.0, 0, 0); a.add(widget); return a; } public static Alignment southEast(Widget widget) { Alignment a = new Alignment(1.0, 1.0, 0, 0); a.add(widget); return a; } code: end outFile: Alignment file: GtkAspectFrame.html struct: GtkAspectFrame class: AspectFrame prefix: gtk_aspect_frame_ prefix: gtk_ import: glib.Str outFile: AspectFrame file: GtkHBox.html struct: GtkHBox class: HBox prefix: gtk_hbox_ prefix: gtk_ outFile: HBox file: GtkVBox.html struct: GtkVBox class: VBox prefix: gtk_vbox_ prefix: gtk_ outFile: VBox file: GtkHButtonBox.html struct: GtkHButtonBox class: HButtonBox import: gtk.ButtonBox prefix: gtk_hbutton_box_ prefix: gtk_ code: start /** * Creates a new HButtonBox and sets comon parameters */ static ButtonBox createActionBox() { ButtonBox bBox = new HButtonBox(); bBox.setLayout(ButtonBoxStyle.END); bBox.setBorderWidth(5); bBox.setSpacing(7); return bBox; } code: end outFile: HButtonBox file: GtkVButtonBox.html struct: GtkVButtonBox class: VButtonBox import: gtk.ObjectGtk import: gtk.ButtonBox prefix: gtk_vbutton_box_ prefix: gtk_ code: start /** * Creates a new vertical button box and sets standart values for it's comon parameters * @return a new vertical button box */ static ButtonBox createActionBox() { ButtonBox bBox = new VButtonBox(); bBox.setLayout(ButtonBoxStyle.START); bBox.setBorderWidth(5); bBox.setSpacing(7); return bBox; } code: end outFile: VButtonBox file: GtkFixed.html struct: GtkFixed class: Fixed prefix: gtk_fixed_ prefix: gtk_ import: gtk.Widget outFile: Fixed file: GtkHPaned.html struct: GtkHPaned class: HPaned prefix: gtk_hpaned_ prefix: gtk_ import: gtk.Widget code: start /** * Creates a new HPaned and adds two widgets as it's children * @param child1 * @param child2 */ this(Widget child1, Widget child2) { this(); add1(child1); add2(child2); } code: end outFile: HPaned file: GtkVPaned.html struct: GtkVPaned class: VPaned prefix: gtk_vpaned_ prefix: gtk_ import: gtk.Widget code: start /** * Creates a new HPaned and adds two widgets as it's children * @param child1 * @param child2 */ this(Widget child1, Widget child2) { this(); add1(child1); add2(child2); } code: end outFile: VPaned file: GtkLayout.html struct: GtkLayout class: Layout prefix: gtk_layout_ prefix: gtk_ import: gtk.Adjustment import: gtk.Widget outFile: Layout file: GtkNotebook.html struct: GtkNotebook class: Notebook prefix: gtk_notebook_ prefix: gtk_ import: glib.Str import: gtk.Label import: gtk.Widget code: start /** The GtkNotebookTab is not documented */ public enum GtkNotebookTab { GTK_NOTEBOOK_TAB_FIRST, GTK_NOTEBOOK_TAB_LAST } alias GtkNotebookTab NotebookTab; /** * Append a page with a widget and a text for a label */ public int appendPage(Widget child, char[] tabLabel) { return appendPage(child, new Label(tabLabel)); } void setCurrentPage(Widget child) { gtk_notebook_set_current_page(gtkNotebook,gtk_notebook_page_num(gtkNotebook, child.getWidgetStruct())); } code: end outFile: Notebook file: GtkTable.html struct: GtkTable class: Table import: gtk.Widget prefix: gtk_table_ prefix: gtk_ nocode: gtk_table_new code: start int row; int col; int maxRows; int maxCols; public AttachOptions defaultXOption = AttachOptions.SHRINK; public AttachOptions defaultYOption = AttachOptions.SHRINK; /** * Removes all children and resizes the table to 1,1 */ void removeAll() { super.removeAll(); resize(1,1); } /** * Used to create a new table widget. An initial size must be given by * specifying how many rows and columns the table should have, although * this can be changed later with gtk_table_resize(). rows and columns * must both be in the range 0 .. 65535. * rows: * The number of rows the new table should have. * columns: * The number of columns the new table should have. * homogeneous: * If set to TRUE, all table cells are resized to the size of the cell * containing the largest widget. * Returns: * A pointer to the the newly created table widget. */ public this (uint rows, uint columns, int homogeneous) { // GtkWidget* gtk_table_new (guint rows, guint columns, gboolean homogeneous); this(cast(GtkTable*)gtk_table_new(rows, columns, homogeneous) ); row = 0; col = 0; maxRows = rows; maxCols = columns; } /** * Attach a new widget creating a new row if necessary */ void attach(Widget child) { attach(child, col, col + 1, row, row + 1, defaultXOption, defaultYOption, getDefaultColSpacing(), getDefaultRowSpacing()); ++col; if (col >= maxCols) { col = 0; ++row; } } code: end outFile: Table file: GtkExpander.html struct: GtkExpander class: Expander prefix: gtk_expander_ prefix: gtk_ import: glib.Str import: gtk.Widget nocode: gtk_expander_new nocode: gtk_expander_new_with_mnemonic code: start /** * Creates a new expander using label as the text of the label. * If mnemonic os true * If characters in label are preceded by an underscore, they are underlined. * If you need a literal underscore character in a label, use '__' (two * underscores). The first underlined character represents a keyboard * accelerator called a mnemonic. * label: * the text of the label * Returns: * a new GtkExpander widget. * Since 2.4 */ public this (char[] label, bit mnemonic=true) { if ( mnemonic ) { // GtkWidget* gtk_expander_new_with_mnemonic (const gchar *label); this(cast(GtkExpander*)gtk_expander_new_with_mnemonic(Str.toStringz(label)) ); } else { // GtkWidget* gtk_expander_new (const gchar *label); this(cast(GtkExpander*)gtk_expander_new(Str.toStringz(label)) ); } } code: end outFile: Expander ########################################################### ### Ornaments ############################################# ########################################################### file: GtkFrame.html struct: GtkFrame class: Frame prefix: gtk_frame_ prefix: gtk_ import: glib.Str import: gtk.Widget code: start /** * Creates frame with label and set it's child widget */ public this(Widget widget, char[] label) { this(label); add(widget); } code: end outFile: Frame file: GtkHSeparator.html struct: GtkHSeparator class: HSeparator prefix: gtk_hseparator_ prefix: gtk_ outFile: HSeparator file: GtkVSeparator.html struct: GtkVSeparator class: VSeparator prefix: gtk_vseparator_ prefix: gtk_ outFile: VSeparator ########################################################### ### Scrolling ############################################# ########################################################### file: GtkHScrollbar.html struct: GtkHScrollbar class: HScrollbar prefix: gtk_hscrollbar_ prefix: gtk_ import: gtk.Adjustment outFile: HScrollbar file: GtkVScrollbar.html struct: GtkVScrollbar class: VScrollbar prefix: gtk_vscrollbar_ prefix: gtk_ import: gtk.Adjustment outFile: VScrollbar file: GtkScrolledWindow.html struct: GtkScrolledWindow class: ScrolledWindow prefix: gtk_scrolled_window_ prefix: gtk_ import: gtk.Widget import: gtk.Adjustment nocode: gtk_scrolled_window_new code: start public this() { this(null, null); } public this(Widget widget) { this(); addWithViewport(widget); } /** * Creates a new scrolled window. The two arguments are the scrolled * window's adjustments; these will be shared with the scrollbars and the * child widget to keep the bars in sync with the child. Usually you want * to pass NULL for the adjustments, which will cause the scrolled window * to create them for you. * hadjustment: * Horizontal adjustment. * vadjustment: * Vertical adjustment. * Returns: * New scrolled window. */ public this (Adjustment hadjustment, Adjustment vadjustment) { // GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment, GtkAdjustment *vadjustment); this(cast(GtkScrolledWindow*)gtk_scrolled_window_new( hadjustment is null ? null : hadjustment.getAdjustmentStruct(), vadjustment is null ? null : vadjustment.getAdjustmentStruct()) ); } /** * Creates a new Scrolled window and set the policy type * @param hPolicy the horizontal policy * @param vPolicy the vertical policy */ this(PolicyType hPolicy, PolicyType vPolicy) { this(); setPolicy(hPolicy, vPolicy); } code: end outFile: ScrolledWindow ########################################################### ### Miscellaneous ######################################### ########################################################### file: GtkAdjustment.html struct: GtkAdjustment class: Adjustment prefix: gtk_adjustment_ prefix: gtk_ import: gtk.ObjectGtk outFile: Adjustment file: GtkArrow.html struct: GtkArrow class: Arrow import: gtk.Misc prefix: gtk_arrow_ prefix: gtk_ outFile: Arrow file: GtkCalendar.html struct: GtkCalendar import: gtk.Widget class: Calendar prefix: gtk_calendar_ prefix: gtk_ outFile: Calendar file: GtkDrawingArea.html struct: GtkDrawingArea class: DrawingArea import: gtk.Widget prefix: gtk_drawing_area_ prefix: gtk_ code: start /** * Create a new DrawingArea and sets the SizeRequest * Params: * width = * height = * Returns: */ this(int width, int height) { this(); setSizeRequest(width, height); } code: end outFile: DrawingArea file: GtkEventBox.html struct: GtkEventBox class: EventBox import: gtk.Bin prefix: gtk_event_box_ prefix: gtk_ outFile: EventBox file: GtkHandleBox.html struct: GtkHandleBox class: HandleBox import: gtk.Bin prefix: gtk_handle_box_ prefix: gtk_ outFile: HandleBox file: GtkIMContextSimple.html struct: GtkIMContextSimple class: IMContextSimple prefix: gtk_im_context_simple_ prefix: gtk_ import: gtk.IMContext outFile: IMContextSimple file: GtkIMMulticontext.html struct: GtkIMMulticontext class: IMMulticontext prefix: gtk_im_multicontext_ prefix: gtk_ import: gtk.IMContext import: gtk.MenuShell outFile: IMMulticontext file: GtkSizeGroup.html struct: GtkSizeGroup class: SizeGroup prefix: gtk_size_group_ prefix: gtk_ import: gtk.Widget outFile: SizeGroup file: GtkTooltips.html struct: GtkTooltips class: Tooltips prefix: gtk_tooltips_ prefix: gtk_ import: glib.Str import: gtk.ObjectGtk import: gtk.Widget #import: gtk.TooltipsData import: gtk.Window outFile: Tooltips file: GtkViewport.html struct: GtkViewport class: Viewport prefix: gtk_viewport_ prefix: gtk_ import: gtk.Adjustment import: gtk.Bin outFile: Viewport file: GtkAccessible.html struct: GtkAccessible class: Accessible prefix: gtk_accessible_ prefix: gtk_ outFile: Accessible ########################################################### ### Abstract Base Classes ################################# ########################################################### file: GtkBin.html struct: GtkBin class: Bin prefix: gtk_bin_ prefix: gtk_ import: gtk.Widget import: gtk.Container outFile: Bin file: GtkBox.html struct: GtkBox class: Box import: gtk.Widget import: gtk.Container prefix: gtk_box_ prefix: gtk_ #import: gtk.PackType outFile: Box file: GtkButtonBox.html struct: GtkButtonBox class: ButtonBox prefix: gtk_button_box_ prefix: gtk_ import: gtk.Widget import: gtk.Button import: gtk.HButtonBox import: gtk.VButtonBox code: start static ButtonBox createActionBox( void delegate(Button) onClicked, StockID[] stocks, char[][] actions, bool vertical=false ) { ButtonBox bBox; if ( vertical ) { bBox = VButtonBox.createActionBox(); } else { bBox = HButtonBox.createActionBox(); } Button button; for( int i=0 ; i