1// Copyright (c) 2013-2014 Conformal Systems <info@conformal.com> 2// 3// This file originated from: http://opensource.conformal.com/ 4// 5// Permission to use, copy, modify, and distribute this software for any 6// purpose with or without fee is hereby granted, provided that the above 7// copyright notice and this permission notice appear in all copies. 8// 9// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 17// Go bindings for GTK+ 3. Supports version 3.6 and later. 18// 19// Functions use the same names as the native C function calls, but use 20// CamelCase. In cases where native GTK uses pointers to values to 21// simulate multiple return values, Go's native multiple return values 22// are used instead. Whenever a native GTK call could return an 23// unexpected NULL pointer, an additional error is returned in the Go 24// binding. 25// 26// GTK's C API documentation can be very useful for understanding how the 27// functions in this package work and what each type is for. This 28// documentation can be found at https://developer.gnome.org/gtk3/. 29// 30// In addition to Go versions of the C GTK functions, every struct type 31// includes a method named Native (either by direct implementation, or 32// by means of struct embedding). These methods return a uintptr of the 33// native C object the binding type represents. These pointers may be 34// type switched to a native C pointer using unsafe and used with cgo 35// function calls outside this package. 36// 37// Memory management is handled in proper Go fashion, using runtime 38// finalizers to properly free memory when it is no longer needed. Each 39// time a Go type is created with a pointer to a GObject, a reference is 40// added for Go, sinking the floating reference when necessary. After 41// going out of scope and the next time Go's garbage collector is run, a 42// finalizer is run to remove Go's reference to the GObject. When this 43// reference count hits zero (when neither Go nor GTK holds ownership) 44// the object will be freed internally by GTK. 45package gtk 46 47// #cgo pkg-config: gdk-3.0 gio-2.0 glib-2.0 gobject-2.0 gtk+-3.0 48// #include <gio/gio.h> 49// #include <gtk/gtk.h> 50// #include "gtk.go.h" 51import "C" 52import ( 53 "errors" 54 "fmt" 55 "reflect" 56 "runtime" 57 "sync" 58 "unsafe" 59 60 "github.com/gotk3/gotk3/cairo" 61 "github.com/gotk3/gotk3/gdk" 62 "github.com/gotk3/gotk3/glib" 63 "github.com/gotk3/gotk3/internal/callback" 64 "github.com/gotk3/gotk3/pango" 65) 66 67func init() { 68 tm := []glib.TypeMarshaler{ 69 // Enums 70 {glib.Type(C.gtk_align_get_type()), marshalAlign}, 71 {glib.Type(C.gtk_accel_flags_get_type()), marshalAccelFlags}, 72 {glib.Type(C.gtk_accel_group_get_type()), marshalAccelGroup}, 73 {glib.Type(C.gtk_accel_map_get_type()), marshalAccelMap}, 74 {glib.Type(C.gtk_arrow_placement_get_type()), marshalArrowPlacement}, 75 {glib.Type(C.gtk_arrow_type_get_type()), marshalArrowType}, 76 {glib.Type(C.gtk_assistant_page_type_get_type()), marshalAssistantPageType}, 77 {glib.Type(C.gtk_buttons_type_get_type()), marshalButtonsType}, 78 {glib.Type(C.gtk_calendar_display_options_get_type()), marshalCalendarDisplayOptions}, 79 {glib.Type(C.gtk_cell_renderer_accel_mode_get_type()), marshalCellRendererAccelMode}, 80 {glib.Type(C.gtk_cell_renderer_mode_get_type()), marshalCellRendererMode}, 81 {glib.Type(C.gtk_cell_renderer_state_get_type()), marshalCellRendererState}, 82 {glib.Type(C.gtk_corner_type_get_type()), marshalCornerType}, 83 {glib.Type(C.gtk_dest_defaults_get_type()), marshalDestDefaults}, 84 {glib.Type(C.gtk_dialog_flags_get_type()), marshalDialogFlags}, 85 {glib.Type(C.gtk_entry_icon_position_get_type()), marshalEntryIconPosition}, 86 {glib.Type(C.gtk_file_chooser_action_get_type()), marshalFileChooserAction}, 87 {glib.Type(C.gtk_icon_lookup_flags_get_type()), marshalSortType}, 88 {glib.Type(C.gtk_icon_size_get_type()), marshalIconSize}, 89 {glib.Type(C.gtk_image_type_get_type()), marshalImageType}, 90 {glib.Type(C.gtk_input_hints_get_type()), marshalInputHints}, 91 {glib.Type(C.gtk_input_purpose_get_type()), marshalInputPurpose}, 92 {glib.Type(C.gtk_direction_type_get_type()), marshalDirectionType}, 93 {glib.Type(C.gtk_justification_get_type()), marshalJustification}, 94 {glib.Type(C.gtk_license_get_type()), marshalLicense}, 95 {glib.Type(C.gtk_message_type_get_type()), marshalMessageType}, 96 {glib.Type(C.gtk_orientation_get_type()), marshalOrientation}, 97 {glib.Type(C.gtk_pack_type_get_type()), marshalPackType}, 98 {glib.Type(C.gtk_path_type_get_type()), marshalPathType}, 99 {glib.Type(C.gtk_policy_type_get_type()), marshalPolicyType}, 100 {glib.Type(C.gtk_position_type_get_type()), marshalPositionType}, 101 {glib.Type(C.gtk_relief_style_get_type()), marshalReliefStyle}, 102 {glib.Type(C.gtk_response_type_get_type()), marshalResponseType}, 103 {glib.Type(C.gtk_selection_mode_get_type()), marshalSelectionMode}, 104 {glib.Type(C.gtk_scroll_type_get_type()), marshalScrollType}, 105 {glib.Type(C.gtk_scroll_step_get_type()), marshalScrollStep}, 106 {glib.Type(C.gtk_sensitivity_type_get_type()), marshalSensitivityType}, 107 {glib.Type(C.gtk_shadow_type_get_type()), marshalShadowType}, 108 {glib.Type(C.gtk_sort_type_get_type()), marshalSortType}, 109 {glib.Type(C.gtk_spin_button_update_policy_get_type()), marshalSpinButtonUpdatePolicy}, 110 {glib.Type(C.gtk_spin_type_get_type()), marshalSpinType}, 111 {glib.Type(C.gtk_state_flags_get_type()), marshalStateFlags}, 112 {glib.Type(C.gtk_target_flags_get_type()), marshalTargetFlags}, 113 {glib.Type(C.gtk_text_direction_get_type()), marshalTextDirection}, 114 {glib.Type(C.gtk_text_search_flags_get_type()), marshalTextSearchFlags}, 115 {glib.Type(C.gtk_toolbar_style_get_type()), marshalToolbarStyle}, 116 {glib.Type(C.gtk_tree_model_flags_get_type()), marshalTreeModelFlags}, 117 {glib.Type(C.gtk_window_position_get_type()), marshalWindowPosition}, 118 {glib.Type(C.gtk_window_type_get_type()), marshalWindowType}, 119 {glib.Type(C.gtk_wrap_mode_get_type()), marshalWrapMode}, 120 121 // Objects/Interfaces 122 {glib.Type(C.gtk_accel_group_get_type()), marshalAccelGroup}, 123 {glib.Type(C.gtk_accel_map_get_type()), marshalAccelMap}, 124 {glib.Type(C.gtk_adjustment_get_type()), marshalAdjustment}, 125 {glib.Type(C.gtk_application_get_type()), marshalApplication}, 126 {glib.Type(C.gtk_application_window_get_type()), marshalApplicationWindow}, 127 {glib.Type(C.gtk_assistant_get_type()), marshalAssistant}, 128 {glib.Type(C.gtk_bin_get_type()), marshalBin}, 129 {glib.Type(C.gtk_builder_get_type()), marshalBuilder}, 130 {glib.Type(C.gtk_button_get_type()), marshalButton}, 131 {glib.Type(C.gtk_button_box_get_type()), marshalButtonBox}, 132 {glib.Type(C.gtk_box_get_type()), marshalBox}, 133 {glib.Type(C.gtk_calendar_get_type()), marshalCalendar}, 134 {glib.Type(C.gtk_cell_layout_get_type()), marshalCellLayout}, 135 {glib.Type(C.gtk_cell_editable_get_type()), marshalCellEditable}, 136 {glib.Type(C.gtk_cell_renderer_get_type()), marshalCellRenderer}, 137 {glib.Type(C.gtk_cell_renderer_spinner_get_type()), marshalCellRendererSpinner}, 138 {glib.Type(C.gtk_cell_renderer_pixbuf_get_type()), marshalCellRendererPixbuf}, 139 {glib.Type(C.gtk_cell_renderer_text_get_type()), marshalCellRendererText}, 140 {glib.Type(C.gtk_cell_renderer_progress_get_type()), marshalCellRendererProgress}, 141 {glib.Type(C.gtk_cell_renderer_toggle_get_type()), marshalCellRendererToggle}, 142 {glib.Type(C.gtk_cell_renderer_combo_get_type()), marshalCellRendererCombo}, 143 {glib.Type(C.gtk_cell_renderer_accel_get_type()), marshalCellRendererAccel}, 144 {glib.Type(C.gtk_cell_renderer_spin_get_type()), marshalCellRendererSpin}, 145 {glib.Type(C.gtk_check_button_get_type()), marshalCheckButton}, 146 {glib.Type(C.gtk_check_menu_item_get_type()), marshalCheckMenuItem}, 147 {glib.Type(C.gtk_clipboard_get_type()), marshalClipboard}, 148 {glib.Type(C.gtk_container_get_type()), marshalContainer}, 149 {glib.Type(C.gtk_dialog_get_type()), marshalDialog}, 150 {glib.Type(C.gtk_drawing_area_get_type()), marshalDrawingArea}, 151 {glib.Type(C.gtk_editable_get_type()), marshalEditable}, 152 {glib.Type(C.gtk_entry_get_type()), marshalEntry}, 153 {glib.Type(C.gtk_entry_buffer_get_type()), marshalEntryBuffer}, 154 {glib.Type(C.gtk_entry_completion_get_type()), marshalEntryCompletion}, 155 {glib.Type(C.gtk_event_box_get_type()), marshalEventBox}, 156 {glib.Type(C.gtk_expander_get_type()), marshalExpander}, 157 {glib.Type(C.gtk_file_chooser_get_type()), marshalFileChooser}, 158 {glib.Type(C.gtk_file_chooser_button_get_type()), marshalFileChooserButton}, 159 {glib.Type(C.gtk_file_chooser_dialog_get_type()), marshalFileChooserDialog}, 160 {glib.Type(C.gtk_file_chooser_widget_get_type()), marshalFileChooserWidget}, 161 {glib.Type(C.gtk_frame_get_type()), marshalFrame}, 162 {glib.Type(C.gtk_aspect_frame_get_type()), marshalAspectFrame}, 163 {glib.Type(C.gtk_grid_get_type()), marshalGrid}, 164 {glib.Type(C.gtk_icon_view_get_type()), marshalIconView}, 165 {glib.Type(C.gtk_image_get_type()), marshalImage}, 166 {glib.Type(C.gtk_label_get_type()), marshalLabel}, 167 {glib.Type(C.gtk_link_button_get_type()), marshalLinkButton}, 168 {glib.Type(C.gtk_lock_button_get_type()), marshalLockButton}, 169 {glib.Type(C.gtk_layout_get_type()), marshalLayout}, 170 {glib.Type(C.gtk_tree_model_sort_get_type()), marshalTreeModelSort}, 171 {glib.Type(C.gtk_list_store_get_type()), marshalListStore}, 172 {glib.Type(C.gtk_menu_get_type()), marshalMenu}, 173 {glib.Type(C.gtk_menu_bar_get_type()), marshalMenuBar}, 174 {glib.Type(C.gtk_menu_button_get_type()), marshalMenuButton}, 175 {glib.Type(C.gtk_menu_item_get_type()), marshalMenuItem}, 176 {glib.Type(C.gtk_menu_shell_get_type()), marshalMenuShell}, 177 {glib.Type(C.gtk_message_dialog_get_type()), marshalMessageDialog}, 178 {glib.Type(C.gtk_notebook_get_type()), marshalNotebook}, 179 {glib.Type(C.gtk_offscreen_window_get_type()), marshalOffscreenWindow}, 180 {glib.Type(C.gtk_orientable_get_type()), marshalOrientable}, 181 {glib.Type(C.gtk_overlay_get_type()), marshalOverlay}, 182 {glib.Type(C.gtk_paned_get_type()), marshalPaned}, 183 {glib.Type(C.gtk_progress_bar_get_type()), marshalProgressBar}, 184 {glib.Type(C.gtk_radio_button_get_type()), marshalRadioButton}, 185 {glib.Type(C.gtk_radio_menu_item_get_type()), marshalRadioMenuItem}, 186 {glib.Type(C.gtk_range_get_type()), marshalRange}, 187 {glib.Type(C.gtk_scale_button_get_type()), marshalScaleButton}, 188 {glib.Type(C.gtk_scale_get_type()), marshalScale}, 189 {glib.Type(C.gtk_scrollbar_get_type()), marshalScrollbar}, 190 {glib.Type(C.gtk_scrolled_window_get_type()), marshalScrolledWindow}, 191 {glib.Type(C.gtk_search_entry_get_type()), marshalSearchEntry}, 192 {glib.Type(C.gtk_selection_data_get_type()), marshalSelectionData}, 193 {glib.Type(C.gtk_separator_get_type()), marshalSeparator}, 194 {glib.Type(C.gtk_separator_menu_item_get_type()), marshalSeparatorMenuItem}, 195 {glib.Type(C.gtk_separator_tool_item_get_type()), marshalSeparatorToolItem}, 196 {glib.Type(C.gtk_spin_button_get_type()), marshalSpinButton}, 197 {glib.Type(C.gtk_spinner_get_type()), marshalSpinner}, 198 {glib.Type(C.gtk_statusbar_get_type()), marshalStatusbar}, 199 {glib.Type(C.gtk_switch_get_type()), marshalSwitch}, 200 {glib.Type(C.gtk_text_view_get_type()), marshalTextView}, 201 {glib.Type(C.gtk_text_tag_get_type()), marshalTextTag}, 202 {glib.Type(C.gtk_text_tag_table_get_type()), marshalTextTagTable}, 203 {glib.Type(C.gtk_text_buffer_get_type()), marshalTextBuffer}, 204 {glib.Type(C.gtk_toggle_button_get_type()), marshalToggleButton}, 205 {glib.Type(C.gtk_toolbar_get_type()), marshalToolbar}, 206 {glib.Type(C.gtk_tool_button_get_type()), marshalToolButton}, 207 {glib.Type(C.gtk_toggle_tool_button_get_type()), marshalToggleToolButton}, 208 {glib.Type(C.gtk_tool_item_get_type()), marshalToolItem}, 209 {glib.Type(C.gtk_tooltip_get_type()), marshalTooltip}, 210 {glib.Type(C.gtk_tree_model_get_type()), marshalTreeModel}, 211 {glib.Type(C.gtk_tree_sortable_get_type()), marshalTreeSortable}, 212 {glib.Type(C.gtk_tree_selection_get_type()), marshalTreeSelection}, 213 {glib.Type(C.gtk_tree_store_get_type()), marshalTreeStore}, 214 {glib.Type(C.gtk_tree_view_get_type()), marshalTreeView}, 215 {glib.Type(C.gtk_tree_view_column_get_type()), marshalTreeViewColumn}, 216 {glib.Type(C.gtk_cell_area_get_type()), marshalCellArea}, 217 {glib.Type(C.gtk_cell_area_context_get_type()), marshalCellAreaContext}, 218 {glib.Type(C.gtk_cell_area_box_get_type()), marshalCellAreaBox}, 219 {glib.Type(C.gtk_volume_button_get_type()), marshalVolumeButton}, 220 {glib.Type(C.gtk_widget_get_type()), marshalWidget}, 221 {glib.Type(C.gtk_window_get_type()), marshalWindow}, 222 {glib.Type(C.gtk_window_group_get_type()), marshalWindowGroup}, 223 224 // Boxed 225 {glib.Type(C.gtk_target_entry_get_type()), marshalTargetEntry}, 226 {glib.Type(C.gtk_text_iter_get_type()), marshalTextIter}, 227 {glib.Type(C.gtk_text_mark_get_type()), marshalTextMark}, 228 {glib.Type(C.gtk_tree_iter_get_type()), marshalTreeIter}, 229 {glib.Type(C.gtk_tree_path_get_type()), marshalTreePath}, 230 } 231 glib.RegisterGValueMarshalers(tm) 232} 233 234/* 235 * Callback helpers 236 */ 237 238//export gotk3_callbackDelete 239func gotk3_callbackDelete(callbackID C.gpointer) { 240 callback.Delete(uintptr(callbackID)) 241} 242 243/* 244 * Type conversions 245 */ 246 247func gbool(b bool) C.gboolean { 248 if b { 249 return C.gboolean(1) 250 } 251 return C.gboolean(0) 252} 253 254func gobool(b C.gboolean) bool { 255 return b != C.FALSE 256} 257 258func cGSList(clist *glib.SList) *C.GSList { 259 if clist == nil { 260 return nil 261 } 262 return (*C.GSList)(unsafe.Pointer(clist.Native())) 263} 264 265func free(str ...interface{}) { 266 for _, s := range str { 267 switch x := s.(type) { 268 case *C.char: 269 C.free(unsafe.Pointer(x)) 270 case []*C.char: 271 for _, cp := range x { 272 C.free(unsafe.Pointer(cp)) 273 } 274 /* 275 case C.gpointer: 276 C.g_free(C.gpointer(c)) 277 */ 278 default: 279 fmt.Printf("utils.go free(): Unknown type: %T\n", x) 280 } 281 282 } 283} 284 285// nextguchar increments guchar by 1. Hopefully, this could be inlined by the Go 286// compiler. 287func nextguchar(guchar *C.guchar) *C.guchar { 288 return (*C.guchar)(unsafe.Pointer(uintptr(unsafe.Pointer(guchar)) + 1)) 289} 290 291// ucharString returns a copy of the given guchar pointer. The pointer guchar 292// array is assumed to have valid UTF-8. 293func ucharString(guchar *C.guchar) string { 294 // Seek and find the string length. 295 var strlen int 296 for ptr := guchar; *ptr != 0; ptr = nextguchar(ptr) { 297 strlen++ 298 } 299 300 // Array of unsigned char means GoString is unavailable, so maybe this is 301 // fine. 302 var data []byte 303 sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data)) 304 sliceHeader.Len = strlen 305 sliceHeader.Cap = strlen 306 sliceHeader.Data = uintptr(unsafe.Pointer(guchar)) 307 308 // Return a copy of the string. 309 return string(data) 310} 311 312// nextgcharptr increments gcharptr by 1. Hopefully, this could be inlined by 313// the Go compiler. 314func nextgcharptr(gcharptr **C.gchar) **C.gchar { 315 return (**C.gchar)(unsafe.Pointer(uintptr(unsafe.Pointer(gcharptr)) + 1)) 316} 317 318func goString(cstr *C.gchar) string { 319 return C.GoString((*C.char)(cstr)) 320} 321 322// same implementation as package glib 323func toGoStringArray(c **C.gchar) []string { 324 if c == nil { 325 return nil 326 } 327 328 // free when done 329 defer C.g_strfreev(c) 330 331 strsLen := 0 332 for scan := c; *scan != nil; scan = nextgcharptr(scan) { 333 strsLen++ 334 } 335 336 strs := make([]string, strsLen) 337 for i := range strs { 338 strs[i] = C.GoString((*C.char)(*c)) 339 c = nextgcharptr(c) 340 } 341 342 return strs 343} 344 345// Wrapper function for TestBoolConvs since cgo can't be used with 346// testing package 347func testBoolConvs() error { 348 b := gobool(gbool(true)) 349 if b != true { 350 return errors.New("Unexpected bool conversion result") 351 } 352 353 cb := gbool(gobool(C.gboolean(0))) 354 if cb != C.gboolean(0) { 355 return errors.New("Unexpected bool conversion result") 356 } 357 358 return nil 359} 360 361/* 362 * Unexported vars 363 */ 364 365var nilPtrErr = errors.New("cgo returned unexpected nil pointer") 366 367/* 368 * Constants 369 */ 370 371// Align is a representation of GTK's GtkAlign. 372type Align int 373 374const ( 375 ALIGN_FILL Align = C.GTK_ALIGN_FILL 376 ALIGN_START Align = C.GTK_ALIGN_START 377 ALIGN_END Align = C.GTK_ALIGN_END 378 ALIGN_CENTER Align = C.GTK_ALIGN_CENTER 379) 380 381func marshalAlign(p uintptr) (interface{}, error) { 382 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 383 return Align(c), nil 384} 385 386// ArrowPlacement is a representation of GTK's GtkArrowPlacement. 387type ArrowPlacement int 388 389const ( 390 ARROWS_BOTH ArrowPlacement = C.GTK_ARROWS_BOTH 391 ARROWS_START ArrowPlacement = C.GTK_ARROWS_START 392 ARROWS_END ArrowPlacement = C.GTK_ARROWS_END 393) 394 395func marshalArrowPlacement(p uintptr) (interface{}, error) { 396 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 397 return ArrowPlacement(c), nil 398} 399 400// ArrowType is a representation of GTK's GtkArrowType. 401type ArrowType int 402 403const ( 404 ARROW_UP ArrowType = C.GTK_ARROW_UP 405 ARROW_DOWN ArrowType = C.GTK_ARROW_DOWN 406 ARROW_LEFT ArrowType = C.GTK_ARROW_LEFT 407 ARROW_RIGHT ArrowType = C.GTK_ARROW_RIGHT 408 ARROW_NONE ArrowType = C.GTK_ARROW_NONE 409) 410 411func marshalArrowType(p uintptr) (interface{}, error) { 412 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 413 return ArrowType(c), nil 414} 415 416// AssistantPageType is a representation of GTK's GtkAssistantPageType. 417type AssistantPageType int 418 419const ( 420 ASSISTANT_PAGE_CONTENT AssistantPageType = C.GTK_ASSISTANT_PAGE_CONTENT 421 ASSISTANT_PAGE_INTRO AssistantPageType = C.GTK_ASSISTANT_PAGE_INTRO 422 ASSISTANT_PAGE_CONFIRM AssistantPageType = C.GTK_ASSISTANT_PAGE_CONFIRM 423 ASSISTANT_PAGE_SUMMARY AssistantPageType = C.GTK_ASSISTANT_PAGE_SUMMARY 424 ASSISTANT_PAGE_PROGRESS AssistantPageType = C.GTK_ASSISTANT_PAGE_PROGRESS 425 ASSISTANT_PAGE_CUSTOM AssistantPageType = C.GTK_ASSISTANT_PAGE_CUSTOM 426) 427 428func marshalAssistantPageType(p uintptr) (interface{}, error) { 429 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 430 return AssistantPageType(c), nil 431} 432 433// ButtonsType is a representation of GTK's GtkButtonsType. 434type ButtonsType int 435 436const ( 437 BUTTONS_NONE ButtonsType = C.GTK_BUTTONS_NONE 438 BUTTONS_OK ButtonsType = C.GTK_BUTTONS_OK 439 BUTTONS_CLOSE ButtonsType = C.GTK_BUTTONS_CLOSE 440 BUTTONS_CANCEL ButtonsType = C.GTK_BUTTONS_CANCEL 441 BUTTONS_YES_NO ButtonsType = C.GTK_BUTTONS_YES_NO 442 BUTTONS_OK_CANCEL ButtonsType = C.GTK_BUTTONS_OK_CANCEL 443) 444 445func marshalButtonsType(p uintptr) (interface{}, error) { 446 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 447 return ButtonsType(c), nil 448} 449 450// SensitivityType is a representation of GTK's GtkSensitivityType 451type SensitivityType int 452 453const ( 454 SENSITIVITY_AUTO SensitivityType = C.GTK_SENSITIVITY_AUTO 455 SENSITIVITY_ON SensitivityType = C.GTK_SENSITIVITY_ON 456 SENSITIVITY_OFF SensitivityType = C.GTK_SENSITIVITY_OFF 457) 458 459func marshalSensitivityType(p uintptr) (interface{}, error) { 460 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 461 return SensitivityType(c), nil 462} 463 464// CalendarDisplayOptions is a representation of GTK's GtkCalendarDisplayOptions 465type CalendarDisplayOptions int 466 467const ( 468 CALENDAR_SHOW_HEADING CalendarDisplayOptions = C.GTK_CALENDAR_SHOW_HEADING 469 CALENDAR_SHOW_DAY_NAMES CalendarDisplayOptions = C.GTK_CALENDAR_SHOW_DAY_NAMES 470 CALENDAR_NO_MONTH_CHANGE CalendarDisplayOptions = C.GTK_CALENDAR_NO_MONTH_CHANGE 471 CALENDAR_SHOW_WEEK_NUMBERS CalendarDisplayOptions = C.GTK_CALENDAR_SHOW_WEEK_NUMBERS 472 CALENDAR_SHOW_DETAILS CalendarDisplayOptions = C.GTK_CALENDAR_SHOW_DETAILS 473) 474 475func marshalCalendarDisplayOptions(p uintptr) (interface{}, error) { 476 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 477 return CalendarDisplayOptions(c), nil 478} 479 480// DestDefaults is a representation of GTK's GtkDestDefaults. 481type DestDefaults int 482 483const ( 484 DEST_DEFAULT_MOTION DestDefaults = C.GTK_DEST_DEFAULT_MOTION 485 DEST_DEFAULT_HIGHLIGHT DestDefaults = C.GTK_DEST_DEFAULT_HIGHLIGHT 486 DEST_DEFAULT_DROP DestDefaults = C.GTK_DEST_DEFAULT_DROP 487 DEST_DEFAULT_ALL DestDefaults = C.GTK_DEST_DEFAULT_ALL 488) 489 490func marshalDestDefaults(p uintptr) (interface{}, error) { 491 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 492 return DestDefaults(c), nil 493} 494 495// DialogFlags is a representation of GTK's GtkDialogFlags. 496type DialogFlags int 497 498const ( 499 DIALOG_MODAL DialogFlags = C.GTK_DIALOG_MODAL 500 DIALOG_DESTROY_WITH_PARENT DialogFlags = C.GTK_DIALOG_DESTROY_WITH_PARENT 501) 502 503func marshalDialogFlags(p uintptr) (interface{}, error) { 504 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 505 return DialogFlags(c), nil 506} 507 508// EntryIconPosition is a representation of GTK's GtkEntryIconPosition. 509type EntryIconPosition int 510 511const ( 512 ENTRY_ICON_PRIMARY EntryIconPosition = C.GTK_ENTRY_ICON_PRIMARY 513 ENTRY_ICON_SECONDARY EntryIconPosition = C.GTK_ENTRY_ICON_SECONDARY 514) 515 516func marshalEntryIconPosition(p uintptr) (interface{}, error) { 517 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 518 return EntryIconPosition(c), nil 519} 520 521// FileChooserAction is a representation of GTK's GtkFileChooserAction. 522type FileChooserAction int 523 524const ( 525 FILE_CHOOSER_ACTION_OPEN FileChooserAction = C.GTK_FILE_CHOOSER_ACTION_OPEN 526 FILE_CHOOSER_ACTION_SAVE FileChooserAction = C.GTK_FILE_CHOOSER_ACTION_SAVE 527 FILE_CHOOSER_ACTION_SELECT_FOLDER FileChooserAction = C.GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER 528 FILE_CHOOSER_ACTION_CREATE_FOLDER FileChooserAction = C.GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER 529) 530 531func marshalFileChooserAction(p uintptr) (interface{}, error) { 532 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 533 return FileChooserAction(c), nil 534} 535 536// IconLookupFlags is a representation of GTK's GtkIconLookupFlags. 537type IconLookupFlags int 538 539const ( 540 ICON_LOOKUP_NO_SVG IconLookupFlags = C.GTK_ICON_LOOKUP_NO_SVG 541 ICON_LOOKUP_FORCE_SVG IconLookupFlags = C.GTK_ICON_LOOKUP_FORCE_SVG 542 ICON_LOOKUP_USE_BUILTIN IconLookupFlags = C.GTK_ICON_LOOKUP_USE_BUILTIN 543 ICON_LOOKUP_GENERIC_FALLBACK IconLookupFlags = C.GTK_ICON_LOOKUP_GENERIC_FALLBACK 544 ICON_LOOKUP_FORCE_SIZE IconLookupFlags = C.GTK_ICON_LOOKUP_FORCE_SIZE 545) 546 547func marshalIconLookupFlags(p uintptr) (interface{}, error) { 548 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 549 return IconLookupFlags(c), nil 550} 551 552// IconSize is a representation of GTK's GtkIconSize. 553type IconSize int 554 555const ( 556 ICON_SIZE_INVALID IconSize = C.GTK_ICON_SIZE_INVALID 557 ICON_SIZE_MENU IconSize = C.GTK_ICON_SIZE_MENU 558 ICON_SIZE_SMALL_TOOLBAR IconSize = C.GTK_ICON_SIZE_SMALL_TOOLBAR 559 ICON_SIZE_LARGE_TOOLBAR IconSize = C.GTK_ICON_SIZE_LARGE_TOOLBAR 560 ICON_SIZE_BUTTON IconSize = C.GTK_ICON_SIZE_BUTTON 561 ICON_SIZE_DND IconSize = C.GTK_ICON_SIZE_DND 562 ICON_SIZE_DIALOG IconSize = C.GTK_ICON_SIZE_DIALOG 563) 564 565func marshalIconSize(p uintptr) (interface{}, error) { 566 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 567 return IconSize(c), nil 568} 569 570// ImageType is a representation of GTK's GtkImageType. 571type ImageType int 572 573const ( 574 IMAGE_EMPTY ImageType = C.GTK_IMAGE_EMPTY 575 IMAGE_PIXBUF ImageType = C.GTK_IMAGE_PIXBUF 576 IMAGE_STOCK ImageType = C.GTK_IMAGE_STOCK 577 IMAGE_ICON_SET ImageType = C.GTK_IMAGE_ICON_SET 578 IMAGE_ANIMATION ImageType = C.GTK_IMAGE_ANIMATION 579 IMAGE_ICON_NAME ImageType = C.GTK_IMAGE_ICON_NAME 580 IMAGE_GICON ImageType = C.GTK_IMAGE_GICON 581) 582 583// TODO: add GTK_IMAGE_SURFACE for GTK 3.10 584 585func marshalImageType(p uintptr) (interface{}, error) { 586 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 587 return ImageType(c), nil 588} 589 590// InputHints is a representation of GTK's GtkInputHints. 591type InputHints int 592 593const ( 594 INPUT_HINT_NONE InputHints = C.GTK_INPUT_HINT_NONE 595 INPUT_HINT_SPELLCHECK InputHints = C.GTK_INPUT_HINT_SPELLCHECK 596 INPUT_HINT_NO_SPELLCHECK InputHints = C.GTK_INPUT_HINT_NO_SPELLCHECK 597 INPUT_HINT_WORD_COMPLETION InputHints = C.GTK_INPUT_HINT_WORD_COMPLETION 598 INPUT_HINT_LOWERCASE InputHints = C.GTK_INPUT_HINT_LOWERCASE 599 INPUT_HINT_UPPERCASE_CHARS InputHints = C.GTK_INPUT_HINT_UPPERCASE_CHARS 600 INPUT_HINT_UPPERCASE_WORDS InputHints = C.GTK_INPUT_HINT_UPPERCASE_WORDS 601 INPUT_HINT_UPPERCASE_SENTENCES InputHints = C.GTK_INPUT_HINT_UPPERCASE_SENTENCES 602 INPUT_HINT_INHIBIT_OSK InputHints = C.GTK_INPUT_HINT_INHIBIT_OSK 603) 604 605// TODO: 606// GTK_INPUT_HINT_VERTICAL_WRITING Since 3.18 607// GTK_INPUT_HINT_EMOJI Since 3.22.20 608// GTK_INPUT_HINT_NO_EMOJI Since 3.22.20 609 610func marshalInputHints(p uintptr) (interface{}, error) { 611 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 612 return InputHints(c), nil 613} 614 615// InputPurpose is a representation of GTK's GtkInputPurpose. 616type InputPurpose int 617 618const ( 619 INPUT_PURPOSE_FREE_FORM InputPurpose = C.GTK_INPUT_PURPOSE_FREE_FORM 620 INPUT_PURPOSE_ALPHA InputPurpose = C.GTK_INPUT_PURPOSE_ALPHA 621 INPUT_PURPOSE_DIGITS InputPurpose = C.GTK_INPUT_PURPOSE_DIGITS 622 INPUT_PURPOSE_NUMBER InputPurpose = C.GTK_INPUT_PURPOSE_NUMBER 623 INPUT_PURPOSE_PHONE InputPurpose = C.GTK_INPUT_PURPOSE_PHONE 624 INPUT_PURPOSE_URL InputPurpose = C.GTK_INPUT_PURPOSE_URL 625 INPUT_PURPOSE_EMAIL InputPurpose = C.GTK_INPUT_PURPOSE_EMAIL 626 INPUT_PURPOSE_NAME InputPurpose = C.GTK_INPUT_PURPOSE_NAME 627 INPUT_PURPOSE_PASSWORD InputPurpose = C.GTK_INPUT_PURPOSE_PASSWORD 628 INPUT_PURPOSE_PIN InputPurpose = C.GTK_INPUT_PURPOSE_PIN 629) 630 631func marshalInputPurpose(p uintptr) (interface{}, error) { 632 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 633 return InputPurpose(c), nil 634} 635 636// TODO: 637// GtkBaselinePosition 638// GtkDeleteType 639 640// DirectionType is a representation of GTK's GtkDirectionType. 641type DirectionType int 642 643const ( 644 DIR_TAB_FORWARD DirectionType = C.GTK_DIR_TAB_FORWARD 645 DIR_TAB_BACKWARD DirectionType = C.GTK_DIR_TAB_BACKWARD 646 DIR_UP DirectionType = C.GTK_DIR_UP 647 DIR_DOWN DirectionType = C.GTK_DIR_DOWN 648 DIR_LEFT DirectionType = C.GTK_DIR_LEFT 649 DIR_RIGHT DirectionType = C.GTK_DIR_RIGHT 650) 651 652func marshalDirectionType(p uintptr) (interface{}, error) { 653 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 654 return DirectionType(c), nil 655} 656 657// Justification is a representation of GTK's GtkJustification. 658type Justification int 659 660const ( 661 JUSTIFY_LEFT Justification = C.GTK_JUSTIFY_LEFT 662 JUSTIFY_RIGHT Justification = C.GTK_JUSTIFY_RIGHT 663 JUSTIFY_CENTER Justification = C.GTK_JUSTIFY_CENTER 664 JUSTIFY_FILL Justification = C.GTK_JUSTIFY_FILL 665) 666 667func marshalJustification(p uintptr) (interface{}, error) { 668 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 669 return Justification(c), nil 670} 671 672// License is a representation of GTK's GtkLicense. 673type License int 674 675const ( 676 LICENSE_UNKNOWN License = C.GTK_LICENSE_UNKNOWN 677 LICENSE_CUSTOM License = C.GTK_LICENSE_CUSTOM 678 LICENSE_GPL_2_0 License = C.GTK_LICENSE_GPL_2_0 679 LICENSE_GPL_3_0 License = C.GTK_LICENSE_GPL_3_0 680 LICENSE_LGPL_2_1 License = C.GTK_LICENSE_LGPL_2_1 681 LICENSE_LGPL_3_0 License = C.GTK_LICENSE_LGPL_3_0 682 LICENSE_BSD License = C.GTK_LICENSE_BSD 683 LICENSE_MIT_X11 License = C.GTK_LICENSE_MIT_X11 684 LICENSE_GTK_ARTISTIC License = C.GTK_LICENSE_ARTISTIC 685) 686 687func marshalLicense(p uintptr) (interface{}, error) { 688 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 689 return License(c), nil 690} 691 692// MessageType is a representation of GTK's GtkMessageType. 693type MessageType int 694 695const ( 696 MESSAGE_INFO MessageType = C.GTK_MESSAGE_INFO 697 MESSAGE_WARNING MessageType = C.GTK_MESSAGE_WARNING 698 MESSAGE_QUESTION MessageType = C.GTK_MESSAGE_QUESTION 699 MESSAGE_ERROR MessageType = C.GTK_MESSAGE_ERROR 700 MESSAGE_OTHER MessageType = C.GTK_MESSAGE_OTHER 701) 702 703func marshalMessageType(p uintptr) (interface{}, error) { 704 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 705 return MessageType(c), nil 706} 707 708// TODO: 709// GtkMovementStep 710 711// Orientation is a representation of GTK's GtkOrientation. 712type Orientation int 713 714const ( 715 ORIENTATION_HORIZONTAL Orientation = C.GTK_ORIENTATION_HORIZONTAL 716 ORIENTATION_VERTICAL Orientation = C.GTK_ORIENTATION_VERTICAL 717) 718 719func marshalOrientation(p uintptr) (interface{}, error) { 720 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 721 return Orientation(c), nil 722} 723 724// PackType is a representation of GTK's GtkPackType. 725type PackType int 726 727const ( 728 PACK_START PackType = C.GTK_PACK_START 729 PACK_END PackType = C.GTK_PACK_END 730) 731 732func marshalPackType(p uintptr) (interface{}, error) { 733 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 734 return PackType(c), nil 735} 736 737// PathType is a representation of GTK's GtkPathType. 738type PathType int 739 740const ( 741 PATH_WIDGET PathType = C.GTK_PATH_WIDGET 742 PATH_WIDGET_CLASS PathType = C.GTK_PATH_WIDGET_CLASS 743 PATH_CLASS PathType = C.GTK_PATH_CLASS 744) 745 746func marshalPathType(p uintptr) (interface{}, error) { 747 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 748 return PathType(c), nil 749} 750 751// PolicyType is a representation of GTK's GtkPolicyType. 752type PolicyType int 753 754const ( 755 POLICY_ALWAYS PolicyType = C.GTK_POLICY_ALWAYS 756 POLICY_AUTOMATIC PolicyType = C.GTK_POLICY_AUTOMATIC 757 POLICY_NEVER PolicyType = C.GTK_POLICY_NEVER 758) 759 760func marshalPolicyType(p uintptr) (interface{}, error) { 761 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 762 return PolicyType(c), nil 763} 764 765// SpinButtonUpdatePolicy is a representation of GTK's GtkSpinButtonUpdatePolicy. 766type SpinButtonUpdatePolicy int 767 768const ( 769 UPDATE_ALWAYS SpinButtonUpdatePolicy = C.GTK_UPDATE_ALWAYS 770 UPDATE_IF_VALID SpinButtonUpdatePolicy = C.GTK_UPDATE_IF_VALID 771) 772 773func marshalSpinButtonUpdatePolicy(p uintptr) (interface{}, error) { 774 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 775 return SpinButtonUpdatePolicy(c), nil 776} 777 778// SpinType is a representation of GTK's GtkSpinType. 779type SpinType int 780 781const ( 782 SPIN_STEP_FORWARD SpinType = C.GTK_SPIN_STEP_FORWARD 783 SPIN_STEP_BACKWARD SpinType = C.GTK_SPIN_STEP_BACKWARD 784 SPIN_PAGE_BACKWARD SpinType = C.GTK_SPIN_PAGE_BACKWARD 785 SPIN_HOME SpinType = C.GTK_SPIN_HOME 786 SPIN_END SpinType = C.GTK_SPIN_END 787 SPIN_USER_DEFINED SpinType = C.GTK_SPIN_USER_DEFINED 788) 789 790func marshalSpinType(p uintptr) (interface{}, error) { 791 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 792 return SpinType(c), nil 793} 794 795// TreeViewGridLine is a representation of GTK's GtkTreeViewGridLines. 796type TreeViewGridLines int 797 798const ( 799 TREE_VIEW_GRID_LINES_NONE TreeViewGridLines = C.GTK_TREE_VIEW_GRID_LINES_NONE 800 TREE_VIEW_GRID_LINES_HORIZONTAL TreeViewGridLines = C.GTK_TREE_VIEW_GRID_LINES_HORIZONTAL 801 TREE_VIEW_GRID_LINES_VERTICAL TreeViewGridLines = C.GTK_TREE_VIEW_GRID_LINES_VERTICAL 802 TREE_VIEW_GRID_LINES_BOTH TreeViewGridLines = C.GTK_TREE_VIEW_GRID_LINES_BOTH 803) 804 805// CellRendererAccelMode is a representation of GtkCellRendererAccelMode 806type CellRendererAccelMode int 807 808const ( 809 // CELL_RENDERER_ACCEL_MODE_GTK is documented as GTK+ accelerators mode 810 CELL_RENDERER_ACCEL_MODE_GTK CellRendererAccelMode = C.GTK_CELL_RENDERER_ACCEL_MODE_GTK 811 // CELL_RENDERER_ACCEL_MODE_OTHER is documented as Other accelerator mode 812 CELL_RENDERER_ACCEL_MODE_OTHER CellRendererAccelMode = C.GTK_CELL_RENDERER_ACCEL_MODE_OTHER 813) 814 815func marshalCellRendererAccelMode(p uintptr) (interface{}, error) { 816 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 817 return CellRendererAccelMode(c), nil 818} 819 820// CellRendererState is a representation of GTK's GtkCellRendererState 821type CellRendererState int 822 823const ( 824 CELL_RENDERER_SELECTED CellRendererState = C.GTK_CELL_RENDERER_SELECTED 825 CELL_RENDERER_PRELIT CellRendererState = C.GTK_CELL_RENDERER_PRELIT 826 CELL_RENDERER_INSENSITIVE CellRendererState = C.GTK_CELL_RENDERER_INSENSITIVE 827 CELL_RENDERER_SORTED CellRendererState = C.GTK_CELL_RENDERER_SORTED 828 CELL_RENDERER_FOCUSED CellRendererState = C.GTK_CELL_RENDERER_FOCUSED 829 CELL_RENDERER_EXPANDABLE CellRendererState = C.GTK_CELL_RENDERER_EXPANDABLE // since 3.4 830 CELL_RENDERER_EXPANDED CellRendererState = C.GTK_CELL_RENDERER_EXPANDED // since 3.4 831) 832 833func marshalCellRendererState(p uintptr) (interface{}, error) { 834 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 835 return CellRendererState(c), nil 836} 837 838// CellRendererMode is a representation of GTK's GtkCellRendererMode 839type CellRendererMode int 840 841const ( 842 CELL_RENDERER_MODE_INERT CellRendererMode = C.GTK_CELL_RENDERER_MODE_INERT 843 CELL_RENDERER_MODE_ACTIVATABLE CellRendererMode = C.GTK_CELL_RENDERER_MODE_ACTIVATABLE 844 CELL_RENDERER_MODE_EDITABLE CellRendererMode = C.GTK_CELL_RENDERER_MODE_EDITABLE 845) 846 847func marshalCellRendererMode(p uintptr) (interface{}, error) { 848 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 849 return CellRendererMode(c), nil 850} 851 852// PositionType is a representation of GTK's GtkPositionType. 853type PositionType int 854 855const ( 856 POS_LEFT PositionType = C.GTK_POS_LEFT 857 POS_RIGHT PositionType = C.GTK_POS_RIGHT 858 POS_TOP PositionType = C.GTK_POS_TOP 859 POS_BOTTOM PositionType = C.GTK_POS_BOTTOM 860) 861 862func marshalPositionType(p uintptr) (interface{}, error) { 863 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 864 return PositionType(c), nil 865} 866 867// ReliefStyle is a representation of GTK's GtkReliefStyle. 868type ReliefStyle int 869 870const ( 871 RELIEF_NORMAL ReliefStyle = C.GTK_RELIEF_NORMAL 872 RELIEF_HALF ReliefStyle = C.GTK_RELIEF_HALF 873 RELIEF_NONE ReliefStyle = C.GTK_RELIEF_NONE 874) 875 876func marshalReliefStyle(p uintptr) (interface{}, error) { 877 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 878 return ReliefStyle(c), nil 879} 880 881// ResponseType is a representation of GTK's GtkResponseType. 882type ResponseType int 883 884const ( 885 RESPONSE_NONE ResponseType = C.GTK_RESPONSE_NONE 886 RESPONSE_REJECT ResponseType = C.GTK_RESPONSE_REJECT 887 RESPONSE_ACCEPT ResponseType = C.GTK_RESPONSE_ACCEPT 888 RESPONSE_DELETE_EVENT ResponseType = C.GTK_RESPONSE_DELETE_EVENT 889 RESPONSE_OK ResponseType = C.GTK_RESPONSE_OK 890 RESPONSE_CANCEL ResponseType = C.GTK_RESPONSE_CANCEL 891 RESPONSE_CLOSE ResponseType = C.GTK_RESPONSE_CLOSE 892 RESPONSE_YES ResponseType = C.GTK_RESPONSE_YES 893 RESPONSE_NO ResponseType = C.GTK_RESPONSE_NO 894 RESPONSE_APPLY ResponseType = C.GTK_RESPONSE_APPLY 895 RESPONSE_HELP ResponseType = C.GTK_RESPONSE_HELP 896) 897 898func marshalResponseType(p uintptr) (interface{}, error) { 899 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 900 return ResponseType(c), nil 901} 902 903// ScrollType is a representation of GTK's GtkScrollType. 904type ScrollType int 905 906const ( 907 SCROLL_NONE ScrollType = C.GTK_SCROLL_NONE 908 SCROLL_JUMP ScrollType = C.GTK_SCROLL_JUMP 909 SCROLL_STEP_BACKWARD ScrollType = C.GTK_SCROLL_STEP_BACKWARD 910 SCROLL_STEP_FORWARD ScrollType = C.GTK_SCROLL_STEP_FORWARD 911 SCROLL_PAGE_BACKWARD ScrollType = C.GTK_SCROLL_PAGE_BACKWARD 912 SCROLL_PAGE_FORWARD ScrollType = C.GTK_SCROLL_PAGE_FORWARD 913 SCROLL_STEP_UP ScrollType = C.GTK_SCROLL_STEP_UP 914 SCROLL_STEP_DOWN ScrollType = C.GTK_SCROLL_STEP_DOWN 915 SCROLL_PAGE_UP ScrollType = C.GTK_SCROLL_PAGE_UP 916 SCROLL_PAGE_DOWN ScrollType = C.GTK_SCROLL_PAGE_DOWN 917 SCROLL_STEP_LEFT ScrollType = C.GTK_SCROLL_STEP_LEFT 918 SCROLL_STEP_RIGHT ScrollType = C.GTK_SCROLL_STEP_RIGHT 919 SCROLL_PAGE_LEFT ScrollType = C.GTK_SCROLL_PAGE_LEFT 920 SCROLL_PAGE_RIGHT ScrollType = C.GTK_SCROLL_PAGE_RIGHT 921 SCROLL_START ScrollType = C.GTK_SCROLL_START 922 SCROLL_END ScrollType = C.GTK_SCROLL_END 923) 924 925func marshalScrollType(p uintptr) (interface{}, error) { 926 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 927 return ScrollType(c), nil 928} 929 930// ScrollStep is a representation of GTK's GtkScrollStep. 931type ScrollStep int 932 933const ( 934 SCROLL_STEPS ScrollStep = C.GTK_SCROLL_STEPS 935 SCROLL_PAGES ScrollStep = C.GTK_SCROLL_PAGES 936 SCROLL_ENDS ScrollStep = C.GTK_SCROLL_ENDS 937 SCROLL_HORIZONTAL_STEPS ScrollStep = C.GTK_SCROLL_HORIZONTAL_STEPS 938 SCROLL_HORIZONTAL_PAGES ScrollStep = C.GTK_SCROLL_HORIZONTAL_PAGES 939 SCROLL_HORIZONTAL_ENDS ScrollStep = C.GTK_SCROLL_HORIZONTAL_ENDS 940) 941 942func marshalScrollStep(p uintptr) (interface{}, error) { 943 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 944 return ScrollStep(c), nil 945} 946 947// SelectionMode is a representation of GTK's GtkSelectionMode. 948type SelectionMode int 949 950const ( 951 SELECTION_NONE SelectionMode = C.GTK_SELECTION_NONE 952 SELECTION_SINGLE SelectionMode = C.GTK_SELECTION_SINGLE 953 SELECTION_BROWSE SelectionMode = C.GTK_SELECTION_BROWSE 954 SELECTION_MULTIPLE SelectionMode = C.GTK_SELECTION_MULTIPLE 955) 956 957func marshalSelectionMode(p uintptr) (interface{}, error) { 958 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 959 return SelectionMode(c), nil 960} 961 962// ShadowType is a representation of GTK's GtkShadowType. 963type ShadowType int 964 965const ( 966 SHADOW_NONE ShadowType = C.GTK_SHADOW_NONE 967 SHADOW_IN ShadowType = C.GTK_SHADOW_IN 968 SHADOW_OUT ShadowType = C.GTK_SHADOW_OUT 969 SHADOW_ETCHED_IN ShadowType = C.GTK_SHADOW_ETCHED_IN 970 SHADOW_ETCHED_OUT ShadowType = C.GTK_SHADOW_ETCHED_OUT 971) 972 973func marshalShadowType(p uintptr) (interface{}, error) { 974 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 975 return ShadowType(c), nil 976} 977 978// SizeGroupMode is a representation of GTK's GtkSizeGroupMode 979type SizeGroupMode int 980 981const ( 982 SIZE_GROUP_NONE SizeGroupMode = C.GTK_SIZE_GROUP_NONE 983 SIZE_GROUP_HORIZONTAL SizeGroupMode = C.GTK_SIZE_GROUP_HORIZONTAL 984 SIZE_GROUP_VERTICAL SizeGroupMode = C.GTK_SIZE_GROUP_VERTICAL 985 SIZE_GROUP_BOTH SizeGroupMode = C.GTK_SIZE_GROUP_BOTH 986) 987 988func marshalSizeGroupMode(p uintptr) (interface{}, error) { 989 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 990 return SizeGroupMode(c), nil 991} 992 993// SortType is a representation of GTK's GtkSortType. 994type SortType int 995 996const ( 997 SORT_ASCENDING SortType = C.GTK_SORT_ASCENDING 998 SORT_DESCENDING = C.GTK_SORT_DESCENDING 999) 1000 1001// Use as column id in SetSortColumnId to specify ListStore sorted 1002// by default column or unsorted 1003const ( 1004 SORT_COLUMN_DEFAULT int = -1 1005 SORT_COLUMN_UNSORTED int = -2 1006) 1007 1008func marshalSortType(p uintptr) (interface{}, error) { 1009 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1010 return SortType(c), nil 1011} 1012 1013// StateFlags is a representation of GTK's GtkStateFlags. 1014type StateFlags int 1015 1016const ( 1017 STATE_FLAG_NORMAL StateFlags = C.GTK_STATE_FLAG_NORMAL 1018 STATE_FLAG_ACTIVE StateFlags = C.GTK_STATE_FLAG_ACTIVE 1019 STATE_FLAG_PRELIGHT StateFlags = C.GTK_STATE_FLAG_PRELIGHT 1020 STATE_FLAG_SELECTED StateFlags = C.GTK_STATE_FLAG_SELECTED 1021 STATE_FLAG_INSENSITIVE StateFlags = C.GTK_STATE_FLAG_INSENSITIVE 1022 STATE_FLAG_INCONSISTENT StateFlags = C.GTK_STATE_FLAG_INCONSISTENT 1023 STATE_FLAG_FOCUSED StateFlags = C.GTK_STATE_FLAG_FOCUSED 1024 STATE_FLAG_BACKDROP StateFlags = C.GTK_STATE_FLAG_BACKDROP 1025) 1026 1027func marshalStateFlags(p uintptr) (interface{}, error) { 1028 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1029 return StateFlags(c), nil 1030} 1031 1032// TextDirection is a representation of GTK's GtkTextDirection. 1033type TextDirection int 1034 1035const ( 1036 TEXT_DIR_NONE TextDirection = C.GTK_TEXT_DIR_NONE 1037 TEXT_DIR_LTR TextDirection = C.GTK_TEXT_DIR_LTR 1038 TEXT_DIR_RTL TextDirection = C.GTK_TEXT_DIR_RTL 1039) 1040 1041func marshalTextDirection(p uintptr) (interface{}, error) { 1042 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1043 return TextDirection(c), nil 1044} 1045 1046// TargetFlags is a representation of GTK's GtkTargetFlags. 1047type TargetFlags int 1048 1049const ( 1050 TARGET_SAME_APP TargetFlags = C.GTK_TARGET_SAME_APP 1051 TARGET_SAME_WIDGET TargetFlags = C.GTK_TARGET_SAME_WIDGET 1052 TARGET_OTHER_APP TargetFlags = C.GTK_TARGET_OTHER_APP 1053 TARGET_OTHER_WIDGET TargetFlags = C.GTK_TARGET_OTHER_WIDGET 1054) 1055 1056func marshalTargetFlags(p uintptr) (interface{}, error) { 1057 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1058 return TargetFlags(c), nil 1059} 1060 1061// ToolbarStyle is a representation of GTK's GtkToolbarStyle. 1062type ToolbarStyle int 1063 1064const ( 1065 TOOLBAR_ICONS ToolbarStyle = C.GTK_TOOLBAR_ICONS 1066 TOOLBAR_TEXT ToolbarStyle = C.GTK_TOOLBAR_TEXT 1067 TOOLBAR_BOTH ToolbarStyle = C.GTK_TOOLBAR_BOTH 1068 TOOLBAR_BOTH_HORIZ ToolbarStyle = C.GTK_TOOLBAR_BOTH_HORIZ 1069) 1070 1071func marshalToolbarStyle(p uintptr) (interface{}, error) { 1072 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1073 return ToolbarStyle(c), nil 1074} 1075 1076// TreeModelFlags is a representation of GTK's GtkTreeModelFlags. 1077type TreeModelFlags int 1078 1079const ( 1080 TREE_MODEL_ITERS_PERSIST TreeModelFlags = C.GTK_TREE_MODEL_ITERS_PERSIST 1081 TREE_MODEL_LIST_ONLY TreeModelFlags = C.GTK_TREE_MODEL_LIST_ONLY 1082) 1083 1084func marshalTreeModelFlags(p uintptr) (interface{}, error) { 1085 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1086 return TreeModelFlags(c), nil 1087} 1088 1089// WindowPosition is a representation of GTK's GtkWindowPosition. 1090type WindowPosition int 1091 1092const ( 1093 WIN_POS_NONE WindowPosition = C.GTK_WIN_POS_NONE 1094 WIN_POS_CENTER WindowPosition = C.GTK_WIN_POS_CENTER 1095 WIN_POS_MOUSE WindowPosition = C.GTK_WIN_POS_MOUSE 1096 WIN_POS_CENTER_ALWAYS WindowPosition = C.GTK_WIN_POS_CENTER_ALWAYS 1097 WIN_POS_CENTER_ON_PARENT WindowPosition = C.GTK_WIN_POS_CENTER_ON_PARENT 1098) 1099 1100func marshalWindowPosition(p uintptr) (interface{}, error) { 1101 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1102 return WindowPosition(c), nil 1103} 1104 1105// WindowType is a representation of GTK's GtkWindowType. 1106type WindowType int 1107 1108const ( 1109 WINDOW_TOPLEVEL WindowType = C.GTK_WINDOW_TOPLEVEL 1110 WINDOW_POPUP WindowType = C.GTK_WINDOW_POPUP 1111) 1112 1113func marshalWindowType(p uintptr) (interface{}, error) { 1114 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1115 return WindowType(c), nil 1116} 1117 1118// WrapMode is a representation of GTK's GtkWrapMode. 1119type WrapMode int 1120 1121const ( 1122 WRAP_NONE WrapMode = C.GTK_WRAP_NONE 1123 WRAP_CHAR WrapMode = C.GTK_WRAP_CHAR 1124 WRAP_WORD WrapMode = C.GTK_WRAP_WORD 1125 WRAP_WORD_CHAR WrapMode = C.GTK_WRAP_WORD_CHAR 1126) 1127 1128func marshalWrapMode(p uintptr) (interface{}, error) { 1129 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1130 return WrapMode(c), nil 1131} 1132 1133// TextSearchFlags is a representation of GTK's GtkTextSearchFlags. 1134type TextSearchFlags int 1135 1136const ( 1137 TEXT_SEARCH_VISIBLE_ONLY TextSearchFlags = C.GTK_TEXT_SEARCH_VISIBLE_ONLY 1138 TEXT_SEARCH_TEXT_ONLY TextSearchFlags = C.GTK_TEXT_SEARCH_TEXT_ONLY 1139 TEXT_SEARCH_CASE_INSENSITIVE TextSearchFlags = C.GTK_TEXT_SEARCH_CASE_INSENSITIVE 1140) 1141 1142func marshalTextSearchFlags(p uintptr) (interface{}, error) { 1143 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1144 return TextSearchFlags(c), nil 1145} 1146 1147// CornerType is a representation of GTK's GtkCornerType. 1148type CornerType int 1149 1150const ( 1151 CORNER_TOP_LEFT CornerType = C.GTK_CORNER_TOP_LEFT 1152 CORNER_BOTTOM_LEFT CornerType = C.GTK_CORNER_BOTTOM_LEFT 1153 CORNER_TOP_RIGHT CornerType = C.GTK_CORNER_TOP_RIGHT 1154 CORNER_BOTTOM_RIGHT CornerType = C.GTK_CORNER_BOTTOM_RIGHT 1155) 1156 1157func marshalCornerType(p uintptr) (interface{}, error) { 1158 c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) 1159 return CornerType(c), nil 1160} 1161 1162/* 1163 * Init and main event loop 1164 */ 1165 1166/* 1167Init() is a wrapper around gtk_init() and must be called before any 1168other GTK calls and is used to initialize everything necessary. 1169 1170In addition to setting up GTK for usage, a pointer to a slice of 1171strings may be passed in to parse standard GTK command line arguments. 1172args will be modified to remove any flags that were handled. 1173Alternatively, nil may be passed in to not perform any command line 1174parsing. 1175*/ 1176func Init(args *[]string) { 1177 if args != nil { 1178 argc := C.int(len(*args)) 1179 argv := C.make_strings(argc) 1180 defer C.destroy_strings(argv) 1181 1182 for i, arg := range *args { 1183 cstr := C.CString(arg) 1184 C.set_string(argv, C.int(i), (*C.gchar)(cstr)) 1185 } 1186 1187 C.gtk_init((*C.int)(unsafe.Pointer(&argc)), 1188 (***C.char)(unsafe.Pointer(&argv))) 1189 1190 unhandled := make([]string, argc) 1191 for i := 0; i < int(argc); i++ { 1192 cstr := C.get_string(argv, C.int(i)) 1193 unhandled[i] = goString(cstr) 1194 C.free(unsafe.Pointer(cstr)) 1195 } 1196 *args = unhandled 1197 } else { 1198 C.gtk_init(nil, nil) 1199 } 1200} 1201 1202/* 1203InitCheck() is a wrapper around gtk_init_check() and works exactly like Init() 1204only that it doesn't terminate the program if initialization fails. 1205*/ 1206func InitCheck(args *[]string) error { 1207 success := false 1208 if args != nil { 1209 argc := C.int(len(*args)) 1210 argv := C.make_strings(argc) 1211 defer C.destroy_strings(argv) 1212 1213 for i, arg := range *args { 1214 cstr := C.CString(arg) 1215 C.set_string(argv, C.int(i), (*C.gchar)(cstr)) 1216 } 1217 1218 success = gobool(C.gtk_init_check((*C.int)(unsafe.Pointer(&argc)), 1219 (***C.char)(unsafe.Pointer(&argv)))) 1220 1221 unhandled := make([]string, argc) 1222 for i := 0; i < int(argc); i++ { 1223 cstr := C.get_string(argv, C.int(i)) 1224 unhandled[i] = goString(cstr) 1225 C.free(unsafe.Pointer(cstr)) 1226 } 1227 *args = unhandled 1228 } else { 1229 success = gobool(C.gtk_init_check(nil, nil)) 1230 } 1231 if success { 1232 return nil 1233 } else { 1234 return errors.New("Unable to initialize GTK") 1235 } 1236} 1237 1238// Main() is a wrapper around gtk_main() and runs the GTK main loop, 1239// blocking until MainQuit() is called. 1240func Main() { 1241 C.gtk_main() 1242} 1243 1244// MainIteration is a wrapper around gtk_main_iteration. 1245func MainIteration() bool { 1246 return gobool(C.gtk_main_iteration()) 1247} 1248 1249// MainIterationDo is a wrapper around gtk_main_iteration_do. 1250func MainIterationDo(blocking bool) bool { 1251 return gobool(C.gtk_main_iteration_do(gbool(blocking))) 1252} 1253 1254// EventsPending is a wrapper around gtk_events_pending. 1255func EventsPending() bool { 1256 return gobool(C.gtk_events_pending()) 1257} 1258 1259// MainQuit() is a wrapper around gtk_main_quit() is used to terminate 1260// the GTK main loop (started by Main()). 1261func MainQuit() { 1262 C.gtk_main_quit() 1263} 1264 1265/* 1266 * GtkAdjustment 1267 */ 1268 1269// Adjustment is a representation of GTK's GtkAdjustment. 1270type Adjustment struct { 1271 glib.InitiallyUnowned 1272} 1273 1274// native returns a pointer to the underlying GtkAdjustment. 1275func (v *Adjustment) native() *C.GtkAdjustment { 1276 if v == nil || v.GObject == nil { 1277 return nil 1278 } 1279 p := unsafe.Pointer(v.GObject) 1280 return C.toGtkAdjustment(p) 1281} 1282 1283func marshalAdjustment(p uintptr) (interface{}, error) { 1284 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 1285 obj := glib.Take(unsafe.Pointer(c)) 1286 return wrapAdjustment(obj), nil 1287} 1288 1289func wrapAdjustment(obj *glib.Object) *Adjustment { 1290 if obj == nil { 1291 return nil 1292 } 1293 1294 return &Adjustment{glib.InitiallyUnowned{obj}} 1295} 1296 1297// AdjustmentNew is a wrapper around gtk_adjustment_new(). 1298func AdjustmentNew(value, lower, upper, stepIncrement, pageIncrement, pageSize float64) (*Adjustment, error) { 1299 c := C.gtk_adjustment_new(C.gdouble(value), 1300 C.gdouble(lower), 1301 C.gdouble(upper), 1302 C.gdouble(stepIncrement), 1303 C.gdouble(pageIncrement), 1304 C.gdouble(pageSize)) 1305 if c == nil { 1306 return nil, nilPtrErr 1307 } 1308 obj := glib.Take(unsafe.Pointer(c)) 1309 return wrapAdjustment(obj), nil 1310} 1311 1312// GetValue is a wrapper around gtk_adjustment_get_value(). 1313func (v *Adjustment) GetValue() float64 { 1314 c := C.gtk_adjustment_get_value(v.native()) 1315 return float64(c) 1316} 1317 1318// SetValue is a wrapper around gtk_adjustment_set_value(). 1319func (v *Adjustment) SetValue(value float64) { 1320 C.gtk_adjustment_set_value(v.native(), C.gdouble(value)) 1321} 1322 1323// GetLower is a wrapper around gtk_adjustment_get_lower(). 1324func (v *Adjustment) GetLower() float64 { 1325 c := C.gtk_adjustment_get_lower(v.native()) 1326 return float64(c) 1327} 1328 1329// GetPageSize is a wrapper around gtk_adjustment_get_page_size(). 1330func (v *Adjustment) GetPageSize() float64 { 1331 return float64(C.gtk_adjustment_get_page_size(v.native())) 1332} 1333 1334// SetPageSize is a wrapper around gtk_adjustment_set_page_size(). 1335func (v *Adjustment) SetPageSize(value float64) { 1336 C.gtk_adjustment_set_page_size(v.native(), C.gdouble(value)) 1337} 1338 1339// Configure is a wrapper around gtk_adjustment_configure(). 1340func (v *Adjustment) Configure(value, lower, upper, stepIncrement, pageIncrement, pageSize float64) { 1341 C.gtk_adjustment_configure(v.native(), C.gdouble(value), 1342 C.gdouble(lower), C.gdouble(upper), C.gdouble(stepIncrement), 1343 C.gdouble(pageIncrement), C.gdouble(pageSize)) 1344} 1345 1346// SetLower is a wrapper around gtk_adjustment_set_lower(). 1347func (v *Adjustment) SetLower(value float64) { 1348 C.gtk_adjustment_set_lower(v.native(), C.gdouble(value)) 1349} 1350 1351// GetUpper is a wrapper around gtk_adjustment_get_upper(). 1352func (v *Adjustment) GetUpper() float64 { 1353 c := C.gtk_adjustment_get_upper(v.native()) 1354 return float64(c) 1355} 1356 1357// SetUpper is a wrapper around gtk_adjustment_set_upper(). 1358func (v *Adjustment) SetUpper(value float64) { 1359 C.gtk_adjustment_set_upper(v.native(), C.gdouble(value)) 1360} 1361 1362// GetPageIncrement is a wrapper around gtk_adjustment_get_page_increment(). 1363func (v *Adjustment) GetPageIncrement() float64 { 1364 c := C.gtk_adjustment_get_page_increment(v.native()) 1365 return float64(c) 1366} 1367 1368// SetPageIncrement is a wrapper around gtk_adjustment_set_page_increment(). 1369func (v *Adjustment) SetPageIncrement(value float64) { 1370 C.gtk_adjustment_set_page_increment(v.native(), C.gdouble(value)) 1371} 1372 1373// GetStepIncrement is a wrapper around gtk_adjustment_get_step_increment(). 1374func (v *Adjustment) GetStepIncrement() float64 { 1375 c := C.gtk_adjustment_get_step_increment(v.native()) 1376 return float64(c) 1377} 1378 1379// SetStepIncrement is a wrapper around gtk_adjustment_set_step_increment(). 1380func (v *Adjustment) SetStepIncrement(value float64) { 1381 C.gtk_adjustment_set_step_increment(v.native(), C.gdouble(value)) 1382} 1383 1384// GetMinimumIncrement is a wrapper around gtk_adjustment_get_minimum_increment(). 1385func (v *Adjustment) GetMinimumIncrement() float64 { 1386 c := C.gtk_adjustment_get_minimum_increment(v.native()) 1387 return float64(c) 1388} 1389 1390/* 1391void gtk_adjustment_clamp_page () 1392void gtk_adjustment_changed () 1393void gtk_adjustment_value_changed () 1394void gtk_adjustment_configure () 1395*/ 1396 1397/* 1398 * GtkAssistant 1399 */ 1400 1401// Assistant is a representation of GTK's GtkAssistant. 1402type Assistant struct { 1403 Window 1404} 1405 1406// native returns a pointer to the underlying GtkAssistant. 1407func (v *Assistant) native() *C.GtkAssistant { 1408 if v == nil || v.GObject == nil { 1409 return nil 1410 } 1411 p := unsafe.Pointer(v.GObject) 1412 return C.toGtkAssistant(p) 1413} 1414 1415func marshalAssistant(p uintptr) (interface{}, error) { 1416 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 1417 obj := glib.Take(unsafe.Pointer(c)) 1418 return wrapAssistant(obj), nil 1419} 1420 1421func wrapAssistant(obj *glib.Object) *Assistant { 1422 if obj == nil { 1423 return nil 1424 } 1425 1426 return &Assistant{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} 1427} 1428 1429// AssistantNew is a wrapper around gtk_assistant_new(). 1430func AssistantNew() (*Assistant, error) { 1431 c := C.gtk_assistant_new() 1432 if c == nil { 1433 return nil, nilPtrErr 1434 } 1435 obj := glib.Take(unsafe.Pointer(c)) 1436 return wrapAssistant(obj), nil 1437} 1438 1439// GetCurrentPage is a wrapper around gtk_assistant_get_current_page(). 1440func (v *Assistant) GetCurrentPage() int { 1441 c := C.gtk_assistant_get_current_page(v.native()) 1442 return int(c) 1443} 1444 1445// SetCurrentPage is a wrapper around gtk_assistant_set_current_page(). 1446func (v *Assistant) SetCurrentPage(pageNum int) { 1447 C.gtk_assistant_set_current_page(v.native(), C.gint(pageNum)) 1448} 1449 1450// GetNPages is a wrapper around gtk_assistant_get_n_pages(). 1451func (v *Assistant) GetNPages() int { 1452 c := C.gtk_assistant_get_n_pages(v.native()) 1453 return int(c) 1454} 1455 1456// GetNthPage is a wrapper around gtk_assistant_get_nth_page(). 1457func (v *Assistant) GetNthPage(pageNum int) (IWidget, error) { 1458 c := C.gtk_assistant_get_nth_page(v.native(), C.gint(pageNum)) 1459 if c == nil { 1460 return nil, fmt.Errorf("page %d is out of bounds", pageNum) 1461 } 1462 return castWidget(c) 1463} 1464 1465// PrependPage is a wrapper around gtk_assistant_prepend_page(). 1466func (v *Assistant) PrependPage(page IWidget) int { 1467 c := C.gtk_assistant_prepend_page(v.native(), page.toWidget()) 1468 return int(c) 1469} 1470 1471// AppendPage is a wrapper around gtk_assistant_append_page(). 1472func (v *Assistant) AppendPage(page IWidget) int { 1473 c := C.gtk_assistant_append_page(v.native(), page.toWidget()) 1474 return int(c) 1475} 1476 1477// InsertPage is a wrapper around gtk_assistant_insert_page(). 1478func (v *Assistant) InsertPage(page IWidget, position int) int { 1479 c := C.gtk_assistant_insert_page(v.native(), page.toWidget(), 1480 C.gint(position)) 1481 return int(c) 1482} 1483 1484// RemovePage is a wrapper around gtk_assistant_remove_page(). 1485func (v *Assistant) RemovePage(pageNum int) { 1486 C.gtk_assistant_remove_page(v.native(), C.gint(pageNum)) 1487} 1488 1489// TODO: gtk_assistant_set_forward_page_func 1490 1491// SetPageType is a wrapper around gtk_assistant_set_page_type(). 1492func (v *Assistant) SetPageType(page IWidget, ptype AssistantPageType) { 1493 C.gtk_assistant_set_page_type(v.native(), page.toWidget(), 1494 C.GtkAssistantPageType(ptype)) 1495} 1496 1497// GetPageType is a wrapper around gtk_assistant_get_page_type(). 1498func (v *Assistant) GetPageType(page IWidget) AssistantPageType { 1499 c := C.gtk_assistant_get_page_type(v.native(), page.toWidget()) 1500 return AssistantPageType(c) 1501} 1502 1503// SetPageTitle is a wrapper around gtk_assistant_set_page_title(). 1504func (v *Assistant) SetPageTitle(page IWidget, title string) { 1505 cstr := C.CString(title) 1506 defer C.free(unsafe.Pointer(cstr)) 1507 C.gtk_assistant_set_page_title(v.native(), page.toWidget(), 1508 (*C.gchar)(cstr)) 1509} 1510 1511// GetPageTitle is a wrapper around gtk_assistant_get_page_title(). 1512func (v *Assistant) GetPageTitle(page IWidget) string { 1513 return goString(C.gtk_assistant_get_page_title(v.native(), page.toWidget())) 1514} 1515 1516// SetPageComplete is a wrapper around gtk_assistant_set_page_complete(). 1517func (v *Assistant) SetPageComplete(page IWidget, complete bool) { 1518 C.gtk_assistant_set_page_complete(v.native(), page.toWidget(), 1519 gbool(complete)) 1520} 1521 1522// GetPageComplete is a wrapper around gtk_assistant_get_page_complete(). 1523func (v *Assistant) GetPageComplete(page IWidget) bool { 1524 c := C.gtk_assistant_get_page_complete(v.native(), page.toWidget()) 1525 return gobool(c) 1526} 1527 1528// AddActionWidget is a wrapper around gtk_assistant_add_action_widget(). 1529func (v *Assistant) AddActionWidget(child IWidget) { 1530 C.gtk_assistant_add_action_widget(v.native(), child.toWidget()) 1531} 1532 1533// RemoveActionWidget is a wrapper around gtk_assistant_remove_action_widget(). 1534func (v *Assistant) RemoveActionWidget(child IWidget) { 1535 C.gtk_assistant_remove_action_widget(v.native(), child.toWidget()) 1536} 1537 1538// UpdateButtonsState is a wrapper around gtk_assistant_update_buttons_state(). 1539func (v *Assistant) UpdateButtonsState() { 1540 C.gtk_assistant_update_buttons_state(v.native()) 1541} 1542 1543// Commit is a wrapper around gtk_assistant_commit(). 1544func (v *Assistant) Commit() { 1545 C.gtk_assistant_commit(v.native()) 1546} 1547 1548// NextPage is a wrapper around gtk_assistant_next_page(). 1549func (v *Assistant) NextPage() { 1550 C.gtk_assistant_next_page(v.native()) 1551} 1552 1553// PreviousPage is a wrapper around gtk_assistant_previous_page(). 1554func (v *Assistant) PreviousPage() { 1555 C.gtk_assistant_previous_page(v.native()) 1556} 1557 1558/* 1559 * GtkBin 1560 */ 1561 1562// Bin is a representation of GTK's GtkBin. 1563type Bin struct { 1564 Container 1565} 1566 1567// native returns a pointer to the underlying GtkBin. 1568func (v *Bin) native() *C.GtkBin { 1569 if v == nil || v.GObject == nil { 1570 return nil 1571 } 1572 p := unsafe.Pointer(v.GObject) 1573 return C.toGtkBin(p) 1574} 1575 1576func marshalBin(p uintptr) (interface{}, error) { 1577 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 1578 obj := glib.Take(unsafe.Pointer(c)) 1579 return wrapBin(obj), nil 1580} 1581 1582func wrapBin(obj *glib.Object) *Bin { 1583 if obj == nil { 1584 return nil 1585 } 1586 1587 return &Bin{Container{Widget{glib.InitiallyUnowned{obj}}}} 1588} 1589 1590// GetChild is a wrapper around gtk_bin_get_child(). 1591func (v *Bin) GetChild() (IWidget, error) { 1592 c := C.gtk_bin_get_child(v.native()) 1593 if c == nil { 1594 return nil, nil 1595 } 1596 return castWidget(c) 1597} 1598 1599/* 1600 * GtkBuilder 1601 */ 1602 1603// Builder is a representation of GTK's GtkBuilder. 1604type Builder struct { 1605 *glib.Object 1606} 1607 1608// native() returns a pointer to the underlying GtkBuilder. 1609func (b *Builder) native() *C.GtkBuilder { 1610 if b == nil || b.GObject == nil { 1611 return nil 1612 } 1613 p := unsafe.Pointer(b.GObject) 1614 return C.toGtkBuilder(p) 1615} 1616 1617func marshalBuilder(p uintptr) (interface{}, error) { 1618 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 1619 obj := glib.Take(unsafe.Pointer(c)) 1620 return &Builder{obj}, nil 1621} 1622 1623// BuilderNew is a wrapper around gtk_builder_new(). 1624func BuilderNew() (*Builder, error) { 1625 c := C.gtk_builder_new() 1626 if c == nil { 1627 return nil, nilPtrErr 1628 } 1629 obj := glib.Take(unsafe.Pointer(c)) 1630 return &Builder{obj}, nil 1631} 1632 1633// AddFromFile is a wrapper around gtk_builder_add_from_file(). 1634func (b *Builder) AddFromFile(filename string) error { 1635 cstr := C.CString(filename) 1636 defer C.free(unsafe.Pointer(cstr)) 1637 var err *C.GError = nil 1638 res := C.gtk_builder_add_from_file(b.native(), (*C.gchar)(cstr), &err) 1639 if res == 0 { 1640 defer C.g_error_free(err) 1641 return errors.New(goString(err.message)) 1642 } 1643 return nil 1644} 1645 1646// AddFromResource is a wrapper around gtk_builder_add_from_resource(). 1647func (b *Builder) AddFromResource(path string) error { 1648 cstr := C.CString(path) 1649 defer C.free(unsafe.Pointer(cstr)) 1650 var err *C.GError = nil 1651 res := C.gtk_builder_add_from_resource(b.native(), (*C.gchar)(cstr), &err) 1652 if res == 0 { 1653 defer C.g_error_free(err) 1654 return errors.New(goString(err.message)) 1655 } 1656 return nil 1657} 1658 1659// AddFromString is a wrapper around gtk_builder_add_from_string(). 1660func (b *Builder) AddFromString(str string) error { 1661 cstr := C.CString(str) 1662 defer C.free(unsafe.Pointer(cstr)) 1663 length := (C.gsize)(len(str)) 1664 var err *C.GError = nil 1665 res := C.gtk_builder_add_from_string(b.native(), (*C.gchar)(cstr), length, &err) 1666 if res == 0 { 1667 defer C.g_error_free(err) 1668 return errors.New(goString(err.message)) 1669 } 1670 return nil 1671} 1672 1673// GetObject is a wrapper around gtk_builder_get_object(). The returned result 1674// is an IObject, so it will need to be type-asserted to the appropriate type before 1675// being used. For example, to get an object and type assert it as a window: 1676// 1677// obj, err := builder.GetObject("window") 1678// if err != nil { 1679// // object not found 1680// return 1681// } 1682// if w, ok := obj.(*gtk.Window); ok { 1683// // do stuff with w here 1684// } else { 1685// // not a *gtk.Window 1686// } 1687// 1688func (b *Builder) GetObject(name string) (glib.IObject, error) { 1689 cstr := C.CString(name) 1690 defer C.free(unsafe.Pointer(cstr)) 1691 c := C.gtk_builder_get_object(b.native(), (*C.gchar)(cstr)) 1692 if c == nil { 1693 return nil, errors.New("object '" + name + "' not found") 1694 } 1695 obj, err := cast(c) 1696 if err != nil { 1697 return nil, err 1698 } 1699 return obj, nil 1700} 1701 1702var ( 1703 builderSignals = struct { 1704 sync.RWMutex 1705 m map[*C.GtkBuilder]map[string]interface{} 1706 }{ 1707 m: make(map[*C.GtkBuilder]map[string]interface{}), 1708 } 1709) 1710 1711// ConnectSignals is a wrapper around gtk_builder_connect_signals_full(). 1712func (b *Builder) ConnectSignals(signals map[string]interface{}) { 1713 builderSignals.Lock() 1714 builderSignals.m[b.native()] = signals 1715 builderSignals.Unlock() 1716 1717 C._gtk_builder_connect_signals_full(b.native()) 1718} 1719 1720/* 1721 * GtkBuildable 1722 */ 1723 1724// TODO: 1725// GtkBuildableIface 1726// gtk_buildable_set_name(). 1727// gtk_buildable_get_name(). 1728// gtk_buildable_add_child(). 1729// gtk_buildable_set_buildable_property(). 1730// gtk_buildable_construct_child(). 1731// gtk_buildable_custom_tag_start(). 1732// gtk_buildable_custom_tag_end(). 1733// gtk_buildable_custom_finished(). 1734// gtk_buildable_parser_finished(). 1735// gtk_buildable_get_internal_child(). 1736 1737/* 1738 * GtkButton 1739 */ 1740 1741// Button is a representation of GTK's GtkButton. 1742type Button struct { 1743 Bin 1744 1745 // Interfaces 1746 IActionable 1747} 1748 1749// native() returns a pointer to the underlying GtkButton. 1750func (v *Button) native() *C.GtkButton { 1751 if v == nil || v.GObject == nil { 1752 return nil 1753 } 1754 p := unsafe.Pointer(v.GObject) 1755 return C.toGtkButton(p) 1756} 1757 1758func marshalButton(p uintptr) (interface{}, error) { 1759 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 1760 obj := glib.Take(unsafe.Pointer(c)) 1761 return wrapButton(obj), nil 1762} 1763 1764func wrapButton(obj *glib.Object) *Button { 1765 if obj == nil { 1766 return nil 1767 } 1768 1769 actionable := &Actionable{obj} 1770 return &Button{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}, actionable} 1771} 1772 1773// ButtonNew() is a wrapper around gtk_button_new(). 1774func ButtonNew() (*Button, error) { 1775 c := C.gtk_button_new() 1776 if c == nil { 1777 return nil, nilPtrErr 1778 } 1779 obj := glib.Take(unsafe.Pointer(c)) 1780 return wrapButton(obj), nil 1781} 1782 1783// ButtonNewWithLabel() is a wrapper around gtk_button_new_with_label(). 1784func ButtonNewWithLabel(label string) (*Button, error) { 1785 cstr := C.CString(label) 1786 defer C.free(unsafe.Pointer(cstr)) 1787 c := C.gtk_button_new_with_label((*C.gchar)(cstr)) 1788 if c == nil { 1789 return nil, nilPtrErr 1790 } 1791 obj := glib.Take(unsafe.Pointer(c)) 1792 return wrapButton(obj), nil 1793} 1794 1795// ButtonNewWithMnemonic() is a wrapper around gtk_button_new_with_mnemonic(). 1796func ButtonNewWithMnemonic(label string) (*Button, error) { 1797 cstr := C.CString(label) 1798 defer C.free(unsafe.Pointer(cstr)) 1799 c := C.gtk_button_new_with_mnemonic((*C.gchar)(cstr)) 1800 if c == nil { 1801 return nil, nilPtrErr 1802 } 1803 obj := glib.Take(unsafe.Pointer(c)) 1804 return wrapButton(obj), nil 1805} 1806 1807// Clicked() is a wrapper around gtk_button_clicked(). 1808func (v *Button) Clicked() { 1809 C.gtk_button_clicked(v.native()) 1810} 1811 1812// SetRelief() is a wrapper around gtk_button_set_relief(). 1813func (v *Button) SetRelief(newStyle ReliefStyle) { 1814 C.gtk_button_set_relief(v.native(), C.GtkReliefStyle(newStyle)) 1815} 1816 1817// GetRelief() is a wrapper around gtk_button_get_relief(). 1818func (v *Button) GetRelief() ReliefStyle { 1819 c := C.gtk_button_get_relief(v.native()) 1820 return ReliefStyle(c) 1821} 1822 1823// SetLabel() is a wrapper around gtk_button_set_label(). 1824func (v *Button) SetLabel(label string) { 1825 cstr := C.CString(label) 1826 defer C.free(unsafe.Pointer(cstr)) 1827 C.gtk_button_set_label(v.native(), (*C.gchar)(cstr)) 1828} 1829 1830// GetLabel() is a wrapper around gtk_button_get_label(). 1831func (v *Button) GetLabel() (string, error) { 1832 c := C.gtk_button_get_label(v.native()) 1833 if c == nil { 1834 return "", nilPtrErr 1835 } 1836 return goString(c), nil 1837} 1838 1839// SetUseUnderline() is a wrapper around gtk_button_set_use_underline(). 1840func (v *Button) SetUseUnderline(useUnderline bool) { 1841 C.gtk_button_set_use_underline(v.native(), gbool(useUnderline)) 1842} 1843 1844// GetUseUnderline() is a wrapper around gtk_button_get_use_underline(). 1845func (v *Button) GetUseUnderline() bool { 1846 c := C.gtk_button_get_use_underline(v.native()) 1847 return gobool(c) 1848} 1849 1850// SetImage() is a wrapper around gtk_button_set_image(). 1851func (v *Button) SetImage(image IWidget) { 1852 C.gtk_button_set_image(v.native(), image.toWidget()) 1853} 1854 1855// GetImage() is a wrapper around gtk_button_get_image(). 1856func (v *Button) GetImage() (IWidget, error) { 1857 c := C.gtk_button_get_image(v.native()) 1858 if c == nil { 1859 return nil, nil 1860 } 1861 return castWidget(c) 1862} 1863 1864// SetImagePosition() is a wrapper around gtk_button_set_image_position(). 1865func (v *Button) SetImagePosition(position PositionType) { 1866 C.gtk_button_set_image_position(v.native(), C.GtkPositionType(position)) 1867} 1868 1869// GetImagePosition() is a wrapper around gtk_button_get_image_position(). 1870func (v *Button) GetImagePosition() PositionType { 1871 c := C.gtk_button_get_image_position(v.native()) 1872 return PositionType(c) 1873} 1874 1875// SetAlwaysShowImage() is a wrapper around gtk_button_set_always_show_image(). 1876func (v *Button) SetAlwaysShowImage(alwaysShow bool) { 1877 C.gtk_button_set_always_show_image(v.native(), gbool(alwaysShow)) 1878} 1879 1880// GetAlwaysShowImage() is a wrapper around gtk_button_get_always_show_image(). 1881func (v *Button) GetAlwaysShowImage() bool { 1882 c := C.gtk_button_get_always_show_image(v.native()) 1883 return gobool(c) 1884} 1885 1886// GetEventWindow() is a wrapper around gtk_button_get_event_window(). 1887func (v *Button) GetEventWindow() (*gdk.Window, error) { 1888 c := C.gtk_button_get_event_window(v.native()) 1889 if c == nil { 1890 return nil, nilPtrErr 1891 } 1892 1893 w := &gdk.Window{glib.Take(unsafe.Pointer(c))} 1894 return w, nil 1895} 1896 1897/* 1898 * GtkColorButton 1899 */ 1900 1901// ColorButton is a representation of GTK's GtkColorButton. 1902type ColorButton struct { 1903 Button 1904 1905 // Interfaces 1906 ColorChooser 1907} 1908 1909// Native returns a pointer to the underlying GtkColorButton. 1910func (v *ColorButton) native() *C.GtkColorButton { 1911 if v == nil || v.GObject == nil { 1912 return nil 1913 } 1914 p := unsafe.Pointer(v.GObject) 1915 return C.toGtkColorButton(p) 1916} 1917 1918func wrapColorButton(obj *glib.Object) *ColorButton { 1919 if obj == nil { 1920 return nil 1921 } 1922 1923 cc := wrapColorChooser(obj) 1924 actionable := wrapActionable(obj) 1925 return &ColorButton{Button{Bin{Container{Widget{ 1926 glib.InitiallyUnowned{obj}}}}, actionable}, *cc} 1927} 1928 1929// ColorButtonNew is a wrapper around gtk_color_button_new(). 1930func ColorButtonNew() (*ColorButton, error) { 1931 c := C.gtk_color_button_new() 1932 if c == nil { 1933 return nil, nilPtrErr 1934 } 1935 return wrapColorButton(glib.Take(unsafe.Pointer(c))), nil 1936} 1937 1938// ColorButtonNewWithRGBA is a wrapper around gtk_color_button_new_with_rgba(). 1939func ColorButtonNewWithRGBA(gdkColor *gdk.RGBA) (*ColorButton, error) { 1940 c := C.gtk_color_button_new_with_rgba((*C.GdkRGBA)(unsafe.Pointer(gdkColor.Native()))) 1941 if c == nil { 1942 return nil, nilPtrErr 1943 } 1944 return wrapColorButton(glib.Take(unsafe.Pointer(c))), nil 1945} 1946 1947// SetTitle is a wrapper around gtk_color_button_set_title(). 1948func (v *ColorButton) SetTitle(title string) { 1949 cstr := C.CString(title) 1950 defer C.free(unsafe.Pointer(cstr)) 1951 C.gtk_color_button_set_title(v.native(), (*C.gchar)(cstr)) 1952} 1953 1954// GetTitle is a wrapper around gtk_color_button_get_title(). 1955func (v *ColorButton) GetTitle() string { 1956 c := C.gtk_color_button_get_title(v.native()) 1957 defer C.free(unsafe.Pointer(c)) 1958 return goString(c) 1959} 1960 1961/* 1962 * GtkBox 1963 */ 1964 1965// Box is a representation of GTK's GtkBox. 1966type Box struct { 1967 Container 1968} 1969 1970// native() returns a pointer to the underlying GtkBox. 1971func (v *Box) native() *C.GtkBox { 1972 if v == nil || v.GObject == nil { 1973 return nil 1974 } 1975 p := unsafe.Pointer(v.GObject) 1976 return C.toGtkBox(p) 1977} 1978 1979func marshalBox(p uintptr) (interface{}, error) { 1980 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 1981 obj := glib.Take(unsafe.Pointer(c)) 1982 return wrapBox(obj), nil 1983} 1984 1985func wrapBox(obj *glib.Object) *Box { 1986 if obj == nil { 1987 return nil 1988 } 1989 1990 return &Box{Container{Widget{glib.InitiallyUnowned{obj}}}} 1991} 1992 1993func (v *Box) toOrientable() *C.GtkOrientable { 1994 if v == nil { 1995 return nil 1996 } 1997 return C.toGtkOrientable(unsafe.Pointer(v.GObject)) 1998} 1999 2000// GetOrientation() is a wrapper around C.gtk_orientable_get_orientation() for a GtkBox 2001func (v *Box) GetOrientation() Orientation { 2002 return Orientation(C.gtk_orientable_get_orientation(v.toOrientable())) 2003} 2004 2005// SetOrientation() is a wrapper around C.gtk_orientable_set_orientation() for a GtkBox 2006func (v *Box) SetOrientation(o Orientation) { 2007 C.gtk_orientable_set_orientation(v.toOrientable(), C.GtkOrientation(o)) 2008} 2009 2010// BoxNew() is a wrapper around gtk_box_new(). 2011func BoxNew(orientation Orientation, spacing int) (*Box, error) { 2012 c := C.gtk_box_new(C.GtkOrientation(orientation), C.gint(spacing)) 2013 if c == nil { 2014 return nil, nilPtrErr 2015 } 2016 obj := glib.Take(unsafe.Pointer(c)) 2017 return wrapBox(obj), nil 2018} 2019 2020// PackStart() is a wrapper around gtk_box_pack_start(). 2021func (v *Box) PackStart(child IWidget, expand, fill bool, padding uint) { 2022 C.gtk_box_pack_start(v.native(), child.toWidget(), gbool(expand), 2023 gbool(fill), C.guint(padding)) 2024} 2025 2026// PackEnd() is a wrapper around gtk_box_pack_end(). 2027func (v *Box) PackEnd(child IWidget, expand, fill bool, padding uint) { 2028 C.gtk_box_pack_end(v.native(), child.toWidget(), gbool(expand), 2029 gbool(fill), C.guint(padding)) 2030} 2031 2032// GetHomogeneous() is a wrapper around gtk_box_get_homogeneous(). 2033func (v *Box) GetHomogeneous() bool { 2034 c := C.gtk_box_get_homogeneous(v.native()) 2035 return gobool(c) 2036} 2037 2038// SetHomogeneous() is a wrapper around gtk_box_set_homogeneous(). 2039func (v *Box) SetHomogeneous(homogeneous bool) { 2040 C.gtk_box_set_homogeneous(v.native(), gbool(homogeneous)) 2041} 2042 2043// GetSpacing() is a wrapper around gtk_box_get_spacing(). 2044func (v *Box) GetSpacing() int { 2045 c := C.gtk_box_get_spacing(v.native()) 2046 return int(c) 2047} 2048 2049// SetSpacing() is a wrapper around gtk_box_set_spacing() 2050func (v *Box) SetSpacing(spacing int) { 2051 C.gtk_box_set_spacing(v.native(), C.gint(spacing)) 2052} 2053 2054// ReorderChild() is a wrapper around gtk_box_reorder_child(). 2055func (v *Box) ReorderChild(child IWidget, position int) { 2056 C.gtk_box_reorder_child(v.native(), child.toWidget(), C.gint(position)) 2057} 2058 2059// QueryChildPacking() is a wrapper around gtk_box_query_child_packing(). 2060func (v *Box) QueryChildPacking(child IWidget) (expand, fill bool, padding uint, packType PackType) { 2061 var cexpand, cfill C.gboolean 2062 var cpadding C.guint 2063 var cpackType C.GtkPackType 2064 2065 C.gtk_box_query_child_packing(v.native(), child.toWidget(), &cexpand, 2066 &cfill, &cpadding, &cpackType) 2067 return gobool(cexpand), gobool(cfill), uint(cpadding), PackType(cpackType) 2068} 2069 2070// SetChildPacking() is a wrapper around gtk_box_set_child_packing(). 2071func (v *Box) SetChildPacking(child IWidget, expand, fill bool, padding uint, packType PackType) { 2072 C.gtk_box_set_child_packing(v.native(), child.toWidget(), gbool(expand), 2073 gbool(fill), C.guint(padding), C.GtkPackType(packType)) 2074} 2075 2076/* 2077 * GtkCalendar 2078 */ 2079 2080// Calendar is a representation of GTK's GtkCalendar. 2081type Calendar struct { 2082 Widget 2083} 2084 2085// native() returns a pointer to the underlying GtkCalendar. 2086func (v *Calendar) native() *C.GtkCalendar { 2087 if v == nil || v.GObject == nil { 2088 return nil 2089 } 2090 p := unsafe.Pointer(v.GObject) 2091 return C.toGtkCalendar(p) 2092} 2093 2094func marshalCalendar(p uintptr) (interface{}, error) { 2095 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2096 obj := glib.Take(unsafe.Pointer(c)) 2097 return wrapCalendar(obj), nil 2098} 2099 2100func wrapCalendar(obj *glib.Object) *Calendar { 2101 if obj == nil { 2102 return nil 2103 } 2104 2105 return &Calendar{Widget{glib.InitiallyUnowned{obj}}} 2106} 2107 2108// TODO: 2109// GtkCalendarDetailFunc 2110 2111// CalendarNew is a wrapper around gtk_calendar_new(). 2112func CalendarNew() (*Calendar, error) { 2113 c := C.gtk_calendar_new() 2114 if c == nil { 2115 return nil, nilPtrErr 2116 } 2117 obj := glib.Take(unsafe.Pointer(c)) 2118 return wrapCalendar(obj), nil 2119} 2120 2121// SelectMonth is a wrapper around gtk_calendar_select_month(). 2122func (v *Calendar) SelectMonth(month, year uint) { 2123 C.gtk_calendar_select_month(v.native(), C.guint(month), C.guint(year)) 2124} 2125 2126// SelectDay is a wrapper around gtk_calendar_select_day(). 2127func (v *Calendar) SelectDay(day uint) { 2128 C.gtk_calendar_select_day(v.native(), C.guint(day)) 2129} 2130 2131// MarkDay is a wrapper around gtk_calendar_mark_day(). 2132func (v *Calendar) MarkDay(day uint) { 2133 C.gtk_calendar_mark_day(v.native(), C.guint(day)) 2134} 2135 2136// UnmarkDay is a wrapper around gtk_calendar_unmark_day(). 2137func (v *Calendar) UnmarkDay(day uint) { 2138 C.gtk_calendar_unmark_day(v.native(), C.guint(day)) 2139} 2140 2141// GetDayIsMarked is a wrapper around gtk_calendar_get_day_is_marked(). 2142func (v *Calendar) GetDayIsMarked(day uint) bool { 2143 c := C.gtk_calendar_get_day_is_marked(v.native(), C.guint(day)) 2144 return gobool(c) 2145} 2146 2147// ClearMarks is a wrapper around gtk_calendar_clear_marks(). 2148func (v *Calendar) ClearMarks() { 2149 C.gtk_calendar_clear_marks(v.native()) 2150} 2151 2152// GetDisplayOptions is a wrapper around gtk_calendar_get_display_options(). 2153func (v *Calendar) GetDisplayOptions() CalendarDisplayOptions { 2154 c := C.gtk_calendar_get_display_options(v.native()) 2155 return CalendarDisplayOptions(c) 2156} 2157 2158// SetDisplayOptions is a wrapper around gtk_calendar_set_display_options(). 2159func (v *Calendar) SetDisplayOptions(flags CalendarDisplayOptions) { 2160 C.gtk_calendar_set_display_options(v.native(), 2161 C.GtkCalendarDisplayOptions(flags)) 2162} 2163 2164// GetDate is a wrapper around gtk_calendar_get_date(). 2165func (v *Calendar) GetDate() (year, month, day uint) { 2166 var cyear, cmonth, cday C.guint 2167 C.gtk_calendar_get_date(v.native(), &cyear, &cmonth, &cday) 2168 return uint(cyear), uint(cmonth), uint(cday) 2169} 2170 2171// TODO: 2172// gtk_calendar_set_detail_func(). 2173 2174// GetDetailWidthChars is a wrapper around gtk_calendar_get_detail_width_chars(). 2175func (v *Calendar) GetDetailWidthChars() int { 2176 c := C.gtk_calendar_get_detail_width_chars(v.native()) 2177 return int(c) 2178} 2179 2180// SetDetailWidthChars is a wrapper around gtk_calendar_set_detail_width_chars(). 2181func (v *Calendar) SetDetailWidthChars(chars int) { 2182 C.gtk_calendar_set_detail_width_chars(v.native(), C.gint(chars)) 2183} 2184 2185// GetDetailHeightRows is a wrapper around gtk_calendar_get_detail_height_rows(). 2186func (v *Calendar) GetDetailHeightRows() int { 2187 c := C.gtk_calendar_get_detail_height_rows(v.native()) 2188 return int(c) 2189} 2190 2191// SetDetailHeightRows is a wrapper around gtk_calendar_set_detail_height_rows(). 2192func (v *Calendar) SetDetailHeightRows(rows int) { 2193 C.gtk_calendar_set_detail_height_rows(v.native(), C.gint(rows)) 2194} 2195 2196/* 2197 * GtkCellLayout 2198 */ 2199 2200// CellLayout is a representation of GTK's GtkCellLayout GInterface. 2201type CellLayout struct { 2202 *glib.Object 2203} 2204 2205// ICellLayout is an interface type implemented by all structs 2206// embedding a CellLayout. It is meant to be used as an argument type 2207// for wrapper functions that wrap around a C GTK function taking a 2208// GtkCellLayout. 2209type ICellLayout interface { 2210 toCellLayout() *C.GtkCellLayout 2211} 2212 2213// native() returns a pointer to the underlying GObject as a GtkCellLayout. 2214func (v *CellLayout) native() *C.GtkCellLayout { 2215 if v == nil || v.GObject == nil { 2216 return nil 2217 } 2218 p := unsafe.Pointer(v.GObject) 2219 return C.toGtkCellLayout(p) 2220} 2221 2222func marshalCellLayout(p uintptr) (interface{}, error) { 2223 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2224 obj := glib.Take(unsafe.Pointer(c)) 2225 return wrapCellLayout(obj), nil 2226} 2227 2228func wrapCellLayout(obj *glib.Object) *CellLayout { 2229 if obj == nil { 2230 return nil 2231 } 2232 2233 return &CellLayout{obj} 2234} 2235 2236func (v *CellLayout) toCellLayout() *C.GtkCellLayout { 2237 if v == nil { 2238 return nil 2239 } 2240 return v.native() 2241} 2242 2243// PackStart is a wrapper around gtk_cell_layout_pack_start(). 2244func (v *CellLayout) PackStart(cell ICellRenderer, expand bool) { 2245 C.gtk_cell_layout_pack_start(v.native(), cell.toCellRenderer(), 2246 gbool(expand)) 2247} 2248 2249// AddAttribute is a wrapper around gtk_cell_layout_add_attribute(). 2250func (v *CellLayout) AddAttribute(cell ICellRenderer, attribute string, column int) { 2251 cstr := C.CString(attribute) 2252 defer C.free(unsafe.Pointer(cstr)) 2253 C.gtk_cell_layout_add_attribute(v.native(), cell.toCellRenderer(), 2254 (*C.gchar)(cstr), C.gint(column)) 2255} 2256 2257// ClearAttributes is a wrapper around gtk_cell_layout_clear_attributes() 2258func (v *CellLayout) ClearAttributes(cell ICellRenderer) { 2259 C.gtk_cell_layout_clear_attributes(v.native(), cell.toCellRenderer()) 2260} 2261 2262/* 2263 * GtkCellView 2264 */ 2265 2266// TODO: 2267// GtkCellView 2268// gtk_cell_view_new(). 2269// gtk_cell_view_new_with_context(). 2270// gtk_cell_view_new_with_text(). 2271// gtk_cell_view_new_with_markup(). 2272// gtk_cell_view_new_with_pixbuf(). 2273// gtk_cell_view_set_model(). 2274// gtk_cell_view_get_model(). 2275// gtk_cell_view_set_displayed_row(). 2276// gtk_cell_view_get_displayed_row(). 2277// gtk_cell_view_set_background_rgba(). 2278// gtk_cell_view_set_draw_sensitive(). 2279// gtk_cell_view_get_draw_sensitive(). 2280// gtk_cell_view_set_fit_model(). 2281// gtk_cell_view_get_fit_model(). 2282 2283/* 2284 * GtkCellEditable 2285 */ 2286 2287// CellEditable is a representation of GTK's GtkCellEditable GInterface. 2288type CellEditable struct { 2289 glib.InitiallyUnowned 2290 // Widget 2291} 2292 2293// ICellEditable is an interface type implemented by all structs 2294// embedding an CellEditable. It is meant to be used as an argument type 2295// for wrapper functions that wrap around a C GTK function taking a 2296// GtkCellEditable. 2297type ICellEditable interface { 2298 toCellEditable() *C.GtkCellEditable 2299 ToEntry() *Entry 2300} 2301 2302// native() returns a pointer to the underlying GObject as a GtkCellEditable. 2303func (v *CellEditable) native() *C.GtkCellEditable { 2304 if v == nil || v.GObject == nil { 2305 return nil 2306 } 2307 p := unsafe.Pointer(v.GObject) 2308 return C.toGtkCellEditable(p) 2309} 2310 2311func marshalCellEditable(p uintptr) (interface{}, error) { 2312 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2313 obj := glib.Take(unsafe.Pointer(c)) 2314 return wrapCellEditable(obj), nil 2315} 2316 2317func wrapCellEditable(obj *glib.Object) *CellEditable { 2318 if obj == nil { 2319 return nil 2320 } 2321 2322 // return &CellEditable{Widget{glib.InitiallyUnowned{obj}}} 2323 return &CellEditable{glib.InitiallyUnowned{obj}} 2324} 2325 2326func (v *CellEditable) toCellEditable() *C.GtkCellEditable { 2327 if v == nil { 2328 return nil 2329 } 2330 return v.native() 2331} 2332 2333// ToEntry is a helper tool, e.g: it returns *gtk.CellEditable as a *gtk.Entry 2334// that embedding this CellEditable instance, then it can be used with 2335// CellRendererText to adding EntryCompletion tools or intercepting EntryBuffer, 2336// (to bypass "canceled" signal for example) then record entry, and much more. 2337func (v *CellEditable) ToEntry() *Entry { 2338 return &Entry{Widget{glib.InitiallyUnowned{v.Object}}, 2339 Editable{v.Object}, 2340 *v} 2341} 2342 2343// StartEditing is a wrapper around gtk_cell_editable_start_editing(). 2344func (v *CellEditable) StartEditing(event *gdk.Event) { 2345 C.gtk_cell_editable_start_editing(v.native(), 2346 (*C.GdkEvent)(unsafe.Pointer(event.Native()))) 2347} 2348 2349// EditingDone is a wrapper around gtk_cell_editable_editing_done(). 2350func (v *CellEditable) EditingDone() { 2351 C.gtk_cell_editable_editing_done(v.native()) 2352} 2353 2354// RemoveWidget is a wrapper around gtk_cell_editable_remove_widget(). 2355func (v *CellEditable) RemoveWidget() { 2356 C.gtk_cell_editable_remove_widget(v.native()) 2357} 2358 2359/* 2360 * GtkCellRenderer 2361 */ 2362 2363// CellRenderer is a representation of GTK's GtkCellRenderer. 2364type CellRenderer struct { 2365 glib.InitiallyUnowned 2366} 2367 2368// ICellRenderer is an interface type implemented by all structs 2369// embedding a CellRenderer. It is meant to be used as an argument type 2370// for wrapper functions that wrap around a C GTK function taking a 2371// GtkCellRenderer. 2372type ICellRenderer interface { 2373 toCellRenderer() *C.GtkCellRenderer 2374} 2375 2376// native returns a pointer to the underlying GtkCellRenderer. 2377func (v *CellRenderer) native() *C.GtkCellRenderer { 2378 if v == nil || v.GObject == nil { 2379 return nil 2380 } 2381 p := unsafe.Pointer(v.GObject) 2382 return C.toGtkCellRenderer(p) 2383} 2384 2385func (v *CellRenderer) toCellRenderer() *C.GtkCellRenderer { 2386 if v == nil { 2387 return nil 2388 } 2389 return v.native() 2390} 2391 2392func marshalCellRenderer(p uintptr) (interface{}, error) { 2393 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2394 obj := glib.Take(unsafe.Pointer(c)) 2395 return wrapCellRenderer(obj), nil 2396} 2397 2398func wrapCellRenderer(obj *glib.Object) *CellRenderer { 2399 if obj == nil { 2400 return nil 2401 } 2402 2403 return &CellRenderer{glib.InitiallyUnowned{obj}} 2404} 2405 2406// Activate is a wrapper around gtk_cell_renderer_activate(). 2407func (v *CellRenderer) Activate(event *gdk.Event, widget IWidget, path string, 2408 backgroundArea, cellArea *gdk.Rectangle, flags CellRendererState) bool { 2409 2410 cstr := C.CString(path) 2411 defer C.free(unsafe.Pointer(cstr)) 2412 e := (*C.GdkEvent)(unsafe.Pointer(event.Native())) 2413 2414 c := C.gtk_cell_renderer_activate(v.native(), e, widget.toWidget(), 2415 (*C.gchar)(cstr), nativeGdkRectangle(*backgroundArea), 2416 nativeGdkRectangle(*cellArea), C.GtkCellRendererState(flags)) 2417 2418 return gobool(c) 2419} 2420 2421// StartEditing is a wrapper around gtk_cell_renderer_start_editing(). 2422func (v *CellRenderer) StartEditing(event *gdk.Event, widget IWidget, path string, 2423 backgroundArea, cellArea *gdk.Rectangle, flags CellRendererState) (ICellEditable, error) { 2424 2425 cstr := C.CString(path) 2426 defer C.free(unsafe.Pointer(cstr)) 2427 e := (*C.GdkEvent)(unsafe.Pointer(event.Native())) 2428 2429 c := C.gtk_cell_renderer_start_editing(v.native(), e, widget.toWidget(), 2430 (*C.gchar)(cstr), nativeGdkRectangle(*backgroundArea), 2431 nativeGdkRectangle(*cellArea), C.GtkCellRendererState(flags)) 2432 2433 return castCellEditable(c) 2434} 2435 2436// StopEditing is a wrapper around gtk_cell_renderer_stop_editing(). 2437func (v *CellRenderer) StopEditing(canceled bool) { 2438 C.gtk_cell_renderer_stop_editing(v.native(), gbool(canceled)) 2439} 2440 2441// GetVisible is a wrapper around gtk_cell_renderer_get_visible(). 2442func (v *CellRenderer) GetVisible() bool { 2443 return gobool(C.gtk_cell_renderer_get_visible(v.native())) 2444} 2445 2446// SetVisible is a wrapper around gtk_cell_renderer_set_visible(). 2447func (v *CellRenderer) SetVisible(visible bool) { 2448 C.gtk_cell_renderer_set_visible(v.native(), gbool(visible)) 2449} 2450 2451// GetSensitive is a wrapper around gtk_cell_renderer_get_sensitive(). 2452func (v *CellRenderer) GetSensitive() bool { 2453 return gobool(C.gtk_cell_renderer_get_sensitive(v.native())) 2454} 2455 2456// SetSentitive is a wrapper around gtk_cell_renderer_set_sensitive(). 2457func (v *CellRenderer) SetSentitive(sensitive bool) { 2458 C.gtk_cell_renderer_set_sensitive(v.native(), gbool(sensitive)) 2459} 2460 2461// IsActivatable is a wrapper around gtk_cell_renderer_is_activatable(). 2462func (v *CellRenderer) IsActivatable() bool { 2463 return gobool(C.gtk_cell_renderer_is_activatable(v.native())) 2464} 2465 2466// GetState is a wrapper around gtk_cell_renderer_get_state(). 2467func (v *CellRenderer) GetState(widget IWidget, 2468 flags CellRendererState) StateFlags { 2469 2470 return StateFlags(C.gtk_cell_renderer_get_state(v.native(), 2471 widget.toWidget(), 2472 C.GtkCellRendererState(flags))) 2473} 2474 2475// SetAlignment is a wrapper around gtk_tree_view_column_set_alignment(). 2476func (v *CellRenderer) SetAlignment(xalign float64, yalign float64) { 2477 C.gtk_cell_renderer_set_alignment(v.native(), C.gfloat(xalign), C.gfloat(yalign)) 2478} 2479 2480// TODO: gtk_cell_renderer_get_aligned_area 2481// TODO: gtk_cell_renderer_get_size 2482// TODO: gtk_cell_renderer_render 2483// TODO: gtk_cell_renderer_activate 2484// TODO: gtk_cell_renderer_start_editing 2485// TODO: gtk_cell_renderer_stop_editing 2486// TODO: gtk_cell_renderer_get_fixed_size 2487// TODO: gtk_cell_renderer_set_fixed_size 2488// TODO: gtk_cell_renderer_get_visible 2489// TODO: gtk_cell_renderer_set_visible 2490// TODO: gtk_cell_renderer_get_sensitive 2491// TODO: gtk_cell_renderer_set_sensitive 2492// TODO: gtk_cell_renderer_get_alignment 2493// TODO: gtk_cell_renderer_set_alignment 2494// TODO: gtk_cell_renderer_get_padding 2495// TODO: gtk_cell_renderer_set_padding 2496// TODO: gtk_cell_renderer_get_state 2497// TODO: gtk_cell_renderer_is_activatable 2498// TODO: gtk_cell_renderer_get_preferred_height 2499// TODO: gtk_cell_renderer_get_preferred_height_for_width 2500// TODO: gtk_cell_renderer_get_preferred_size 2501// TODO: gtk_cell_renderer_get_preferred_width 2502// TODO: gtk_cell_renderer_get_preferred_width_for_height 2503// TODO: gtk_cell_renderer_get_request_mode 2504 2505/* 2506 * GtkCellRendererSpinner 2507 */ 2508 2509// CellRendererSpinner is a representation of GTK's GtkCellRendererSpinner. 2510type CellRendererSpinner struct { 2511 CellRenderer 2512} 2513 2514// native returns a pointer to the underlying GtkCellRendererSpinner. 2515func (v *CellRendererSpinner) native() *C.GtkCellRendererSpinner { 2516 if v == nil || v.GObject == nil { 2517 return nil 2518 } 2519 p := unsafe.Pointer(v.GObject) 2520 return C.toGtkCellRendererSpinner(p) 2521} 2522 2523func marshalCellRendererSpinner(p uintptr) (interface{}, error) { 2524 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2525 obj := glib.Take(unsafe.Pointer(c)) 2526 return wrapCellRendererSpinner(obj), nil 2527} 2528 2529func wrapCellRendererSpinner(obj *glib.Object) *CellRendererSpinner { 2530 if obj == nil { 2531 return nil 2532 } 2533 2534 return &CellRendererSpinner{CellRenderer{glib.InitiallyUnowned{obj}}} 2535} 2536 2537// CellRendererSpinnerNew is a wrapper around gtk_cell_renderer_spinner_new(). 2538func CellRendererSpinnerNew() (*CellRendererSpinner, error) { 2539 c := C.gtk_cell_renderer_spinner_new() 2540 if c == nil { 2541 return nil, nilPtrErr 2542 } 2543 obj := glib.Take(unsafe.Pointer(c)) 2544 return wrapCellRendererSpinner(obj), nil 2545} 2546 2547/* 2548 * GtkCellRendererPixbuf 2549 */ 2550 2551// CellRendererPixbuf is a representation of GTK's GtkCellRendererPixbuf. 2552type CellRendererPixbuf struct { 2553 CellRenderer 2554} 2555 2556// native returns a pointer to the underlying GtkCellRendererPixbuf. 2557func (v *CellRendererPixbuf) native() *C.GtkCellRendererPixbuf { 2558 if v == nil || v.GObject == nil { 2559 return nil 2560 } 2561 p := unsafe.Pointer(v.GObject) 2562 return C.toGtkCellRendererPixbuf(p) 2563} 2564 2565func marshalCellRendererPixbuf(p uintptr) (interface{}, error) { 2566 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2567 obj := glib.Take(unsafe.Pointer(c)) 2568 return wrapCellRendererPixbuf(obj), nil 2569} 2570 2571func wrapCellRendererPixbuf(obj *glib.Object) *CellRendererPixbuf { 2572 if obj == nil { 2573 return nil 2574 } 2575 2576 return &CellRendererPixbuf{CellRenderer{glib.InitiallyUnowned{obj}}} 2577} 2578 2579// CellRendererPixbufNew is a wrapper around gtk_cell_renderer_pixbuf_new(). 2580func CellRendererPixbufNew() (*CellRendererPixbuf, error) { 2581 c := C.gtk_cell_renderer_pixbuf_new() 2582 if c == nil { 2583 return nil, nilPtrErr 2584 } 2585 obj := glib.Take(unsafe.Pointer(c)) 2586 return wrapCellRendererPixbuf(obj), nil 2587} 2588 2589/* 2590 * GtkCellRendererProgress 2591 */ 2592 2593// CellRendererProgress is a representation of GTK's GtkCellRendererProgress. 2594type CellRendererProgress struct { 2595 CellRenderer 2596} 2597 2598// native returns a pointer to the underlying GtkCellRendererProgress. 2599func (v *CellRendererProgress) native() *C.GtkCellRendererProgress { 2600 if v == nil || v.GObject == nil { 2601 return nil 2602 } 2603 p := unsafe.Pointer(v.GObject) 2604 return C.toGtkCellRendererProgress(p) 2605} 2606 2607func marshalCellRendererProgress(p uintptr) (interface{}, error) { 2608 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2609 obj := glib.Take(unsafe.Pointer(c)) 2610 return wrapCellRendererProgress(obj), nil 2611} 2612 2613func wrapCellRendererProgress(obj *glib.Object) *CellRendererProgress { 2614 if obj == nil { 2615 return nil 2616 } 2617 2618 return &CellRendererProgress{CellRenderer{glib.InitiallyUnowned{obj}}} 2619} 2620 2621// CellRendererProgressNew is a wrapper around gtk_cell_renderer_progress_new(). 2622func CellRendererProgressNew() (*CellRendererProgress, error) { 2623 c := C.gtk_cell_renderer_progress_new() 2624 if c == nil { 2625 return nil, nilPtrErr 2626 } 2627 obj := glib.Take(unsafe.Pointer(c)) 2628 return wrapCellRendererProgress(obj), nil 2629} 2630 2631/* 2632 * GtkCellRendererText 2633 */ 2634 2635// CellRendererText is a representation of GTK's GtkCellRendererText. 2636type CellRendererText struct { 2637 CellRenderer 2638} 2639 2640// native returns a pointer to the underlying GtkCellRendererText. 2641func (v *CellRendererText) native() *C.GtkCellRendererText { 2642 if v == nil || v.GObject == nil { 2643 return nil 2644 } 2645 p := unsafe.Pointer(v.GObject) 2646 return C.toGtkCellRendererText(p) 2647} 2648 2649func marshalCellRendererText(p uintptr) (interface{}, error) { 2650 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2651 obj := glib.Take(unsafe.Pointer(c)) 2652 return wrapCellRendererText(obj), nil 2653} 2654 2655func wrapCellRendererText(obj *glib.Object) *CellRendererText { 2656 if obj == nil { 2657 return nil 2658 } 2659 2660 return &CellRendererText{CellRenderer{glib.InitiallyUnowned{obj}}} 2661} 2662 2663// CellRendererTextNew is a wrapper around gtk_cell_renderer_text_new(). 2664func CellRendererTextNew() (*CellRendererText, error) { 2665 c := C.gtk_cell_renderer_text_new() 2666 if c == nil { 2667 return nil, nilPtrErr 2668 } 2669 obj := glib.Take(unsafe.Pointer(c)) 2670 return wrapCellRendererText(obj), nil 2671} 2672 2673// SetFixedHeightFromFont is a wrapper around gtk_cell_renderer_text_set_fixed_height_from_font 2674func (v *CellRendererText) SetFixedHeightFromFont(numberOfRows int) { 2675 C.gtk_cell_renderer_text_set_fixed_height_from_font(v.native(), C.gint(numberOfRows)) 2676} 2677 2678/* 2679 * GtkCellRendererToggle 2680 */ 2681 2682// CellRendererToggle is a representation of GTK's GtkCellRendererToggle. 2683type CellRendererToggle struct { 2684 CellRenderer 2685} 2686 2687// native returns a pointer to the underlying GtkCellRendererToggle. 2688func (v *CellRendererToggle) native() *C.GtkCellRendererToggle { 2689 if v == nil || v.GObject == nil { 2690 return nil 2691 } 2692 p := unsafe.Pointer(v.GObject) 2693 return C.toGtkCellRendererToggle(p) 2694} 2695 2696func (v *CellRendererToggle) toCellRenderer() *C.GtkCellRenderer { 2697 if v == nil { 2698 return nil 2699 } 2700 return v.CellRenderer.native() 2701} 2702 2703func marshalCellRendererToggle(p uintptr) (interface{}, error) { 2704 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2705 obj := glib.Take(unsafe.Pointer(c)) 2706 return wrapCellRendererToggle(obj), nil 2707} 2708 2709func wrapCellRendererToggle(obj *glib.Object) *CellRendererToggle { 2710 if obj == nil { 2711 return nil 2712 } 2713 2714 return &CellRendererToggle{CellRenderer{glib.InitiallyUnowned{obj}}} 2715} 2716 2717// CellRendererToggleNew is a wrapper around gtk_cell_renderer_toggle_new(). 2718func CellRendererToggleNew() (*CellRendererToggle, error) { 2719 c := C.gtk_cell_renderer_toggle_new() 2720 if c == nil { 2721 return nil, nilPtrErr 2722 } 2723 obj := glib.Take(unsafe.Pointer(c)) 2724 return wrapCellRendererToggle(obj), nil 2725} 2726 2727// SetRadio is a wrapper around gtk_cell_renderer_toggle_set_radio(). 2728func (v *CellRendererToggle) SetRadio(set bool) { 2729 C.gtk_cell_renderer_toggle_set_radio(v.native(), gbool(set)) 2730} 2731 2732// GetRadio is a wrapper around gtk_cell_renderer_toggle_get_radio(). 2733func (v *CellRendererToggle) GetRadio() bool { 2734 c := C.gtk_cell_renderer_toggle_get_radio(v.native()) 2735 return gobool(c) 2736} 2737 2738// SetActive is a wrapper around gtk_cell_renderer_toggle_set_active(). 2739func (v *CellRendererToggle) SetActive(active bool) { 2740 C.gtk_cell_renderer_toggle_set_active(v.native(), gbool(active)) 2741} 2742 2743// GetActive is a wrapper around gtk_cell_renderer_toggle_get_active(). 2744func (v *CellRendererToggle) GetActive() bool { 2745 c := C.gtk_cell_renderer_toggle_get_active(v.native()) 2746 return gobool(c) 2747} 2748 2749// SetActivatable is a wrapper around gtk_cell_renderer_toggle_set_activatable(). 2750func (v *CellRendererToggle) SetActivatable(activatable bool) { 2751 C.gtk_cell_renderer_toggle_set_activatable(v.native(), 2752 gbool(activatable)) 2753} 2754 2755// GetActivatable is a wrapper around gtk_cell_renderer_toggle_get_activatable(). 2756func (v *CellRendererToggle) GetActivatable() bool { 2757 c := C.gtk_cell_renderer_toggle_get_activatable(v.native()) 2758 return gobool(c) 2759} 2760 2761/* 2762 * GtkCellRendererAccel 2763 */ 2764 2765// CellRendererAccel is a representation of GtkCellRendererAccel. 2766type CellRendererAccel struct { 2767 CellRendererText 2768} 2769 2770// native returns a pointer to the underlying GtkCellRendererAccel. 2771func (v *CellRendererAccel) native() *C.GtkCellRendererAccel { 2772 if v == nil || v.GObject == nil { 2773 return nil 2774 } 2775 p := unsafe.Pointer(v.GObject) 2776 return C.toGtkCellRendererAccel(p) 2777} 2778 2779func marshalCellRendererAccel(p uintptr) (interface{}, error) { 2780 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2781 obj := glib.Take(unsafe.Pointer(c)) 2782 return wrapCellRendererAccel(obj), nil 2783} 2784 2785func wrapCellRendererAccel(obj *glib.Object) *CellRendererAccel { 2786 if obj == nil { 2787 return nil 2788 } 2789 2790 return &CellRendererAccel{CellRendererText{CellRenderer{glib.InitiallyUnowned{obj}}}} 2791} 2792 2793// CellRendererAccelNew is a wrapper around gtk_cell_renderer_accel_new(). 2794func CellRendererAccelNew() (*CellRendererAccel, error) { 2795 c := C.gtk_cell_renderer_accel_new() 2796 if c == nil { 2797 return nil, nilPtrErr 2798 } 2799 obj := glib.Take(unsafe.Pointer(c)) 2800 return wrapCellRendererAccel(obj), nil 2801} 2802 2803/* 2804 * GtkCellRendererCombo 2805 */ 2806 2807// CellRendererCombo is a representation of GtkCellRendererCombo. 2808type CellRendererCombo struct { 2809 CellRendererText 2810} 2811 2812// native returns a pointer to the underlying GtkCellRendererCombo. 2813func (v *CellRendererCombo) native() *C.GtkCellRendererCombo { 2814 if v == nil || v.GObject == nil { 2815 return nil 2816 } 2817 p := unsafe.Pointer(v.GObject) 2818 return C.toGtkCellRendererCombo(p) 2819} 2820 2821func marshalCellRendererCombo(p uintptr) (interface{}, error) { 2822 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2823 obj := glib.Take(unsafe.Pointer(c)) 2824 return wrapCellRendererCombo(obj), nil 2825} 2826 2827func wrapCellRendererCombo(obj *glib.Object) *CellRendererCombo { 2828 if obj == nil { 2829 return nil 2830 } 2831 2832 return &CellRendererCombo{CellRendererText{CellRenderer{glib.InitiallyUnowned{obj}}}} 2833} 2834 2835// CellRendererComboNew is a wrapper around gtk_cell_renderer_combo_new(). 2836func CellRendererComboNew() (*CellRendererCombo, error) { 2837 c := C.gtk_cell_renderer_combo_new() 2838 if c == nil { 2839 return nil, nilPtrErr 2840 } 2841 obj := glib.Take(unsafe.Pointer(c)) 2842 return wrapCellRendererCombo(obj), nil 2843} 2844 2845/* 2846 * GtkCellRendererSpin 2847 */ 2848 2849// CellRendererSpin is a representation of GtkCellRendererSpin. 2850type CellRendererSpin struct { 2851 CellRendererText 2852} 2853 2854// native returns a pointer to the underlying GtkCellRendererSpin. 2855func (v *CellRendererSpin) native() *C.GtkCellRendererSpin { 2856 if v == nil || v.GObject == nil { 2857 return nil 2858 } 2859 p := unsafe.Pointer(v.GObject) 2860 return C.toGtkCellRendererSpin(p) 2861} 2862 2863func marshalCellRendererSpin(p uintptr) (interface{}, error) { 2864 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2865 obj := glib.Take(unsafe.Pointer(c)) 2866 return wrapCellRendererSpin(obj), nil 2867} 2868 2869func wrapCellRendererSpin(obj *glib.Object) *CellRendererSpin { 2870 if obj == nil { 2871 return nil 2872 } 2873 2874 return &CellRendererSpin{CellRendererText{CellRenderer{glib.InitiallyUnowned{obj}}}} 2875} 2876 2877// CellRendererSpinNew is a wrapper around gtk_cell_renderer_spin_new(). 2878func CellRendererSpinNew() (*CellRendererSpin, error) { 2879 c := C.gtk_cell_renderer_spin_new() 2880 if c == nil { 2881 return nil, nilPtrErr 2882 } 2883 obj := glib.Take(unsafe.Pointer(c)) 2884 return wrapCellRendererSpin(obj), nil 2885} 2886 2887/* 2888 * GtkCheckButton 2889 */ 2890 2891// CheckButton is a wrapper around GTK's GtkCheckButton. 2892type CheckButton struct { 2893 ToggleButton 2894} 2895 2896// native returns a pointer to the underlying GtkCheckButton. 2897func (v *CheckButton) native() *C.GtkCheckButton { 2898 if v == nil || v.GObject == nil { 2899 return nil 2900 } 2901 p := unsafe.Pointer(v.GObject) 2902 return C.toGtkCheckButton(p) 2903} 2904 2905func marshalCheckButton(p uintptr) (interface{}, error) { 2906 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2907 obj := glib.Take(unsafe.Pointer(c)) 2908 return wrapCheckButton(obj), nil 2909} 2910 2911func wrapCheckButton(obj *glib.Object) *CheckButton { 2912 if obj == nil { 2913 return nil 2914 } 2915 2916 actionable := wrapActionable(obj) 2917 return &CheckButton{ToggleButton{Button{Bin{Container{Widget{ 2918 glib.InitiallyUnowned{obj}}}}, actionable}}} 2919} 2920 2921// CheckButtonNew is a wrapper around gtk_check_button_new(). 2922func CheckButtonNew() (*CheckButton, error) { 2923 c := C.gtk_check_button_new() 2924 if c == nil { 2925 return nil, nilPtrErr 2926 } 2927 obj := glib.Take(unsafe.Pointer(c)) 2928 return wrapCheckButton(obj), nil 2929} 2930 2931// CheckButtonNewWithLabel is a wrapper around 2932// gtk_check_button_new_with_label(). 2933func CheckButtonNewWithLabel(label string) (*CheckButton, error) { 2934 cstr := C.CString(label) 2935 defer C.free(unsafe.Pointer(cstr)) 2936 c := C.gtk_check_button_new_with_label((*C.gchar)(cstr)) 2937 if c == nil { 2938 return nil, nilPtrErr 2939 } 2940 return wrapCheckButton(glib.Take(unsafe.Pointer(c))), nil 2941} 2942 2943// CheckButtonNewWithMnemonic is a wrapper around 2944// gtk_check_button_new_with_mnemonic(). 2945func CheckButtonNewWithMnemonic(label string) (*CheckButton, error) { 2946 cstr := C.CString(label) 2947 defer C.free(unsafe.Pointer(cstr)) 2948 c := C.gtk_check_button_new_with_mnemonic((*C.gchar)(cstr)) 2949 if c == nil { 2950 return nil, nilPtrErr 2951 } 2952 obj := glib.Take(unsafe.Pointer(c)) 2953 return wrapCheckButton(obj), nil 2954} 2955 2956/* 2957 * GtkCheckMenuItem 2958 */ 2959 2960type CheckMenuItem struct { 2961 MenuItem 2962} 2963 2964// native returns a pointer to the underlying GtkCheckMenuItem. 2965func (v *CheckMenuItem) native() *C.GtkCheckMenuItem { 2966 if v == nil || v.GObject == nil { 2967 return nil 2968 } 2969 p := unsafe.Pointer(v.GObject) 2970 return C.toGtkCheckMenuItem(p) 2971} 2972 2973func marshalCheckMenuItem(p uintptr) (interface{}, error) { 2974 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 2975 obj := glib.Take(unsafe.Pointer(c)) 2976 return wrapCheckMenuItem(obj), nil 2977} 2978 2979func wrapCheckMenuItem(obj *glib.Object) *CheckMenuItem { 2980 if obj == nil { 2981 return nil 2982 } 2983 2984 return &CheckMenuItem{MenuItem{Bin{Container{Widget{ 2985 glib.InitiallyUnowned{obj}}}}}} 2986} 2987 2988// CheckMenuItemNew is a wrapper around gtk_check_menu_item_new(). 2989func CheckMenuItemNew() (*CheckMenuItem, error) { 2990 c := C.gtk_check_menu_item_new() 2991 if c == nil { 2992 return nil, nilPtrErr 2993 } 2994 obj := glib.Take(unsafe.Pointer(c)) 2995 return wrapCheckMenuItem(obj), nil 2996} 2997 2998// CheckMenuItemNewWithLabel is a wrapper around gtk_check_menu_item_new_with_label(). 2999func CheckMenuItemNewWithLabel(label string) (*CheckMenuItem, error) { 3000 cstr := C.CString(label) 3001 defer C.free(unsafe.Pointer(cstr)) 3002 c := C.gtk_check_menu_item_new_with_label((*C.gchar)(cstr)) 3003 if c == nil { 3004 return nil, nilPtrErr 3005 } 3006 obj := glib.Take(unsafe.Pointer(c)) 3007 return wrapCheckMenuItem(obj), nil 3008} 3009 3010// CheckMenuItemNewWithMnemonic is a wrapper around gtk_check_menu_item_new_with_mnemonic(). 3011func CheckMenuItemNewWithMnemonic(label string) (*CheckMenuItem, error) { 3012 cstr := C.CString(label) 3013 defer C.free(unsafe.Pointer(cstr)) 3014 c := C.gtk_check_menu_item_new_with_mnemonic((*C.gchar)(cstr)) 3015 if c == nil { 3016 return nil, nilPtrErr 3017 } 3018 obj := glib.Take(unsafe.Pointer(c)) 3019 return wrapCheckMenuItem(obj), nil 3020} 3021 3022// GetActive is a wrapper around gtk_check_menu_item_get_active(). 3023func (v *CheckMenuItem) GetActive() bool { 3024 c := C.gtk_check_menu_item_get_active(v.native()) 3025 return gobool(c) 3026} 3027 3028// SetActive is a wrapper around gtk_check_menu_item_set_active(). 3029func (v *CheckMenuItem) SetActive(isActive bool) { 3030 C.gtk_check_menu_item_set_active(v.native(), gbool(isActive)) 3031} 3032 3033// Toggled is a wrapper around gtk_check_menu_item_toggled(). 3034func (v *CheckMenuItem) Toggled() { 3035 C.gtk_check_menu_item_toggled(v.native()) 3036} 3037 3038// GetInconsistent is a wrapper around gtk_check_menu_item_get_inconsistent(). 3039func (v *CheckMenuItem) GetInconsistent() bool { 3040 c := C.gtk_check_menu_item_get_inconsistent(v.native()) 3041 return gobool(c) 3042} 3043 3044// SetInconsistent is a wrapper around gtk_check_menu_item_set_inconsistent(). 3045func (v *CheckMenuItem) SetInconsistent(setting bool) { 3046 C.gtk_check_menu_item_set_inconsistent(v.native(), gbool(setting)) 3047} 3048 3049// SetDrawAsRadio is a wrapper around gtk_check_menu_item_set_draw_as_radio(). 3050func (v *CheckMenuItem) SetDrawAsRadio(drawAsRadio bool) { 3051 C.gtk_check_menu_item_set_draw_as_radio(v.native(), gbool(drawAsRadio)) 3052} 3053 3054// GetDrawAsRadio is a wrapper around gtk_check_menu_item_get_draw_as_radio(). 3055func (v *CheckMenuItem) GetDrawAsRadio() bool { 3056 c := C.gtk_check_menu_item_get_draw_as_radio(v.native()) 3057 return gobool(c) 3058} 3059 3060/* 3061 * GtkClipboard 3062 */ 3063 3064// Clipboard is a wrapper around GTK's GtkClipboard. 3065type Clipboard struct { 3066 *glib.Object 3067} 3068 3069// native returns a pointer to the underlying GtkClipboard. 3070func (v *Clipboard) native() *C.GtkClipboard { 3071 if v == nil || v.GObject == nil { 3072 return nil 3073 } 3074 p := unsafe.Pointer(v.GObject) 3075 return C.toGtkClipboard(p) 3076} 3077 3078func marshalClipboard(p uintptr) (interface{}, error) { 3079 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 3080 obj := glib.Take(unsafe.Pointer(c)) 3081 return wrapClipboard(obj), nil 3082} 3083 3084func wrapClipboard(obj *glib.Object) *Clipboard { 3085 if obj == nil { 3086 return nil 3087 } 3088 3089 return &Clipboard{obj} 3090} 3091 3092// Store is a wrapper around gtk_clipboard_store 3093func (v *Clipboard) Store() { 3094 C.gtk_clipboard_store(v.native()) 3095} 3096 3097// ClipboardGet() is a wrapper around gtk_clipboard_get(). 3098func ClipboardGet(atom gdk.Atom) (*Clipboard, error) { 3099 c := C.gtk_clipboard_get(C.GdkAtom(unsafe.Pointer(atom))) 3100 if c == nil { 3101 return nil, nilPtrErr 3102 } 3103 3104 cb := &Clipboard{glib.Take(unsafe.Pointer(c))} 3105 return cb, nil 3106} 3107 3108// ClipboardGetForDisplay() is a wrapper around gtk_clipboard_get_for_display(). 3109func ClipboardGetForDisplay(display *gdk.Display, atom gdk.Atom) (*Clipboard, error) { 3110 displayPtr := (*C.GdkDisplay)(unsafe.Pointer(display.Native())) 3111 c := C.gtk_clipboard_get_for_display(displayPtr, 3112 C.GdkAtom(unsafe.Pointer(atom))) 3113 if c == nil { 3114 return nil, nilPtrErr 3115 } 3116 3117 cb := &Clipboard{glib.Take(unsafe.Pointer(c))} 3118 return cb, nil 3119} 3120 3121// WaitIsTextAvailable is a wrapper around gtk_clipboard_wait_is_text_available 3122func (v *Clipboard) WaitIsTextAvailable() bool { 3123 c := C.gtk_clipboard_wait_is_text_available(v.native()) 3124 return gobool(c) 3125} 3126 3127// WaitForText is a wrapper around gtk_clipboard_wait_for_text 3128func (v *Clipboard) WaitForText() (string, error) { 3129 c := C.gtk_clipboard_wait_for_text(v.native()) 3130 if c == nil { 3131 return "", nilPtrErr 3132 } 3133 defer C.g_free(C.gpointer(c)) 3134 return goString(c), nil 3135} 3136 3137// SetText() is a wrapper around gtk_clipboard_set_text(). 3138func (v *Clipboard) SetText(text string) { 3139 cstr := C.CString(text) 3140 defer C.free(unsafe.Pointer(cstr)) 3141 C.gtk_clipboard_set_text(v.native(), (*C.gchar)(cstr), 3142 C.gint(len(text))) 3143} 3144 3145// WaitIsRichTextAvailable is a wrapper around gtk_clipboard_wait_is_rich_text_available 3146func (v *Clipboard) WaitIsRichTextAvailable(buf *TextBuffer) bool { 3147 c := C.gtk_clipboard_wait_is_rich_text_available(v.native(), buf.native()) 3148 return gobool(c) 3149} 3150 3151// WaitIsUrisAvailable is a wrapper around gtk_clipboard_wait_is_uris_available 3152func (v *Clipboard) WaitIsUrisAvailable() bool { 3153 c := C.gtk_clipboard_wait_is_uris_available(v.native()) 3154 return gobool(c) 3155} 3156 3157// WaitIsImageAvailable is a wrapper around gtk_clipboard_wait_is_image_available 3158func (v *Clipboard) WaitIsImageAvailable() bool { 3159 c := C.gtk_clipboard_wait_is_image_available(v.native()) 3160 return gobool(c) 3161} 3162 3163// SetImage is a wrapper around gtk_clipboard_set_image 3164func (v *Clipboard) SetImage(pixbuf *gdk.Pixbuf) { 3165 C.gtk_clipboard_set_image(v.native(), (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native()))) 3166} 3167 3168// WaitForImage is a wrapper around gtk_clipboard_wait_for_image 3169func (v *Clipboard) WaitForImage() (*gdk.Pixbuf, error) { 3170 c := C.gtk_clipboard_wait_for_image(v.native()) 3171 if c == nil { 3172 return nil, nilPtrErr 3173 } 3174 3175 p := &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))} 3176 return p, nil 3177} 3178 3179// WaitIsTargetAvailable is a wrapper around gtk_clipboard_wait_is_target_available 3180func (v *Clipboard) WaitIsTargetAvailable(target gdk.Atom) bool { 3181 c := C.gtk_clipboard_wait_is_target_available(v.native(), C.GdkAtom(unsafe.Pointer(target))) 3182 return gobool(c) 3183} 3184 3185// WaitForContents is a wrapper around gtk_clipboard_wait_for_contents 3186func (v *Clipboard) WaitForContents(target gdk.Atom) (*SelectionData, error) { 3187 c := C.gtk_clipboard_wait_for_contents(v.native(), C.GdkAtom(unsafe.Pointer(target))) 3188 if c == nil { 3189 return nil, nilPtrErr 3190 } 3191 p := &SelectionData{c} 3192 runtime.SetFinalizer(p, (*SelectionData).free) 3193 return p, nil 3194} 3195 3196/* 3197 * GtkContainer 3198 */ 3199 3200// Container is a representation of GTK's GtkContainer. 3201type Container struct { 3202 Widget 3203} 3204 3205// native returns a pointer to the underlying GtkContainer. 3206func (v *Container) native() *C.GtkContainer { 3207 if v == nil || v.GObject == nil { 3208 return nil 3209 } 3210 p := unsafe.Pointer(v.GObject) 3211 return C.toGtkContainer(p) 3212} 3213 3214func marshalContainer(p uintptr) (interface{}, error) { 3215 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 3216 obj := glib.Take(unsafe.Pointer(c)) 3217 return wrapContainer(obj), nil 3218} 3219 3220func wrapContainer(obj *glib.Object) *Container { 3221 if obj == nil { 3222 return nil 3223 } 3224 3225 return &Container{Widget{glib.InitiallyUnowned{obj}}} 3226} 3227 3228// Add is a wrapper around gtk_container_add(). 3229func (v *Container) Add(w IWidget) { 3230 C.gtk_container_add(v.native(), w.toWidget()) 3231} 3232 3233// Remove is a wrapper around gtk_container_remove(). 3234func (v *Container) Remove(w IWidget) { 3235 C.gtk_container_remove(v.native(), w.toWidget()) 3236} 3237 3238// TODO: gtk_container_add_with_properties 3239 3240// CheckResize is a wrapper around gtk_container_check_resize(). 3241func (v *Container) CheckResize() { 3242 C.gtk_container_check_resize(v.native()) 3243} 3244 3245// TODO: gtk_container_foreach 3246 3247// GetChildren is a wrapper around gtk_container_get_children(). 3248func (v *Container) GetChildren() *glib.List { 3249 clist := C.gtk_container_get_children(v.native()) 3250 if clist == nil { 3251 return nil 3252 } 3253 3254 glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) 3255 glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { 3256 return wrapWidget(glib.Take(ptr)) 3257 }) 3258 3259 return glist 3260} 3261 3262// TODO: gtk_container_get_path_for_child 3263 3264// GetFocusChild is a wrapper around gtk_container_get_focus_child(). 3265func (v *Container) GetFocusChild() (IWidget, error) { 3266 c := C.gtk_container_get_focus_child(v.native()) 3267 if c == nil { 3268 return nil, nil 3269 } 3270 return castWidget(c) 3271} 3272 3273// SetFocusChild is a wrapper around gtk_container_set_focus_child(). 3274func (v *Container) SetFocusChild(child IWidget) { 3275 C.gtk_container_set_focus_child(v.native(), child.toWidget()) 3276} 3277 3278// GetFocusVAdjustment is a wrapper around gtk_container_get_focus_vadjustment(). 3279func (v *Container) GetFocusVAdjustment() *Adjustment { 3280 c := C.gtk_container_get_focus_vadjustment(v.native()) 3281 if c == nil { 3282 return nil 3283 } 3284 obj := glib.Take(unsafe.Pointer(c)) 3285 return wrapAdjustment(obj) 3286} 3287 3288// SetFocusVAdjustment is a wrapper around gtk_container_set_focus_vadjustment(). 3289func (v *Container) SetFocusVAdjustment(adjustment *Adjustment) { 3290 C.gtk_container_set_focus_vadjustment(v.native(), adjustment.native()) 3291} 3292 3293// GetFocusHAdjustment is a wrapper around gtk_container_get_focus_hadjustment(). 3294func (v *Container) GetFocusHAdjustment() *Adjustment { 3295 c := C.gtk_container_get_focus_hadjustment(v.native()) 3296 if c == nil { 3297 return nil 3298 } 3299 obj := glib.Take(unsafe.Pointer(c)) 3300 return wrapAdjustment(obj) 3301} 3302 3303// SetFocusHAdjustment is a wrapper around gtk_container_set_focus_hadjustment(). 3304func (v *Container) SetFocusHAdjustment(adjustment *Adjustment) { 3305 C.gtk_container_set_focus_hadjustment(v.native(), adjustment.native()) 3306} 3307 3308// ChildType is a wrapper around gtk_container_child_type(). 3309func (v *Container) ChildType() glib.Type { 3310 c := C.gtk_container_child_type(v.native()) 3311 return glib.Type(c) 3312} 3313 3314// TODO: 3315// gtk_container_child_get(). 3316// gtk_container_child_set(). 3317 3318// ChildNotify is a wrapper around gtk_container_child_notify(). 3319func (v *Container) ChildNotify(child IWidget, childProperty string) { 3320 cstr := C.CString(childProperty) 3321 defer C.free(unsafe.Pointer(cstr)) 3322 C.gtk_container_child_notify(v.native(), child.toWidget(), 3323 (*C.gchar)(cstr)) 3324} 3325 3326// ChildGetProperty is a wrapper around gtk_container_child_get_property(). 3327func (v *Container) ChildGetProperty(child IWidget, name string, valueType glib.Type) (interface{}, error) { 3328 gv, e := glib.ValueInit(valueType) 3329 if e != nil { 3330 return nil, e 3331 } 3332 cstr := C.CString(name) 3333 defer C.free(unsafe.Pointer(cstr)) 3334 3335 C.gtk_container_child_get_property(v.native(), child.toWidget(), (*C.gchar)(cstr), (*C.GValue)(unsafe.Pointer(gv.Native()))) 3336 return gv.GoValue() 3337} 3338 3339// ChildSetProperty is a wrapper around gtk_container_child_set_property(). 3340func (v *Container) ChildSetProperty(child IWidget, name string, value interface{}) error { 3341 gv, e := glib.GValue(value) 3342 if e != nil { 3343 return e 3344 } 3345 cstr := C.CString(name) 3346 defer C.free(unsafe.Pointer(cstr)) 3347 3348 C.gtk_container_child_set_property(v.native(), child.toWidget(), (*C.gchar)(cstr), (*C.GValue)(unsafe.Pointer(gv.Native()))) 3349 return nil 3350} 3351 3352// TODO: 3353// gtk_container_child_get_valist(). 3354// gtk_container_child_set_valist(). 3355// gtk_container_child_notify_by_pspec(). 3356// gtk_container_forall(). 3357 3358// GetBorderWidth is a wrapper around gtk_container_get_border_width(). 3359func (v *Container) GetBorderWidth() uint { 3360 c := C.gtk_container_get_border_width(v.native()) 3361 return uint(c) 3362} 3363 3364// SetBorderWidth is a wrapper around gtk_container_set_border_width(). 3365func (v *Container) SetBorderWidth(borderWidth uint) { 3366 C.gtk_container_set_border_width(v.native(), C.guint(borderWidth)) 3367} 3368 3369// PropagateDraw is a wrapper around gtk_container_propagate_draw(). 3370func (v *Container) PropagateDraw(child IWidget, cr *cairo.Context) { 3371 context := (*C.cairo_t)(unsafe.Pointer(cr.Native())) 3372 C.gtk_container_propagate_draw(v.native(), child.toWidget(), context) 3373} 3374 3375// TODO: 3376// gtk_container_class_find_child_property(). 3377// gtk_container_class_install_child_property(). 3378// gtk_container_class_install_child_properties(). 3379// gtk_container_class_list_child_properties(). 3380// gtk_container_class_handle_border_width(). 3381// GtkResizeMode 3382 3383// GdkCairoSetSourcePixBuf() is a wrapper around gdk_cairo_set_source_pixbuf(). 3384func GdkCairoSetSourcePixBuf(cr *cairo.Context, pixbuf *gdk.Pixbuf, pixbufX, pixbufY float64) { 3385 context := (*C.cairo_t)(unsafe.Pointer(cr.Native())) 3386 ptr := (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native())) 3387 C.gdk_cairo_set_source_pixbuf(context, ptr, C.gdouble(pixbufX), C.gdouble(pixbufY)) 3388} 3389 3390/* 3391 * GtkCssProvider 3392 */ 3393 3394// CssProvider is a representation of GTK's GtkCssProvider. 3395type CssProvider struct { 3396 *glib.Object 3397} 3398 3399func (v *CssProvider) toStyleProvider() *C.GtkStyleProvider { 3400 if v == nil { 3401 return nil 3402 } 3403 return C.toGtkStyleProvider(unsafe.Pointer(v.native())) 3404} 3405 3406// native returns a pointer to the underlying GtkCssProvider. 3407func (v *CssProvider) native() *C.GtkCssProvider { 3408 if v == nil || v.Object == nil { 3409 return nil 3410 } 3411 p := unsafe.Pointer(v.GObject) 3412 return C.toGtkCssProvider(p) 3413} 3414 3415func wrapCssProvider(obj *glib.Object) *CssProvider { 3416 if obj == nil { 3417 return nil 3418 } 3419 3420 return &CssProvider{obj} 3421} 3422 3423// CssProviderNew is a wrapper around gtk_css_provider_new(). 3424func CssProviderNew() (*CssProvider, error) { 3425 c := C.gtk_css_provider_new() 3426 if c == nil { 3427 return nil, nilPtrErr 3428 } 3429 3430 return wrapCssProvider(glib.Take(unsafe.Pointer(c))), nil 3431} 3432 3433// LoadFromPath is a wrapper around gtk_css_provider_load_from_path(). 3434func (v *CssProvider) LoadFromPath(path string) error { 3435 cpath := C.CString(path) 3436 defer C.free(unsafe.Pointer(cpath)) 3437 var gerr *C.GError 3438 if C.gtk_css_provider_load_from_path(v.native(), (*C.gchar)(cpath), &gerr) == 0 { 3439 defer C.g_error_free(gerr) 3440 return errors.New(goString(gerr.message)) 3441 } 3442 return nil 3443} 3444 3445// LoadFromData is a wrapper around gtk_css_provider_load_from_data(). 3446func (v *CssProvider) LoadFromData(data string) error { 3447 cdata := C.CString(data) 3448 defer C.free(unsafe.Pointer(cdata)) 3449 var gerr *C.GError 3450 if C.gtk_css_provider_load_from_data(v.native(), (*C.gchar)(unsafe.Pointer(cdata)), C.gssize(len(data)), &gerr) == 0 { 3451 defer C.g_error_free(gerr) 3452 return errors.New(goString(gerr.message)) 3453 } 3454 return nil 3455} 3456 3457// ToString is a wrapper around gtk_css_provider_to_string(). 3458func (v *CssProvider) ToString() (string, error) { 3459 c := C.gtk_css_provider_to_string(v.native()) 3460 if c == nil { 3461 return "", nilPtrErr 3462 } 3463 return C.GoString(c), nil 3464} 3465 3466// CssProviderGetNamed is a wrapper around gtk_css_provider_get_named(). 3467func CssProviderGetNamed(name string, variant string) (*CssProvider, error) { 3468 cname := C.CString(name) 3469 defer C.free(unsafe.Pointer(cname)) 3470 cvariant := C.CString(variant) 3471 defer C.free(unsafe.Pointer(cvariant)) 3472 3473 c := C.gtk_css_provider_get_named((*C.gchar)(cname), (*C.gchar)(cvariant)) 3474 if c == nil { 3475 return nil, nilPtrErr 3476 } 3477 3478 obj := glib.Take(unsafe.Pointer(c)) 3479 return wrapCssProvider(obj), nil 3480} 3481 3482/* 3483 * GtkDialog 3484 */ 3485 3486// Dialog is a representation of GTK's GtkDialog. 3487type Dialog struct { 3488 Window 3489} 3490 3491// native returns a pointer to the underlying GtkDialog. 3492func (v *Dialog) native() *C.GtkDialog { 3493 if v == nil || v.GObject == nil { 3494 return nil 3495 } 3496 p := unsafe.Pointer(v.GObject) 3497 return C.toGtkDialog(p) 3498} 3499 3500func marshalDialog(p uintptr) (interface{}, error) { 3501 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 3502 obj := glib.Take(unsafe.Pointer(c)) 3503 return wrapDialog(obj), nil 3504} 3505 3506func wrapDialog(obj *glib.Object) *Dialog { 3507 if obj == nil { 3508 return nil 3509 } 3510 3511 return &Dialog{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} 3512} 3513 3514// DialogNew() is a wrapper around gtk_dialog_new(). 3515func DialogNew() (*Dialog, error) { 3516 c := C.gtk_dialog_new() 3517 if c == nil { 3518 return nil, nilPtrErr 3519 } 3520 obj := glib.Take(unsafe.Pointer(c)) 3521 return wrapDialog(obj), nil 3522} 3523 3524// Run() is a wrapper around gtk_dialog_run(). 3525func (v *Dialog) Run() ResponseType { 3526 c := C.gtk_dialog_run(v.native()) 3527 return ResponseType(c) 3528} 3529 3530// Response() is a wrapper around gtk_dialog_response(). 3531func (v *Dialog) Response(response ResponseType) { 3532 C.gtk_dialog_response(v.native(), C.gint(response)) 3533} 3534 3535// AddButton() is a wrapper around gtk_dialog_add_button(). text may 3536// be either the literal button text, or if using GTK 3.8 or earlier, a 3537// Stock type converted to a string. 3538func (v *Dialog) AddButton(text string, id ResponseType) (*Button, error) { 3539 cstr := C.CString(text) 3540 defer C.free(unsafe.Pointer(cstr)) 3541 c := C.gtk_dialog_add_button(v.native(), (*C.gchar)(cstr), C.gint(id)) 3542 if c == nil { 3543 return nil, nilPtrErr 3544 } 3545 obj := glib.Take(unsafe.Pointer(c)) 3546 return wrapButton(obj), nil 3547} 3548 3549// TODO: 3550// gtk_dialog_add_buttons(). 3551 3552// AddActionWidget() is a wrapper around gtk_dialog_add_action_widget(). 3553func (v *Dialog) AddActionWidget(child IWidget, id ResponseType) { 3554 C.gtk_dialog_add_action_widget(v.native(), child.toWidget(), C.gint(id)) 3555} 3556 3557// SetDefaultResponse() is a wrapper around gtk_dialog_set_default_response(). 3558func (v *Dialog) SetDefaultResponse(id ResponseType) { 3559 C.gtk_dialog_set_default_response(v.native(), C.gint(id)) 3560} 3561 3562// SetResponseSensitive() is a wrapper around gtk_dialog_set_response_sensitive(). 3563func (v *Dialog) SetResponseSensitive(id ResponseType, setting bool) { 3564 C.gtk_dialog_set_response_sensitive(v.native(), C.gint(id), 3565 gbool(setting)) 3566} 3567 3568// GetResponseForWidget is a wrapper around gtk_dialog_get_response_for_widget(). 3569func (v *Dialog) GetResponseForWidget(widget IWidget) ResponseType { 3570 c := C.gtk_dialog_get_response_for_widget(v.native(), widget.toWidget()) 3571 return ResponseType(c) 3572} 3573 3574// GetWidgetForResponse is a wrapper around gtk_dialog_get_widget_for_response(). 3575func (v *Dialog) GetWidgetForResponse(id ResponseType) (IWidget, error) { 3576 c := C.gtk_dialog_get_widget_for_response(v.native(), C.gint(id)) 3577 if c == nil { 3578 return nil, nil 3579 } 3580 return castWidget(c) 3581} 3582 3583// GetContentArea() is a wrapper around gtk_dialog_get_content_area(). 3584func (v *Dialog) GetContentArea() (*Box, error) { 3585 c := C.gtk_dialog_get_content_area(v.native()) 3586 if c == nil { 3587 return nil, nilPtrErr 3588 } 3589 obj := glib.Take(unsafe.Pointer(c)) 3590 b := &Box{Container{Widget{glib.InitiallyUnowned{obj}}}} 3591 return b, nil 3592} 3593 3594// DialogNewWithButtons() is a wrapper around gtk_dialog_new_with_buttons(). 3595// i.e: []interface{}{"Accept", gtk.RESPONSE_ACCEPT}. 3596func DialogNewWithButtons(title string, parent IWindow, flags DialogFlags, buttons ...[]interface{}) (dialog *Dialog, err error) { 3597 cstr := (*C.gchar)(C.CString(title)) 3598 defer C.free(unsafe.Pointer(cstr)) 3599 3600 var w *C.GtkWindow = nil 3601 if parent != nil { 3602 w = parent.toWindow() 3603 } 3604 3605 var cbutton *C.gchar = nil 3606 c := C._gtk_dialog_new_with_buttons(cstr, w, C.GtkDialogFlags(flags), cbutton) 3607 if c == nil { 3608 return nil, nilPtrErr 3609 } 3610 dialog = wrapDialog(glib.Take(unsafe.Pointer(c))) 3611 3612 for idx := 0; idx < len(buttons); idx++ { 3613 cbutton = (*C.gchar)(C.CString(buttons[idx][0].(string))) 3614 defer C.free(unsafe.Pointer(cbutton)) 3615 3616 if C.gtk_dialog_add_button(dialog.native(), cbutton, C.gint(buttons[idx][1].(ResponseType))) == nil { 3617 return nil, nilPtrErr 3618 } 3619 } 3620 return 3621} 3622 3623/* 3624 * GtkDrawingArea 3625 */ 3626 3627// DrawingArea is a representation of GTK's GtkDrawingArea. 3628type DrawingArea struct { 3629 Widget 3630} 3631 3632// native returns a pointer to the underlying GtkDrawingArea. 3633func (v *DrawingArea) native() *C.GtkDrawingArea { 3634 if v == nil || v.GObject == nil { 3635 return nil 3636 } 3637 p := unsafe.Pointer(v.GObject) 3638 return C.toGtkDrawingArea(p) 3639} 3640 3641func marshalDrawingArea(p uintptr) (interface{}, error) { 3642 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 3643 obj := glib.Take(unsafe.Pointer(c)) 3644 return wrapDrawingArea(obj), nil 3645} 3646 3647func wrapDrawingArea(obj *glib.Object) *DrawingArea { 3648 if obj == nil { 3649 return nil 3650 } 3651 3652 return &DrawingArea{Widget{glib.InitiallyUnowned{obj}}} 3653} 3654 3655// DrawingAreaNew is a wrapper around gtk_drawing_area_new(). 3656func DrawingAreaNew() (*DrawingArea, error) { 3657 c := C.gtk_drawing_area_new() 3658 if c == nil { 3659 return nil, nilPtrErr 3660 } 3661 obj := glib.Take(unsafe.Pointer(c)) 3662 return wrapDrawingArea(obj), nil 3663} 3664 3665/* 3666 * GtkEditable 3667 */ 3668 3669// Editable is a representation of GTK's GtkEditable GInterface. 3670type Editable struct { 3671 *glib.Object 3672} 3673 3674// IEditable is an interface type implemented by all structs 3675// embedding an Editable. It is meant to be used as an argument type 3676// for wrapper functions that wrap around a C GTK function taking a 3677// GtkEditable. 3678type IEditable interface { 3679 toEditable() *C.GtkEditable 3680} 3681 3682// native() returns a pointer to the underlying GObject as a GtkEditable. 3683func (v *Editable) native() *C.GtkEditable { 3684 if v == nil || v.GObject == nil { 3685 return nil 3686 } 3687 p := unsafe.Pointer(v.GObject) 3688 return C.toGtkEditable(p) 3689} 3690 3691func marshalEditable(p uintptr) (interface{}, error) { 3692 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 3693 obj := glib.Take(unsafe.Pointer(c)) 3694 return wrapEditable(obj), nil 3695} 3696 3697func wrapEditable(obj *glib.Object) *Editable { 3698 if obj == nil { 3699 return nil 3700 } 3701 3702 return &Editable{obj} 3703} 3704 3705func (v *Editable) toEditable() *C.GtkEditable { 3706 if v == nil { 3707 return nil 3708 } 3709 return v.native() 3710} 3711 3712// SelectRegion is a wrapper around gtk_editable_select_region(). 3713func (v *Editable) SelectRegion(startPos, endPos int) { 3714 C.gtk_editable_select_region(v.native(), C.gint(startPos), 3715 C.gint(endPos)) 3716} 3717 3718// GetSelectionBounds is a wrapper around gtk_editable_get_selection_bounds(). 3719func (v *Editable) GetSelectionBounds() (start, end int, nonEmpty bool) { 3720 var cstart, cend C.gint 3721 c := C.gtk_editable_get_selection_bounds(v.native(), &cstart, &cend) 3722 return int(cstart), int(cend), gobool(c) 3723} 3724 3725// InsertText is a wrapper around gtk_editable_insert_text(). The returned 3726// int is the position after the inserted text. 3727func (v *Editable) InsertText(newText string, position int) int { 3728 cstr := C.CString(newText) 3729 defer C.free(unsafe.Pointer(cstr)) 3730 pos := new(C.gint) 3731 *pos = C.gint(position) 3732 C.gtk_editable_insert_text(v.native(), (*C.gchar)(cstr), 3733 C.gint(len(newText)), pos) 3734 return int(*pos) 3735} 3736 3737// DeleteText is a wrapper around gtk_editable_delete_text(). 3738func (v *Editable) DeleteText(startPos, endPos int) { 3739 C.gtk_editable_delete_text(v.native(), C.gint(startPos), C.gint(endPos)) 3740} 3741 3742// GetChars is a wrapper around gtk_editable_get_chars(). 3743func (v *Editable) GetChars(startPos, endPos int) string { 3744 c := C.gtk_editable_get_chars(v.native(), C.gint(startPos), 3745 C.gint(endPos)) 3746 defer C.free(unsafe.Pointer(c)) 3747 return goString(c) 3748} 3749 3750// CutClipboard is a wrapper around gtk_editable_cut_clipboard(). 3751func (v *Editable) CutClipboard() { 3752 C.gtk_editable_cut_clipboard(v.native()) 3753} 3754 3755// CopyClipboard is a wrapper around gtk_editable_copy_clipboard(). 3756func (v *Editable) CopyClipboard() { 3757 C.gtk_editable_copy_clipboard(v.native()) 3758} 3759 3760// PasteClipboard is a wrapper around gtk_editable_paste_clipboard(). 3761func (v *Editable) PasteClipboard() { 3762 C.gtk_editable_paste_clipboard(v.native()) 3763} 3764 3765// DeleteSelection is a wrapper around gtk_editable_delete_selection(). 3766func (v *Editable) DeleteSelection() { 3767 C.gtk_editable_delete_selection(v.native()) 3768} 3769 3770// SetPosition is a wrapper around gtk_editable_set_position(). 3771func (v *Editable) SetPosition(position int) { 3772 C.gtk_editable_set_position(v.native(), C.gint(position)) 3773} 3774 3775// GetPosition is a wrapper around gtk_editable_get_position(). 3776func (v *Editable) GetPosition() int { 3777 c := C.gtk_editable_get_position(v.native()) 3778 return int(c) 3779} 3780 3781// SetEditable is a wrapper around gtk_editable_set_editable(). 3782func (v *Editable) SetEditable(isEditable bool) { 3783 C.gtk_editable_set_editable(v.native(), gbool(isEditable)) 3784} 3785 3786// GetEditable is a wrapper around gtk_editable_get_editable(). 3787func (v *Editable) GetEditable() bool { 3788 c := C.gtk_editable_get_editable(v.native()) 3789 return gobool(c) 3790} 3791 3792/* 3793 * GtkEntry 3794 */ 3795 3796// Entry is a representation of GTK's GtkEntry. 3797type Entry struct { 3798 Widget 3799 3800 // Interfaces 3801 Editable 3802 CellEditable 3803} 3804 3805type IEntry interface { 3806 toEntry() *C.GtkEntry 3807} 3808 3809func (v *Entry) toEntry() *C.GtkEntry { 3810 return v.native() 3811} 3812 3813// native returns a pointer to the underlying GtkEntry. 3814func (v *Entry) native() *C.GtkEntry { 3815 if v == nil || v.GObject == nil { 3816 return nil 3817 } 3818 p := unsafe.Pointer(v.GObject) 3819 return C.toGtkEntry(p) 3820} 3821 3822func marshalEntry(p uintptr) (interface{}, error) { 3823 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 3824 obj := glib.Take(unsafe.Pointer(c)) 3825 return wrapEntry(obj), nil 3826} 3827 3828func wrapEntry(obj *glib.Object) *Entry { 3829 if obj == nil { 3830 return nil 3831 } 3832 3833 e := wrapEditable(obj) 3834 ce := wrapCellEditable(obj) 3835 return &Entry{Widget{glib.InitiallyUnowned{obj}}, *e, *ce} 3836} 3837 3838// EntryNew() is a wrapper around gtk_entry_new(). 3839func EntryNew() (*Entry, error) { 3840 c := C.gtk_entry_new() 3841 if c == nil { 3842 return nil, nilPtrErr 3843 } 3844 obj := glib.Take(unsafe.Pointer(c)) 3845 return wrapEntry(obj), nil 3846} 3847 3848// EntryNewWithBuffer() is a wrapper around gtk_entry_new_with_buffer(). 3849func EntryNewWithBuffer(buffer *EntryBuffer) (*Entry, error) { 3850 c := C.gtk_entry_new_with_buffer(buffer.native()) 3851 if c == nil { 3852 return nil, nilPtrErr 3853 } 3854 obj := glib.Take(unsafe.Pointer(c)) 3855 return wrapEntry(obj), nil 3856} 3857 3858// GetBuffer() is a wrapper around gtk_entry_get_buffer(). 3859func (v *Entry) GetBuffer() (*EntryBuffer, error) { 3860 c := C.gtk_entry_get_buffer(v.native()) 3861 if c == nil { 3862 return nil, nilPtrErr 3863 } 3864 obj := glib.Take(unsafe.Pointer(c)) 3865 return &EntryBuffer{obj}, nil 3866} 3867 3868// SetBuffer() is a wrapper around gtk_entry_set_buffer(). 3869func (v *Entry) SetBuffer(buffer *EntryBuffer) { 3870 C.gtk_entry_set_buffer(v.native(), buffer.native()) 3871} 3872 3873// SetText() is a wrapper around gtk_entry_set_text(). 3874func (v *Entry) SetText(text string) { 3875 cstr := C.CString(text) 3876 defer C.free(unsafe.Pointer(cstr)) 3877 C.gtk_entry_set_text(v.native(), (*C.gchar)(cstr)) 3878} 3879 3880// GetText() is a wrapper around gtk_entry_get_text(). 3881func (v *Entry) GetText() (string, error) { 3882 c := C.gtk_entry_get_text(v.native()) 3883 if c == nil { 3884 return "", nilPtrErr 3885 } 3886 return goString(c), nil 3887} 3888 3889// GetTextLength() is a wrapper around gtk_entry_get_text_length(). 3890func (v *Entry) GetTextLength() uint16 { 3891 c := C.gtk_entry_get_text_length(v.native()) 3892 return uint16(c) 3893} 3894 3895// GetTextArea is a wrapper around gtk_entry_get_text_area(). 3896func (v *Entry) GetTextArea() *gdk.Rectangle { 3897 var cRect *C.GdkRectangle 3898 C.gtk_entry_get_text_area(v.native(), cRect) 3899 textArea := gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) 3900 return textArea 3901} 3902 3903// SetVisibility is a wrapper around gtk_entry_set_visibility(). 3904func (v *Entry) SetVisibility(visible bool) { 3905 C.gtk_entry_set_visibility(v.native(), gbool(visible)) 3906} 3907 3908// SetInvisibleChar is a wrapper around gtk_entry_set_invisible_char(). 3909func (v *Entry) SetInvisibleChar(ch rune) { 3910 C.gtk_entry_set_invisible_char(v.native(), C.gunichar(ch)) 3911} 3912 3913// UnsetInvisibleChar is a wrapper around gtk_entry_unset_invisible_char(). 3914func (v *Entry) UnsetInvisibleChar() { 3915 C.gtk_entry_unset_invisible_char(v.native()) 3916} 3917 3918// SetMaxLength is a wrapper around gtk_entry_set_max_length(). 3919func (v *Entry) SetMaxLength(len int) { 3920 C.gtk_entry_set_max_length(v.native(), C.gint(len)) 3921} 3922 3923// GetActivatesDefault is a wrapper around gtk_entry_get_activates_default(). 3924func (v *Entry) GetActivatesDefault() bool { 3925 c := C.gtk_entry_get_activates_default(v.native()) 3926 return gobool(c) 3927} 3928 3929// GetHasFrame is a wrapper around gtk_entry_get_has_frame(). 3930func (v *Entry) GetHasFrame() bool { 3931 c := C.gtk_entry_get_has_frame(v.native()) 3932 return gobool(c) 3933} 3934 3935// GetWidthChars is a wrapper around gtk_entry_get_width_chars(). 3936func (v *Entry) GetWidthChars() int { 3937 c := C.gtk_entry_get_width_chars(v.native()) 3938 return int(c) 3939} 3940 3941// SetActivatesDefault is a wrapper around gtk_entry_set_activates_default(). 3942func (v *Entry) SetActivatesDefault(setting bool) { 3943 C.gtk_entry_set_activates_default(v.native(), gbool(setting)) 3944} 3945 3946// SetHasFrame is a wrapper around gtk_entry_set_has_frame(). 3947func (v *Entry) SetHasFrame(setting bool) { 3948 C.gtk_entry_set_has_frame(v.native(), gbool(setting)) 3949} 3950 3951// SetWidthChars is a wrapper around gtk_entry_set_width_chars(). 3952func (v *Entry) SetWidthChars(nChars int) { 3953 C.gtk_entry_set_width_chars(v.native(), C.gint(nChars)) 3954} 3955 3956// GetInvisibleChar is a wrapper around gtk_entry_get_invisible_char(). 3957func (v *Entry) GetInvisibleChar() rune { 3958 c := C.gtk_entry_get_invisible_char(v.native()) 3959 return rune(c) 3960} 3961 3962// SetAlignment is a wrapper around gtk_entry_set_alignment(). 3963func (v *Entry) SetAlignment(xalign float32) { 3964 C.gtk_entry_set_alignment(v.native(), C.gfloat(xalign)) 3965} 3966 3967// GetAlignment is a wrapper around gtk_entry_get_alignment(). 3968func (v *Entry) GetAlignment() float32 { 3969 c := C.gtk_entry_get_alignment(v.native()) 3970 return float32(c) 3971} 3972 3973// SetPlaceholderText is a wrapper around gtk_entry_set_placeholder_text(). 3974func (v *Entry) SetPlaceholderText(text string) { 3975 cstr := C.CString(text) 3976 defer C.free(unsafe.Pointer(cstr)) 3977 C.gtk_entry_set_placeholder_text(v.native(), (*C.gchar)(cstr)) 3978} 3979 3980// GetPlaceholderText is a wrapper around gtk_entry_get_placeholder_text(). 3981func (v *Entry) GetPlaceholderText() (string, error) { 3982 c := C.gtk_entry_get_placeholder_text(v.native()) 3983 if c == nil { 3984 return "", nilPtrErr 3985 } 3986 return goString(c), nil 3987} 3988 3989// SetOverwriteMode is a wrapper around gtk_entry_set_overwrite_mode(). 3990func (v *Entry) SetOverwriteMode(overwrite bool) { 3991 C.gtk_entry_set_overwrite_mode(v.native(), gbool(overwrite)) 3992} 3993 3994// GetOverwriteMode is a wrapper around gtk_entry_get_overwrite_mode(). 3995func (v *Entry) GetOverwriteMode() bool { 3996 c := C.gtk_entry_get_overwrite_mode(v.native()) 3997 return gobool(c) 3998} 3999 4000// GetLayout is a wrapper around gtk_entry_get_layout(). 4001func (v *Entry) GetLayout() *pango.Layout { 4002 c := C.gtk_entry_get_layout(v.native()) 4003 return pango.WrapLayout(uintptr(unsafe.Pointer(c))) 4004} 4005 4006// GetLayoutOffsets is a wrapper around gtk_entry_get_layout_offsets(). 4007func (v *Entry) GetLayoutOffsets() (x, y int) { 4008 var gx, gy C.gint 4009 C.gtk_entry_get_layout_offsets(v.native(), &gx, &gy) 4010 return int(gx), int(gy) 4011} 4012 4013// LayoutIndexToTextIndex is a wrapper around gtk_entry_layout_index_to_text_index(). 4014func (v *Entry) LayoutIndexToTextIndex(layoutIndex int) int { 4015 c := C.gtk_entry_layout_index_to_text_index(v.native(), 4016 C.gint(layoutIndex)) 4017 return int(c) 4018} 4019 4020// TextIndexToLayoutIndex is a wrapper around gtk_entry_text_index_to_layout_index(). 4021func (v *Entry) TextIndexToLayoutIndex(textIndex int) int { 4022 c := C.gtk_entry_text_index_to_layout_index(v.native(), 4023 C.gint(textIndex)) 4024 return int(c) 4025} 4026 4027// TODO: depends on PandoAttrList 4028// SetAttributes is a wrapper around gtk_entry_set_attributes(). 4029// func (v *Entry) SetAttributes(attrList *pango.AttrList) { 4030// C.gtk_entry_set_attributes(v.native(), (*C.PangoAttrList)(unsafe.Pointer(attrList.Native()))) 4031// } 4032 4033// TODO: depends on PandoAttrList 4034// GetAttributes is a wrapper around gtk_entry_get_attributes(). 4035// func (v *Entry) GetAttributes() (*pango.AttrList, error) { 4036// c := C.gtk_entry_get_attributes(v.native()) 4037// if c == nil { 4038// return nil, nilPtrErr 4039// } 4040// return &pango.AttrList{unsafe.Pointer(c)}, nil 4041// } 4042 4043// GetMaxLength is a wrapper around gtk_entry_get_max_length(). 4044func (v *Entry) GetMaxLength() int { 4045 c := C.gtk_entry_get_max_length(v.native()) 4046 return int(c) 4047} 4048 4049// GetVisibility is a wrapper around gtk_entry_get_visibility(). 4050func (v *Entry) GetVisibility() bool { 4051 c := C.gtk_entry_get_visibility(v.native()) 4052 return gobool(c) 4053} 4054 4055// SetCompletion is a wrapper around gtk_entry_set_completion(). 4056func (v *Entry) SetCompletion(completion *EntryCompletion) { 4057 C.gtk_entry_set_completion(v.native(), completion.native()) 4058} 4059 4060// GetCompletion is a wrapper around gtk_entry_get_completion(). 4061func (v *Entry) GetCompletion() (*EntryCompletion, error) { 4062 c := C.gtk_entry_get_completion(v.native()) 4063 if c == nil { 4064 return nil, nilPtrErr 4065 } 4066 4067 e := &EntryCompletion{glib.Take(unsafe.Pointer(c))} 4068 return e, nil 4069} 4070 4071// SetCursorHAdjustment is a wrapper around gtk_entry_set_cursor_hadjustment(). 4072func (v *Entry) SetCursorHAdjustment(adjustment *Adjustment) { 4073 C.gtk_entry_set_cursor_hadjustment(v.native(), adjustment.native()) 4074} 4075 4076// GetCursorHAdjustment is a wrapper around gtk_entry_get_cursor_hadjustment(). 4077func (v *Entry) GetCursorHAdjustment() (*Adjustment, error) { 4078 c := C.gtk_entry_get_cursor_hadjustment(v.native()) 4079 if c == nil { 4080 return nil, nilPtrErr 4081 } 4082 obj := glib.Take(unsafe.Pointer(c)) 4083 return &Adjustment{glib.InitiallyUnowned{obj}}, nil 4084} 4085 4086// SetProgressFraction is a wrapper around gtk_entry_set_progress_fraction(). 4087func (v *Entry) SetProgressFraction(fraction float64) { 4088 C.gtk_entry_set_progress_fraction(v.native(), C.gdouble(fraction)) 4089} 4090 4091// GetProgressFraction is a wrapper around gtk_entry_get_progress_fraction(). 4092func (v *Entry) GetProgressFraction() float64 { 4093 c := C.gtk_entry_get_progress_fraction(v.native()) 4094 return float64(c) 4095} 4096 4097// SetProgressPulseStep is a wrapper around gtk_entry_set_progress_pulse_step(). 4098func (v *Entry) SetProgressPulseStep(fraction float64) { 4099 C.gtk_entry_set_progress_pulse_step(v.native(), C.gdouble(fraction)) 4100} 4101 4102// GetProgressPulseStep is a wrapper around gtk_entry_get_progress_pulse_step(). 4103func (v *Entry) GetProgressPulseStep() float64 { 4104 c := C.gtk_entry_get_progress_pulse_step(v.native()) 4105 return float64(c) 4106} 4107 4108// ProgressPulse is a wrapper around gtk_entry_progress_pulse(). 4109func (v *Entry) ProgressPulse() { 4110 C.gtk_entry_progress_pulse(v.native()) 4111} 4112 4113// IMContextFilterKeypress is a wrapper around gtk_entry_im_context_filter_keypress(). 4114func (v *Entry) IMContextFilterKeypress(eventKey *gdk.EventKey) bool { 4115 key := (*C.GdkEventKey)(unsafe.Pointer(eventKey.Native())) 4116 c := C.gtk_entry_im_context_filter_keypress(v.native(), key) 4117 return gobool(c) 4118} 4119 4120// ResetIMContext is a wrapper around gtk_entry_reset_im_context(). 4121func (v *Entry) ResetIMContext() { 4122 C.gtk_entry_reset_im_context(v.native()) 4123} 4124 4125// SetIconFromPixbuf is a wrapper around gtk_entry_set_icon_from_pixbuf(). 4126func (v *Entry) SetIconFromPixbuf(iconPos EntryIconPosition, pixbuf *gdk.Pixbuf) { 4127 var pb *C.GdkPixbuf 4128 if pixbuf != nil { 4129 pb = (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native())) 4130 } 4131 4132 C.gtk_entry_set_icon_from_pixbuf(v.native(), C.GtkEntryIconPosition(iconPos), pb) 4133} 4134 4135// SetIconFromIconName is a wrapper around gtk_entry_set_icon_from_icon_name(). 4136func (v *Entry) SetIconFromIconName(iconPos EntryIconPosition, name string) { 4137 var icon *C.gchar 4138 if name != "" { 4139 n := C.CString(name) 4140 defer C.free(unsafe.Pointer(n)) 4141 icon = (*C.gchar)(n) 4142 } 4143 4144 C.gtk_entry_set_icon_from_icon_name(v.native(), C.GtkEntryIconPosition(iconPos), icon) 4145} 4146 4147// RemoveIcon is a convenience func to set a nil pointer to the icon name. 4148func (v *Entry) RemoveIcon(iconPos EntryIconPosition) { 4149 C.gtk_entry_set_icon_from_icon_name(v.native(), C.GtkEntryIconPosition(iconPos), nil) 4150} 4151 4152// TODO: Needs gio/GIcon implemented first 4153// SetIconFromGIcon is a wrapper around gtk_entry_set_icon_from_gicon(). 4154func (v *Entry) SetIconFromGIcon(iconPos EntryIconPosition, icon *glib.Icon) { 4155 C.gtk_entry_set_icon_from_gicon(v.native(), 4156 C.GtkEntryIconPosition(iconPos), 4157 (*C.GIcon)(icon.NativePrivate())) 4158} 4159 4160// GetIconStorageType is a wrapper around gtk_entry_get_icon_storage_type(). 4161func (v *Entry) GetIconStorageType(iconPos EntryIconPosition) ImageType { 4162 c := C.gtk_entry_get_icon_storage_type(v.native(), C.GtkEntryIconPosition(iconPos)) 4163 return ImageType(c) 4164} 4165 4166// GetIconPixbuf is a wrapper around gtk_entry_get_icon_pixbuf(). 4167func (v *Entry) GetIconPixbuf(iconPos EntryIconPosition) (*gdk.Pixbuf, error) { 4168 c := C.gtk_entry_get_icon_pixbuf(v.native(), C.GtkEntryIconPosition(iconPos)) 4169 if c == nil { 4170 return nil, nilPtrErr 4171 } 4172 return &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))}, nil 4173} 4174 4175// GetIconName is a wrapper around gtk_entry_get_icon_name(). 4176func (v *Entry) GetIconName(iconPos EntryIconPosition) (string, error) { 4177 c := C.gtk_entry_get_icon_name(v.native(), C.GtkEntryIconPosition(iconPos)) 4178 if c == nil { 4179 return "", nilPtrErr 4180 } 4181 return goString(c), nil 4182} 4183 4184// GetIconGIcon is a wrapper around gtk_entry_get_icon_gicon(). 4185func (v *Entry) GetIconGIcon(iconPos EntryIconPosition) (*glib.Icon, error) { 4186 c := C.gtk_entry_get_icon_gicon(v.native(), C.GtkEntryIconPosition(iconPos)) 4187 if c == nil { 4188 return nil, nilPtrErr 4189 } 4190 obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} 4191 i := &glib.Icon{obj} 4192 runtime.SetFinalizer(i, func(_ interface{}) { obj.Unref() }) 4193 return i, nil 4194} 4195 4196// SetIconActivatable is a wrapper around gtk_entry_set_icon_activatable(). 4197func (v *Entry) SetIconActivatable(iconPos EntryIconPosition, activatable bool) { 4198 C.gtk_entry_set_icon_activatable(v.native(), C.GtkEntryIconPosition(iconPos), gbool(activatable)) 4199} 4200 4201// GetIconActivatable is a wrapper around gtk_entry_get_icon_activatable(). 4202func (v *Entry) GetIconActivatable(iconPos EntryIconPosition) bool { 4203 c := C.gtk_entry_get_icon_activatable(v.native(), C.GtkEntryIconPosition(iconPos)) 4204 return gobool(c) 4205} 4206 4207// SetIconSensitive is a wrapper around gtk_entry_set_icon_sensitive(). 4208func (v *Entry) SetIconSensitive(iconPos EntryIconPosition, sensitive bool) { 4209 C.gtk_entry_set_icon_sensitive(v.native(), C.GtkEntryIconPosition(iconPos), gbool(sensitive)) 4210} 4211 4212// GetIconSensitive is a wrapper around gtk_entry_get_icon_sensitive(). 4213func (v *Entry) GetIconSensitive(iconPos EntryIconPosition) bool { 4214 c := C.gtk_entry_get_icon_sensitive(v.native(), C.GtkEntryIconPosition(iconPos)) 4215 return gobool(c) 4216} 4217 4218// GetIconAtPos is a wrapper around gtk_entry_get_icon_at_pos(). 4219func (v *Entry) GetIconAtPos(x, y int) int { 4220 c := C.gtk_entry_get_icon_at_pos(v.native(), C.gint(x), C.gint(y)) 4221 return int(c) 4222} 4223 4224// SetIconTooltipText is a wrapper around gtk_entry_set_icon_tooltip_text(). 4225func (v *Entry) SetIconTooltipText(iconPos EntryIconPosition, tooltip string) { 4226 var text *C.gchar 4227 if tooltip != "" { 4228 cstr := C.CString(tooltip) 4229 defer C.free(unsafe.Pointer(cstr)) 4230 text = cstr 4231 } 4232 4233 C.gtk_entry_set_icon_tooltip_text(v.native(), C.GtkEntryIconPosition(iconPos), text) 4234} 4235 4236// GetIconTooltipText is a wrapper around gtk_entry_get_icon_tooltip_text(). 4237func (v *Entry) GetIconTooltipText(iconPos EntryIconPosition) (string, error) { 4238 c := C.gtk_entry_get_icon_tooltip_text(v.native(), 4239 C.GtkEntryIconPosition(iconPos)) 4240 if c == nil { 4241 return "", nilPtrErr 4242 } 4243 return goString(c), nil 4244} 4245 4246// SetIconTooltipMarkup is a wrapper around gtk_entry_set_icon_tooltip_markup(). 4247func (v *Entry) SetIconTooltipMarkup(iconPos EntryIconPosition, tooltip string) { 4248 var text *C.gchar 4249 if tooltip != "" { 4250 cstr := C.CString(tooltip) 4251 defer C.free(unsafe.Pointer(cstr)) 4252 text = cstr 4253 } 4254 4255 C.gtk_entry_set_icon_tooltip_markup(v.native(), C.GtkEntryIconPosition(iconPos), text) 4256} 4257 4258// GetIconTooltipMarkup is a wrapper around gtk_entry_get_icon_tooltip_markup(). 4259func (v *Entry) GetIconTooltipMarkup(iconPos EntryIconPosition) (string, error) { 4260 c := C.gtk_entry_get_icon_tooltip_markup(v.native(), 4261 C.GtkEntryIconPosition(iconPos)) 4262 if c == nil { 4263 return "", nilPtrErr 4264 } 4265 return goString(c), nil 4266} 4267 4268// TODO: depends on GtkTargetList 4269// SetIconDragSource is a wrapper around gtk_entry_set_icon_drag_source(). 4270// func (v *Entry) SetIconDragSource(iconPos EntryIconPosition, targetList *TargetList, action gdk.DragAction) { 4271// C.gtk_entry_set_icon_drag_source(v.native(), C.GtkEntryIconPosition(iconPos), 4272// targetList.native(), C.GdkDragAction(action)) 4273// } 4274 4275// GetCurrentIconDragSource is a wrapper around gtk_entry_get_current_icon_drag_source(). 4276func (v *Entry) GetCurrentIconDragSource() int { 4277 c := C.gtk_entry_get_current_icon_drag_source(v.native()) 4278 return int(c) 4279} 4280 4281// GetIconArea is a wrapper around gtk_entry_get_icon_area(). 4282func (v *Entry) GetIconArea(iconPos EntryIconPosition) *gdk.Rectangle { 4283 var cRect *C.GdkRectangle 4284 C.gtk_entry_get_icon_area(v.native(), C.GtkEntryIconPosition(iconPos), cRect) 4285 iconArea := gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) 4286 return iconArea 4287} 4288 4289// SetInputPurpose is a wrapper around gtk_entry_set_input_purpose(). 4290func (v *Entry) SetInputPurpose(purpose InputPurpose) { 4291 C.gtk_entry_set_input_purpose(v.native(), C.GtkInputPurpose(purpose)) 4292} 4293 4294// GetInputPurpose is a wrapper around gtk_entry_get_input_purpose(). 4295func (v *Entry) GetInputPurpose() InputPurpose { 4296 c := C.gtk_entry_get_input_purpose(v.native()) 4297 return InputPurpose(c) 4298} 4299 4300// SetInputHints is a wrapper around gtk_entry_set_input_hints(). 4301func (v *Entry) SetInputHints(hints InputHints) { 4302 C.gtk_entry_set_input_hints(v.native(), C.GtkInputHints(hints)) 4303} 4304 4305// GetInputHints is a wrapper around gtk_entry_get_input_hints(). 4306func (v *Entry) GetInputHints() InputHints { 4307 c := C.gtk_entry_get_input_hints(v.native()) 4308 return InputHints(c) 4309} 4310 4311/* 4312 * GtkEntryBuffer 4313 */ 4314 4315// EntryBuffer is a representation of GTK's GtkEntryBuffer. 4316type EntryBuffer struct { 4317 *glib.Object 4318} 4319 4320// native returns a pointer to the underlying GtkEntryBuffer. 4321func (v *EntryBuffer) native() *C.GtkEntryBuffer { 4322 if v == nil || v.GObject == nil { 4323 return nil 4324 } 4325 p := unsafe.Pointer(v.GObject) 4326 return C.toGtkEntryBuffer(p) 4327} 4328 4329func marshalEntryBuffer(p uintptr) (interface{}, error) { 4330 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 4331 obj := glib.Take(unsafe.Pointer(c)) 4332 return wrapEntryBuffer(obj), nil 4333} 4334 4335func wrapEntryBuffer(obj *glib.Object) *EntryBuffer { 4336 if obj == nil { 4337 return nil 4338 } 4339 4340 return &EntryBuffer{obj} 4341} 4342 4343// EntryBufferNew() is a wrapper around gtk_entry_buffer_new(). 4344func EntryBufferNew(initialChars string, nInitialChars int) (*EntryBuffer, error) { 4345 cstr := C.CString(initialChars) 4346 defer C.free(unsafe.Pointer(cstr)) 4347 c := C.gtk_entry_buffer_new((*C.gchar)(cstr), C.gint(nInitialChars)) 4348 if c == nil { 4349 return nil, nilPtrErr 4350 } 4351 4352 e := wrapEntryBuffer(glib.Take(unsafe.Pointer(c))) 4353 return e, nil 4354} 4355 4356// GetText() is a wrapper around gtk_entry_buffer_get_text(). A 4357// non-nil error is returned in the case that gtk_entry_buffer_get_text 4358// returns NULL to differentiate between NULL and an empty string. 4359func (v *EntryBuffer) GetText() (string, error) { 4360 c := C.gtk_entry_buffer_get_text(v.native()) 4361 if c == nil { 4362 return "", nilPtrErr 4363 } 4364 return goString(c), nil 4365} 4366 4367// SetText() is a wrapper around gtk_entry_buffer_set_text(). 4368func (v *EntryBuffer) SetText(text string) { 4369 cstr := C.CString(text) 4370 defer C.free(unsafe.Pointer(cstr)) 4371 C.gtk_entry_buffer_set_text(v.native(), (*C.gchar)(cstr), 4372 C.gint(len(text))) 4373} 4374 4375// GetBytes() is a wrapper around gtk_entry_buffer_get_bytes(). 4376func (v *EntryBuffer) GetBytes() uint { 4377 c := C.gtk_entry_buffer_get_bytes(v.native()) 4378 return uint(c) 4379} 4380 4381// GetLength() is a wrapper around gtk_entry_buffer_get_length(). 4382func (v *EntryBuffer) GetLength() uint { 4383 c := C.gtk_entry_buffer_get_length(v.native()) 4384 return uint(c) 4385} 4386 4387// GetMaxLength() is a wrapper around gtk_entry_buffer_get_max_length(). 4388func (v *EntryBuffer) GetMaxLength() int { 4389 c := C.gtk_entry_buffer_get_max_length(v.native()) 4390 return int(c) 4391} 4392 4393// SetMaxLength() is a wrapper around gtk_entry_buffer_set_max_length(). 4394func (v *EntryBuffer) SetMaxLength(maxLength int) { 4395 C.gtk_entry_buffer_set_max_length(v.native(), C.gint(maxLength)) 4396} 4397 4398// InsertText() is a wrapper around gtk_entry_buffer_insert_text(). 4399func (v *EntryBuffer) InsertText(position uint, text string) uint { 4400 cstr := C.CString(text) 4401 defer C.free(unsafe.Pointer(cstr)) 4402 c := C.gtk_entry_buffer_insert_text(v.native(), C.guint(position), 4403 (*C.gchar)(cstr), C.gint(len(text))) 4404 return uint(c) 4405} 4406 4407// DeleteText() is a wrapper around gtk_entry_buffer_delete_text(). 4408func (v *EntryBuffer) DeleteText(position uint, nChars int) uint { 4409 c := C.gtk_entry_buffer_delete_text(v.native(), C.guint(position), 4410 C.gint(nChars)) 4411 return uint(c) 4412} 4413 4414// EmitDeletedText() is a wrapper around gtk_entry_buffer_emit_deleted_text(). 4415func (v *EntryBuffer) EmitDeletedText(pos, nChars uint) { 4416 C.gtk_entry_buffer_emit_deleted_text(v.native(), C.guint(pos), 4417 C.guint(nChars)) 4418} 4419 4420// EmitInsertedText() is a wrapper around gtk_entry_buffer_emit_inserted_text(). 4421func (v *EntryBuffer) EmitInsertedText(pos uint, text string) { 4422 cstr := C.CString(text) 4423 defer C.free(unsafe.Pointer(cstr)) 4424 C.gtk_entry_buffer_emit_inserted_text(v.native(), C.guint(pos), 4425 (*C.gchar)(cstr), C.guint(len(text))) 4426} 4427 4428/* 4429 * GtkEntryCompletion 4430 */ 4431 4432// EntryCompletion is a representation of GTK's GtkEntryCompletion. 4433type EntryCompletion struct { 4434 *glib.Object 4435} 4436 4437// native returns a pointer to the underlying GtkEntryCompletion. 4438func (v *EntryCompletion) native() *C.GtkEntryCompletion { 4439 if v == nil || v.GObject == nil { 4440 return nil 4441 } 4442 p := unsafe.Pointer(v.GObject) 4443 return C.toGtkEntryCompletion(p) 4444} 4445 4446func marshalEntryCompletion(p uintptr) (interface{}, error) { 4447 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 4448 obj := glib.Take(unsafe.Pointer(c)) 4449 return wrapEntryCompletion(obj), nil 4450} 4451 4452func wrapEntryCompletion(obj *glib.Object) *EntryCompletion { 4453 if obj == nil { 4454 return nil 4455 } 4456 4457 return &EntryCompletion{obj} 4458} 4459 4460// TODO: 4461// GtkEntryCompletionMatchFunc 4462 4463// EntryCompletionNew is a wrapper around gtk_entry_completion_new 4464func EntryCompletionNew() (*EntryCompletion, error) { 4465 c := C.gtk_entry_completion_new() 4466 if c == nil { 4467 return nil, nilPtrErr 4468 } 4469 obj := glib.Take(unsafe.Pointer(c)) 4470 return wrapEntryCompletion(obj), nil 4471} 4472 4473// TODO: 4474// gtk_entry_completion_new_with_area(). 4475// gtk_entry_completion_get_entry(). 4476 4477// SetModel is a wrapper around gtk_entry_completion_set_model 4478func (v *EntryCompletion) SetModel(model ITreeModel) { 4479 var mptr *C.GtkTreeModel 4480 if model != nil { 4481 mptr = model.toTreeModel() 4482 } 4483 C.gtk_entry_completion_set_model(v.native(), mptr) 4484} 4485 4486// GetModel is a wrapper around gtk_entry_completion_get_model 4487func (v *EntryCompletion) GetModel() (ITreeModel, error) { 4488 c := C.gtk_entry_completion_get_model(v.native()) 4489 if c == nil { 4490 return nil, nilPtrErr 4491 } 4492 return castTreeModel(c) 4493} 4494 4495// TODO: 4496// gtk_entry_completion_set_match_func(). 4497 4498// SetMinimumKeyLength is a wrapper around gtk_entry_completion_set_minimum_key_length 4499func (v *EntryCompletion) SetMinimumKeyLength(minimumLength int) { 4500 C.gtk_entry_completion_set_minimum_key_length(v.native(), C.gint(minimumLength)) 4501} 4502 4503// GetMinimumKeyLength is a wrapper around gtk_entry_completion_get_minimum_key_length 4504func (v *EntryCompletion) GetMinimumKeyLength() int { 4505 c := C.gtk_entry_completion_get_minimum_key_length(v.native()) 4506 return int(c) 4507} 4508 4509// TODO: 4510// gtk_entry_completion_compute_prefix(). 4511// gtk_entry_completion_complete(). 4512// gtk_entry_completion_get_completion_prefix(). 4513// gtk_entry_completion_insert_prefix(). 4514// gtk_entry_completion_insert_action_text(). 4515// gtk_entry_completion_insert_action_markup(). 4516// gtk_entry_completion_delete_action(). 4517 4518// SetTextColumn is a wrapper around gtk_entry_completion_set_text_column 4519func (v *EntryCompletion) SetTextColumn(textColumn int) { 4520 C.gtk_entry_completion_set_text_column(v.native(), C.gint(textColumn)) 4521} 4522 4523// GetTextColumn is a wrapper around gtk_entry_completion_get_text_column 4524func (v *EntryCompletion) GetTextColumn() int { 4525 c := C.gtk_entry_completion_get_text_column(v.native()) 4526 return int(c) 4527} 4528 4529// SetInlineCompletion is a wrapper around gtk_entry_completion_set_inline_completion 4530func (v *EntryCompletion) SetInlineCompletion(inlineCompletion bool) { 4531 C.gtk_entry_completion_set_inline_completion(v.native(), gbool(inlineCompletion)) 4532} 4533 4534// GetInlineCompletion is a wrapper around gtk_entry_completion_get_inline_completion 4535func (v *EntryCompletion) GetInlineCompletion() bool { 4536 c := C.gtk_entry_completion_get_inline_completion(v.native()) 4537 return gobool(c) 4538} 4539 4540// TODO 4541// gtk_entry_completion_set_inline_selection(). 4542// gtk_entry_completion_get_inline_selection(). 4543 4544// SetPopupCompletion is a wrapper around gtk_entry_completion_set_popup_completion 4545func (v *EntryCompletion) SetPopupCompletion(popupCompletion bool) { 4546 C.gtk_entry_completion_set_popup_completion(v.native(), gbool(popupCompletion)) 4547} 4548 4549// GetPopupCompletion is a wrapper around gtk_entry_completion_get_popup_completion 4550func (v *EntryCompletion) GetPopupCompletion() bool { 4551 c := C.gtk_entry_completion_get_popup_completion(v.native()) 4552 return gobool(c) 4553} 4554 4555// SetPopupSetWidth is a wrapper around gtk_entry_completion_set_popup_set_width 4556func (v *EntryCompletion) SetPopupSetWidth(popupSetWidth bool) { 4557 C.gtk_entry_completion_set_popup_set_width(v.native(), gbool(popupSetWidth)) 4558} 4559 4560// GetPopupSetWidth is a wrapper around gtk_entry_completion_get_popup_set_width 4561func (v *EntryCompletion) GetPopupSetWidth() bool { 4562 c := C.gtk_entry_completion_get_popup_set_width(v.native()) 4563 return gobool(c) 4564} 4565 4566// TODO: 4567// gtk_entry_completion_set_popup_single_match(). 4568// gtk_entry_completion_get_popup_single_match(). 4569 4570/* 4571 * GtkEventBox 4572 */ 4573 4574// EventBox is a representation of GTK's GtkEventBox. 4575type EventBox struct { 4576 Bin 4577} 4578 4579// native returns a pointer to the underlying GtkEventBox. 4580func (v *EventBox) native() *C.GtkEventBox { 4581 if v == nil || v.GObject == nil { 4582 return nil 4583 } 4584 p := unsafe.Pointer(v.GObject) 4585 return C.toGtkEventBox(p) 4586} 4587 4588func marshalEventBox(p uintptr) (interface{}, error) { 4589 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 4590 obj := glib.Take(unsafe.Pointer(c)) 4591 return wrapEventBox(obj), nil 4592} 4593 4594func wrapEventBox(obj *glib.Object) *EventBox { 4595 if obj == nil { 4596 return nil 4597 } 4598 4599 return &EventBox{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} 4600} 4601 4602// EventBoxNew is a wrapper around gtk_event_box_new(). 4603func EventBoxNew() (*EventBox, error) { 4604 c := C.gtk_event_box_new() 4605 if c == nil { 4606 return nil, nilPtrErr 4607 } 4608 obj := glib.Take(unsafe.Pointer(c)) 4609 return wrapEventBox(obj), nil 4610} 4611 4612// SetAboveChild is a wrapper around gtk_event_box_set_above_child(). 4613func (v *EventBox) SetAboveChild(aboveChild bool) { 4614 C.gtk_event_box_set_above_child(v.native(), gbool(aboveChild)) 4615} 4616 4617// GetAboveChild is a wrapper around gtk_event_box_get_above_child(). 4618func (v *EventBox) GetAboveChild() bool { 4619 c := C.gtk_event_box_get_above_child(v.native()) 4620 return gobool(c) 4621} 4622 4623// SetVisibleWindow is a wrapper around gtk_event_box_set_visible_window(). 4624func (v *EventBox) SetVisibleWindow(visibleWindow bool) { 4625 C.gtk_event_box_set_visible_window(v.native(), gbool(visibleWindow)) 4626} 4627 4628// GetVisibleWindow is a wrapper around gtk_event_box_get_visible_window(). 4629func (v *EventBox) GetVisibleWindow() bool { 4630 c := C.gtk_event_box_get_visible_window(v.native()) 4631 return gobool(c) 4632} 4633 4634/* 4635 * GtkExpander 4636 */ 4637 4638// Expander is a representation of GTK's GtkExpander. 4639type Expander struct { 4640 Bin 4641} 4642 4643// native returns a pointer to the underlying GtkExpander. 4644func (v *Expander) native() *C.GtkExpander { 4645 if v == nil || v.GObject == nil { 4646 return nil 4647 } 4648 p := unsafe.Pointer(v.GObject) 4649 return C.toGtkExpander(p) 4650} 4651 4652func marshalExpander(p uintptr) (interface{}, error) { 4653 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 4654 obj := glib.Take(unsafe.Pointer(c)) 4655 return wrapExpander(obj), nil 4656} 4657 4658func wrapExpander(obj *glib.Object) *Expander { 4659 if obj == nil { 4660 return nil 4661 } 4662 4663 return &Expander{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} 4664} 4665 4666// ExpanderNew is a wrapper around gtk_expander_new(). 4667func ExpanderNew(label string) (*Expander, error) { 4668 var cstr *C.gchar 4669 if label != "" { 4670 cstr = (*C.gchar)(C.CString(label)) 4671 defer C.free(unsafe.Pointer(cstr)) 4672 } 4673 c := C.gtk_expander_new(cstr) 4674 if c == nil { 4675 return nil, nilPtrErr 4676 } 4677 obj := glib.Take(unsafe.Pointer(c)) 4678 return wrapExpander(obj), nil 4679} 4680 4681// TODO: 4682// gtk_expander_new_with_mnemonic(). 4683 4684// SetExpanded is a wrapper around gtk_expander_set_expanded(). 4685func (v *Expander) SetExpanded(expanded bool) { 4686 C.gtk_expander_set_expanded(v.native(), gbool(expanded)) 4687} 4688 4689// GetExpanded is a wrapper around gtk_expander_get_expanded(). 4690func (v *Expander) GetExpanded() bool { 4691 c := C.gtk_expander_get_expanded(v.native()) 4692 return gobool(c) 4693} 4694 4695// SetLabel is a wrapper around gtk_expander_set_label(). 4696func (v *Expander) SetLabel(label string) { 4697 var cstr *C.char 4698 if label != "" { 4699 cstr = C.CString(label) 4700 defer C.free(unsafe.Pointer(cstr)) 4701 } 4702 C.gtk_expander_set_label(v.native(), (*C.gchar)(cstr)) 4703} 4704 4705// GetLabel is a wrapper around gtk_expander_get_label(). 4706func (v *Expander) GetLabel() string { 4707 c := C.gtk_expander_get_label(v.native()) 4708 return goString(c) 4709} 4710 4711// TODO: 4712// gtk_expander_set_use_underline(). 4713// gtk_expander_get_use_underline(). 4714// gtk_expander_set_use_markup(). 4715// gtk_expander_get_use_markup(). 4716 4717// SetLabelWidget is a wrapper around gtk_expander_set_label_widget(). 4718func (v *Expander) SetLabelWidget(widget IWidget) { 4719 C.gtk_expander_set_label_widget(v.native(), widget.toWidget()) 4720} 4721 4722// TODO: 4723// gtk_expander_get_label_widget(). 4724// gtk_expander_set_label_fill(). 4725// gtk_expander_get_label_fill(). 4726// gtk_expander_set_resize_toplevel(). 4727// gtk_expander_get_resize_toplevel(). 4728 4729/* 4730 * GtkFileChooser 4731 */ 4732 4733// FileChoser is a representation of GTK's GtkFileChooser GInterface. 4734type FileChooser struct { 4735 *glib.Object 4736} 4737 4738// native returns a pointer to the underlying GObject as a GtkFileChooser. 4739func (v *FileChooser) native() *C.GtkFileChooser { 4740 if v == nil || v.GObject == nil { 4741 return nil 4742 } 4743 p := unsafe.Pointer(v.GObject) 4744 return C.toGtkFileChooser(p) 4745} 4746 4747func marshalFileChooser(p uintptr) (interface{}, error) { 4748 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 4749 obj := glib.Take(unsafe.Pointer(c)) 4750 return wrapFileChooser(obj), nil 4751} 4752 4753func wrapFileChooser(obj *glib.Object) *FileChooser { 4754 if obj == nil { 4755 return nil 4756 } 4757 4758 return &FileChooser{obj} 4759} 4760 4761// SetFilename is a wrapper around gtk_file_chooser_set_filename(). 4762func (v *FileChooser) SetFilename(filename string) bool { 4763 cstr := C.CString(filename) 4764 defer C.free(unsafe.Pointer(cstr)) 4765 c := C.gtk_file_chooser_set_filename(v.native(), cstr) 4766 return gobool(c) 4767} 4768 4769// GetFilename is a wrapper around gtk_file_chooser_get_filename(). 4770func (v *FileChooser) GetFilename() string { 4771 c := C.gtk_file_chooser_get_filename(v.native()) 4772 s := goString(c) 4773 defer C.g_free((C.gpointer)(c)) 4774 return s 4775} 4776 4777// SelectFilename is a wrapper around gtk_file_chooser_select_filename(). 4778func (v *FileChooser) SelectFilename(filename string) bool { 4779 cstr := C.CString(filename) 4780 defer C.free(unsafe.Pointer(cstr)) 4781 c := C.gtk_file_chooser_select_filename(v.native(), cstr) 4782 return gobool(c) 4783} 4784 4785// UnselectFilename is a wrapper around gtk_file_chooser_unselect_filename(). 4786func (v *FileChooser) UnselectFilename(filename string) { 4787 cstr := C.CString(filename) 4788 defer C.free(unsafe.Pointer(cstr)) 4789 C.gtk_file_chooser_unselect_filename(v.native(), cstr) 4790} 4791 4792// SelectAll is a wrapper around gtk_file_chooser_select_all(). 4793func (v *FileChooser) SelectAll() { 4794 C.gtk_file_chooser_select_all(v.native()) 4795} 4796 4797// UnselectAll is a wrapper around gtk_file_chooser_unselect_all(). 4798func (v *FileChooser) UnselectAll() { 4799 C.gtk_file_chooser_unselect_all(v.native()) 4800} 4801 4802// GetFilenames is a wrapper around gtk_file_chooser_get_filenames(). 4803func (v *FileChooser) GetFilenames() ([]string, error) { 4804 clist := C.gtk_file_chooser_get_filenames(v.native()) 4805 if clist == nil { 4806 return nil, nilPtrErr 4807 } 4808 4809 slist := glib.WrapSList(uintptr(unsafe.Pointer(clist))) 4810 defer slist.Free() 4811 4812 var filenames = make([]string, 0, slist.Length()) 4813 for ; slist.DataRaw() != nil; slist = slist.Next() { 4814 w := (*C.char)(slist.DataRaw()) 4815 defer C.free(unsafe.Pointer(w)) 4816 4817 filenames = append(filenames, C.GoString(w)) 4818 } 4819 4820 return filenames, nil 4821} 4822 4823// GetURIs is a wrapper around gtk_file_chooser_get_uris(). 4824func (v FileChooser) GetURIs() ([]string, error) { 4825 // TODO: do the same as in (v *FileChooser) GetFilenames() 4826 clist := C.gtk_file_chooser_get_uris(v.native()) 4827 if clist == nil { 4828 return nil, nilPtrErr 4829 } 4830 4831 slist := glib.WrapSList(uintptr(unsafe.Pointer(clist))) 4832 defer slist.Free() 4833 4834 var uris = make([]string, 0, slist.Length()) 4835 for ; slist.DataRaw() != nil; slist = slist.Next() { 4836 w := (*C.char)(slist.DataRaw()) 4837 defer C.free(unsafe.Pointer(w)) 4838 4839 uris = append(uris, C.GoString(w)) 4840 } 4841 4842 return uris, nil 4843} 4844 4845// SetDoOverwriteConfirmation is a wrapper around gtk_file_chooser_set_do_overwrite_confirmation(). 4846func (v *FileChooser) SetDoOverwriteConfirmation(value bool) { 4847 C.gtk_file_chooser_set_do_overwrite_confirmation(v.native(), gbool(value)) 4848} 4849 4850// GetDoOverwriteConfirmation is a wrapper around gtk_file_chooser_get_do_overwrite_confirmation(). 4851func (v *FileChooser) GetDoOverwriteConfirmation() bool { 4852 c := C.gtk_file_chooser_get_do_overwrite_confirmation(v.native()) 4853 return gobool(c) 4854} 4855 4856// SetCreateFolders is a wrapper around gtk_file_chooser_set_create_folders(). 4857func (v *FileChooser) SetCreateFolders(value bool) { 4858 C.gtk_file_chooser_set_create_folders(v.native(), gbool(value)) 4859} 4860 4861// GetCreateFolders is a wrapper around gtk_file_chooser_get_create_folders(). 4862func (v *FileChooser) GetCreateFolders() bool { 4863 c := C.gtk_file_chooser_get_create_folders(v.native()) 4864 return gobool(c) 4865} 4866 4867// SetCurrentName is a wrapper around gtk_file_chooser_set_current_name(). 4868func (v *FileChooser) SetCurrentName(name string) { 4869 cstr := C.CString(name) 4870 defer C.free(unsafe.Pointer(cstr)) 4871 C.gtk_file_chooser_set_current_name(v.native(), (*C.gchar)(cstr)) 4872 return 4873} 4874 4875// SetCurrentFolder is a wrapper around gtk_file_chooser_set_current_folder(). 4876func (v *FileChooser) SetCurrentFolder(folder string) bool { 4877 cstr := C.CString(folder) 4878 defer C.free(unsafe.Pointer(cstr)) 4879 c := C.gtk_file_chooser_set_current_folder(v.native(), (*C.gchar)(cstr)) 4880 return gobool(c) 4881} 4882 4883// GetCurrentFolder is a wrapper around gtk_file_chooser_get_current_folder(). 4884func (v *FileChooser) GetCurrentFolder() (string, error) { 4885 c := C.gtk_file_chooser_get_current_folder(v.native()) 4886 if c == nil { 4887 return "", nilPtrErr 4888 } 4889 defer C.free(unsafe.Pointer(c)) 4890 return goString(c), nil 4891} 4892 4893// SetPreviewWidget is a wrapper around gtk_file_chooser_set_preview_widget(). 4894func (v *FileChooser) SetPreviewWidget(widget IWidget) { 4895 C.gtk_file_chooser_set_preview_widget(v.native(), widget.toWidget()) 4896} 4897 4898// SetPreviewWidgetActive is a wrapper around gtk_file_chooser_set_preview_widget_active(). 4899func (v *FileChooser) SetPreviewWidgetActive(active bool) { 4900 C.gtk_file_chooser_set_preview_widget_active(v.native(), gbool(active)) 4901} 4902 4903// GetPreviewFilename is a wrapper around gtk_file_chooser_get_preview_filename(). 4904func (v *FileChooser) GetPreviewFilename() string { 4905 c := C.gtk_file_chooser_get_preview_filename(v.native()) 4906 defer C.free(unsafe.Pointer(c)) 4907 return C.GoString(c) 4908} 4909 4910// GetURI is a wrapper around gtk_file_chooser_get_uri(). 4911func (v *FileChooser) GetURI() string { 4912 c := C.gtk_file_chooser_get_uri(v.native()) 4913 s := goString(c) 4914 defer C.g_free((C.gpointer)(c)) 4915 return s 4916} 4917 4918// AddFilter is a wrapper around gtk_file_chooser_add_filter(). 4919func (v *FileChooser) AddFilter(filter *FileFilter) { 4920 C.gtk_file_chooser_add_filter(v.native(), filter.native()) 4921} 4922 4923// RemoveFilter is a wrapper around gtk_file_chooser_remove_filter(). 4924func (v *FileChooser) RemoveFilter(filter *FileFilter) { 4925 C.gtk_file_chooser_remove_filter(v.native(), filter.native()) 4926} 4927 4928// SetFilter is a wrapper around gtk_file_chooser_set_filter(). 4929func (v *FileChooser) SetFilter(filter *FileFilter) { 4930 C.gtk_file_chooser_set_filter(v.native(), filter.native()) 4931} 4932 4933// AddShortcutFolder is a wrapper around gtk_file_chooser_add_shortcut_folder(). 4934func (v *FileChooser) AddShortcutFolder(folder string) bool { 4935 cstr := C.CString(folder) 4936 defer C.free(unsafe.Pointer(cstr)) 4937 c := C.gtk_file_chooser_add_shortcut_folder(v.native(), cstr, nil) 4938 return gobool(c) 4939} 4940 4941// SetLocalOnly is a wrapper around gtk_file_chooser_set_local_only(). 4942func (v *FileChooser) SetLocalOnly(value bool) { 4943 C.gtk_file_chooser_set_local_only(v.native(), gbool(value)) 4944} 4945 4946// GetLocalOnly is a wrapper around gtk_file_chooser_get_local_only(). 4947func (v *FileChooser) GetLocalOnly() bool { 4948 c := C.gtk_file_chooser_get_local_only(v.native()) 4949 return gobool(c) 4950} 4951 4952// SetSelectMultiple is a wrapper around gtk_file_chooser_set_select_multiple(). 4953func (v *FileChooser) SetSelectMultiple(value bool) { 4954 C.gtk_file_chooser_set_select_multiple(v.native(), gbool(value)) 4955} 4956 4957// GetSelectMultiple is a wrapper around gtk_file_chooser_get_select_multiple(). 4958func (v *FileChooser) GetSelectMultiple() bool { 4959 c := C.gtk_file_chooser_get_select_multiple(v.native()) 4960 return gobool(c) 4961} 4962 4963/* 4964 * GtkFileChooserButton 4965 */ 4966 4967// FileChooserButton is a representation of GTK's GtkFileChooserButton. 4968type FileChooserButton struct { 4969 Box 4970 4971 // Interfaces 4972 FileChooser 4973} 4974 4975// native returns a pointer to the underlying GtkFileChooserButton. 4976func (v *FileChooserButton) native() *C.GtkFileChooserButton { 4977 if v == nil || v.GObject == nil { 4978 return nil 4979 } 4980 p := unsafe.Pointer(v.GObject) 4981 return C.toGtkFileChooserButton(p) 4982} 4983 4984func marshalFileChooserButton(p uintptr) (interface{}, error) { 4985 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 4986 obj := glib.Take(unsafe.Pointer(c)) 4987 return wrapFileChooserButton(obj), nil 4988} 4989 4990func wrapFileChooserButton(obj *glib.Object) *FileChooserButton { 4991 if obj == nil { 4992 return nil 4993 } 4994 4995 fc := wrapFileChooser(obj) 4996 return &FileChooserButton{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}, *fc} 4997} 4998 4999// FileChooserButtonNew is a wrapper around gtk_file_chooser_button_new(). 5000func FileChooserButtonNew(title string, action FileChooserAction) (*FileChooserButton, error) { 5001 cstr := C.CString(title) 5002 defer C.free(unsafe.Pointer(cstr)) 5003 c := C.gtk_file_chooser_button_new((*C.gchar)(cstr), 5004 (C.GtkFileChooserAction)(action)) 5005 if c == nil { 5006 return nil, nilPtrErr 5007 } 5008 obj := glib.Take(unsafe.Pointer(c)) 5009 return wrapFileChooserButton(obj), nil 5010} 5011 5012// FileChooserButtonNewWithDialog is a wrapper around gtk_file_chooser_button_new_with_dialog(). 5013func FileChooserButtonNewWithDialog(dialog IWidget) (*FileChooserButton, error) { 5014 c := C.gtk_file_chooser_button_new_with_dialog(dialog.toWidget()) 5015 if c == nil { 5016 return nil, nilPtrErr 5017 } 5018 return wrapFileChooserButton(glib.Take(unsafe.Pointer(c))), nil 5019} 5020 5021// GetTitle is a wrapper around gtk_file_chooser_button_get_title(). 5022func (v *FileChooserButton) GetTitle() string { 5023 // docs say: The returned value should not be modified or freed. 5024 return goString(C.gtk_file_chooser_button_get_title(v.native())) 5025} 5026 5027// SetTitle is a wrapper around gtk_file_chooser_button_set_title(). 5028func (v *FileChooserButton) SetTitle(title string) { 5029 cstr := C.CString(title) 5030 defer C.free(unsafe.Pointer(cstr)) 5031 C.gtk_file_chooser_button_set_title(v.native(), (*C.gchar)(cstr)) 5032} 5033 5034// GetWidthChars is a wrapper around gtk_file_chooser_button_get_width_chars(). 5035func (v *FileChooserButton) GetWidthChars() int { 5036 return int(C.gtk_file_chooser_button_get_width_chars(v.native())) 5037} 5038 5039// SetWidthChars is a wrapper around gtk_file_chooser_button_set_width_chars(). 5040func (v *FileChooserButton) SetWidthChars(width int) { 5041 C.gtk_file_chooser_button_set_width_chars(v.native(), C.gint(width)) 5042} 5043 5044/* 5045 * GtkFileChooserDialog 5046 */ 5047 5048// FileChooserDialog is a representation of GTK's GtkFileChooserDialog. 5049type FileChooserDialog struct { 5050 Dialog 5051 5052 // Interfaces 5053 FileChooser 5054} 5055 5056// native returns a pointer to the underlying GtkFileChooserDialog. 5057func (v *FileChooserDialog) native() *C.GtkFileChooserDialog { 5058 if v == nil || v.GObject == nil { 5059 return nil 5060 } 5061 p := unsafe.Pointer(v.GObject) 5062 return C.toGtkFileChooserDialog(p) 5063} 5064 5065func marshalFileChooserDialog(p uintptr) (interface{}, error) { 5066 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 5067 obj := glib.Take(unsafe.Pointer(c)) 5068 return wrapFileChooserDialog(obj), nil 5069} 5070 5071func wrapFileChooserDialog(obj *glib.Object) *FileChooserDialog { 5072 if obj == nil { 5073 return nil 5074 } 5075 5076 fc := wrapFileChooser(obj) 5077 return &FileChooserDialog{Dialog{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}}, *fc} 5078} 5079 5080// FileChooserDialogNewWith1Button is a wrapper around gtk_file_chooser_dialog_new() with one button. 5081func FileChooserDialogNewWith1Button( 5082 title string, 5083 parent IWindow, 5084 action FileChooserAction, 5085 first_button_text string, 5086 first_button_id ResponseType) (*FileChooserDialog, error) { 5087 5088 var w *C.GtkWindow = nil 5089 if parent != nil { 5090 w = parent.toWindow() 5091 } 5092 5093 c_title := C.CString(title) 5094 defer C.free(unsafe.Pointer(c_title)) 5095 c_first_button_text := C.CString(first_button_text) 5096 defer C.free(unsafe.Pointer(c_first_button_text)) 5097 c := C.gtk_file_chooser_dialog_new_1( 5098 (*C.gchar)(c_title), w, C.GtkFileChooserAction(action), 5099 (*C.gchar)(c_first_button_text), C.int(first_button_id)) 5100 if c == nil { 5101 return nil, nilPtrErr 5102 } 5103 obj := glib.Take(unsafe.Pointer(c)) 5104 return wrapFileChooserDialog(obj), nil 5105} 5106 5107// FileChooserDialogNewWith2Buttons is a wrapper around gtk_file_chooser_dialog_new() with two buttons. 5108func FileChooserDialogNewWith2Buttons( 5109 title string, 5110 parent IWindow, 5111 action FileChooserAction, 5112 first_button_text string, 5113 first_button_id ResponseType, 5114 second_button_text string, 5115 second_button_id ResponseType) (*FileChooserDialog, error) { 5116 5117 var w *C.GtkWindow = nil 5118 if parent != nil { 5119 w = parent.toWindow() 5120 } 5121 5122 c_title := C.CString(title) 5123 defer C.free(unsafe.Pointer(c_title)) 5124 c_first_button_text := C.CString(first_button_text) 5125 defer C.free(unsafe.Pointer(c_first_button_text)) 5126 c_second_button_text := C.CString(second_button_text) 5127 defer C.free(unsafe.Pointer(c_second_button_text)) 5128 c := C.gtk_file_chooser_dialog_new_2( 5129 (*C.gchar)(c_title), w, C.GtkFileChooserAction(action), 5130 (*C.gchar)(c_first_button_text), C.int(first_button_id), 5131 (*C.gchar)(c_second_button_text), C.int(second_button_id)) 5132 if c == nil { 5133 return nil, nilPtrErr 5134 } 5135 obj := glib.Take(unsafe.Pointer(c)) 5136 return wrapFileChooserDialog(obj), nil 5137} 5138 5139/* 5140 * GtkFileChooserWidget 5141 */ 5142 5143// FileChooserWidget is a representation of GTK's GtkFileChooserWidget. 5144type FileChooserWidget struct { 5145 Box 5146 5147 // Interfaces 5148 FileChooser 5149} 5150 5151// native returns a pointer to the underlying GtkFileChooserWidget. 5152func (v *FileChooserWidget) native() *C.GtkFileChooserWidget { 5153 if v == nil || v.GObject == nil { 5154 return nil 5155 } 5156 p := unsafe.Pointer(v.GObject) 5157 return C.toGtkFileChooserWidget(p) 5158} 5159 5160func marshalFileChooserWidget(p uintptr) (interface{}, error) { 5161 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 5162 obj := glib.Take(unsafe.Pointer(c)) 5163 return wrapFileChooserWidget(obj), nil 5164} 5165 5166func wrapFileChooserWidget(obj *glib.Object) *FileChooserWidget { 5167 if obj == nil { 5168 return nil 5169 } 5170 5171 fc := wrapFileChooser(obj) 5172 return &FileChooserWidget{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}, *fc} 5173} 5174 5175// FileChooserWidgetNew is a wrapper around gtk_file_chooser_widget_new(). 5176func FileChooserWidgetNew(action FileChooserAction) (*FileChooserWidget, error) { 5177 c := C.gtk_file_chooser_widget_new((C.GtkFileChooserAction)(action)) 5178 if c == nil { 5179 return nil, nilPtrErr 5180 } 5181 obj := glib.Take(unsafe.Pointer(c)) 5182 return wrapFileChooserWidget(obj), nil 5183} 5184 5185/* 5186 * GtkFileFilter 5187 */ 5188 5189// FileChoser is a representation of GTK's GtkFileFilter GInterface. 5190type FileFilter struct { 5191 *glib.Object 5192} 5193 5194// native returns a pointer to the underlying GObject as a GtkFileFilter. 5195func (v *FileFilter) native() *C.GtkFileFilter { 5196 if v == nil || v.GObject == nil { 5197 return nil 5198 } 5199 p := unsafe.Pointer(v.GObject) 5200 return C.toGtkFileFilter(p) 5201} 5202 5203func marshalFileFilter(p uintptr) (interface{}, error) { 5204 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 5205 obj := glib.Take(unsafe.Pointer(c)) 5206 return wrapFileFilter(obj), nil 5207} 5208 5209func wrapFileFilter(obj *glib.Object) *FileFilter { 5210 if obj == nil { 5211 return nil 5212 } 5213 5214 return &FileFilter{obj} 5215} 5216 5217// FileFilterNew is a wrapper around gtk_file_filter_new(). 5218func FileFilterNew() (*FileFilter, error) { 5219 c := C.gtk_file_filter_new() 5220 if c == nil { 5221 return nil, nilPtrErr 5222 } 5223 obj := glib.Take(unsafe.Pointer(c)) 5224 return wrapFileFilter(obj), nil 5225} 5226 5227// SetName is a wrapper around gtk_file_filter_set_name(). 5228func (v *FileFilter) SetName(name string) { 5229 cstr := C.CString(name) 5230 defer C.free(unsafe.Pointer(cstr)) 5231 C.gtk_file_filter_set_name(v.native(), (*C.gchar)(cstr)) 5232} 5233 5234// GetName is a wrapper around gtk_file_filter_get_name(). 5235func (v *FileFilter) GetName() (name string) { 5236 cstr := C.gtk_file_filter_get_name(v.native()) 5237 if cstr != nil { 5238 name = goString(cstr) 5239 } 5240 return 5241} 5242 5243// AddMimeType is a wrapper around gtk_file_filter_add_mime_type(). 5244func (v *FileFilter) AddMimeType(mimeType string) { 5245 cstr := C.CString(mimeType) 5246 defer C.free(unsafe.Pointer(cstr)) 5247 C.gtk_file_filter_add_mime_type(v.native(), (*C.gchar)(cstr)) 5248} 5249 5250// AddPattern is a wrapper around gtk_file_filter_add_pattern(). 5251func (v *FileFilter) AddPattern(pattern string) { 5252 cstr := C.CString(pattern) 5253 defer C.free(unsafe.Pointer(cstr)) 5254 C.gtk_file_filter_add_pattern(v.native(), (*C.gchar)(cstr)) 5255} 5256 5257// AddPixbufFormats is a wrapper around gtk_file_filter_add_pixbuf_formats(). 5258func (v *FileFilter) AddPixbufFormats() { 5259 C.gtk_file_filter_add_pixbuf_formats(v.native()) 5260} 5261 5262/* 5263 * GtkFrame 5264 */ 5265 5266// Frame is a representation of GTK's GtkFrame. 5267type Frame struct { 5268 Bin 5269} 5270 5271// native returns a pointer to the underlying GtkFrame. 5272func (v *Frame) native() *C.GtkFrame { 5273 if v == nil || v.GObject == nil { 5274 return nil 5275 } 5276 p := unsafe.Pointer(v.GObject) 5277 return C.toGtkFrame(p) 5278} 5279 5280func marshalFrame(p uintptr) (interface{}, error) { 5281 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 5282 obj := glib.Take(unsafe.Pointer(c)) 5283 return wrapFrame(obj), nil 5284} 5285 5286func wrapFrame(obj *glib.Object) *Frame { 5287 if obj == nil { 5288 return nil 5289 } 5290 5291 return &Frame{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} 5292} 5293 5294// FrameNew is a wrapper around gtk_frame_new(). 5295func FrameNew(label string) (*Frame, error) { 5296 var cstr *C.char 5297 if label != "" { 5298 cstr = C.CString(label) 5299 defer C.free(unsafe.Pointer(cstr)) 5300 } 5301 c := C.gtk_frame_new((*C.gchar)(cstr)) 5302 if c == nil { 5303 return nil, nilPtrErr 5304 } 5305 obj := glib.Take(unsafe.Pointer(c)) 5306 return wrapFrame(obj), nil 5307} 5308 5309// SetLabel is a wrapper around gtk_frame_set_label(). 5310func (v *Frame) SetLabel(label string) { 5311 cstr := C.CString(label) 5312 defer C.free(unsafe.Pointer(cstr)) 5313 C.gtk_frame_set_label(v.native(), (*C.gchar)(cstr)) 5314} 5315 5316// SetLabelWidget is a wrapper around gtk_frame_set_label_widget(). 5317func (v *Frame) SetLabelWidget(labelWidget IWidget) { 5318 C.gtk_frame_set_label_widget(v.native(), labelWidget.toWidget()) 5319} 5320 5321// SetLabelAlign is a wrapper around gtk_frame_set_label_align(). 5322func (v *Frame) SetLabelAlign(xAlign, yAlign float32) { 5323 C.gtk_frame_set_label_align(v.native(), C.gfloat(xAlign), 5324 C.gfloat(yAlign)) 5325} 5326 5327// SetShadowType is a wrapper around gtk_frame_set_shadow_type(). 5328func (v *Frame) SetShadowType(t ShadowType) { 5329 C.gtk_frame_set_shadow_type(v.native(), C.GtkShadowType(t)) 5330} 5331 5332// GetLabel is a wrapper around gtk_frame_get_label(). 5333func (v *Frame) GetLabel() string { 5334 c := C.gtk_frame_get_label(v.native()) 5335 return goString(c) 5336} 5337 5338// GetLabelAlign is a wrapper around gtk_frame_get_label_align(). 5339func (v *Frame) GetLabelAlign() (xAlign, yAlign float32) { 5340 var x, y C.gfloat 5341 C.gtk_frame_get_label_align(v.native(), &x, &y) 5342 return float32(x), float32(y) 5343} 5344 5345// GetLabelWidget is a wrapper around gtk_frame_get_label_widget(). 5346func (v *Frame) GetLabelWidget() (IWidget, error) { 5347 c := C.gtk_frame_get_label_widget(v.native()) 5348 if c == nil { 5349 return nil, nil 5350 } 5351 return castWidget(c) 5352} 5353 5354// GetShadowType is a wrapper around gtk_frame_get_shadow_type(). 5355func (v *Frame) GetShadowType() ShadowType { 5356 c := C.gtk_frame_get_shadow_type(v.native()) 5357 return ShadowType(c) 5358} 5359 5360/* 5361 * GtkAspectFrame 5362 */ 5363 5364// AspectFrame is a representation of GTK's GtkAspectFrame. 5365type AspectFrame struct { 5366 Frame 5367} 5368 5369// native returns a pointer to the underlying GtkAspectFrame. 5370func (v *AspectFrame) native() *C.GtkAspectFrame { 5371 if v == nil || v.GObject == nil { 5372 return nil 5373 } 5374 p := unsafe.Pointer(v.GObject) 5375 return C.toGtkAspectFrame(p) 5376} 5377 5378func marshalAspectFrame(p uintptr) (interface{}, error) { 5379 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 5380 obj := glib.Take(unsafe.Pointer(c)) 5381 return wrapAspectFrame(obj), nil 5382} 5383 5384func wrapAspectFrame(obj *glib.Object) *AspectFrame { 5385 if obj == nil { 5386 return nil 5387 } 5388 5389 return &AspectFrame{Frame{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} 5390} 5391 5392// AspectFrameNew is a wrapper around gtk_aspect_frame_new(). 5393func AspectFrameNew(label string, xalign, yalign, ratio float32, obeyChild bool) (*AspectFrame, error) { 5394 var cstr *C.char 5395 if label != "" { 5396 cstr = C.CString(label) 5397 defer C.free(unsafe.Pointer(cstr)) 5398 } 5399 c := C.gtk_aspect_frame_new((*C.gchar)(cstr), (C.gfloat)(xalign), (C.gfloat)(yalign), (C.gfloat)(ratio), gbool(obeyChild)) 5400 if c == nil { 5401 return nil, nilPtrErr 5402 } 5403 obj := glib.Take(unsafe.Pointer(c)) 5404 return wrapAspectFrame(obj), nil 5405} 5406 5407// TODO: 5408// gtk_aspect_frame_set(). 5409 5410/* 5411 * GtkGrid 5412 */ 5413 5414// Grid is a representation of GTK's GtkGrid. 5415type Grid struct { 5416 Container 5417 5418 // Interfaces 5419 Orientable 5420} 5421 5422// native returns a pointer to the underlying GtkGrid. 5423func (v *Grid) native() *C.GtkGrid { 5424 if v == nil || v.GObject == nil { 5425 return nil 5426 } 5427 p := unsafe.Pointer(v.GObject) 5428 return C.toGtkGrid(p) 5429} 5430 5431func (v *Grid) toOrientable() *C.GtkOrientable { 5432 if v == nil { 5433 return nil 5434 } 5435 return C.toGtkOrientable(unsafe.Pointer(v.GObject)) 5436} 5437 5438func marshalGrid(p uintptr) (interface{}, error) { 5439 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 5440 obj := glib.Take(unsafe.Pointer(c)) 5441 return wrapGrid(obj), nil 5442} 5443 5444func wrapGrid(obj *glib.Object) *Grid { 5445 if obj == nil { 5446 return nil 5447 } 5448 5449 o := wrapOrientable(obj) 5450 return &Grid{Container{Widget{glib.InitiallyUnowned{obj}}}, *o} 5451} 5452 5453// GridNew() is a wrapper around gtk_grid_new(). 5454func GridNew() (*Grid, error) { 5455 c := C.gtk_grid_new() 5456 if c == nil { 5457 return nil, nilPtrErr 5458 } 5459 obj := glib.Take(unsafe.Pointer(c)) 5460 return wrapGrid(obj), nil 5461} 5462 5463// Attach() is a wrapper around gtk_grid_attach(). 5464func (v *Grid) Attach(child IWidget, left, top, width, height int) { 5465 C.gtk_grid_attach(v.native(), child.toWidget(), C.gint(left), 5466 C.gint(top), C.gint(width), C.gint(height)) 5467} 5468 5469// AttachNextTo() is a wrapper around gtk_grid_attach_next_to(). 5470func (v *Grid) AttachNextTo(child, sibling IWidget, side PositionType, width, height int) { 5471 C.gtk_grid_attach_next_to(v.native(), child.toWidget(), 5472 sibling.toWidget(), C.GtkPositionType(side), C.gint(width), 5473 C.gint(height)) 5474} 5475 5476// GetChildAt() is a wrapper around gtk_grid_get_child_at(). 5477func (v *Grid) GetChildAt(left, top int) (IWidget, error) { 5478 c := C.gtk_grid_get_child_at(v.native(), C.gint(left), C.gint(top)) 5479 if c == nil { 5480 return nil, nil 5481 } 5482 return castWidget(c) 5483} 5484 5485// InsertRow() is a wrapper around gtk_grid_insert_row(). 5486func (v *Grid) InsertRow(position int) { 5487 C.gtk_grid_insert_row(v.native(), C.gint(position)) 5488} 5489 5490// InsertColumn() is a wrapper around gtk_grid_insert_column(). 5491func (v *Grid) InsertColumn(position int) { 5492 C.gtk_grid_insert_column(v.native(), C.gint(position)) 5493} 5494 5495// InsertNextTo() is a wrapper around gtk_grid_insert_next_to() 5496func (v *Grid) InsertNextTo(sibling IWidget, side PositionType) { 5497 C.gtk_grid_insert_next_to(v.native(), sibling.toWidget(), 5498 C.GtkPositionType(side)) 5499} 5500 5501// SetRowHomogeneous() is a wrapper around gtk_grid_set_row_homogeneous(). 5502func (v *Grid) SetRowHomogeneous(homogeneous bool) { 5503 C.gtk_grid_set_row_homogeneous(v.native(), gbool(homogeneous)) 5504} 5505 5506// GetRowHomogeneous() is a wrapper around gtk_grid_get_row_homogeneous(). 5507func (v *Grid) GetRowHomogeneous() bool { 5508 c := C.gtk_grid_get_row_homogeneous(v.native()) 5509 return gobool(c) 5510} 5511 5512// SetRowSpacing() is a wrapper around gtk_grid_set_row_spacing(). 5513func (v *Grid) SetRowSpacing(spacing uint) { 5514 C.gtk_grid_set_row_spacing(v.native(), C.guint(spacing)) 5515} 5516 5517// GetRowSpacing() is a wrapper around gtk_grid_get_row_spacing(). 5518func (v *Grid) GetRowSpacing() uint { 5519 c := C.gtk_grid_get_row_spacing(v.native()) 5520 return uint(c) 5521} 5522 5523// SetColumnHomogeneous() is a wrapper around gtk_grid_set_column_homogeneous(). 5524func (v *Grid) SetColumnHomogeneous(homogeneous bool) { 5525 C.gtk_grid_set_column_homogeneous(v.native(), gbool(homogeneous)) 5526} 5527 5528// GetColumnHomogeneous() is a wrapper around gtk_grid_get_column_homogeneous(). 5529func (v *Grid) GetColumnHomogeneous() bool { 5530 c := C.gtk_grid_get_column_homogeneous(v.native()) 5531 return gobool(c) 5532} 5533 5534// SetColumnSpacing() is a wrapper around gtk_grid_set_column_spacing(). 5535func (v *Grid) SetColumnSpacing(spacing uint) { 5536 C.gtk_grid_set_column_spacing(v.native(), C.guint(spacing)) 5537} 5538 5539// GetColumnSpacing() is a wrapper around gtk_grid_get_column_spacing(). 5540func (v *Grid) GetColumnSpacing() uint { 5541 c := C.gtk_grid_get_column_spacing(v.native()) 5542 return uint(c) 5543} 5544 5545/* 5546 * GtkIconTheme 5547 */ 5548 5549// IconTheme is a representation of GTK's GtkIconTheme 5550type IconTheme struct { 5551 Theme *C.GtkIconTheme 5552} 5553 5554// IconThemeGetDefault is a wrapper around gtk_icon_theme_get_default(). 5555func IconThemeGetDefault() (*IconTheme, error) { 5556 c := C.gtk_icon_theme_get_default() 5557 if c == nil { 5558 return nil, nilPtrErr 5559 } 5560 return &IconTheme{c}, nil 5561} 5562 5563// IconThemeGetForScreen is a wrapper around gtk_icon_theme_get_for_screen(). 5564func IconThemeGetForScreen(screen gdk.Screen) (*IconTheme, error) { 5565 cScreen := (*C.GdkScreen)(unsafe.Pointer(screen.Native())) 5566 c := C.gtk_icon_theme_get_for_screen(cScreen) 5567 if c == nil { 5568 return nil, nilPtrErr 5569 } 5570 return &IconTheme{c}, nil 5571} 5572 5573// LoadIcon is a wrapper around gtk_icon_theme_load_icon(). 5574func (v *IconTheme) LoadIcon(iconName string, size int, flags IconLookupFlags) (*gdk.Pixbuf, error) { 5575 cstr := C.CString(iconName) 5576 defer C.free(unsafe.Pointer(cstr)) 5577 var err *C.GError = nil 5578 c := C.gtk_icon_theme_load_icon(v.Theme, (*C.gchar)(cstr), C.gint(size), C.GtkIconLookupFlags(flags), &err) 5579 if c == nil { 5580 defer C.g_error_free(err) 5581 return nil, errors.New(goString(err.message)) 5582 } 5583 return &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))}, nil 5584} 5585 5586// HasIcon is a wrapper around gtk_icon_theme_has_icon(). 5587func (v *IconTheme) HasIcon(iconName string) bool { 5588 cstr := C.CString(iconName) 5589 defer C.free(unsafe.Pointer(cstr)) 5590 5591 c := C.gtk_icon_theme_has_icon(v.Theme, (*C.gchar)(cstr)) 5592 return gobool(c) 5593} 5594 5595/* 5596 * GtkImage 5597 */ 5598 5599// Image is a representation of GTK's GtkImage. 5600type Image struct { 5601 Widget 5602} 5603 5604// native returns a pointer to the underlying GtkImage. 5605func (v *Image) native() *C.GtkImage { 5606 if v == nil || v.GObject == nil { 5607 return nil 5608 } 5609 p := unsafe.Pointer(v.GObject) 5610 return C.toGtkImage(p) 5611} 5612 5613func marshalImage(p uintptr) (interface{}, error) { 5614 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 5615 obj := glib.Take(unsafe.Pointer(c)) 5616 return wrapImage(obj), nil 5617} 5618 5619func wrapImage(obj *glib.Object) *Image { 5620 if obj == nil { 5621 return nil 5622 } 5623 5624 return &Image{Widget{glib.InitiallyUnowned{obj}}} 5625} 5626 5627// ImageNew() is a wrapper around gtk_image_new(). 5628func ImageNew() (*Image, error) { 5629 c := C.gtk_image_new() 5630 if c == nil { 5631 return nil, nilPtrErr 5632 } 5633 obj := glib.Take(unsafe.Pointer(c)) 5634 return wrapImage(obj), nil 5635} 5636 5637// ImageNewFromFile() is a wrapper around gtk_image_new_from_file(). 5638func ImageNewFromFile(filename string) (*Image, error) { 5639 cstr := C.CString(filename) 5640 defer C.free(unsafe.Pointer(cstr)) 5641 c := C.gtk_image_new_from_file((*C.gchar)(cstr)) 5642 if c == nil { 5643 return nil, nilPtrErr 5644 } 5645 obj := glib.Take(unsafe.Pointer(c)) 5646 return wrapImage(obj), nil 5647} 5648 5649// ImageNewFromResource() is a wrapper around gtk_image_new_from_resource(). 5650func ImageNewFromResource(resourcePath string) (*Image, error) { 5651 cstr := C.CString(resourcePath) 5652 defer C.free(unsafe.Pointer(cstr)) 5653 c := C.gtk_image_new_from_resource((*C.gchar)(cstr)) 5654 if c == nil { 5655 return nil, nilPtrErr 5656 } 5657 obj := glib.Take(unsafe.Pointer(c)) 5658 return wrapImage(obj), nil 5659} 5660 5661// ImageNewFromPixbuf is a wrapper around gtk_image_new_from_pixbuf(). 5662func ImageNewFromPixbuf(pixbuf *gdk.Pixbuf) (*Image, error) { 5663 c := C.gtk_image_new_from_pixbuf((*C.GdkPixbuf)(pixbuf.NativePrivate())) 5664 if c == nil { 5665 return nil, nilPtrErr 5666 } 5667 obj := glib.Take(unsafe.Pointer(c)) 5668 return wrapImage(obj), nil 5669} 5670 5671// ImageNewFromIconName() is a wrapper around gtk_image_new_from_icon_name(). 5672func ImageNewFromIconName(iconName string, size IconSize) (*Image, error) { 5673 cstr := C.CString(iconName) 5674 defer C.free(unsafe.Pointer(cstr)) 5675 c := C.gtk_image_new_from_icon_name((*C.gchar)(cstr), 5676 C.GtkIconSize(size)) 5677 if c == nil { 5678 return nil, nilPtrErr 5679 } 5680 obj := glib.Take(unsafe.Pointer(c)) 5681 return wrapImage(obj), nil 5682} 5683 5684// ImageNewFromGIcon is a wrapper around gtk_image_new_from_gicon() 5685func ImageNewFromGIcon(icon *glib.Icon, size IconSize) (*Image, error) { 5686 c := C.gtk_image_new_from_gicon( 5687 (*C.GIcon)(icon.NativePrivate()), 5688 C.GtkIconSize(size)) 5689 5690 if c == nil { 5691 return nil, nilPtrErr 5692 } 5693 obj := glib.Take(unsafe.Pointer(c)) 5694 return wrapImage(obj), nil 5695} 5696 5697// Clear() is a wrapper around gtk_image_clear(). 5698func (v *Image) Clear() { 5699 C.gtk_image_clear(v.native()) 5700} 5701 5702// SetFromFile() is a wrapper around gtk_image_set_from_file(). 5703func (v *Image) SetFromFile(filename string) { 5704 cstr := C.CString(filename) 5705 defer C.free(unsafe.Pointer(cstr)) 5706 C.gtk_image_set_from_file(v.native(), (*C.gchar)(cstr)) 5707} 5708 5709// SetFromResource() is a wrapper around gtk_image_set_from_resource(). 5710func (v *Image) SetFromResource(resourcePath string) { 5711 cstr := C.CString(resourcePath) 5712 defer C.free(unsafe.Pointer(cstr)) 5713 C.gtk_image_set_from_resource(v.native(), (*C.gchar)(cstr)) 5714} 5715 5716// SetFromFixbuf is a wrapper around gtk_image_set_from_pixbuf(). 5717func (v *Image) SetFromPixbuf(pixbuf *gdk.Pixbuf) { 5718 pbptr := (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native())) 5719 C.gtk_image_set_from_pixbuf(v.native(), pbptr) 5720} 5721 5722// SetFromIconName() is a wrapper around gtk_image_set_from_icon_name(). 5723func (v *Image) SetFromIconName(iconName string, size IconSize) { 5724 cstr := C.CString(iconName) 5725 defer C.free(unsafe.Pointer(cstr)) 5726 C.gtk_image_set_from_icon_name(v.native(), (*C.gchar)(cstr), 5727 C.GtkIconSize(size)) 5728} 5729 5730// SetFromGIcon is a wrapper around gtk_image_set_from_gicon() 5731func (v *Image) SetFromGIcon(icon *glib.Icon, size IconSize) { 5732 C.gtk_image_set_from_gicon( 5733 v.native(), 5734 (*C.GIcon)(icon.NativePrivate()), 5735 C.GtkIconSize(size)) 5736} 5737 5738// SetPixelSize() is a wrapper around gtk_image_set_pixel_size(). 5739func (v *Image) SetPixelSize(pixelSize int) { 5740 C.gtk_image_set_pixel_size(v.native(), C.gint(pixelSize)) 5741} 5742 5743// GetStorageType() is a wrapper around gtk_image_get_storage_type(). 5744func (v *Image) GetStorageType() ImageType { 5745 c := C.gtk_image_get_storage_type(v.native()) 5746 return ImageType(c) 5747} 5748 5749// GetPixbuf() is a wrapper around gtk_image_get_pixbuf(). 5750func (v *Image) GetPixbuf() *gdk.Pixbuf { 5751 c := C.gtk_image_get_pixbuf(v.native()) 5752 if c == nil { 5753 return nil 5754 } 5755 5756 pb := &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))} 5757 return pb 5758} 5759 5760// GetAnimation() is a wrapper around gtk_image_get_animation() 5761func (v *Image) GetAnimation() *gdk.PixbufAnimation { 5762 c := C.gtk_image_get_animation(v.native()) 5763 if c == nil { 5764 return nil 5765 } 5766 return &gdk.PixbufAnimation{glib.Take(unsafe.Pointer(c))} 5767} 5768 5769// ImageNewFromAnimation() is a wrapper around gtk_image_new_from_animation() 5770func ImageNewFromAnimation(animation *gdk.PixbufAnimation) (*Image, error) { 5771 c := C.gtk_image_new_from_animation((*C.GdkPixbufAnimation)(animation.NativePrivate())) 5772 if c == nil { 5773 return nil, nilPtrErr 5774 } 5775 obj := glib.Take(unsafe.Pointer(c)) 5776 return wrapImage(obj), nil 5777} 5778 5779// SetFromAnimation is a wrapper around gtk_image_set_from_animation(). 5780func (v *Image) SetFromAnimation(animation *gdk.PixbufAnimation) { 5781 pbaptr := (*C.GdkPixbufAnimation)(unsafe.Pointer(animation.NativePrivate())) 5782 C.gtk_image_set_from_animation(v.native(), pbaptr) 5783} 5784 5785// GetIconName() is a wrapper around gtk_image_get_icon_name(). 5786func (v *Image) GetIconName() (string, IconSize) { 5787 var iconName *C.gchar 5788 var size C.GtkIconSize 5789 C.gtk_image_get_icon_name(v.native(), &iconName, &size) 5790 return goString(iconName), IconSize(size) 5791} 5792 5793// GetGIcon is a wrapper around gtk_image_get_gicon() 5794func (v *Image) GetGIcon() (*glib.Icon, IconSize, error) { 5795 var gicon *C.GIcon 5796 var size *C.GtkIconSize 5797 C.gtk_image_get_gicon( 5798 v.native(), 5799 &gicon, 5800 size) 5801 5802 if gicon == nil { 5803 return nil, ICON_SIZE_INVALID, nilPtrErr 5804 } 5805 5806 obj := &glib.Object{glib.ToGObject(unsafe.Pointer(gicon))} 5807 i := &glib.Icon{obj} 5808 5809 runtime.SetFinalizer(i, func(_ interface{}) { obj.Unref() }) 5810 return i, IconSize(*size), nil 5811} 5812 5813// GetPixelSize() is a wrapper around gtk_image_get_pixel_size(). 5814func (v *Image) GetPixelSize() int { 5815 c := C.gtk_image_get_pixel_size(v.native()) 5816 return int(c) 5817} 5818 5819// added by terrak 5820/* 5821 * GtkLayout 5822 */ 5823 5824// Layout is a representation of GTK's GtkLayout. 5825type Layout struct { 5826 Container 5827} 5828 5829// native returns a pointer to the underlying GtkDrawingArea. 5830func (v *Layout) native() *C.GtkLayout { 5831 if v == nil || v.GObject == nil { 5832 return nil 5833 } 5834 p := unsafe.Pointer(v.GObject) 5835 return C.toGtkLayout(p) 5836} 5837 5838func marshalLayout(p uintptr) (interface{}, error) { 5839 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 5840 obj := glib.Take(unsafe.Pointer(c)) 5841 return wrapLayout(obj), nil 5842} 5843 5844func wrapLayout(obj *glib.Object) *Layout { 5845 if obj == nil { 5846 return nil 5847 } 5848 5849 return &Layout{Container{Widget{glib.InitiallyUnowned{obj}}}} 5850} 5851 5852// LayoutNew is a wrapper around gtk_layout_new(). 5853func LayoutNew(hadjustment, vadjustment *Adjustment) (*Layout, error) { 5854 c := C.gtk_layout_new(hadjustment.native(), vadjustment.native()) 5855 if c == nil { 5856 return nil, nilPtrErr 5857 } 5858 obj := glib.Take(unsafe.Pointer(c)) 5859 return wrapLayout(obj), nil 5860} 5861 5862// Layout.Put is a wrapper around gtk_layout_put(). 5863func (v *Layout) Put(w IWidget, x, y int) { 5864 C.gtk_layout_put(v.native(), w.toWidget(), C.gint(x), C.gint(y)) 5865} 5866 5867// Layout.Move is a wrapper around gtk_layout_move(). 5868func (v *Layout) Move(w IWidget, x, y int) { 5869 C.gtk_layout_move(v.native(), w.toWidget(), C.gint(x), C.gint(y)) 5870} 5871 5872// Layout.SetSize is a wrapper around gtk_layout_set_size 5873func (v *Layout) SetSize(width, height uint) { 5874 C.gtk_layout_set_size(v.native(), C.guint(width), C.guint(height)) 5875} 5876 5877// Layout.GetSize is a wrapper around gtk_layout_get_size 5878func (v *Layout) GetSize() (width, height uint) { 5879 var w, h C.guint 5880 C.gtk_layout_get_size(v.native(), &w, &h) 5881 return uint(w), uint(h) 5882} 5883 5884// TODO: 5885// gtk_layout_get_bin_window(). 5886 5887/* 5888 * GtkLinkButton 5889 */ 5890 5891// LinkButton is a representation of GTK's GtkLinkButton. 5892type LinkButton struct { 5893 Button 5894} 5895 5896// native returns a pointer to the underlying GtkLinkButton. 5897func (v *LinkButton) native() *C.GtkLinkButton { 5898 if v == nil || v.GObject == nil { 5899 return nil 5900 } 5901 p := unsafe.Pointer(v.GObject) 5902 return C.toGtkLinkButton(p) 5903} 5904 5905func marshalLinkButton(p uintptr) (interface{}, error) { 5906 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 5907 obj := glib.Take(unsafe.Pointer(c)) 5908 return wrapLinkButton(obj), nil 5909} 5910 5911func wrapLinkButton(obj *glib.Object) *LinkButton { 5912 if obj == nil { 5913 return nil 5914 } 5915 5916 actionable := wrapActionable(obj) 5917 return &LinkButton{Button{Bin{Container{Widget{ 5918 glib.InitiallyUnowned{obj}}}}, actionable}} 5919} 5920 5921// LinkButtonNew is a wrapper around gtk_link_button_new(). 5922func LinkButtonNew(label string) (*LinkButton, error) { 5923 cstr := C.CString(label) 5924 defer C.free(unsafe.Pointer(cstr)) 5925 c := C.gtk_link_button_new((*C.gchar)(cstr)) 5926 if c == nil { 5927 return nil, nilPtrErr 5928 } 5929 return wrapLinkButton(glib.Take(unsafe.Pointer(c))), nil 5930} 5931 5932// LinkButtonNewWithLabel is a wrapper around gtk_link_button_new_with_label(). 5933func LinkButtonNewWithLabel(uri, label string) (*LinkButton, error) { 5934 curi := C.CString(uri) 5935 defer C.free(unsafe.Pointer(curi)) 5936 clabel := C.CString(label) 5937 defer C.free(unsafe.Pointer(clabel)) 5938 c := C.gtk_link_button_new_with_label((*C.gchar)(curi), (*C.gchar)(clabel)) 5939 if c == nil { 5940 return nil, nilPtrErr 5941 } 5942 return wrapLinkButton(glib.Take(unsafe.Pointer(c))), nil 5943} 5944 5945// GetUri is a wrapper around gtk_link_button_get_uri(). 5946func (v *LinkButton) GetUri() string { 5947 c := C.gtk_link_button_get_uri(v.native()) 5948 return goString(c) 5949} 5950 5951// SetUri is a wrapper around gtk_link_button_set_uri(). 5952func (v *LinkButton) SetUri(uri string) { 5953 cstr := C.CString(uri) 5954 C.gtk_link_button_set_uri(v.native(), (*C.gchar)(cstr)) 5955} 5956 5957// GetVisited is a wrapper around gtk_link_button_get_visited(). 5958func (v *LinkButton) GetVisited() bool { 5959 c := C.gtk_link_button_get_visited(v.native()) 5960 return gobool(c) 5961} 5962 5963// SetVisited is a wrapper around gtk_link_button_set_visited(). 5964func (v *LinkButton) SetVisited(visited bool) { 5965 C.gtk_link_button_set_visited(v.native(), gbool(visited)) 5966} 5967 5968/* 5969 * GtkLockButton 5970 */ 5971 5972// LockButton is a representation of GTK's GtkLockButton. 5973type LockButton struct { 5974 Button 5975} 5976 5977// native returns a pointer to the underlying GtkLockButton. 5978func (v *LockButton) native() *C.GtkLockButton { 5979 if v == nil || v.GObject == nil { 5980 return nil 5981 } 5982 p := unsafe.Pointer(v.GObject) 5983 return C.toGtkLockButton(p) 5984} 5985 5986func marshalLockButton(p uintptr) (interface{}, error) { 5987 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 5988 obj := glib.Take(unsafe.Pointer(c)) 5989 return wrapLockButton(obj), nil 5990} 5991 5992func wrapLockButton(obj *glib.Object) *LockButton { 5993 if obj == nil { 5994 return nil 5995 } 5996 5997 actionable := wrapActionable(obj) 5998 return &LockButton{Button{Bin{Container{Widget{ 5999 glib.InitiallyUnowned{obj}}}}, actionable}} 6000} 6001 6002// LockButtonNew is a wrapper around gtk_lock_button_new(). 6003func LockButtonNew(permission *glib.Permission) (*LockButton, error) { 6004 c := C.gtk_lock_button_new(nativeGPermission(permission)) 6005 if c == nil { 6006 return nil, nilPtrErr 6007 } 6008 return wrapLockButton(glib.Take(unsafe.Pointer(c))), nil 6009} 6010 6011// GetPermission is a wrapper around gtk_lock_button_get_permission(). 6012func (v *LockButton) GetPermission() *glib.Permission { 6013 c := C.gtk_lock_button_get_permission(v.native()) 6014 return glib.WrapPermission(unsafe.Pointer(c)) 6015} 6016 6017// SetPermission is a wrapper around gtk_lock_button_set_permission(). 6018func (v *LockButton) SetPermission(permission *glib.Permission) { 6019 C.gtk_lock_button_set_permission(v.native(), nativeGPermission(permission)) 6020} 6021 6022/* 6023 * GtkListStore 6024 */ 6025 6026// ListStore is a representation of GTK's GtkListStore. 6027type ListStore struct { 6028 *glib.Object 6029 6030 // Interfaces 6031 TreeModel 6032 TreeSortable 6033} 6034 6035// native returns a pointer to the underlying GtkListStore. 6036func (v *ListStore) native() *C.GtkListStore { 6037 if v == nil || v.GObject == nil { 6038 return nil 6039 } 6040 p := unsafe.Pointer(v.GObject) 6041 return C.toGtkListStore(p) 6042} 6043 6044func marshalListStore(p uintptr) (interface{}, error) { 6045 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 6046 obj := glib.Take(unsafe.Pointer(c)) 6047 return wrapListStore(obj), nil 6048} 6049 6050func wrapListStore(obj *glib.Object) *ListStore { 6051 if obj == nil { 6052 return nil 6053 } 6054 6055 tm := wrapTreeModel(obj) 6056 ts := wrapTreeSortable(obj) 6057 return &ListStore{obj, *tm, *ts} 6058} 6059 6060func (v *ListStore) toTreeModel() *C.GtkTreeModel { 6061 if v == nil { 6062 return nil 6063 } 6064 return C.toGtkTreeModel(unsafe.Pointer(v.GObject)) 6065} 6066 6067func (v *ListStore) toTreeSortable() *C.GtkTreeSortable { 6068 if v == nil { 6069 return nil 6070 } 6071 return C.toGtkTreeSortable(unsafe.Pointer(v.GObject)) 6072} 6073 6074// ListStoreNew is a wrapper around gtk_list_store_newv(). 6075func ListStoreNew(types ...glib.Type) (*ListStore, error) { 6076 gtypes := C.alloc_types(C.int(len(types))) 6077 for n, val := range types { 6078 C.set_type(gtypes, C.int(n), C.GType(val)) 6079 } 6080 defer C.g_free(C.gpointer(gtypes)) 6081 c := C.gtk_list_store_newv(C.gint(len(types)), gtypes) 6082 if c == nil { 6083 return nil, nilPtrErr 6084 } 6085 6086 ls := wrapListStore(glib.Take(unsafe.Pointer(c))) 6087 return ls, nil 6088} 6089 6090// Remove is a wrapper around gtk_list_store_remove(). 6091func (v *ListStore) Remove(iter *TreeIter) bool { 6092 c := C.gtk_list_store_remove(v.native(), iter.native()) 6093 return gobool(c) 6094} 6095 6096// SetColumnTypes is a wrapper around gtk_list_store_set_column_types(). 6097// The size of glib.Type must match the number of columns 6098func (v *ListStore) SetColumnTypes(types ...glib.Type) { 6099 gtypes := C.alloc_types(C.int(len(types))) 6100 for n, val := range types { 6101 C.set_type(gtypes, C.int(n), C.GType(val)) 6102 } 6103 defer C.g_free(C.gpointer(gtypes)) 6104 C.gtk_list_store_set_column_types(v.native(), C.gint(len(types)), gtypes) 6105} 6106 6107// Set() is a wrapper around gtk_list_store_set_value() but provides 6108// a function similar to gtk_list_store_set() in that multiple columns 6109// may be set by one call. The length of columns and values slices must 6110// match, or Set() will return a non-nil error. 6111// 6112// As an example, a call to: 6113// store.Set(iter, []int{0, 1}, []interface{}{"Foo", "Bar"}) 6114// is functionally equivalent to calling the native C GTK function: 6115// gtk_list_store_set(store, iter, 0, "Foo", 1, "Bar", -1); 6116func (v *ListStore) Set(iter *TreeIter, columns []int, values []interface{}) error { 6117 if len(columns) != len(values) { 6118 return errors.New("columns and values lengths do not match") 6119 } 6120 for i, val := range values { 6121 v.SetValue(iter, columns[i], val) 6122 } 6123 return nil 6124} 6125 6126// SetValue is a wrapper around gtk_list_store_set_value(). 6127func (v *ListStore) SetValue(iter *TreeIter, column int, value interface{}) error { 6128 switch value.(type) { 6129 case *gdk.Pixbuf: 6130 pix := value.(*gdk.Pixbuf) 6131 C._gtk_list_store_set(v.native(), iter.native(), C.gint(column), unsafe.Pointer(pix.Native())) 6132 6133 default: 6134 gv, err := glib.GValue(value) 6135 if err != nil { 6136 return err 6137 } 6138 6139 C.gtk_list_store_set_value(v.native(), iter.native(), 6140 C.gint(column), 6141 (*C.GValue)(unsafe.Pointer(gv.Native()))) 6142 } 6143 6144 return nil 6145} 6146 6147// func (v *ListStore) Model(model ITreeModel) { 6148// obj := &glib.Object{glib.ToGObject(unsafe.Pointer(model.toTreeModel()))} 6149// v.TreeModel = *wrapTreeModel(obj) 6150//} 6151 6152func (v *ListStore) SetCols(iter *TreeIter, cols Cols) error { 6153 for key, value := range cols { 6154 err := v.SetValue(iter, key, value) 6155 if err != nil { 6156 return err 6157 } 6158 } 6159 return nil 6160} 6161 6162// Convenient map for Columns and values (See ListStore, TreeStore) 6163type Cols map[int]interface{} 6164 6165// InsertWithValues() is a wrapper around gtk_list_store_insert_with_valuesv(). 6166func (v *ListStore) InsertWithValues(iter *TreeIter, position int, inColumns []int, inValues []interface{}) error { 6167 length := len(inColumns) 6168 if len(inValues) < length { 6169 length = len(inValues) 6170 } 6171 6172 var cColumns []C.gint 6173 var cValues []C.GValue 6174 for i := 0; i < length; i++ { 6175 cColumns = append(cColumns, C.gint(inColumns[i])) 6176 6177 gv, err := glib.GValue(inValues[i]) 6178 if err != nil { 6179 return err 6180 } 6181 6182 var cvp *C.GValue = (*C.GValue)(unsafe.Pointer(gv.Native())) 6183 cValues = append(cValues, *cvp) 6184 } 6185 var cColumnsPointer *C.gint 6186 if len(cColumns) > 0 { 6187 cColumnsPointer = &cColumns[0] 6188 } 6189 var cValuesPointer *C.GValue 6190 if len(cValues) > 0 { 6191 cValuesPointer = &cValues[0] 6192 } 6193 6194 C.gtk_list_store_insert_with_valuesv(v.native(), iter.native(), C.gint(position), cColumnsPointer, cValuesPointer, C.gint(length)) 6195 6196 return nil 6197} 6198 6199// Insert() is a wrapper around gtk_list_store_insert(). 6200func (v *ListStore) Insert(position int) *TreeIter { 6201 var ti C.GtkTreeIter 6202 C.gtk_list_store_insert(v.native(), &ti, C.gint(position)) 6203 iter := &TreeIter{ti} 6204 return iter 6205} 6206 6207// InsertBefore() is a wrapper around gtk_list_store_insert_before(). 6208func (v *ListStore) InsertBefore(sibling *TreeIter) *TreeIter { 6209 var ti C.GtkTreeIter 6210 C.gtk_list_store_insert_before(v.native(), &ti, sibling.native()) 6211 iter := &TreeIter{ti} 6212 return iter 6213} 6214 6215// InsertAfter() is a wrapper around gtk_list_store_insert_after(). 6216func (v *ListStore) InsertAfter(sibling *TreeIter) *TreeIter { 6217 var ti C.GtkTreeIter 6218 C.gtk_list_store_insert_after(v.native(), &ti, sibling.native()) 6219 iter := &TreeIter{ti} 6220 return iter 6221} 6222 6223// Prepend() is a wrapper around gtk_list_store_prepend(). 6224func (v *ListStore) Prepend() *TreeIter { 6225 var ti C.GtkTreeIter 6226 C.gtk_list_store_prepend(v.native(), &ti) 6227 iter := &TreeIter{ti} 6228 return iter 6229} 6230 6231// Append() is a wrapper around gtk_list_store_append(). 6232func (v *ListStore) Append() *TreeIter { 6233 var ti C.GtkTreeIter 6234 C.gtk_list_store_append(v.native(), &ti) 6235 iter := &TreeIter{ti} 6236 return iter 6237} 6238 6239// Clear() is a wrapper around gtk_list_store_clear(). 6240func (v *ListStore) Clear() { 6241 C.gtk_list_store_clear(v.native()) 6242} 6243 6244// IterIsValid() is a wrapper around gtk_list_store_iter_is_valid(). 6245func (v *ListStore) IterIsValid(iter *TreeIter) bool { 6246 c := C.gtk_list_store_iter_is_valid(v.native(), iter.native()) 6247 return gobool(c) 6248} 6249 6250// TODO(jrick) 6251/* 6252func (v *ListStore) Reorder(newOrder []int) { 6253} 6254*/ 6255 6256// Swap() is a wrapper around gtk_list_store_swap(). 6257func (v *ListStore) Swap(a, b *TreeIter) { 6258 C.gtk_list_store_swap(v.native(), a.native(), b.native()) 6259} 6260 6261// MoveBefore() is a wrapper around gtk_list_store_move_before(). 6262func (v *ListStore) MoveBefore(iter, position *TreeIter) { 6263 C.gtk_list_store_move_before(v.native(), iter.native(), 6264 position.native()) 6265} 6266 6267// MoveAfter() is a wrapper around gtk_list_store_move_after(). 6268func (v *ListStore) MoveAfter(iter, position *TreeIter) { 6269 C.gtk_list_store_move_after(v.native(), iter.native(), 6270 position.native()) 6271} 6272 6273/* 6274 * GtkMenuBar 6275 */ 6276 6277// MenuBar is a representation of GTK's GtkMenuBar. 6278type MenuBar struct { 6279 MenuShell 6280} 6281 6282// native() returns a pointer to the underlying GtkMenuBar. 6283func (v *MenuBar) native() *C.GtkMenuBar { 6284 if v == nil || v.GObject == nil { 6285 return nil 6286 } 6287 p := unsafe.Pointer(v.GObject) 6288 return C.toGtkMenuBar(p) 6289} 6290 6291func marshalMenuBar(p uintptr) (interface{}, error) { 6292 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 6293 obj := glib.Take(unsafe.Pointer(c)) 6294 return wrapMenuBar(obj), nil 6295} 6296 6297func wrapMenuBar(obj *glib.Object) *MenuBar { 6298 if obj == nil { 6299 return nil 6300 } 6301 6302 return &MenuBar{MenuShell{Container{Widget{glib.InitiallyUnowned{obj}}}}} 6303} 6304 6305// MenuBarNew() is a wrapper around gtk_menu_bar_new(). 6306func MenuBarNew() (*MenuBar, error) { 6307 c := C.gtk_menu_bar_new() 6308 if c == nil { 6309 return nil, nilPtrErr 6310 } 6311 return wrapMenuBar(glib.Take(unsafe.Pointer(c))), nil 6312} 6313 6314/* 6315 * GtkMenuButton 6316 */ 6317 6318// MenuButton is a representation of GTK's GtkMenuButton. 6319type MenuButton struct { 6320 ToggleButton 6321} 6322 6323// native returns a pointer to the underlying GtkMenuButton. 6324func (v *MenuButton) native() *C.GtkMenuButton { 6325 if v == nil || v.GObject == nil { 6326 return nil 6327 } 6328 p := unsafe.Pointer(v.GObject) 6329 return C.toGtkMenuButton(p) 6330} 6331 6332func marshalMenuButton(p uintptr) (interface{}, error) { 6333 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 6334 obj := glib.Take(unsafe.Pointer(c)) 6335 return wrapMenuButton(obj), nil 6336} 6337 6338func wrapMenuButton(obj *glib.Object) *MenuButton { 6339 if obj == nil { 6340 return nil 6341 } 6342 6343 actionable := wrapActionable(obj) 6344 return &MenuButton{ToggleButton{Button{Bin{Container{Widget{ 6345 glib.InitiallyUnowned{obj}}}}, actionable}}} 6346} 6347 6348// MenuButtonNew is a wrapper around gtk_menu_button_new(). 6349func MenuButtonNew() (*MenuButton, error) { 6350 c := C.gtk_menu_button_new() 6351 if c == nil { 6352 return nil, nilPtrErr 6353 } 6354 return wrapMenuButton(glib.Take(unsafe.Pointer(c))), nil 6355} 6356 6357// SetPopup is a wrapper around gtk_menu_button_set_popup(). 6358func (v *MenuButton) SetPopup(menu IMenu) { 6359 C.gtk_menu_button_set_popup(v.native(), menu.toWidget()) 6360} 6361 6362// GetPopup is a wrapper around gtk_menu_button_get_popup(). 6363func (v *MenuButton) GetPopup() *Menu { 6364 c := C.gtk_menu_button_get_popup(v.native()) 6365 if c == nil { 6366 return nil 6367 } 6368 return wrapMenu(glib.Take(unsafe.Pointer(c))) 6369} 6370 6371// SetMenuModel is a wrapper around gtk_menu_button_set_menu_model(). 6372func (v *MenuButton) SetMenuModel(menuModel *glib.MenuModel) { 6373 C.gtk_menu_button_set_menu_model(v.native(), C.toGMenuModel(unsafe.Pointer(menuModel.Native()))) 6374} 6375 6376// GetMenuModel is a wrapper around gtk_menu_button_get_menu_model(). 6377func (v *MenuButton) GetMenuModel() *glib.MenuModel { 6378 c := C.gtk_menu_button_get_menu_model(v.native()) 6379 if c == nil { 6380 return nil 6381 } 6382 return &glib.MenuModel{glib.Take(unsafe.Pointer(c))} 6383} 6384 6385// SetDirection is a wrapper around gtk_menu_button_set_direction(). 6386func (v *MenuButton) SetDirection(direction ArrowType) { 6387 C.gtk_menu_button_set_direction(v.native(), C.GtkArrowType(direction)) 6388} 6389 6390// GetDirection is a wrapper around gtk_menu_button_get_direction(). 6391func (v *MenuButton) GetDirection() ArrowType { 6392 c := C.gtk_menu_button_get_direction(v.native()) 6393 return ArrowType(c) 6394} 6395 6396// SetAlignWidget is a wrapper around gtk_menu_button_set_align_widget(). 6397func (v *MenuButton) SetAlignWidget(alignWidget IWidget) { 6398 C.gtk_menu_button_set_align_widget(v.native(), alignWidget.toWidget()) 6399} 6400 6401// GetAlignWidget is a wrapper around gtk_menu_button_get_align_widget(). 6402func (v *MenuButton) GetAlignWidget() (IWidget, error) { 6403 c := C.gtk_menu_button_get_align_widget(v.native()) 6404 if c == nil { 6405 return nil, nil 6406 } 6407 return castWidget(c) 6408} 6409 6410/* 6411 * GtkMenuItem 6412 */ 6413 6414// MenuItem is a representation of GTK's GtkMenuItem. 6415type MenuItem struct { 6416 Bin 6417} 6418 6419// IMenuItem is an interface type implemented by all structs 6420// embedding a MenuItem. It is meant to be used as an argument type 6421// for wrapper functions that wrap around a C GTK function taking a 6422// GtkMenuItem. 6423type IMenuItem interface { 6424 toMenuItem() *C.GtkMenuItem 6425 toWidget() *C.GtkWidget 6426} 6427 6428// native returns a pointer to the underlying GtkMenuItem. 6429func (v *MenuItem) native() *C.GtkMenuItem { 6430 if v == nil || v.GObject == nil { 6431 return nil 6432 } 6433 p := unsafe.Pointer(v.GObject) 6434 return C.toGtkMenuItem(p) 6435} 6436 6437func (v *MenuItem) toMenuItem() *C.GtkMenuItem { 6438 if v == nil { 6439 return nil 6440 } 6441 return v.native() 6442} 6443 6444func marshalMenuItem(p uintptr) (interface{}, error) { 6445 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 6446 obj := glib.Take(unsafe.Pointer(c)) 6447 return wrapMenuItem(obj), nil 6448} 6449 6450func wrapMenuItem(obj *glib.Object) *MenuItem { 6451 if obj == nil { 6452 return nil 6453 } 6454 6455 return &MenuItem{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} 6456} 6457 6458// MenuItemNew() is a wrapper around gtk_menu_item_new(). 6459func MenuItemNew() (*MenuItem, error) { 6460 c := C.gtk_menu_item_new() 6461 if c == nil { 6462 return nil, nilPtrErr 6463 } 6464 return wrapMenuItem(glib.Take(unsafe.Pointer(c))), nil 6465} 6466 6467// MenuItemNewWithLabel() is a wrapper around gtk_menu_item_new_with_label(). 6468func MenuItemNewWithLabel(label string) (*MenuItem, error) { 6469 cstr := C.CString(label) 6470 defer C.free(unsafe.Pointer(cstr)) 6471 c := C.gtk_menu_item_new_with_label((*C.gchar)(cstr)) 6472 if c == nil { 6473 return nil, nilPtrErr 6474 } 6475 return wrapMenuItem(glib.Take(unsafe.Pointer(c))), nil 6476} 6477 6478// MenuItemNewWithMnemonic() is a wrapper around gtk_menu_item_new_with_mnemonic(). 6479func MenuItemNewWithMnemonic(label string) (*MenuItem, error) { 6480 cstr := C.CString(label) 6481 defer C.free(unsafe.Pointer(cstr)) 6482 c := C.gtk_menu_item_new_with_mnemonic((*C.gchar)(cstr)) 6483 if c == nil { 6484 return nil, nilPtrErr 6485 } 6486 return wrapMenuItem(glib.Take(unsafe.Pointer(c))), nil 6487} 6488 6489// SetSubmenu() is a wrapper around gtk_menu_item_set_submenu(). 6490func (v *MenuItem) SetSubmenu(submenu IWidget) { 6491 C.gtk_menu_item_set_submenu(v.native(), submenu.toWidget()) 6492} 6493 6494// GetSubmenu is a wrapper around gtk_menu_item_get_submenu(). 6495func (v *MenuItem) GetSubmenu() (IMenu, error) { 6496 c := C.gtk_menu_item_get_submenu(v.native()) 6497 if c == nil { 6498 return nil, nilPtrErr 6499 } 6500 obj := glib.Take(unsafe.Pointer(c)) 6501 return wrapMenu(obj), nil 6502} 6503 6504// SetLabel is a wrapper around gtk_menu_item_set_label(). 6505func (v *MenuItem) SetLabel(label string) { 6506 cstr := C.CString(label) 6507 defer C.free(unsafe.Pointer(cstr)) 6508 C.gtk_menu_item_set_label(v.native(), (*C.gchar)(cstr)) 6509} 6510 6511// GetLabel is a wrapper around gtk_menu_item_get_label(). 6512func (v *MenuItem) GetLabel() string { 6513 l := C.gtk_menu_item_get_label(v.native()) 6514 return goString(l) 6515} 6516 6517// SetUseUnderline() is a wrapper around gtk_menu_item_set_use_underline() 6518func (v *MenuItem) SetUseUnderline(settings bool) { 6519 C.gtk_menu_item_set_use_underline(v.native(), gbool(settings)) 6520} 6521 6522// GetUseUnderline() is a wrapper around gtk_menu_item_get_use_underline() 6523func (v *MenuItem) GetUseUnderline() bool { 6524 c := C.gtk_menu_item_get_use_underline(v.native()) 6525 return gobool(c) 6526} 6527 6528// Select is a wrapper around gtk_menu_item_select() 6529func (v *MenuItem) Select() { 6530 C.gtk_menu_item_select(v.native()) 6531} 6532 6533// Deselect is a wrapper around gtk_menu_item_deselect() 6534func (v *MenuItem) Deselect() { 6535 C.gtk_menu_item_deselect(v.native()) 6536} 6537 6538// Activate is a wrapper around gtk_menu_item_activate() 6539func (v *MenuItem) Activate() { 6540 C.gtk_menu_item_activate(v.native()) 6541} 6542 6543// ToggleSizeRequest is a wrapper around gtk_menu_item_toggle_size_request() 6544func (v *MenuItem) ToggleSizeRequest(requisition int) int { 6545 cint := new(C.gint) 6546 *cint = C.gint(requisition) 6547 C.gtk_menu_item_toggle_size_request(v.native(), cint) 6548 return int(*cint) 6549} 6550 6551// ToggleSizeAllocate is a wrapper around gtk_menu_item_toggle_size_allocate() 6552func (v *MenuItem) ToggleSizeAllocate(allocation int) { 6553 C.gtk_menu_item_toggle_size_allocate(v.native(), C.gint(allocation)) 6554} 6555 6556// GetReserveIndicator is a wrapper around gtk_menu_item_get_reserve_indicator(). 6557func (v *MenuItem) GetReserveIndicator() bool { 6558 return gobool(C.gtk_menu_item_get_reserve_indicator(v.native())) 6559} 6560 6561// SetReserveIndicator is a wrapper around gtk_menu_item_set_reserve_indicator(). 6562func (v *MenuItem) SetReserveIndicator(reserve bool) { 6563 C.gtk_menu_item_set_reserve_indicator(v.native(), gbool(reserve)) 6564} 6565 6566/* 6567 * GtkMessageDialog 6568 */ 6569 6570// MessageDialog is a representation of GTK's GtkMessageDialog. 6571type MessageDialog struct { 6572 Dialog 6573} 6574 6575// native returns a pointer to the underlying GtkMessageDialog. 6576func (v *MessageDialog) native() *C.GtkMessageDialog { 6577 if v == nil || v.GObject == nil { 6578 return nil 6579 } 6580 p := unsafe.Pointer(v.GObject) 6581 return C.toGtkMessageDialog(p) 6582} 6583 6584func marshalMessageDialog(p uintptr) (interface{}, error) { 6585 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 6586 obj := glib.Take(unsafe.Pointer(c)) 6587 return wrapMessageDialog(obj), nil 6588} 6589 6590func wrapMessageDialog(obj *glib.Object) *MessageDialog { 6591 if obj == nil { 6592 return nil 6593 } 6594 6595 return &MessageDialog{Dialog{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}}} 6596} 6597 6598// MessageDialogNew() is a wrapper around gtk_message_dialog_new(). 6599// The text is created and formatted by the format specifier and any 6600// additional arguments. 6601func MessageDialogNew(parent IWindow, flags DialogFlags, mType MessageType, buttons ButtonsType, format string, args ...interface{}) *MessageDialog { 6602 s := fmt.Sprintf(format, args...) 6603 cstr := C.CString(s) 6604 defer C.free(unsafe.Pointer(cstr)) 6605 var w *C.GtkWindow = nil 6606 if parent != nil { 6607 w = parent.toWindow() 6608 } 6609 c := C._gtk_message_dialog_new(w, 6610 C.GtkDialogFlags(flags), C.GtkMessageType(mType), 6611 C.GtkButtonsType(buttons), cstr) 6612 return wrapMessageDialog(glib.Take(unsafe.Pointer(c))) 6613} 6614 6615// MessageDialogNewWithMarkup is a wrapper around 6616// gtk_message_dialog_new_with_markup(). 6617func MessageDialogNewWithMarkup(parent IWindow, flags DialogFlags, mType MessageType, buttons ButtonsType, format string, args ...interface{}) *MessageDialog { 6618 s := fmt.Sprintf(format, args...) 6619 cstr := C.CString(s) 6620 defer C.free(unsafe.Pointer(cstr)) 6621 var w *C.GtkWindow = nil 6622 if parent != nil { 6623 w = parent.toWindow() 6624 } 6625 c := C._gtk_message_dialog_new_with_markup(w, 6626 C.GtkDialogFlags(flags), C.GtkMessageType(mType), 6627 C.GtkButtonsType(buttons), cstr) 6628 return wrapMessageDialog(glib.Take(unsafe.Pointer(c))) 6629} 6630 6631// SetMarkup is a wrapper around gtk_message_dialog_set_markup(). 6632func (v *MessageDialog) SetMarkup(str string) { 6633 cstr := C.CString(str) 6634 defer C.free(unsafe.Pointer(cstr)) 6635 C.gtk_message_dialog_set_markup(v.native(), (*C.gchar)(cstr)) 6636} 6637 6638// FormatSecondaryText is a wrapper around 6639// gtk_message_dialog_format_secondary_text(). 6640func (v *MessageDialog) FormatSecondaryText(format string, args ...interface{}) { 6641 s := fmt.Sprintf(format, args...) 6642 cstr := C.CString(s) 6643 defer C.free(unsafe.Pointer(cstr)) 6644 C._gtk_message_dialog_format_secondary_text(v.native(), 6645 (*C.gchar)(cstr)) 6646} 6647 6648// FormatSecondaryMarkup is a wrapper around 6649// gtk_message_dialog_format_secondary_text(). 6650func (v *MessageDialog) FormatSecondaryMarkup(format string, args ...interface{}) { 6651 s := fmt.Sprintf(format, args...) 6652 cstr := C.CString(s) 6653 defer C.free(unsafe.Pointer(cstr)) 6654 C._gtk_message_dialog_format_secondary_markup(v.native(), 6655 (*C.gchar)(cstr)) 6656} 6657 6658// GetMessageArea() is a wrapper around gtk_message_dialog_get_message_area(). 6659func (v *MessageDialog) GetMessageArea() (*Box, error) { 6660 c := C.gtk_message_dialog_get_message_area(v.native()) 6661 if c == nil { 6662 return nil, nilPtrErr 6663 } 6664 obj := glib.Take(unsafe.Pointer(c)) 6665 b := &Box{Container{Widget{glib.InitiallyUnowned{obj}}}} 6666 return b, nil 6667} 6668 6669/* 6670 * GtkNotebook 6671 */ 6672 6673// Notebook is a representation of GTK's GtkNotebook. 6674type Notebook struct { 6675 Container 6676} 6677 6678// native returns a pointer to the underlying GtkNotebook. 6679func (v *Notebook) native() *C.GtkNotebook { 6680 if v == nil || v.GObject == nil { 6681 return nil 6682 } 6683 p := unsafe.Pointer(v.GObject) 6684 return C.toGtkNotebook(p) 6685} 6686 6687func marshalNotebook(p uintptr) (interface{}, error) { 6688 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 6689 obj := glib.Take(unsafe.Pointer(c)) 6690 return wrapNotebook(obj), nil 6691} 6692 6693func wrapNotebook(obj *glib.Object) *Notebook { 6694 if obj == nil { 6695 return nil 6696 } 6697 6698 return &Notebook{Container{Widget{glib.InitiallyUnowned{obj}}}} 6699} 6700 6701// NotebookNew() is a wrapper around gtk_notebook_new(). 6702func NotebookNew() (*Notebook, error) { 6703 c := C.gtk_notebook_new() 6704 if c == nil { 6705 return nil, nilPtrErr 6706 } 6707 return wrapNotebook(glib.Take(unsafe.Pointer(c))), nil 6708} 6709 6710// AppendPage() is a wrapper around gtk_notebook_append_page(). 6711func (v *Notebook) AppendPage(child IWidget, tabLabel IWidget) int { 6712 cTabLabel := nullableWidget(tabLabel) 6713 c := C.gtk_notebook_append_page(v.native(), child.toWidget(), cTabLabel) 6714 return int(c) 6715} 6716 6717// AppendPageMenu() is a wrapper around gtk_notebook_append_page_menu(). 6718func (v *Notebook) AppendPageMenu(child IWidget, tabLabel IWidget, menuLabel IWidget) int { 6719 c := C.gtk_notebook_append_page_menu(v.native(), child.toWidget(), 6720 tabLabel.toWidget(), menuLabel.toWidget()) 6721 return int(c) 6722} 6723 6724// PrependPage() is a wrapper around gtk_notebook_prepend_page(). 6725func (v *Notebook) PrependPage(child IWidget, tabLabel IWidget) int { 6726 cTabLabel := nullableWidget(tabLabel) 6727 c := C.gtk_notebook_prepend_page(v.native(), child.toWidget(), cTabLabel) 6728 return int(c) 6729} 6730 6731// PrependPageMenu() is a wrapper around gtk_notebook_prepend_page_menu(). 6732func (v *Notebook) PrependPageMenu(child IWidget, tabLabel IWidget, menuLabel IWidget) int { 6733 c := C.gtk_notebook_prepend_page_menu(v.native(), child.toWidget(), 6734 tabLabel.toWidget(), menuLabel.toWidget()) 6735 return int(c) 6736} 6737 6738// InsertPage() is a wrapper around gtk_notebook_insert_page(). 6739func (v *Notebook) InsertPage(child IWidget, tabLabel IWidget, position int) int { 6740 label := nullableWidget(tabLabel) 6741 c := C.gtk_notebook_insert_page(v.native(), child.toWidget(), label, C.gint(position)) 6742 6743 return int(c) 6744} 6745 6746// InsertPageMenu() is a wrapper around gtk_notebook_insert_page_menu(). 6747func (v *Notebook) InsertPageMenu(child IWidget, tabLabel IWidget, menuLabel IWidget, position int) int { 6748 c := C.gtk_notebook_insert_page_menu(v.native(), child.toWidget(), 6749 tabLabel.toWidget(), menuLabel.toWidget(), C.gint(position)) 6750 return int(c) 6751} 6752 6753// RemovePage() is a wrapper around gtk_notebook_remove_page(). 6754func (v *Notebook) RemovePage(pageNum int) { 6755 C.gtk_notebook_remove_page(v.native(), C.gint(pageNum)) 6756} 6757 6758// PageNum() is a wrapper around gtk_notebook_page_num(). 6759func (v *Notebook) PageNum(child IWidget) int { 6760 c := C.gtk_notebook_page_num(v.native(), child.toWidget()) 6761 return int(c) 6762} 6763 6764// NextPage() is a wrapper around gtk_notebook_next_page(). 6765func (v *Notebook) NextPage() { 6766 C.gtk_notebook_next_page(v.native()) 6767} 6768 6769// PrevPage() is a wrapper around gtk_notebook_prev_page(). 6770func (v *Notebook) PrevPage() { 6771 C.gtk_notebook_prev_page(v.native()) 6772} 6773 6774// ReorderChild() is a wrapper around gtk_notebook_reorder_child(). 6775func (v *Notebook) ReorderChild(child IWidget, position int) { 6776 C.gtk_notebook_reorder_child(v.native(), child.toWidget(), 6777 C.gint(position)) 6778} 6779 6780// SetTabPos() is a wrapper around gtk_notebook_set_tab_pos(). 6781func (v *Notebook) SetTabPos(pos PositionType) { 6782 C.gtk_notebook_set_tab_pos(v.native(), C.GtkPositionType(pos)) 6783} 6784 6785// SetShowTabs() is a wrapper around gtk_notebook_set_show_tabs(). 6786func (v *Notebook) SetShowTabs(showTabs bool) { 6787 C.gtk_notebook_set_show_tabs(v.native(), gbool(showTabs)) 6788} 6789 6790// SetShowBorder() is a wrapper around gtk_notebook_set_show_border(). 6791func (v *Notebook) SetShowBorder(showBorder bool) { 6792 C.gtk_notebook_set_show_border(v.native(), gbool(showBorder)) 6793} 6794 6795// SetScrollable() is a wrapper around gtk_notebook_set_scrollable(). 6796func (v *Notebook) SetScrollable(scrollable bool) { 6797 C.gtk_notebook_set_scrollable(v.native(), gbool(scrollable)) 6798} 6799 6800// PopupEnable() is a wrapper around gtk_notebook_popup_enable(). 6801func (v *Notebook) PopupEnable() { 6802 C.gtk_notebook_popup_enable(v.native()) 6803} 6804 6805// PopupDisable() is a wrapper around gtk_notebook_popup_disable(). 6806func (v *Notebook) PopupDisable() { 6807 C.gtk_notebook_popup_disable(v.native()) 6808} 6809 6810// GetCurrentPage() is a wrapper around gtk_notebook_get_current_page(). 6811func (v *Notebook) GetCurrentPage() int { 6812 c := C.gtk_notebook_get_current_page(v.native()) 6813 return int(c) 6814} 6815 6816// GetMenuLabel() is a wrapper around gtk_notebook_get_menu_label(). 6817func (v *Notebook) GetMenuLabel(child IWidget) (IWidget, error) { 6818 c := C.gtk_notebook_get_menu_label(v.native(), child.toWidget()) 6819 if c == nil { 6820 return nil, nil 6821 } 6822 return castWidget(c) 6823} 6824 6825// GetNthPage() is a wrapper around gtk_notebook_get_nth_page(). 6826func (v *Notebook) GetNthPage(pageNum int) (IWidget, error) { 6827 c := C.gtk_notebook_get_nth_page(v.native(), C.gint(pageNum)) 6828 if c == nil { 6829 return nil, fmt.Errorf("page %d is out of bounds", pageNum) 6830 } 6831 return castWidget(c) 6832} 6833 6834// GetNPages() is a wrapper around gtk_notebook_get_n_pages(). 6835func (v *Notebook) GetNPages() int { 6836 c := C.gtk_notebook_get_n_pages(v.native()) 6837 return int(c) 6838} 6839 6840// GetTabLabel() is a wrapper around gtk_notebook_get_tab_label(). 6841func (v *Notebook) GetTabLabel(child IWidget) (IWidget, error) { 6842 c := C.gtk_notebook_get_tab_label(v.native(), child.toWidget()) 6843 if c == nil { 6844 return nil, nil 6845 } 6846 return castWidget(c) 6847} 6848 6849// SetMenuLabel() is a wrapper around gtk_notebook_set_menu_label(). 6850func (v *Notebook) SetMenuLabel(child, menuLabel IWidget) { 6851 C.gtk_notebook_set_menu_label(v.native(), child.toWidget(), 6852 menuLabel.toWidget()) 6853} 6854 6855// SetMenuLabelText() is a wrapper around gtk_notebook_set_menu_label_text(). 6856func (v *Notebook) SetMenuLabelText(child IWidget, menuText string) { 6857 cstr := C.CString(menuText) 6858 defer C.free(unsafe.Pointer(cstr)) 6859 C.gtk_notebook_set_menu_label_text(v.native(), child.toWidget(), 6860 (*C.gchar)(cstr)) 6861} 6862 6863// SetTabLabel() is a wrapper around gtk_notebook_set_tab_label(). 6864func (v *Notebook) SetTabLabel(child, tabLabel IWidget) { 6865 C.gtk_notebook_set_tab_label(v.native(), child.toWidget(), 6866 tabLabel.toWidget()) 6867} 6868 6869// SetTabLabelText() is a wrapper around gtk_notebook_set_tab_label_text(). 6870func (v *Notebook) SetTabLabelText(child IWidget, tabText string) { 6871 cstr := C.CString(tabText) 6872 defer C.free(unsafe.Pointer(cstr)) 6873 C.gtk_notebook_set_tab_label_text(v.native(), child.toWidget(), 6874 (*C.gchar)(cstr)) 6875} 6876 6877// SetTabReorderable() is a wrapper around gtk_notebook_set_tab_reorderable(). 6878func (v *Notebook) SetTabReorderable(child IWidget, reorderable bool) { 6879 C.gtk_notebook_set_tab_reorderable(v.native(), child.toWidget(), 6880 gbool(reorderable)) 6881} 6882 6883// SetTabDetachable() is a wrapper around gtk_notebook_set_tab_detachable(). 6884func (v *Notebook) SetTabDetachable(child IWidget, detachable bool) { 6885 C.gtk_notebook_set_tab_detachable(v.native(), child.toWidget(), 6886 gbool(detachable)) 6887} 6888 6889// GetMenuLabelText() is a wrapper around gtk_notebook_get_menu_label_text(). 6890func (v *Notebook) GetMenuLabelText(child IWidget) (string, error) { 6891 c := C.gtk_notebook_get_menu_label_text(v.native(), child.toWidget()) 6892 if c == nil { 6893 return "", errors.New("No menu label for widget") 6894 } 6895 return goString(c), nil 6896} 6897 6898// GetScrollable() is a wrapper around gtk_notebook_get_scrollable(). 6899func (v *Notebook) GetScrollable() bool { 6900 c := C.gtk_notebook_get_scrollable(v.native()) 6901 return gobool(c) 6902} 6903 6904// GetShowBorder() is a wrapper around gtk_notebook_get_show_border(). 6905func (v *Notebook) GetShowBorder() bool { 6906 c := C.gtk_notebook_get_show_border(v.native()) 6907 return gobool(c) 6908} 6909 6910// GetShowTabs() is a wrapper around gtk_notebook_get_show_tabs(). 6911func (v *Notebook) GetShowTabs() bool { 6912 c := C.gtk_notebook_get_show_tabs(v.native()) 6913 return gobool(c) 6914} 6915 6916// GetTabLabelText() is a wrapper around gtk_notebook_get_tab_label_text(). 6917func (v *Notebook) GetTabLabelText(child IWidget) (string, error) { 6918 c := C.gtk_notebook_get_tab_label_text(v.native(), child.toWidget()) 6919 if c == nil { 6920 return "", errors.New("No tab label for widget") 6921 } 6922 return goString(c), nil 6923} 6924 6925// GetTabPos() is a wrapper around gtk_notebook_get_tab_pos(). 6926func (v *Notebook) GetTabPos() PositionType { 6927 c := C.gtk_notebook_get_tab_pos(v.native()) 6928 return PositionType(c) 6929} 6930 6931// GetTabReorderable() is a wrapper around gtk_notebook_get_tab_reorderable(). 6932func (v *Notebook) GetTabReorderable(child IWidget) bool { 6933 c := C.gtk_notebook_get_tab_reorderable(v.native(), child.toWidget()) 6934 return gobool(c) 6935} 6936 6937// GetTabDetachable() is a wrapper around gtk_notebook_get_tab_detachable(). 6938func (v *Notebook) GetTabDetachable(child IWidget) bool { 6939 c := C.gtk_notebook_get_tab_detachable(v.native(), child.toWidget()) 6940 return gobool(c) 6941} 6942 6943// SetCurrentPage() is a wrapper around gtk_notebook_set_current_page(). 6944func (v *Notebook) SetCurrentPage(pageNum int) { 6945 C.gtk_notebook_set_current_page(v.native(), C.gint(pageNum)) 6946} 6947 6948// SetGroupName() is a wrapper around gtk_notebook_set_group_name(). 6949func (v *Notebook) SetGroupName(groupName string) { 6950 cstr := C.CString(groupName) 6951 defer C.free(unsafe.Pointer(cstr)) 6952 C.gtk_notebook_set_group_name(v.native(), (*C.gchar)(cstr)) 6953} 6954 6955// GetGroupName() is a wrapper around gtk_notebook_get_group_name(). 6956func (v *Notebook) GetGroupName() (string, error) { 6957 c := C.gtk_notebook_get_group_name(v.native()) 6958 if c == nil { 6959 return "", errors.New("No group name") 6960 } 6961 return goString(c), nil 6962} 6963 6964// SetActionWidget() is a wrapper around gtk_notebook_set_action_widget(). 6965func (v *Notebook) SetActionWidget(widget IWidget, packType PackType) { 6966 C.gtk_notebook_set_action_widget(v.native(), widget.toWidget(), 6967 C.GtkPackType(packType)) 6968} 6969 6970// GetActionWidget() is a wrapper around gtk_notebook_get_action_widget(). 6971func (v *Notebook) GetActionWidget(packType PackType) (IWidget, error) { 6972 c := C.gtk_notebook_get_action_widget(v.native(), C.GtkPackType(packType)) 6973 if c == nil { 6974 return nil, nil 6975 } 6976 return castWidget(c) 6977} 6978 6979/* 6980 * GtkOffscreenWindow 6981 */ 6982 6983// OffscreenWindow is a representation of GTK's GtkOffscreenWindow. 6984type OffscreenWindow struct { 6985 Window 6986} 6987 6988// native returns a pointer to the underlying GtkOffscreenWindow. 6989func (v *OffscreenWindow) native() *C.GtkOffscreenWindow { 6990 if v == nil || v.GObject == nil { 6991 return nil 6992 } 6993 p := unsafe.Pointer(v.GObject) 6994 return C.toGtkOffscreenWindow(p) 6995} 6996 6997func marshalOffscreenWindow(p uintptr) (interface{}, error) { 6998 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 6999 obj := glib.Take(unsafe.Pointer(c)) 7000 return wrapOffscreenWindow(obj), nil 7001} 7002 7003func wrapOffscreenWindow(obj *glib.Object) *OffscreenWindow { 7004 if obj == nil { 7005 return nil 7006 } 7007 7008 return &OffscreenWindow{Window{Bin{Container{Widget{ 7009 glib.InitiallyUnowned{obj}}}}}} 7010} 7011 7012// OffscreenWindowNew is a wrapper around gtk_offscreen_window_new(). 7013func OffscreenWindowNew() (*OffscreenWindow, error) { 7014 c := C.gtk_offscreen_window_new() 7015 if c == nil { 7016 return nil, nilPtrErr 7017 } 7018 return wrapOffscreenWindow(glib.Take(unsafe.Pointer(c))), nil 7019} 7020 7021// GetSurface is a wrapper around gtk_offscreen_window_get_surface(). 7022// The returned surface is safe to use over window resizes. 7023func (v *OffscreenWindow) GetSurface() (*cairo.Surface, error) { 7024 c := C.gtk_offscreen_window_get_surface(v.native()) 7025 if c == nil { 7026 return nil, nilPtrErr 7027 } 7028 cairoPtr := (uintptr)(unsafe.Pointer(c)) 7029 s := cairo.NewSurface(cairoPtr, true) 7030 return s, nil 7031} 7032 7033// GetPixbuf is a wrapper around gtk_offscreen_window_get_pixbuf(). 7034func (v *OffscreenWindow) GetPixbuf() (*gdk.Pixbuf, error) { 7035 c := C.gtk_offscreen_window_get_pixbuf(v.native()) 7036 if c == nil { 7037 return nil, nilPtrErr 7038 } 7039 7040 // Pixbuf is returned with ref count of 1, so don't increment. 7041 // Is it a floating reference? 7042 pb := &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))} 7043 return pb, nil 7044} 7045 7046/* 7047 * GtkOrientable 7048 */ 7049 7050// Orientable is a representation of GTK's GtkOrientable GInterface. 7051type Orientable struct { 7052 *glib.Object 7053} 7054 7055// IOrientable is an interface type implemented by all structs 7056// embedding an Orientable. It is meant to be used as an argument type 7057// for wrapper functions that wrap around a C GTK function taking a 7058// GtkOrientable. 7059type IOrientable interface { 7060 toOrientable() *C.GtkOrientable 7061} 7062 7063// native returns a pointer to the underlying GObject as a GtkOrientable. 7064func (v *Orientable) native() *C.GtkOrientable { 7065 if v == nil || v.GObject == nil { 7066 return nil 7067 } 7068 p := unsafe.Pointer(v.GObject) 7069 return C.toGtkOrientable(p) 7070} 7071 7072func marshalOrientable(p uintptr) (interface{}, error) { 7073 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 7074 obj := glib.Take(unsafe.Pointer(c)) 7075 return wrapOrientable(obj), nil 7076} 7077 7078func wrapOrientable(obj *glib.Object) *Orientable { 7079 if obj == nil { 7080 return nil 7081 } 7082 7083 return &Orientable{obj} 7084} 7085 7086// GetOrientation is a wrapper around gtk_orientable_get_orientation(). 7087func (v *Orientable) GetOrientation() Orientation { 7088 c := C.gtk_orientable_get_orientation(v.native()) 7089 return Orientation(c) 7090} 7091 7092// SetOrientation is a wrapper around gtk_orientable_set_orientation(). 7093func (v *Orientable) SetOrientation(orientation Orientation) { 7094 C.gtk_orientable_set_orientation(v.native(), 7095 C.GtkOrientation(orientation)) 7096} 7097 7098/* 7099 * GtkOverlay 7100 */ 7101 7102// Overlay is a representation of GTK's GtkOverlay. 7103type Overlay struct { 7104 Bin 7105} 7106 7107// native returns a pointer to the underlying GtkOverlay. 7108func (v *Overlay) native() *C.GtkOverlay { 7109 if v == nil || v.GObject == nil { 7110 return nil 7111 } 7112 p := unsafe.Pointer(v.GObject) 7113 return C.toGtkOverlay(p) 7114} 7115 7116func marshalOverlay(p uintptr) (interface{}, error) { 7117 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 7118 obj := glib.Take(unsafe.Pointer(c)) 7119 return wrapOverlay(obj), nil 7120} 7121 7122func wrapOverlay(obj *glib.Object) *Overlay { 7123 if obj == nil { 7124 return nil 7125 } 7126 7127 return &Overlay{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} 7128} 7129 7130// OverlayNew() is a wrapper around gtk_overlay_new(). 7131func OverlayNew() (*Overlay, error) { 7132 c := C.gtk_overlay_new() 7133 if c == nil { 7134 return nil, nilPtrErr 7135 } 7136 return wrapOverlay(glib.Take(unsafe.Pointer(c))), nil 7137} 7138 7139// AddOverlay() is a wrapper around gtk_overlay_add_overlay(). 7140func (v *Overlay) AddOverlay(widget IWidget) { 7141 C.gtk_overlay_add_overlay(v.native(), widget.toWidget()) 7142} 7143 7144/* 7145 * GtkPaned 7146 */ 7147 7148// Paned is a representation of GTK's GtkPaned. 7149type Paned struct { 7150 Bin 7151} 7152 7153// native returns a pointer to the underlying GtkPaned. 7154func (v *Paned) native() *C.GtkPaned { 7155 if v == nil || v.GObject == nil { 7156 return nil 7157 } 7158 p := unsafe.Pointer(v.GObject) 7159 return C.toGtkPaned(p) 7160} 7161 7162func marshalPaned(p uintptr) (interface{}, error) { 7163 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 7164 obj := glib.Take(unsafe.Pointer(c)) 7165 return wrapPaned(obj), nil 7166} 7167 7168func wrapPaned(obj *glib.Object) *Paned { 7169 if obj == nil { 7170 return nil 7171 } 7172 7173 return &Paned{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} 7174} 7175 7176// PanedNew() is a wrapper around gtk_paned_new(). 7177func PanedNew(orientation Orientation) (*Paned, error) { 7178 c := C.gtk_paned_new(C.GtkOrientation(orientation)) 7179 if c == nil { 7180 return nil, nilPtrErr 7181 } 7182 return wrapPaned(glib.Take(unsafe.Pointer(c))), nil 7183} 7184 7185// Add1() is a wrapper around gtk_paned_add1(). 7186func (v *Paned) Add1(child IWidget) { 7187 C.gtk_paned_add1(v.native(), child.toWidget()) 7188} 7189 7190// Add2() is a wrapper around gtk_paned_add2(). 7191func (v *Paned) Add2(child IWidget) { 7192 C.gtk_paned_add2(v.native(), child.toWidget()) 7193} 7194 7195// Pack1() is a wrapper around gtk_paned_pack1(). 7196func (v *Paned) Pack1(child IWidget, resize, shrink bool) { 7197 C.gtk_paned_pack1(v.native(), child.toWidget(), gbool(resize), gbool(shrink)) 7198} 7199 7200// Pack2() is a wrapper around gtk_paned_pack2(). 7201func (v *Paned) Pack2(child IWidget, resize, shrink bool) { 7202 C.gtk_paned_pack2(v.native(), child.toWidget(), gbool(resize), gbool(shrink)) 7203} 7204 7205// SetPosition() is a wrapper around gtk_paned_set_position(). 7206func (v *Paned) SetPosition(position int) { 7207 C.gtk_paned_set_position(v.native(), C.gint(position)) 7208} 7209 7210// GetChild1() is a wrapper around gtk_paned_get_child1(). 7211func (v *Paned) GetChild1() (IWidget, error) { 7212 c := C.gtk_paned_get_child1(v.native()) 7213 if c == nil { 7214 return nil, nil 7215 } 7216 return castWidget(c) 7217} 7218 7219// GetChild2() is a wrapper around gtk_paned_get_child2(). 7220func (v *Paned) GetChild2() (IWidget, error) { 7221 c := C.gtk_paned_get_child2(v.native()) 7222 if c == nil { 7223 return nil, nil 7224 } 7225 return castWidget(c) 7226} 7227 7228// GetHandleWindow() is a wrapper around gtk_paned_get_handle_window(). 7229func (v *Paned) GetHandleWindow() (*Window, error) { 7230 c := C.gtk_paned_get_handle_window(v.native()) 7231 if c == nil { 7232 return nil, nilPtrErr 7233 } 7234 return wrapWindow(glib.Take(unsafe.Pointer(c))), nil 7235} 7236 7237// GetPosition() is a wrapper around gtk_paned_get_position(). 7238func (v *Paned) GetPosition() int { 7239 return int(C.gtk_paned_get_position(v.native())) 7240} 7241 7242/* 7243 * GtkInvisible 7244 */ 7245 7246// TODO: 7247// gtk_invisible_new(). 7248// gtk_invisible_new_for_screen(). 7249// gtk_invisible_set_screen(). 7250// gtk_invisible_get_screen(). 7251 7252/* 7253 * GtkProgressBar 7254 */ 7255 7256// ProgressBar is a representation of GTK's GtkProgressBar. 7257type ProgressBar struct { 7258 Widget 7259 // Interfaces 7260 Orientable 7261} 7262 7263// native returns a pointer to the underlying GtkProgressBar. 7264func (v *ProgressBar) native() *C.GtkProgressBar { 7265 if v == nil || v.GObject == nil { 7266 return nil 7267 } 7268 p := unsafe.Pointer(v.GObject) 7269 return C.toGtkProgressBar(p) 7270} 7271 7272func marshalProgressBar(p uintptr) (interface{}, error) { 7273 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 7274 obj := glib.Take(unsafe.Pointer(c)) 7275 return wrapProgressBar(obj), nil 7276} 7277 7278func wrapProgressBar(obj *glib.Object) *ProgressBar { 7279 if obj == nil { 7280 return nil 7281 } 7282 7283 o := wrapOrientable(obj) 7284 return &ProgressBar{Widget{glib.InitiallyUnowned{obj}}, *o} 7285} 7286 7287// ProgressBarNew is a wrapper around gtk_progress_bar_new(). 7288func ProgressBarNew() (*ProgressBar, error) { 7289 c := C.gtk_progress_bar_new() 7290 if c == nil { 7291 return nil, nilPtrErr 7292 } 7293 return wrapProgressBar(glib.Take(unsafe.Pointer(c))), nil 7294} 7295 7296// SetFraction is a wrapper around gtk_progress_bar_set_fraction(). 7297func (v *ProgressBar) SetFraction(fraction float64) { 7298 C.gtk_progress_bar_set_fraction(v.native(), C.gdouble(fraction)) 7299} 7300 7301// GetFraction is a wrapper around gtk_progress_bar_get_fraction(). 7302func (v *ProgressBar) GetFraction() float64 { 7303 c := C.gtk_progress_bar_get_fraction(v.native()) 7304 return float64(c) 7305} 7306 7307// SetShowText is a wrapper around gtk_progress_bar_set_show_text(). 7308func (v *ProgressBar) SetShowText(showText bool) { 7309 C.gtk_progress_bar_set_show_text(v.native(), gbool(showText)) 7310} 7311 7312// GetShowText is a wrapper around gtk_progress_bar_get_show_text(). 7313func (v *ProgressBar) GetShowText() bool { 7314 c := C.gtk_progress_bar_get_show_text(v.native()) 7315 return gobool(c) 7316} 7317 7318// SetText is a wrapper around gtk_progress_bar_set_text(). 7319func (v *ProgressBar) SetText(text string) { 7320 cstr := C.CString(text) 7321 defer C.free(unsafe.Pointer(cstr)) 7322 C.gtk_progress_bar_set_text(v.native(), (*C.gchar)(cstr)) 7323} 7324 7325// TODO: 7326// gtk_progress_bar_get_text(). 7327// gtk_progress_bar_set_ellipsize(). 7328// gtk_progress_bar_get_ellipsize(). 7329 7330// SetPulseStep is a wrapper around gtk_progress_bar_set_pulse_step(). 7331func (v *ProgressBar) SetPulseStep(fraction float64) { 7332 C.gtk_progress_bar_set_pulse_step(v.native(), C.gdouble(fraction)) 7333} 7334 7335// GetPulseStep is a wrapper around gtk_progress_bar_get_pulse_step(). 7336func (v *ProgressBar) GetPulseStep() float64 { 7337 c := C.gtk_progress_bar_get_pulse_step(v.native()) 7338 return float64(c) 7339} 7340 7341// Pulse is a wrapper arountd gtk_progress_bar_pulse(). 7342func (v *ProgressBar) Pulse() { 7343 C.gtk_progress_bar_pulse(v.native()) 7344} 7345 7346// SetInverted is a wrapper around gtk_progress_bar_set_inverted(). 7347func (v *ProgressBar) SetInverted(inverted bool) { 7348 C.gtk_progress_bar_set_inverted(v.native(), gbool(inverted)) 7349} 7350 7351// GetInverted is a wrapper around gtk_progress_bar_get_inverted(). 7352func (v *ProgressBar) GetInverted() bool { 7353 c := C.gtk_progress_bar_get_inverted(v.native()) 7354 return gobool(c) 7355} 7356 7357/* 7358 * GtkRadioButton 7359 */ 7360 7361// RadioButton is a representation of GTK's GtkRadioButton. 7362type RadioButton struct { 7363 CheckButton 7364} 7365 7366// native returns a pointer to the underlying GtkRadioButton. 7367func (v *RadioButton) native() *C.GtkRadioButton { 7368 if v == nil || v.GObject == nil { 7369 return nil 7370 } 7371 p := unsafe.Pointer(v.GObject) 7372 return C.toGtkRadioButton(p) 7373} 7374 7375func marshalRadioButton(p uintptr) (interface{}, error) { 7376 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 7377 obj := glib.Take(unsafe.Pointer(c)) 7378 return wrapRadioButton(obj), nil 7379} 7380 7381func wrapRadioButton(obj *glib.Object) *RadioButton { 7382 if obj == nil { 7383 return nil 7384 } 7385 7386 actionable := wrapActionable(obj) 7387 return &RadioButton{CheckButton{ToggleButton{Button{Bin{Container{ 7388 Widget{glib.InitiallyUnowned{obj}}}}, actionable}}}} 7389} 7390 7391// RadioButtonNew is a wrapper around gtk_radio_button_new(). 7392func RadioButtonNew(group *glib.SList) (*RadioButton, error) { 7393 c := C.gtk_radio_button_new(cGSList(group)) 7394 if c == nil { 7395 return nil, nilPtrErr 7396 } 7397 return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil 7398} 7399 7400// RadioButtonNewFromWidget is a wrapper around gtk_radio_button_new_from_widget(). 7401func RadioButtonNewFromWidget(radioGroupMember *RadioButton) (*RadioButton, error) { 7402 c := C.gtk_radio_button_new_from_widget(radioGroupMember.native()) 7403 if c == nil { 7404 return nil, nilPtrErr 7405 } 7406 return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil 7407} 7408 7409// RadioButtonNewWithLabel is a wrapper around gtk_radio_button_new_with_label(). 7410func RadioButtonNewWithLabel(group *glib.SList, label string) (*RadioButton, error) { 7411 cstr := C.CString(label) 7412 defer C.free(unsafe.Pointer(cstr)) 7413 c := C.gtk_radio_button_new_with_label(cGSList(group), (*C.gchar)(cstr)) 7414 if c == nil { 7415 return nil, nilPtrErr 7416 } 7417 return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil 7418} 7419 7420// RadioButtonNewWithLabelFromWidget is a wrapper around gtk_radio_button_new_with_label_from_widget(). 7421func RadioButtonNewWithLabelFromWidget(radioGroupMember *RadioButton, label string) (*RadioButton, error) { 7422 cstr := C.CString(label) 7423 defer C.free(unsafe.Pointer(cstr)) 7424 var cradio *C.GtkRadioButton 7425 if radioGroupMember != nil { 7426 cradio = radioGroupMember.native() 7427 } 7428 c := C.gtk_radio_button_new_with_label_from_widget(cradio, (*C.gchar)(cstr)) 7429 if c == nil { 7430 return nil, nilPtrErr 7431 } 7432 return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil 7433} 7434 7435// RadioButtonNewWithMnemonic is a wrapper around gtk_radio_button_new_with_mnemonic(). 7436func RadioButtonNewWithMnemonic(group *glib.SList, label string) (*RadioButton, error) { 7437 cstr := C.CString(label) 7438 defer C.free(unsafe.Pointer(cstr)) 7439 c := C.gtk_radio_button_new_with_mnemonic(cGSList(group), (*C.gchar)(cstr)) 7440 if c == nil { 7441 return nil, nilPtrErr 7442 } 7443 return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil 7444} 7445 7446// RadioButtonNewWithMnemonicFromWidget is a wrapper around gtk_radio_button_new_with_mnemonic_from_widget(). 7447func RadioButtonNewWithMnemonicFromWidget(radioGroupMember *RadioButton, label string) (*RadioButton, error) { 7448 cstr := C.CString(label) 7449 defer C.free(unsafe.Pointer(cstr)) 7450 var cradio *C.GtkRadioButton 7451 if radioGroupMember != nil { 7452 cradio = radioGroupMember.native() 7453 } 7454 c := C.gtk_radio_button_new_with_mnemonic_from_widget(cradio, 7455 (*C.gchar)(cstr)) 7456 if c == nil { 7457 return nil, nilPtrErr 7458 } 7459 return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil 7460} 7461 7462// SetGroup is a wrapper around gtk_radio_button_set_group(). 7463func (v *RadioButton) SetGroup(group *glib.SList) { 7464 C.gtk_radio_button_set_group(v.native(), cGSList(group)) 7465} 7466 7467// GetGroup is a wrapper around gtk_radio_button_get_group(). 7468func (v *RadioButton) GetGroup() (*glib.SList, error) { 7469 c := C.gtk_radio_button_get_group(v.native()) 7470 if c == nil { 7471 return nil, nilPtrErr 7472 } 7473 7474 // TODO: call DataWrapper on SList and wrap them to gtk.RadioButton 7475 7476 return glib.WrapSList(uintptr(unsafe.Pointer(c))), nil 7477} 7478 7479// JoinGroup is a wrapper around gtk_radio_button_join_group(). 7480func (v *RadioButton) JoinGroup(groupSource *RadioButton) { 7481 var cgroup *C.GtkRadioButton 7482 if groupSource != nil { 7483 cgroup = groupSource.native() 7484 } 7485 C.gtk_radio_button_join_group(v.native(), cgroup) 7486} 7487 7488/* 7489 * GtkRadioMenuItem 7490 */ 7491 7492// RadioMenuItem is a representation of GTK's GtkRadioMenuItem. 7493type RadioMenuItem struct { 7494 CheckMenuItem 7495} 7496 7497// native returns a pointer to the underlying GtkRadioMenuItem. 7498func (v *RadioMenuItem) native() *C.GtkRadioMenuItem { 7499 if v == nil || v.GObject == nil { 7500 return nil 7501 } 7502 p := unsafe.Pointer(v.GObject) 7503 return C.toGtkRadioMenuItem(p) 7504} 7505 7506func marshalRadioMenuItem(p uintptr) (interface{}, error) { 7507 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 7508 obj := glib.Take(unsafe.Pointer(c)) 7509 return wrapRadioMenuItem(obj), nil 7510} 7511 7512func wrapRadioMenuItem(obj *glib.Object) *RadioMenuItem { 7513 if obj == nil { 7514 return nil 7515 } 7516 7517 return &RadioMenuItem{CheckMenuItem{MenuItem{Bin{Container{ 7518 Widget{glib.InitiallyUnowned{obj}}}}}}} 7519} 7520 7521// RadioMenuItemNew is a wrapper around gtk_radio_menu_item_new(). 7522func RadioMenuItemNew(group *glib.SList) (*RadioMenuItem, error) { 7523 c := C.gtk_radio_menu_item_new(cGSList(group)) 7524 if c == nil { 7525 return nil, nilPtrErr 7526 } 7527 return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil 7528} 7529 7530// RadioMenuItemNewWithLabel is a wrapper around gtk_radio_menu_item_new_with_label(). 7531func RadioMenuItemNewWithLabel(group *glib.SList, label string) (*RadioMenuItem, error) { 7532 cstr := C.CString(label) 7533 defer C.free(unsafe.Pointer(cstr)) 7534 c := C.gtk_radio_menu_item_new_with_label(cGSList(group), (*C.gchar)(cstr)) 7535 if c == nil { 7536 return nil, nilPtrErr 7537 } 7538 return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil 7539} 7540 7541// RadioMenuItemNewWithMnemonic is a wrapper around gtk_radio_menu_item_new_with_mnemonic(). 7542func RadioMenuItemNewWithMnemonic(group *glib.SList, label string) (*RadioMenuItem, error) { 7543 cstr := C.CString(label) 7544 defer C.free(unsafe.Pointer(cstr)) 7545 c := C.gtk_radio_menu_item_new_with_mnemonic(cGSList(group), (*C.gchar)(cstr)) 7546 if c == nil { 7547 return nil, nilPtrErr 7548 } 7549 return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil 7550} 7551 7552// RadioMenuItemNewFromWidget is a wrapper around gtk_radio_menu_item_new_from_widget(). 7553func RadioMenuItemNewFromWidget(group *RadioMenuItem) (*RadioMenuItem, error) { 7554 c := C.gtk_radio_menu_item_new_from_widget(group.native()) 7555 if c == nil { 7556 return nil, nilPtrErr 7557 } 7558 return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil 7559} 7560 7561// RadioMenuItemNewWithLabelFromWidget is a wrapper around gtk_radio_menu_item_new_with_label_from_widget(). 7562func RadioMenuItemNewWithLabelFromWidget(group *RadioMenuItem, label string) (*RadioMenuItem, error) { 7563 cstr := C.CString(label) 7564 defer C.free(unsafe.Pointer(cstr)) 7565 c := C.gtk_radio_menu_item_new_with_label_from_widget(group.native(), 7566 (*C.gchar)(cstr)) 7567 if c == nil { 7568 return nil, nilPtrErr 7569 } 7570 return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil 7571} 7572 7573// RadioMenuItemNewWithMnemonicFromWidget is a wrapper around gtk_radio_menu_item_new_with_mnemonic_from_widget(). 7574func RadioMenuItemNewWithMnemonicFromWidget(group *RadioMenuItem, label string) (*RadioMenuItem, error) { 7575 cstr := C.CString(label) 7576 defer C.free(unsafe.Pointer(cstr)) 7577 c := C.gtk_radio_menu_item_new_with_mnemonic_from_widget(group.native(), 7578 (*C.gchar)(cstr)) 7579 if c == nil { 7580 return nil, nilPtrErr 7581 } 7582 return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil 7583} 7584 7585// SetGroup is a wrapper around gtk_radio_menu_item_set_group(). 7586func (v *RadioMenuItem) SetGroup(group *glib.SList) { 7587 C.gtk_radio_menu_item_set_group(v.native(), cGSList(group)) 7588} 7589 7590// GetGroup is a wrapper around gtk_radio_menu_item_get_group(). 7591func (v *RadioMenuItem) GetGroup() (*glib.SList, error) { 7592 c := C.gtk_radio_menu_item_get_group(v.native()) 7593 if c == nil { 7594 return nil, nilPtrErr 7595 } 7596 7597 // TODO: call DataWrapper on SList and wrap them to gtk.RadioMenuItem 7598 7599 return glib.WrapSList(uintptr(unsafe.Pointer(c))), nil 7600} 7601 7602/* 7603 * GtkRange 7604 */ 7605 7606// Range is a representation of GTK's GtkRange. 7607type Range struct { 7608 Widget 7609} 7610 7611// native returns a pointer to the underlying GtkRange. 7612func (v *Range) native() *C.GtkRange { 7613 if v == nil || v.GObject == nil { 7614 return nil 7615 } 7616 p := unsafe.Pointer(v.GObject) 7617 return C.toGtkRange(p) 7618} 7619 7620func marshalRange(p uintptr) (interface{}, error) { 7621 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 7622 obj := glib.Take(unsafe.Pointer(c)) 7623 return wrapRange(obj), nil 7624} 7625 7626func wrapRange(obj *glib.Object) *Range { 7627 if obj == nil { 7628 return nil 7629 } 7630 7631 return &Range{Widget{glib.InitiallyUnowned{obj}}} 7632} 7633 7634// GetFillLevel is a wrapper around gtk_range_get_fill_level(). 7635func (v *Range) GetFillLevel() float64 { 7636 return float64(C.gtk_range_get_fill_level(v.native())) 7637} 7638 7639// GetRestrictToFillLevel is a wrapper around gtk_range_get_restrict_to_fill_level(). 7640func (v *Range) GetRestrictToFillLevel() bool { 7641 return gobool(C.gtk_range_get_restrict_to_fill_level(v.native())) 7642} 7643 7644// GetShowFillLevel is a wrapper around gtk_range_get_show_fill_level(). 7645func (v *Range) GetShowFillLevel() bool { 7646 return gobool(C.gtk_range_get_show_fill_level(v.native())) 7647} 7648 7649// SetFillLevel is a wrapper around gtk_range_set_fill_level(). 7650func (v *Range) SetFillLevel(fill_level float64) { 7651 C.gtk_range_set_fill_level(v.native(), C.gdouble(fill_level)) 7652} 7653 7654// RestrictToFillLevel is a wrapper around gtk_range_set_restrict_to_fill_level(). 7655func (v *Range) RestrictToFillLevel(restrict_to_fill_level bool) { 7656 C.gtk_range_set_restrict_to_fill_level(v.native(), gbool(restrict_to_fill_level)) 7657} 7658 7659// SetShowFillLevel is a wrapper around gtk_range_set_show_fill_level(). 7660func (v *Range) SetShowFillLevel(show_fill_level bool) { 7661 C.gtk_range_set_show_fill_level(v.native(), gbool(show_fill_level)) 7662} 7663 7664// GetAdjustment is a wrapper around gtk_range_get_adjustment(). 7665func (v *Range) GetAdjustment() *Adjustment { 7666 7667 c := C.gtk_range_get_adjustment(v.native()) 7668 if c == nil { 7669 return nil 7670 } 7671 obj := glib.Take(unsafe.Pointer(c)) 7672 return wrapAdjustment(obj) 7673} 7674 7675// SetAdjustment is a wrapper around gtk_range_set_adjustment(). 7676func (v *Range) SetAdjustment(adjustment *Adjustment) { 7677 C.gtk_range_set_adjustment(v.native(), adjustment.native()) 7678} 7679 7680// GetValue is a wrapper around gtk_range_get_value(). 7681func (v *Range) GetValue() float64 { 7682 c := C.gtk_range_get_value(v.native()) 7683 return float64(c) 7684} 7685 7686// SetValue is a wrapper around gtk_range_set_value(). 7687func (v *Range) SetValue(value float64) { 7688 C.gtk_range_set_value(v.native(), C.gdouble(value)) 7689} 7690 7691// SetIncrements is a wrapper around gtk_range_set_increments(). 7692func (v *Range) SetIncrements(step, page float64) { 7693 C.gtk_range_set_increments(v.native(), C.gdouble(step), C.gdouble(page)) 7694} 7695 7696// SetRange is a wrapper around gtk_range_set_range(). 7697func (v *Range) SetRange(min, max float64) { 7698 C.gtk_range_set_range(v.native(), C.gdouble(min), C.gdouble(max)) 7699} 7700 7701// GetInverted is a wrapper around gtk_range_get_inverted(). 7702func (v *Range) GetInverted() bool { 7703 c := C.gtk_range_get_inverted(v.native()) 7704 return gobool(c) 7705} 7706 7707// SetInverted is a wrapper around gtk_range_set_inverted(). 7708func (v *Range) SetInverted(inverted bool) { 7709 C.gtk_range_set_inverted(v.native(), gbool(inverted)) 7710} 7711 7712// GetRoundDigits is a wrapper around gtk_range_get_round_digits(). 7713func (v *Range) GetRoundDigits() int { 7714 return int(C.gtk_range_get_round_digits(v.native())) 7715} 7716 7717// SetRoundDigits is a wrapper around gtk_range_set_round_digits(). 7718func (v *Range) SetRoundDigits(round_digits int) { 7719 C.gtk_range_set_round_digits(v.native(), C.gint(round_digits)) 7720} 7721 7722// SetLowerStepperSensitivity is a wrapper around gtk_range_set_lower_stepper_sensitivity(). 7723func (v *Range) SetLowerStepperSensitivity(sensitivity SensitivityType) { 7724 C.gtk_range_set_lower_stepper_sensitivity( 7725 v.native(), 7726 C.GtkSensitivityType(sensitivity)) 7727} 7728 7729// GetLowerStepperSensitivity is a wrapper around gtk_range_get_lower_stepper_sensitivity(). 7730func (v *Range) GetLowerStepperSensitivity() SensitivityType { 7731 return SensitivityType(C.gtk_range_get_lower_stepper_sensitivity( 7732 v.native())) 7733} 7734 7735// SetUpperStepperSensitivity is a wrapper around gtk_range_set_upper_stepper_sensitivity(). 7736func (v *Range) SetUpperStepperSensitivity(sensitivity SensitivityType) { 7737 C.gtk_range_set_upper_stepper_sensitivity( 7738 v.native(), 7739 C.GtkSensitivityType(sensitivity)) 7740} 7741 7742// GetUpperStepperSensitivity is a wrapper around gtk_range_get_upper_stepper_sensitivity(). 7743func (v *Range) GetUpperStepperSensitivity() SensitivityType { 7744 return SensitivityType(C.gtk_range_get_upper_stepper_sensitivity( 7745 v.native())) 7746} 7747 7748// GetFlippable is a wrapper around gtk_range_get_flippable(). 7749func (v *Range) GetFlippable() bool { 7750 return gobool(C.gtk_range_get_flippable(v.native())) 7751} 7752 7753// SetFlippable is a wrapper around gtk_range_set_flippable(). 7754func (v *Range) SetFlippable(flippable bool) { 7755 C.gtk_range_set_flippable(v.native(), gbool(flippable)) 7756} 7757 7758// GetRangeRect is a wrapper around gtk_range_get_range_rect(). 7759func (v *Range) GetRangeRect() *gdk.Rectangle { 7760 var cRect *C.GdkRectangle 7761 C.gtk_range_get_range_rect(v.native(), cRect) 7762 return gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) 7763} 7764 7765// GetSliderRange is a wrapper around gtk_range_get_slider_range(). 7766func (v *Range) GetSliderRange() (int, int) { 7767 var cStart, cEnd C.gint 7768 C.gtk_range_get_slider_range(v.native(), &cStart, &cEnd) 7769 return int(cStart), int(cEnd) 7770} 7771 7772// GetSliderFixedSize is a wrapper gtk_range_get_slider_size_fixed(). 7773func (v *Range) GetSliderFixedSize() bool { 7774 return gobool(C.gtk_range_get_slider_size_fixed(v.native())) 7775} 7776 7777// SetSliderFixedSize is a wrapper around gtk_range_set_slider_size_fixed(). 7778func (v *Range) SetSliderFixedSize(size_fixed bool) { 7779 C.gtk_range_set_slider_size_fixed(v.native(), gbool(size_fixed)) 7780} 7781 7782// IRecentChooser is an interface type implemented by all structs 7783// embedding a RecentChooser. It is meant to be used as an argument type 7784// for wrapper functions that wrap around a C GTK function taking a 7785// GtkWidget. 7786type IRecentChooser interface { 7787 toRecentChooser() *C.GtkRecentChooser 7788} 7789 7790/* 7791 * GtkRecentChooser 7792 */ 7793 7794// RecentChooser is a representation of GTK's GtkRecentChooser. 7795type RecentChooser struct { 7796 *glib.Object 7797} 7798 7799// native returns a pointer to the underlying GtkRecentChooser. 7800func (v *RecentChooser) native() *C.GtkRecentChooser { 7801 if v == nil || v.Object == nil { 7802 return nil 7803 } 7804 p := unsafe.Pointer(v.GObject) 7805 return C.toGtkRecentChooser(p) 7806} 7807 7808func wrapRecentChooser(obj *glib.Object) *RecentChooser { 7809 if obj == nil { 7810 return nil 7811 } 7812 7813 return &RecentChooser{obj} 7814} 7815 7816func (v *RecentChooser) toRecentChooser() *C.GtkRecentChooser { 7817 return v.native() 7818} 7819 7820func (v *RecentChooser) GetCurrentUri() string { 7821 curi := C.gtk_recent_chooser_get_current_uri(v.native()) 7822 return goString(curi) 7823} 7824 7825func (v *RecentChooser) AddFilter(filter *RecentFilter) { 7826 C.gtk_recent_chooser_add_filter(v.native(), filter.native()) 7827} 7828 7829func (v *RecentChooser) RemoveFilter(filter *RecentFilter) { 7830 C.gtk_recent_chooser_remove_filter(v.native(), filter.native()) 7831} 7832 7833/* 7834 * GtkRecentChooserWidget 7835 */ 7836 7837// TODO: 7838// gtk_recent_chooser_widget_new(). 7839// gtk_recent_chooser_widget_new_for_manager(). 7840 7841/* 7842 * GtkRecentChooserMenu 7843 */ 7844 7845// RecentChooserMenu is a representation of GTK's GtkRecentChooserMenu. 7846type RecentChooserMenu struct { 7847 Menu 7848 RecentChooser 7849} 7850 7851// native returns a pointer to the underlying GtkRecentManager. 7852func (v *RecentChooserMenu) native() *C.GtkRecentChooserMenu { 7853 if v == nil || v.Object == nil { 7854 return nil 7855 } 7856 p := unsafe.Pointer(v.GObject) 7857 return C.toGtkRecentChooserMenu(p) 7858} 7859 7860func wrapRecentChooserMenu(obj *glib.Object) *RecentChooserMenu { 7861 if obj == nil { 7862 return nil 7863 } 7864 7865 return &RecentChooserMenu{ 7866 Menu{MenuShell{Container{Widget{glib.InitiallyUnowned{obj}}}}}, 7867 RecentChooser{obj}, 7868 } 7869} 7870 7871/* 7872 * GtkRecentFilter 7873 */ 7874 7875// RecentFilter is a representation of GTK's GtkRecentFilter. 7876type RecentFilter struct { 7877 glib.InitiallyUnowned 7878} 7879 7880// native returns a pointer to the underlying GtkRecentFilter. 7881func (v *RecentFilter) native() *C.GtkRecentFilter { 7882 if v == nil || v.Object == nil { 7883 return nil 7884 } 7885 p := unsafe.Pointer(v.GObject) 7886 return C.toGtkRecentFilter(p) 7887} 7888 7889func wrapRecentFilter(obj *glib.Object) *RecentFilter { 7890 if obj == nil { 7891 return nil 7892 } 7893 7894 return &RecentFilter{glib.InitiallyUnowned{obj}} 7895} 7896 7897// RecentFilterNew is a wrapper around gtk_recent_filter_new(). 7898func RecentFilterNew() (*RecentFilter, error) { 7899 c := C.gtk_recent_filter_new() 7900 if c == nil { 7901 return nil, nilPtrErr 7902 } 7903 return wrapRecentFilter(glib.Take(unsafe.Pointer(c))), nil 7904} 7905 7906/* 7907 * GtkRecentManager 7908 */ 7909 7910// RecentManager is a representation of GTK's GtkRecentManager. 7911type RecentManager struct { 7912 *glib.Object 7913} 7914 7915// native returns a pointer to the underlying GtkRecentManager. 7916func (v *RecentManager) native() *C.GtkRecentManager { 7917 if v == nil || v.Object == nil { 7918 return nil 7919 } 7920 p := unsafe.Pointer(v.GObject) 7921 return C.toGtkRecentManager(p) 7922} 7923 7924func marshalRecentManager(p uintptr) (interface{}, error) { 7925 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 7926 obj := glib.Take(unsafe.Pointer(c)) 7927 return wrapRecentManager(obj), nil 7928} 7929 7930func wrapRecentManager(obj *glib.Object) *RecentManager { 7931 if obj == nil { 7932 return nil 7933 } 7934 7935 return &RecentManager{obj} 7936} 7937 7938// RecentManagerGetDefault is a wrapper around gtk_recent_manager_get_default(). 7939func RecentManagerGetDefault() (*RecentManager, error) { 7940 c := C.gtk_recent_manager_get_default() 7941 if c == nil { 7942 return nil, nilPtrErr 7943 } 7944 obj := glib.Take(unsafe.Pointer(c)) 7945 v := wrapRecentManager(obj) 7946 return v, nil 7947} 7948 7949// AddItem is a wrapper around gtk_recent_manager_add_item(). 7950func (v *RecentManager) AddItem(fileURI string) bool { 7951 cstr := C.CString(fileURI) 7952 defer C.free(unsafe.Pointer(cstr)) 7953 cok := C.gtk_recent_manager_add_item(v.native(), (*C.gchar)(cstr)) 7954 return gobool(cok) 7955} 7956 7957/* 7958 * GtkScale 7959 */ 7960 7961// Scale is a representation of GTK's GtkScale. 7962type Scale struct { 7963 Range 7964} 7965 7966// native returns a pointer to the underlying GtkScale. 7967func (v *Scale) native() *C.GtkScale { 7968 if v == nil || v.GObject == nil { 7969 return nil 7970 } 7971 p := unsafe.Pointer(v.GObject) 7972 return C.toGtkScale(p) 7973} 7974 7975func marshalScale(p uintptr) (interface{}, error) { 7976 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 7977 obj := glib.Take(unsafe.Pointer(c)) 7978 return wrapScale(obj), nil 7979} 7980 7981func wrapScale(obj *glib.Object) *Scale { 7982 if obj == nil { 7983 return nil 7984 } 7985 7986 return &Scale{Range{Widget{glib.InitiallyUnowned{obj}}}} 7987} 7988 7989// ScaleNew is a wrapper around gtk_scale_new(). 7990func ScaleNew(orientation Orientation, adjustment *Adjustment) (*Scale, error) { 7991 c := C.gtk_scale_new(C.GtkOrientation(orientation), adjustment.native()) 7992 if c == nil { 7993 return nil, nilPtrErr 7994 } 7995 return wrapScale(glib.Take(unsafe.Pointer(c))), nil 7996} 7997 7998// ScaleNewWithRange is a wrapper around gtk_scale_new_with_range(). 7999func ScaleNewWithRange(orientation Orientation, min, max, step float64) (*Scale, error) { 8000 c := C.gtk_scale_new_with_range(C.GtkOrientation(orientation), 8001 C.gdouble(min), C.gdouble(max), C.gdouble(step)) 8002 8003 if c == nil { 8004 return nil, nilPtrErr 8005 } 8006 return wrapScale(glib.Take(unsafe.Pointer(c))), nil 8007} 8008 8009// TODO: 8010// gtk_scale_set_digits(). 8011 8012// SetDrawValue is a wrapper around gtk_scale_set_draw_value(). 8013func (v *Scale) SetDrawValue(drawValue bool) { 8014 C.gtk_scale_set_draw_value(v.native(), gbool(drawValue)) 8015} 8016 8017// TODO: 8018// gtk_scale_set_has_origin(). 8019// gtk_scale_set_value_pos(). 8020// gtk_scale_get_digits(). 8021// gtk_scale_get_draw_value(). 8022// gtk_scale_get_has_origin(). 8023// gtk_scale_get_value_pos(). 8024// gtk_scale_get_layout(). 8025// gtk_scale_get_layout_offsets(). 8026 8027// AddMark is a wrpaper around gtk_scale_add_mark. 8028func (v *Scale) AddMark(value float64, pos PositionType, markup string) { 8029 var markupchar *C.gchar 8030 if markup != "" { 8031 markupchar = (*C.gchar)(C.CString(markup)) 8032 defer C.free(unsafe.Pointer(markupchar)) 8033 } 8034 8035 C.gtk_scale_add_mark(v.native(), C.gdouble(value), C.GtkPositionType(pos), markupchar) 8036} 8037 8038// ClearMarks is a wrapper around gtk_scale_clear_marks. 8039func (v *Scale) ClearMarks() { 8040 C.gtk_scale_clear_marks(v.native()) 8041} 8042 8043/* 8044 * GtkScaleButton 8045 */ 8046 8047// ScaleButton is a representation of GTK's GtkScaleButton. 8048type ScaleButton struct { 8049 Button 8050} 8051 8052// native returns a pointer to the underlying GtkScaleButton. 8053func (v *ScaleButton) native() *C.GtkScaleButton { 8054 if v == nil || v.GObject == nil { 8055 return nil 8056 } 8057 p := unsafe.Pointer(v.GObject) 8058 return C.toGtkScaleButton(p) 8059} 8060 8061func marshalScaleButton(p uintptr) (interface{}, error) { 8062 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 8063 obj := glib.Take(unsafe.Pointer(c)) 8064 return wrapScaleButton(obj), nil 8065} 8066 8067func wrapScaleButton(obj *glib.Object) *ScaleButton { 8068 if obj == nil { 8069 return nil 8070 } 8071 8072 actionable := wrapActionable(obj) 8073 return &ScaleButton{Button{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}, actionable}} 8074} 8075 8076// ScaleButtonNew is a wrapper around gtk_scale_button_new(). 8077func ScaleButtonNew(size IconSize, min, max, step float64, icons []string) (*ScaleButton, error) { 8078 cicons := make([]*C.gchar, len(icons)) 8079 for i, icon := range icons { 8080 cicons[i] = (*C.gchar)(C.CString(icon)) 8081 defer C.free(unsafe.Pointer(cicons[i])) 8082 } 8083 cicons = append(cicons, nil) 8084 8085 c := C.gtk_scale_button_new(C.GtkIconSize(size), 8086 C.gdouble(min), 8087 C.gdouble(max), 8088 C.gdouble(step), 8089 &cicons[0]) 8090 if c == nil { 8091 return nil, nilPtrErr 8092 } 8093 return wrapScaleButton(glib.Take(unsafe.Pointer(c))), nil 8094} 8095 8096// GetPopup is a wrapper around gtk_scale_button_get_popup(). 8097func (v *ScaleButton) GetPopup() (IWidget, error) { 8098 c := C.gtk_scale_button_get_popup(v.native()) 8099 if c == nil { 8100 return nil, nilPtrErr 8101 } 8102 return castWidget(c) 8103} 8104 8105// GetValue is a wrapper around gtk_scale_button_get_value(). 8106func (v *ScaleButton) GetValue() float64 { 8107 return float64(C.gtk_scale_button_get_value(v.native())) 8108} 8109 8110// SetValue is a wrapper around gtk_scale_button_set_value(). 8111func (v *ScaleButton) SetValue(value float64) { 8112 C.gtk_scale_button_set_value(v.native(), C.gdouble(value)) 8113} 8114 8115// SetIcons is a wrapper around gtk_scale_button_set_icons(). 8116func (v *ScaleButton) SetIcons() []string { 8117 var iconNames *C.gchar = nil 8118 C.gtk_scale_button_set_icons(v.native(), &iconNames) 8119 return toGoStringArray(&iconNames) 8120} 8121 8122// GetAdjustment is a wrapper around gtk_scale_button_get_adjustment(). 8123func (v *ScaleButton) GetAdjustment() *Adjustment { 8124 c := C.gtk_scale_button_get_adjustment(v.native()) 8125 obj := glib.Take(unsafe.Pointer(c)) 8126 return &Adjustment{glib.InitiallyUnowned{obj}} 8127} 8128 8129// SetAdjustment is a wrapper around gtk_scale_button_set_adjustment(). 8130func (v *ScaleButton) SetAdjustment(adjustment *Adjustment) { 8131 C.gtk_scale_button_set_adjustment(v.native(), adjustment.native()) 8132} 8133 8134// GetPlusButton is a wrapper around gtk_scale_button_get_plus_button(). 8135func (v *ScaleButton) GetPlusButton() (IWidget, error) { 8136 c := C.gtk_scale_button_get_plus_button(v.native()) 8137 if c == nil { 8138 return nil, nilPtrErr 8139 } 8140 return castWidget(c) 8141} 8142 8143// GetMinusButton is a wrapper around gtk_scale_button_get_minus_button(). 8144func (v *ScaleButton) GetMinusButton() (IWidget, error) { 8145 c := C.gtk_scale_button_get_minus_button(v.native()) 8146 if c == nil { 8147 return nil, nilPtrErr 8148 } 8149 return castWidget(c) 8150} 8151 8152/* 8153 * GtkScrollable 8154 */ 8155 8156// IScrollable is an interface type implemented by all structs 8157// embedding a Scrollable. It is meant to be used as an argument type 8158// for wrapper functions that wrap around a C GTK function taking a 8159// GtkScrollable. 8160type IScrollable interface { 8161 toScrollable() *C.GtkScrollable 8162} 8163 8164// Scrollable is a representation of GTK's GtkScrollable GInterface. 8165type Scrollable struct { 8166 *glib.Object 8167} 8168 8169// native() returns a pointer to the underlying GObject as a GtkScrollable. 8170func (v *Scrollable) native() *C.GtkScrollable { 8171 if v == nil || v.GObject == nil { 8172 return nil 8173 } 8174 p := unsafe.Pointer(v.GObject) 8175 return C.toGtkScrollable(p) 8176} 8177 8178func wrapScrollable(obj *glib.Object) *Scrollable { 8179 if obj == nil { 8180 return nil 8181 } 8182 8183 return &Scrollable{obj} 8184} 8185 8186func (v *Scrollable) toScrollable() *C.GtkScrollable { 8187 if v == nil { 8188 return nil 8189 } 8190 return v.native() 8191} 8192 8193// SetHAdjustment is a wrapper around gtk_scrollable_set_hadjustment(). 8194func (v *Scrollable) SetHAdjustment(adjustment *Adjustment) { 8195 C.gtk_scrollable_set_hadjustment(v.native(), adjustment.native()) 8196} 8197 8198// GetHAdjustment is a wrapper around gtk_scrollable_get_hadjustment(). 8199func (v *Scrollable) GetHAdjustment() (*Adjustment, error) { 8200 c := C.gtk_scrollable_get_hadjustment(v.native()) 8201 if c == nil { 8202 return nil, nilPtrErr 8203 } 8204 return wrapAdjustment(glib.Take(unsafe.Pointer(c))), nil 8205} 8206 8207// SetVAdjustment is a wrapper around gtk_scrollable_set_vadjustment(). 8208func (v *Scrollable) SetVAdjustment(adjustment *Adjustment) { 8209 C.gtk_scrollable_set_vadjustment(v.native(), adjustment.native()) 8210} 8211 8212// GetVAdjustment is a wrapper around gtk_scrollable_get_vadjustment(). 8213func (v *Scrollable) GetVAdjustment() (*Adjustment, error) { 8214 c := C.gtk_scrollable_get_vadjustment(v.native()) 8215 if c == nil { 8216 return nil, nilPtrErr 8217 } 8218 return wrapAdjustment(glib.Take(unsafe.Pointer(c))), nil 8219} 8220 8221/* 8222 * GtkScrollbar 8223 */ 8224 8225// Scrollbar is a representation of GTK's GtkScrollbar. 8226type Scrollbar struct { 8227 Range 8228} 8229 8230// native returns a pointer to the underlying GtkScrollbar. 8231func (v *Scrollbar) native() *C.GtkScrollbar { 8232 if v == nil || v.GObject == nil { 8233 return nil 8234 } 8235 p := unsafe.Pointer(v.GObject) 8236 return C.toGtkScrollbar(p) 8237} 8238 8239func marshalScrollbar(p uintptr) (interface{}, error) { 8240 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 8241 obj := glib.Take(unsafe.Pointer(c)) 8242 return wrapScrollbar(obj), nil 8243} 8244 8245func wrapScrollbar(obj *glib.Object) *Scrollbar { 8246 if obj == nil { 8247 return nil 8248 } 8249 8250 return &Scrollbar{Range{Widget{glib.InitiallyUnowned{obj}}}} 8251} 8252 8253// ScrollbarNew is a wrapper around gtk_scrollbar_new(). 8254func ScrollbarNew(orientation Orientation, adjustment *Adjustment) (*Scrollbar, error) { 8255 c := C.gtk_scrollbar_new(C.GtkOrientation(orientation), adjustment.native()) 8256 if c == nil { 8257 return nil, nilPtrErr 8258 } 8259 return wrapScrollbar(glib.Take(unsafe.Pointer(c))), nil 8260} 8261 8262/* 8263 * GtkScrolledWindow 8264 */ 8265 8266// ScrolledWindow is a representation of GTK's GtkScrolledWindow. 8267type ScrolledWindow struct { 8268 Bin 8269} 8270 8271// native returns a pointer to the underlying GtkScrolledWindow. 8272func (v *ScrolledWindow) native() *C.GtkScrolledWindow { 8273 if v == nil || v.GObject == nil { 8274 return nil 8275 } 8276 p := unsafe.Pointer(v.GObject) 8277 return C.toGtkScrolledWindow(p) 8278} 8279 8280func marshalScrolledWindow(p uintptr) (interface{}, error) { 8281 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 8282 obj := glib.Take(unsafe.Pointer(c)) 8283 return wrapScrolledWindow(obj), nil 8284} 8285 8286func wrapScrolledWindow(obj *glib.Object) *ScrolledWindow { 8287 if obj == nil { 8288 return nil 8289 } 8290 8291 return &ScrolledWindow{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} 8292} 8293 8294// ScrolledWindowNew() is a wrapper around gtk_scrolled_window_new(). 8295func ScrolledWindowNew(hadjustment, vadjustment *Adjustment) (*ScrolledWindow, error) { 8296 c := C.gtk_scrolled_window_new(hadjustment.native(), 8297 vadjustment.native()) 8298 if c == nil { 8299 return nil, nilPtrErr 8300 } 8301 return wrapScrolledWindow(glib.Take(unsafe.Pointer(c))), nil 8302} 8303 8304// GetPolicy() is a wrapper around gtk_scrolled_window_get_policy(). 8305func (v *ScrolledWindow) GetPolicy() (hScrollbarPolicy, vScrollbarPolicy PolicyType) { 8306 var hScrPol, vScrPol C.GtkPolicyType 8307 C.gtk_scrolled_window_get_policy(v.native(), &hScrPol, &vScrPol) 8308 hScrollbarPolicy, vScrollbarPolicy = PolicyType(hScrPol), PolicyType(vScrPol) 8309 return 8310} 8311 8312// SetPolicy() is a wrapper around gtk_scrolled_window_set_policy(). 8313func (v *ScrolledWindow) SetPolicy(hScrollbarPolicy, vScrollbarPolicy PolicyType) { 8314 C.gtk_scrolled_window_set_policy(v.native(), 8315 C.GtkPolicyType(hScrollbarPolicy), 8316 C.GtkPolicyType(vScrollbarPolicy)) 8317} 8318 8319// GetHAdjustment() is a wrapper around gtk_scrolled_window_get_hadjustment(). 8320func (v *ScrolledWindow) GetHAdjustment() *Adjustment { 8321 c := C.gtk_scrolled_window_get_hadjustment(v.native()) 8322 if c == nil { 8323 return nil 8324 } 8325 return wrapAdjustment(glib.Take(unsafe.Pointer(c))) 8326} 8327 8328// SetHAdjustment is a wrapper around gtk_scrolled_window_set_hadjustment(). 8329func (v *ScrolledWindow) SetHAdjustment(adjustment *Adjustment) { 8330 C.gtk_scrolled_window_set_hadjustment(v.native(), adjustment.native()) 8331} 8332 8333// GetVAdjustment() is a wrapper around gtk_scrolled_window_get_vadjustment(). 8334func (v *ScrolledWindow) GetVAdjustment() *Adjustment { 8335 c := C.gtk_scrolled_window_get_vadjustment(v.native()) 8336 if c == nil { 8337 return nil 8338 } 8339 return wrapAdjustment(glib.Take(unsafe.Pointer(c))) 8340} 8341 8342// SetVAdjustment is a wrapper around gtk_scrolled_window_set_vadjustment(). 8343func (v *ScrolledWindow) SetVAdjustment(adjustment *Adjustment) { 8344 C.gtk_scrolled_window_set_vadjustment(v.native(), adjustment.native()) 8345} 8346 8347// GetHScrollbar is a wrapper around gtk_scrolled_window_get_hscrollbar(). 8348func (v *ScrolledWindow) GetHScrollbar() *Scrollbar { 8349 c := C.gtk_scrolled_window_get_hscrollbar(v.native()) 8350 if c == nil { 8351 return nil 8352 } 8353 return wrapScrollbar(glib.Take(unsafe.Pointer(c))) 8354} 8355 8356// GetVScrollbar is a wrapper around gtk_scrolled_window_get_vscrollbar(). 8357func (v *ScrolledWindow) GetVScrollbar() *Scrollbar { 8358 c := C.gtk_scrolled_window_get_vscrollbar(v.native()) 8359 if c == nil { 8360 return nil 8361 } 8362 return wrapScrollbar(glib.Take(unsafe.Pointer(c))) 8363} 8364 8365// GetPlacement is a wrapper around gtk_scrolled_window_get_placement(). 8366func (v *ScrolledWindow) GetPlacement() CornerType { 8367 c := C.gtk_scrolled_window_get_placement(v.native()) 8368 return CornerType(c) 8369} 8370 8371// SetPlacement is a wrapper around gtk_scrolled_window_set_placement(). 8372func (v *ScrolledWindow) SetPlacement(windowPlacement CornerType) { 8373 C.gtk_scrolled_window_set_placement(v.native(), C.GtkCornerType(windowPlacement)) 8374} 8375 8376// UnsetPlacement is a wrapper around gtk_scrolled_window_unset_placement(). 8377func (v *ScrolledWindow) UnsetPlacement() { 8378 C.gtk_scrolled_window_unset_placement(v.native()) 8379} 8380 8381// GetShadowType is a wrapper around gtk_scrolled_window_get_shadow_type(). 8382func (v *ScrolledWindow) GetShadowType() ShadowType { 8383 c := C.gtk_scrolled_window_get_shadow_type(v.native()) 8384 return ShadowType(c) 8385} 8386 8387// SetShadowType is a wrapper around gtk_scrolled_window_set_shadow_type(). 8388func (v *ScrolledWindow) SetShadowType(t ShadowType) { 8389 C.gtk_scrolled_window_set_shadow_type(v.native(), C.GtkShadowType(t)) 8390} 8391 8392// GetKineticScrolling is a wrapper around gtk_scrolled_window_get_kinetic_scrolling(). 8393func (v *ScrolledWindow) GetKineticScrolling() bool { 8394 c := C.gtk_scrolled_window_get_kinetic_scrolling(v.native()) 8395 return gobool(c) 8396} 8397 8398// SetKineticScrolling is a wrapper around gtk_scrolled_window_set_kinetic_scrolling(). 8399func (v *ScrolledWindow) SetKineticScrolling(kineticScrolling bool) { 8400 C.gtk_scrolled_window_set_kinetic_scrolling(v.native(), gbool(kineticScrolling)) 8401} 8402 8403// GetCaptureButtonPress is a wrapper around gtk_scrolled_window_get_capture_button_press(). 8404func (v *ScrolledWindow) GetCaptureButtonPress() bool { 8405 c := C.gtk_scrolled_window_get_capture_button_press(v.native()) 8406 return gobool(c) 8407} 8408 8409// SetCaptureButtonPress is a wrapper around gtk_scrolled_window_set_capture_button_press(). 8410func (v *ScrolledWindow) SetCaptureButtonPress(captureButtonPress bool) { 8411 C.gtk_scrolled_window_set_capture_button_press(v.native(), gbool(captureButtonPress)) 8412} 8413 8414// GetMinContentWidth is a wrapper around gtk_scrolled_window_get_min_content_width(). 8415func (v *ScrolledWindow) GetMinContentWidth() int { 8416 c := C.gtk_scrolled_window_get_min_content_width(v.native()) 8417 return int(c) 8418} 8419 8420// SetMinContentWidth is a wrapper around gtk_scrolled_window_set_min_content_width(). 8421func (v *ScrolledWindow) SetMinContentWidth(width int) { 8422 C.gtk_scrolled_window_set_min_content_width(v.native(), C.gint(width)) 8423} 8424 8425// GetMinContentHeight is a wrapper around gtk_scrolled_window_get_min_content_height(). 8426func (v *ScrolledWindow) GetMinContentHeight() int { 8427 c := C.gtk_scrolled_window_get_min_content_height(v.native()) 8428 return int(c) 8429} 8430 8431// SetMinContentHeight is a wrapper around gtk_scrolled_window_set_min_content_height(). 8432func (v *ScrolledWindow) SetMinContentHeight(width int) { 8433 C.gtk_scrolled_window_set_min_content_height(v.native(), C.gint(width)) 8434} 8435 8436/* 8437 * GtkSearchEntry 8438 */ 8439 8440// SearchEntry is a reprensentation of GTK's GtkSearchEntry. 8441type SearchEntry struct { 8442 Entry 8443} 8444 8445// native returns a pointer to the underlying GtkSearchEntry. 8446func (v *SearchEntry) native() *C.GtkSearchEntry { 8447 if v == nil || v.GObject == nil { 8448 return nil 8449 } 8450 p := unsafe.Pointer(v.GObject) 8451 return C.toGtkSearchEntry(p) 8452} 8453 8454func marshalSearchEntry(p uintptr) (interface{}, error) { 8455 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 8456 obj := glib.Take(unsafe.Pointer(c)) 8457 return wrapSearchEntry(obj), nil 8458} 8459 8460func wrapSearchEntry(obj *glib.Object) *SearchEntry { 8461 if obj == nil { 8462 return nil 8463 } 8464 8465 e := wrapEditable(obj) 8466 ce := wrapCellEditable(obj) 8467 return &SearchEntry{Entry{Widget{glib.InitiallyUnowned{obj}}, *e, *ce}} 8468} 8469 8470// SearchEntryNew is a wrapper around gtk_search_entry_new(). 8471func SearchEntryNew() (*SearchEntry, error) { 8472 c := C.gtk_search_entry_new() 8473 if c == nil { 8474 return nil, nilPtrErr 8475 } 8476 return wrapSearchEntry(glib.Take(unsafe.Pointer(c))), nil 8477} 8478 8479/* 8480* GtkSelectionData 8481 */ 8482type SelectionData struct { 8483 GtkSelectionData *C.GtkSelectionData 8484} 8485 8486func marshalSelectionData(p uintptr) (interface{}, error) { 8487 c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) 8488 return (*SelectionData)(unsafe.Pointer(c)), nil 8489} 8490 8491// native returns a pointer to the underlying GtkSelectionData. 8492func (v *SelectionData) native() *C.GtkSelectionData { 8493 if v == nil { 8494 return nil 8495 } 8496 8497 // I don't understand why we need this, but we do. 8498 c := (*C.GValue)(unsafe.Pointer(v)) 8499 p := (*C.GtkSelectionData)(unsafe.Pointer(c)) 8500 return p 8501} 8502 8503// GetLength is a wrapper around gtk_selection_data_get_length(). 8504func (v *SelectionData) GetLength() int { 8505 return int(C.gtk_selection_data_get_length(v.native())) 8506} 8507 8508// GetData is a wrapper around gtk_selection_data_get_data_with_length(). 8509// It returns a slice of the correct size with the copy of the selection's data. 8510func (v *SelectionData) GetData() []byte { 8511 var length C.gint 8512 c := C.gtk_selection_data_get_data_with_length(v.native(), &length) 8513 8514 // Only set if length is valid. 8515 if int(length) < 1 { 8516 return nil 8517 } 8518 8519 var data []byte 8520 sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data)) 8521 sliceHeader.Len = int(length) 8522 sliceHeader.Cap = int(length) 8523 sliceHeader.Data = uintptr(unsafe.Pointer(c)) 8524 8525 // Keep the SelectionData alive for as long as the byte slice is. 8526 runtime.SetFinalizer(&data, func(*[]byte) { 8527 runtime.KeepAlive(v) 8528 }) 8529 8530 return data 8531} 8532 8533// SetData is a wrapper around gtk_selection_data_set_data_with_length(). 8534func (v *SelectionData) SetData(atom gdk.Atom, data []byte) { 8535 C.gtk_selection_data_set( 8536 v.native(), 8537 C.GdkAtom(unsafe.Pointer(atom)), 8538 C.gint(8), (*C.guchar)(&data[0]), C.gint(len(data)), 8539 ) 8540} 8541 8542// GetText is a wrapper around gtk_selection_data_get_text(). It returns a copy 8543// of the string from SelectionData and frees the C reference. 8544func (v *SelectionData) GetText() string { 8545 charptr := C.gtk_selection_data_get_text(v.native()) 8546 if charptr == nil { 8547 return "" 8548 } 8549 8550 defer C.g_free(C.gpointer(charptr)) 8551 8552 return ucharString(charptr) 8553} 8554 8555// SetText is a wrapper around gtk_selection_data_set_text(). 8556func (v *SelectionData) SetText(text string) bool { 8557 textPtr := *(*[]byte)(unsafe.Pointer(&text)) 8558 8559 return gobool(C.gtk_selection_data_set_text( 8560 v.native(), 8561 // https://play.golang.org/p/PmGaLDhRuEU 8562 // This is probably safe since we expect Gdk to copy the string anyway. 8563 (*C.gchar)(unsafe.Pointer(&textPtr[0])), C.int(len(text)), 8564 )) 8565} 8566 8567// SetPixbuf is a wrapper around gtk_selection_data_set_pixbuf(). 8568func (v *SelectionData) SetPixbuf(pixbuf *gdk.Pixbuf) bool { 8569 return gobool(C.gtk_selection_data_set_pixbuf( 8570 v.native(), 8571 (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native())), 8572 )) 8573} 8574 8575// GetPixbuf is a wrapper around gtk_selection_data_get_pixbuf(). It returns nil 8576// if the data is a recognized image type that could be converted to a new 8577// Pixbuf. 8578func (v *SelectionData) GetPixbuf() *gdk.Pixbuf { 8579 c := C.gtk_selection_data_get_pixbuf(v.native()) 8580 if c == nil { 8581 return nil 8582 } 8583 8584 obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} 8585 p := &gdk.Pixbuf{obj} 8586 runtime.SetFinalizer(p, func(_ interface{}) { obj.Unref() }) 8587 8588 return p 8589} 8590 8591// SetURIs is a wrapper around gtk_selection_data_set_uris(). 8592func (v *SelectionData) SetURIs(uris []string) bool { 8593 var clist = C.make_strings(C.int(len(uris))) 8594 for i := range uris { 8595 cstring := C.CString(uris[i]) 8596 // This defer will only run once the function exits, not once the loop 8597 // exits, so it's perfectly fine. 8598 defer C.free(unsafe.Pointer(cstring)) 8599 8600 C.set_string(clist, C.int(i), (*C.gchar)(cstring)) 8601 } 8602 8603 return gobool(C.gtk_selection_data_set_uris(v.native(), clist)) 8604} 8605 8606// GetURIs is a wrapper around gtk_selection_data_get_uris(). 8607func (v *SelectionData) GetURIs() []string { 8608 uriPtrs := C.gtk_selection_data_get_uris(v.native()) 8609 return toGoStringArray(uriPtrs) 8610} 8611 8612func (v *SelectionData) free() { 8613 C.gtk_selection_data_free(v.native()) 8614} 8615 8616// DragSetIconPixbuf is used for the "drag-begin" event. It is a wrapper around 8617// gtk_drag_set_icon_pixbuf(). 8618func DragSetIconPixbuf(context *gdk.DragContext, pixbuf *gdk.Pixbuf, hotX, hotY int) { 8619 ctx := unsafe.Pointer(context.Native()) 8620 pix := unsafe.Pointer(pixbuf.Native()) 8621 C.gtk_drag_set_icon_pixbuf((*C.GdkDragContext)(ctx), (*C.GdkPixbuf)(pix), C.gint(hotX), C.gint(hotY)) 8622} 8623 8624// DragSetIconWidget is a wrapper around gtk_drag_set_icon_widget(). 8625func DragSetIconWidget(context *gdk.DragContext, w IWidget, hotX, hotY int) { 8626 ctx := unsafe.Pointer(context.Native()) 8627 C.gtk_drag_set_icon_widget((*C.GdkDragContext)(ctx), w.toWidget(), C.gint(hotX), C.gint(hotY)) 8628} 8629 8630// DragSetIconSurface is a wrapper around gtk_drag_set_icon_surface(). 8631func DragSetIconSurface(context *gdk.DragContext, surface *cairo.Surface) { 8632 ctx := unsafe.Pointer(context.Native()) 8633 sur := unsafe.Pointer(surface.Native()) 8634 C.gtk_drag_set_icon_surface((*C.GdkDragContext)(ctx), (*C.cairo_surface_t)(sur)) 8635} 8636 8637// DragSetIconName is a wrapper around gtk_drag_set_icon_name(). 8638func DragSetIconName(context *gdk.DragContext, iconName string, hotX, hotY int) { 8639 ctx := unsafe.Pointer(context.Native()) 8640 ico := (*C.gchar)(C.CString(iconName)) 8641 defer C.free(unsafe.Pointer(ico)) 8642 8643 C.gtk_drag_set_icon_name((*C.GdkDragContext)(ctx), ico, C.gint(hotX), C.gint(hotY)) 8644} 8645 8646// DragSetIconDefault is a wrapper around gtk_drag_set_icon_default(). 8647func DragSetIconDefault(context *gdk.DragContext) { 8648 ctx := unsafe.Pointer(context.Native()) 8649 C.gtk_drag_set_icon_default((*C.GdkDragContext)(ctx)) 8650} 8651 8652/* 8653 * GtkSeparator 8654 */ 8655 8656// Separator is a representation of GTK's GtkSeparator. 8657type Separator struct { 8658 Widget 8659} 8660 8661// native returns a pointer to the underlying GtkSeperator. 8662func (v *Separator) native() *C.GtkSeparator { 8663 if v == nil || v.GObject == nil { 8664 return nil 8665 } 8666 p := unsafe.Pointer(v.GObject) 8667 return C.toGtkSeparator(p) 8668} 8669 8670func marshalSeparator(p uintptr) (interface{}, error) { 8671 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 8672 obj := glib.Take(unsafe.Pointer(c)) 8673 return wrapSeparator(obj), nil 8674} 8675 8676func wrapSeparator(obj *glib.Object) *Separator { 8677 if obj == nil { 8678 return nil 8679 } 8680 8681 return &Separator{Widget{glib.InitiallyUnowned{obj}}} 8682} 8683 8684// SeparatorNew is a wrapper around gtk_separator_new(). 8685func SeparatorNew(orientation Orientation) (*Separator, error) { 8686 c := C.gtk_separator_new(C.GtkOrientation(orientation)) 8687 if c == nil { 8688 return nil, nilPtrErr 8689 } 8690 return wrapSeparator(glib.Take(unsafe.Pointer(c))), nil 8691} 8692 8693/* 8694 * GtkSeparatorMenuItem 8695 */ 8696 8697// SeparatorMenuItem is a representation of GTK's GtkSeparatorMenuItem. 8698type SeparatorMenuItem struct { 8699 MenuItem 8700} 8701 8702// native returns a pointer to the underlying GtkSeparatorMenuItem. 8703func (v *SeparatorMenuItem) native() *C.GtkSeparatorMenuItem { 8704 if v == nil || v.GObject == nil { 8705 return nil 8706 } 8707 p := unsafe.Pointer(v.GObject) 8708 return C.toGtkSeparatorMenuItem(p) 8709} 8710 8711func marshalSeparatorMenuItem(p uintptr) (interface{}, error) { 8712 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 8713 obj := glib.Take(unsafe.Pointer(c)) 8714 return wrapSeparatorMenuItem(obj), nil 8715} 8716 8717func wrapSeparatorMenuItem(obj *glib.Object) *SeparatorMenuItem { 8718 if obj == nil { 8719 return nil 8720 } 8721 8722 return &SeparatorMenuItem{MenuItem{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} 8723} 8724 8725// SeparatorMenuItemNew is a wrapper around gtk_separator_menu_item_new(). 8726func SeparatorMenuItemNew() (*SeparatorMenuItem, error) { 8727 c := C.gtk_separator_menu_item_new() 8728 if c == nil { 8729 return nil, nilPtrErr 8730 } 8731 return wrapSeparatorMenuItem(glib.Take(unsafe.Pointer(c))), nil 8732} 8733 8734/* 8735 * GtkSeparatorToolItem 8736 */ 8737 8738// SeparatorToolItem is a representation of GTK's GtkSeparatorToolItem. 8739type SeparatorToolItem struct { 8740 ToolItem 8741} 8742 8743// native returns a pointer to the underlying GtkSeparatorToolItem. 8744func (v *SeparatorToolItem) native() *C.GtkSeparatorToolItem { 8745 if v == nil || v.GObject == nil { 8746 return nil 8747 } 8748 p := unsafe.Pointer(v.GObject) 8749 return C.toGtkSeparatorToolItem(p) 8750} 8751 8752func marshalSeparatorToolItem(p uintptr) (interface{}, error) { 8753 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 8754 obj := glib.Take(unsafe.Pointer(c)) 8755 return wrapSeparatorToolItem(obj), nil 8756} 8757 8758func wrapSeparatorToolItem(obj *glib.Object) *SeparatorToolItem { 8759 if obj == nil { 8760 return nil 8761 } 8762 8763 return &SeparatorToolItem{ToolItem{Bin{Container{Widget{ 8764 glib.InitiallyUnowned{obj}}}}}} 8765} 8766 8767// SeparatorToolItemNew is a wrapper around gtk_separator_tool_item_new(). 8768func SeparatorToolItemNew() (*SeparatorToolItem, error) { 8769 c := C.gtk_separator_tool_item_new() 8770 if c == nil { 8771 return nil, nilPtrErr 8772 } 8773 return wrapSeparatorToolItem(glib.Take(unsafe.Pointer(c))), nil 8774} 8775 8776// SetDraw is a wrapper around gtk_separator_tool_item_set_draw(). 8777func (v *SeparatorToolItem) SetDraw(draw bool) { 8778 C.gtk_separator_tool_item_set_draw(v.native(), gbool(draw)) 8779} 8780 8781// GetDraw is a wrapper around gtk_separator_tool_item_get_draw(). 8782func (v *SeparatorToolItem) GetDraw() bool { 8783 c := C.gtk_separator_tool_item_get_draw(v.native()) 8784 return gobool(c) 8785} 8786 8787/* 8788 * GtkSizeGroup 8789 */ 8790 8791// SizeGroup is a representation of GTK's GtkSizeGroup 8792type SizeGroup struct { 8793 *glib.Object 8794} 8795 8796// native() returns a pointer to the underlying GtkSizeGroup 8797func (v *SizeGroup) native() *C.GtkSizeGroup { 8798 if v == nil || v.GObject == nil { 8799 return nil 8800 } 8801 p := unsafe.Pointer(v.GObject) 8802 return C.toGtkSizeGroup(p) 8803} 8804 8805func marshalSizeGroup(p uintptr) (interface{}, error) { 8806 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 8807 obj := glib.Take(unsafe.Pointer(c)) 8808 return &SizeGroup{obj}, nil 8809} 8810 8811func wrapSizeGroup(obj *glib.Object) *SizeGroup { 8812 if obj == nil { 8813 return nil 8814 } 8815 8816 return &SizeGroup{obj} 8817} 8818 8819// SizeGroupNew is a wrapper around gtk_size_group_new(). 8820func SizeGroupNew(mode SizeGroupMode) (*SizeGroup, error) { 8821 c := C.gtk_size_group_new(C.GtkSizeGroupMode(mode)) 8822 if c == nil { 8823 return nil, nilPtrErr 8824 } 8825 return wrapSizeGroup(glib.Take(unsafe.Pointer(c))), nil 8826} 8827 8828func (v *SizeGroup) SetMode(mode SizeGroupMode) { 8829 C.gtk_size_group_set_mode(v.native(), C.GtkSizeGroupMode(mode)) 8830} 8831 8832func (v *SizeGroup) GetMode() SizeGroupMode { 8833 return SizeGroupMode(C.gtk_size_group_get_mode(v.native())) 8834} 8835 8836func (v *SizeGroup) AddWidget(widget IWidget) { 8837 C.gtk_size_group_add_widget(v.native(), widget.toWidget()) 8838} 8839 8840func (v *SizeGroup) RemoveWidget(widget IWidget) { 8841 C.gtk_size_group_remove_widget(v.native(), widget.toWidget()) 8842} 8843 8844func (v *SizeGroup) GetWidgets() *glib.SList { 8845 c := C.gtk_size_group_get_widgets(v.native()) 8846 if c == nil { 8847 return nil 8848 } 8849 8850 // TODO: call DataWrapper on SList and wrap them to gtk.IWidget 8851 // see (v *Container) GetFocusChain() 8852 8853 return glib.WrapSList(uintptr(unsafe.Pointer(c))) 8854} 8855 8856/* 8857 * GtkSpinButton 8858 */ 8859 8860// SpinButton is a representation of GTK's GtkSpinButton. 8861type SpinButton struct { 8862 Entry 8863 Orientable 8864} 8865 8866// native returns a pointer to the underlying GtkSpinButton. 8867func (v *SpinButton) native() *C.GtkSpinButton { 8868 if v == nil || v.GObject == nil { 8869 return nil 8870 } 8871 p := unsafe.Pointer(v.GObject) 8872 return C.toGtkSpinButton(p) 8873} 8874 8875func marshalSpinButton(p uintptr) (interface{}, error) { 8876 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 8877 obj := glib.Take(unsafe.Pointer(c)) 8878 return wrapSpinButton(obj), nil 8879} 8880 8881func wrapSpinButton(obj *glib.Object) *SpinButton { 8882 if obj == nil { 8883 return nil 8884 } 8885 8886 e := wrapEditable(obj) 8887 ce := wrapCellEditable(obj) 8888 o := wrapOrientable(obj) 8889 return &SpinButton{Entry{Widget{glib.InitiallyUnowned{obj}}, *e, *ce}, *o} 8890} 8891 8892// Configure is a wrapper around gtk_spin_button_configure(). 8893func (v *SpinButton) Configure(adjustment *Adjustment, climbRate float64, digits uint) { 8894 C.gtk_spin_button_configure(v.native(), adjustment.native(), 8895 C.gdouble(climbRate), C.guint(digits)) 8896} 8897 8898// SpinButtonNew is a wrapper around gtk_spin_button_new(). 8899func SpinButtonNew(adjustment *Adjustment, climbRate float64, digits uint) (*SpinButton, error) { 8900 c := C.gtk_spin_button_new(adjustment.native(), 8901 C.gdouble(climbRate), C.guint(digits)) 8902 if c == nil { 8903 return nil, nilPtrErr 8904 } 8905 return wrapSpinButton(glib.Take(unsafe.Pointer(c))), nil 8906} 8907 8908// SpinButtonNewWithRange is a wrapper around gtk_spin_button_new_with_range(). 8909func SpinButtonNewWithRange(min, max, step float64) (*SpinButton, error) { 8910 c := C.gtk_spin_button_new_with_range(C.gdouble(min), C.gdouble(max), 8911 C.gdouble(step)) 8912 if c == nil { 8913 return nil, nilPtrErr 8914 } 8915 return wrapSpinButton(glib.Take(unsafe.Pointer(c))), nil 8916} 8917 8918// SetAdjustment() is a wrapper around gtk_spin_button_set_adjustment(). 8919func (v *SpinButton) SetAdjustment(adjustment *Adjustment) { 8920 C.gtk_spin_button_set_adjustment(v.native(), adjustment.native()) 8921} 8922 8923// GetAdjustment() is a wrapper around gtk_spin_button_get_adjustment 8924func (v *SpinButton) GetAdjustment() *Adjustment { 8925 c := C.gtk_spin_button_get_adjustment(v.native()) 8926 if c == nil { 8927 return nil 8928 } 8929 return wrapAdjustment(glib.Take(unsafe.Pointer(c))) 8930} 8931 8932// SetDigits() is a wrapper around gtk_spin_button_set_digits(). 8933func (v *SpinButton) SetDigits(digits uint) { 8934 C.gtk_spin_button_set_digits(v.native(), C.guint(digits)) 8935} 8936 8937// SetIncrements() is a wrapper around gtk_spin_button_set_increments(). 8938func (v *SpinButton) SetIncrements(step, page float64) { 8939 C.gtk_spin_button_set_increments(v.native(), C.gdouble(step), C.gdouble(page)) 8940} 8941 8942// SetRange is a wrapper around gtk_spin_button_set_range(). 8943func (v *SpinButton) SetRange(min, max float64) { 8944 C.gtk_spin_button_set_range(v.native(), C.gdouble(min), C.gdouble(max)) 8945} 8946 8947// SetValue() is a wrapper around gtk_spin_button_set_value(). 8948func (v *SpinButton) SetValue(value float64) { 8949 C.gtk_spin_button_set_value(v.native(), C.gdouble(value)) 8950} 8951 8952// GetValue() is a wrapper around gtk_spin_button_get_value(). 8953func (v *SpinButton) GetValue() float64 { 8954 c := C.gtk_spin_button_get_value(v.native()) 8955 return float64(c) 8956} 8957 8958// GetValueAsInt is a wrapper around gtk_spin_button_get_value_as_int(). 8959func (v *SpinButton) GetValueAsInt() int { 8960 c := C.gtk_spin_button_get_value_as_int(v.native()) 8961 return int(c) 8962} 8963 8964// SetUpdatePolicy() is a wrapper around gtk_spin_button_set_update_policy(). 8965func (v *SpinButton) SetUpdatePolicy(policy SpinButtonUpdatePolicy) { 8966 C.gtk_spin_button_set_update_policy( 8967 v.native(), 8968 C.GtkSpinButtonUpdatePolicy(policy)) 8969} 8970 8971// SetNumeric() is a wrapper around gtk_spin_button_set_numeric(). 8972func (v *SpinButton) SetNumeric(numeric bool) { 8973 C.gtk_spin_button_set_numeric(v.native(), gbool(numeric)) 8974} 8975 8976// Spin() is a wrapper around gtk_spin_button_spin(). 8977func (v *SpinButton) Spin(direction SpinType, increment float64) { 8978 C.gtk_spin_button_spin( 8979 v.native(), 8980 C.GtkSpinType(direction), 8981 C.gdouble(increment)) 8982} 8983 8984// gtk_spin_button_set_wrap(). 8985// gtk_spin_button_set_snap_to_ticks(). 8986 8987// Update() is a wrapper around gtk_spin_button_update(). 8988func (v *SpinButton) Update() { 8989 C.gtk_spin_button_update(v.native()) 8990} 8991 8992// GetDigits() is a wrapper around gtk_spin_button_get_digits(). 8993func (v *SpinButton) GetDigits() uint { 8994 return uint(C.gtk_spin_button_get_digits(v.native())) 8995} 8996 8997// gtk_spin_button_get_increments(). 8998// gtk_spin_button_get_numeric(). 8999// gtk_spin_button_get_range(). 9000// gtk_spin_button_get_snap_to_ticks(). 9001 9002// GetUpdatePolicy() is a wrapper around gtk_spin_button_get_update_policy(). 9003func (v *SpinButton) GetUpdatePolicy() SpinButtonUpdatePolicy { 9004 return SpinButtonUpdatePolicy( 9005 C.gtk_spin_button_get_update_policy( 9006 v.native())) 9007} 9008 9009// gtk_spin_button_get_wrap(). 9010 9011/* 9012 * GtkSpinner 9013 */ 9014 9015// Spinner is a representation of GTK's GtkSpinner. 9016type Spinner struct { 9017 Widget 9018} 9019 9020// native returns a pointer to the underlying GtkSpinner. 9021func (v *Spinner) native() *C.GtkSpinner { 9022 if v == nil || v.GObject == nil { 9023 return nil 9024 } 9025 p := unsafe.Pointer(v.GObject) 9026 return C.toGtkSpinner(p) 9027} 9028 9029func marshalSpinner(p uintptr) (interface{}, error) { 9030 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 9031 obj := glib.Take(unsafe.Pointer(c)) 9032 return wrapSpinner(obj), nil 9033} 9034 9035func wrapSpinner(obj *glib.Object) *Spinner { 9036 if obj == nil { 9037 return nil 9038 } 9039 9040 return &Spinner{Widget{glib.InitiallyUnowned{obj}}} 9041} 9042 9043// SpinnerNew is a wrapper around gtk_spinner_new(). 9044func SpinnerNew() (*Spinner, error) { 9045 c := C.gtk_spinner_new() 9046 if c == nil { 9047 return nil, nilPtrErr 9048 } 9049 return wrapSpinner(glib.Take(unsafe.Pointer(c))), nil 9050} 9051 9052// Start is a wrapper around gtk_spinner_start(). 9053func (v *Spinner) Start() { 9054 C.gtk_spinner_start(v.native()) 9055} 9056 9057// Stop is a wrapper around gtk_spinner_stop(). 9058func (v *Spinner) Stop() { 9059 C.gtk_spinner_stop(v.native()) 9060} 9061 9062/* 9063 * GtkStatusbar 9064 */ 9065 9066// Statusbar is a representation of GTK's GtkStatusbar 9067type Statusbar struct { 9068 Box 9069} 9070 9071// native returns a pointer to the underlying GtkStatusbar 9072func (v *Statusbar) native() *C.GtkStatusbar { 9073 if v == nil || v.GObject == nil { 9074 return nil 9075 } 9076 p := unsafe.Pointer(v.GObject) 9077 return C.toGtkStatusbar(p) 9078} 9079 9080func marshalStatusbar(p uintptr) (interface{}, error) { 9081 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 9082 obj := glib.Take(unsafe.Pointer(c)) 9083 return wrapStatusbar(obj), nil 9084} 9085 9086func wrapStatusbar(obj *glib.Object) *Statusbar { 9087 if obj == nil { 9088 return nil 9089 } 9090 9091 return &Statusbar{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}} 9092} 9093 9094// StatusbarNew() is a wrapper around gtk_statusbar_new(). 9095func StatusbarNew() (*Statusbar, error) { 9096 c := C.gtk_statusbar_new() 9097 if c == nil { 9098 return nil, nilPtrErr 9099 } 9100 return wrapStatusbar(glib.Take(unsafe.Pointer(c))), nil 9101} 9102 9103// GetContextId() is a wrapper around gtk_statusbar_get_context_id(). 9104func (v *Statusbar) GetContextId(contextDescription string) uint { 9105 cstr := C.CString(contextDescription) 9106 defer C.free(unsafe.Pointer(cstr)) 9107 c := C.gtk_statusbar_get_context_id(v.native(), (*C.gchar)(cstr)) 9108 return uint(c) 9109} 9110 9111// Push() is a wrapper around gtk_statusbar_push(). 9112func (v *Statusbar) Push(contextID uint, text string) uint { 9113 cstr := C.CString(text) 9114 defer C.free(unsafe.Pointer(cstr)) 9115 c := C.gtk_statusbar_push(v.native(), C.guint(contextID), 9116 (*C.gchar)(cstr)) 9117 return uint(c) 9118} 9119 9120// Pop() is a wrapper around gtk_statusbar_pop(). 9121func (v *Statusbar) Pop(contextID uint) { 9122 C.gtk_statusbar_pop(v.native(), C.guint(contextID)) 9123} 9124 9125// GetMessageArea() is a wrapper around gtk_statusbar_get_message_area(). 9126func (v *Statusbar) GetMessageArea() (*Box, error) { 9127 c := C.gtk_statusbar_get_message_area(v.native()) 9128 if c == nil { 9129 return nil, nilPtrErr 9130 } 9131 obj := glib.Take(unsafe.Pointer(c)) 9132 return &Box{Container{Widget{glib.InitiallyUnowned{obj}}}}, nil 9133} 9134 9135// RemoveAll() is a wrapper around gtk_statusbar_remove_all() 9136func (v *Statusbar) RemoveAll(contextID uint) { 9137 C.gtk_statusbar_remove_all(v.native(), C.guint(contextID)) 9138} 9139 9140/* 9141 * GtkSwitch 9142 */ 9143 9144// Switch is a representation of GTK's GtkSwitch. 9145type Switch struct { 9146 Widget 9147} 9148 9149// native returns a pointer to the underlying GtkSwitch. 9150func (v *Switch) native() *C.GtkSwitch { 9151 if v == nil || v.GObject == nil { 9152 return nil 9153 } 9154 p := unsafe.Pointer(v.GObject) 9155 return C.toGtkSwitch(p) 9156} 9157 9158func marshalSwitch(p uintptr) (interface{}, error) { 9159 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 9160 obj := glib.Take(unsafe.Pointer(c)) 9161 return wrapSwitch(obj), nil 9162} 9163 9164func wrapSwitch(obj *glib.Object) *Switch { 9165 if obj == nil { 9166 return nil 9167 } 9168 9169 return &Switch{Widget{glib.InitiallyUnowned{obj}}} 9170} 9171 9172// SwitchNew is a wrapper around gtk_switch_new(). 9173func SwitchNew() (*Switch, error) { 9174 c := C.gtk_switch_new() 9175 if c == nil { 9176 return nil, nilPtrErr 9177 } 9178 return wrapSwitch(glib.Take(unsafe.Pointer(c))), nil 9179} 9180 9181// GetActive is a wrapper around gtk_switch_get_active(). 9182func (v *Switch) GetActive() bool { 9183 c := C.gtk_switch_get_active(v.native()) 9184 return gobool(c) 9185} 9186 9187// SetActive is a wrapper around gtk_switch_set_active(). 9188func (v *Switch) SetActive(isActive bool) { 9189 C.gtk_switch_set_active(v.native(), gbool(isActive)) 9190} 9191 9192/* 9193 * GtkTargetEntry 9194 */ 9195 9196// TargetEntry is a representation of GTK's GtkTargetEntry 9197type TargetEntry C.GtkTargetEntry 9198 9199func marshalTargetEntry(p uintptr) (interface{}, error) { 9200 c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) 9201 return (*TargetEntry)(unsafe.Pointer(c)), nil 9202} 9203 9204func (v *TargetEntry) native() *C.GtkTargetEntry { 9205 return (*C.GtkTargetEntry)(unsafe.Pointer(v)) 9206} 9207 9208// TargetEntryNew is a wrapper around gtk_target_entry_new(). 9209func TargetEntryNew(target string, flags TargetFlags, info uint) (*TargetEntry, error) { 9210 cstr := C.CString(target) 9211 defer C.free(unsafe.Pointer(cstr)) 9212 c := C.gtk_target_entry_new((*C.gchar)(cstr), C.guint(flags), C.guint(info)) 9213 if c == nil { 9214 return nil, nilPtrErr 9215 } 9216 t := (*TargetEntry)(unsafe.Pointer(c)) 9217 // causes setFinilizer error 9218 // runtime.SetFinalizer(t, (*TargetEntry).free) 9219 return t, nil 9220} 9221 9222func (v *TargetEntry) free() { 9223 C.gtk_target_entry_free(v.native()) 9224} 9225 9226/* 9227 * GtkTextTag 9228 */ 9229 9230type TextTag struct { 9231 *glib.Object 9232} 9233 9234// native returns a pointer to the underlying GObject as a GtkTextTag. 9235func (v *TextTag) native() *C.GtkTextTag { 9236 if v == nil || v.GObject == nil { 9237 return nil 9238 } 9239 p := unsafe.Pointer(v.GObject) 9240 return C.toGtkTextTag(p) 9241} 9242 9243func marshalTextTag(p uintptr) (interface{}, error) { 9244 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 9245 obj := glib.Take(unsafe.Pointer(c)) 9246 return wrapTextTag(obj), nil 9247} 9248 9249func wrapTextTag(obj *glib.Object) *TextTag { 9250 if obj == nil { 9251 return nil 9252 } 9253 9254 return &TextTag{obj} 9255} 9256 9257// TextTagNew is a wrapper around gtk_text_tag_new(). If name is empty, then the 9258// tag is anonymous. 9259func TextTagNew(name string) (*TextTag, error) { 9260 var gchar *C.gchar 9261 if name != "" { 9262 gchar = (*C.gchar)(C.CString(name)) 9263 defer C.free(unsafe.Pointer(gchar)) 9264 } 9265 9266 c := C.gtk_text_tag_new(gchar) 9267 if c == nil { 9268 return nil, nilPtrErr 9269 } 9270 9271 return wrapTextTag(glib.Take(unsafe.Pointer(c))), nil 9272} 9273 9274// GetPriority() is a wrapper around gtk_text_tag_get_priority(). 9275func (v *TextTag) GetPriority() int { 9276 return int(C.gtk_text_tag_get_priority(v.native())) 9277} 9278 9279// SetPriority() is a wrapper around gtk_text_tag_set_priority(). 9280func (v *TextTag) SetPriority(priority int) { 9281 C.gtk_text_tag_set_priority(v.native(), C.gint(priority)) 9282} 9283 9284// Event() is a wrapper around gtk_text_tag_event(). 9285func (v *TextTag) Event(eventObject *glib.Object, event *gdk.Event, iter *TextIter) bool { 9286 ok := C.gtk_text_tag_event(v.native(), 9287 (*C.GObject)(unsafe.Pointer(eventObject.Native())), 9288 (*C.GdkEvent)(unsafe.Pointer(event.Native())), 9289 (*C.GtkTextIter)(iter), 9290 ) 9291 return gobool(ok) 9292} 9293 9294/* 9295 * GtkTextTagTable 9296 */ 9297 9298type TextTagTable struct { 9299 *glib.Object 9300} 9301 9302// native returns a pointer to the underlying GObject as a GtkTextTagTable. 9303func (v *TextTagTable) native() *C.GtkTextTagTable { 9304 if v == nil || v.GObject == nil { 9305 return nil 9306 } 9307 p := unsafe.Pointer(v.GObject) 9308 return C.toGtkTextTagTable(p) 9309} 9310 9311func marshalTextTagTable(p uintptr) (interface{}, error) { 9312 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 9313 obj := glib.Take(unsafe.Pointer(c)) 9314 return wrapTextTagTable(obj), nil 9315} 9316 9317func wrapTextTagTable(obj *glib.Object) *TextTagTable { 9318 if obj == nil { 9319 return nil 9320 } 9321 9322 return &TextTagTable{obj} 9323} 9324 9325func TextTagTableNew() (*TextTagTable, error) { 9326 c := C.gtk_text_tag_table_new() 9327 if c == nil { 9328 return nil, nilPtrErr 9329 } 9330 return wrapTextTagTable(glib.Take(unsafe.Pointer(c))), nil 9331} 9332 9333// Add() is a wrapper around gtk_text_tag_table_add(). 9334func (v *TextTagTable) Add(tag *TextTag) { 9335 C.gtk_text_tag_table_add(v.native(), tag.native()) 9336 //return gobool(c) // TODO version-separate 9337} 9338 9339// Lookup() is a wrapper around gtk_text_tag_table_lookup(). 9340func (v *TextTagTable) Lookup(name string) (*TextTag, error) { 9341 cname := C.CString(name) 9342 defer C.free(unsafe.Pointer(cname)) 9343 c := C.gtk_text_tag_table_lookup(v.native(), (*C.gchar)(cname)) 9344 if c == nil { 9345 return nil, nilPtrErr 9346 } 9347 return wrapTextTag(glib.Take(unsafe.Pointer(c))), nil 9348} 9349 9350// Remove() is a wrapper around gtk_text_tag_table_remove(). 9351func (v *TextTagTable) Remove(tag *TextTag) { 9352 C.gtk_text_tag_table_remove(v.native(), tag.native()) 9353} 9354 9355/* 9356 * GtkTextBuffer 9357 */ 9358 9359// TextBuffer is a representation of GTK's GtkTextBuffer. 9360type TextBuffer struct { 9361 *glib.Object 9362} 9363 9364// native returns a pointer to the underlying GtkTextBuffer. 9365func (v *TextBuffer) native() *C.GtkTextBuffer { 9366 if v == nil || v.GObject == nil { 9367 return nil 9368 } 9369 p := unsafe.Pointer(v.GObject) 9370 return C.toGtkTextBuffer(p) 9371} 9372 9373func marshalTextBuffer(p uintptr) (interface{}, error) { 9374 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 9375 obj := glib.Take(unsafe.Pointer(c)) 9376 return wrapTextBuffer(obj), nil 9377} 9378 9379func wrapTextBuffer(obj *glib.Object) *TextBuffer { 9380 if obj == nil { 9381 return nil 9382 } 9383 9384 return &TextBuffer{obj} 9385} 9386 9387// TextBufferNew() is a wrapper around gtk_text_buffer_new(). 9388func TextBufferNew(table *TextTagTable) (*TextBuffer, error) { 9389 c := C.gtk_text_buffer_new(table.native()) 9390 if c == nil { 9391 return nil, nilPtrErr 9392 } 9393 9394 e := wrapTextBuffer(glib.Take(unsafe.Pointer(c))) 9395 return e, nil 9396} 9397 9398// ApplyTag() is a wrapper around gtk_text_buffer_apply_tag(). 9399func (v *TextBuffer) ApplyTag(tag *TextTag, start, end *TextIter) { 9400 C.gtk_text_buffer_apply_tag(v.native(), tag.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) 9401} 9402 9403// ApplyTagByName() is a wrapper around gtk_text_buffer_apply_tag_by_name(). 9404func (v *TextBuffer) ApplyTagByName(name string, start, end *TextIter) { 9405 cstr := C.CString(name) 9406 defer C.free(unsafe.Pointer(cstr)) 9407 C.gtk_text_buffer_apply_tag_by_name(v.native(), (*C.gchar)(cstr), 9408 (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) 9409} 9410 9411// SelectRange is a wrapper around gtk_text_buffer_select_range. 9412func (v *TextBuffer) SelectRange(start, end *TextIter) { 9413 C.gtk_text_buffer_select_range(v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) 9414} 9415 9416// CreateChildAnchor() is a wrapper around gtk_text_buffer_create_child_anchor(). 9417// Since it copies garbage from the stack into the padding bytes of iter, 9418// iter can't be reliably reused after this call unless GODEBUG=cgocheck=0. 9419func (v *TextBuffer) CreateChildAnchor(iter *TextIter) (*TextChildAnchor, error) { 9420 c := C.gtk_text_buffer_create_child_anchor(v.native(), iter.native()) 9421 if c == nil { 9422 return nil, nilPtrErr 9423 } 9424 return wrapTextChildAnchor(glib.Take(unsafe.Pointer(c))), nil 9425} 9426 9427// Delete() is a wrapper around gtk_text_buffer_delete(). 9428func (v *TextBuffer) Delete(start, end *TextIter) { 9429 C.gtk_text_buffer_delete(v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) 9430} 9431 9432func (v *TextBuffer) GetBounds() (start, end *TextIter) { 9433 start, end = new(TextIter), new(TextIter) 9434 C.gtk_text_buffer_get_bounds(v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) 9435 return 9436} 9437 9438// GetCharCount() is a wrapper around gtk_text_buffer_get_char_count(). 9439func (v *TextBuffer) GetCharCount() int { 9440 return int(C.gtk_text_buffer_get_char_count(v.native())) 9441} 9442 9443// GetIterAtOffset() is a wrapper around gtk_text_buffer_get_iter_at_offset(). 9444func (v *TextBuffer) GetIterAtOffset(charOffset int) *TextIter { 9445 var iter C.GtkTextIter 9446 C.gtk_text_buffer_get_iter_at_offset(v.native(), &iter, C.gint(charOffset)) 9447 return (*TextIter)(&iter) 9448} 9449 9450// GetIterAtLine() is a wrapper around gtk_text_buffer_get_iter_at_line(). 9451func (v *TextBuffer) GetIterAtLine(line int) *TextIter { 9452 var iter C.GtkTextIter 9453 C.gtk_text_buffer_get_iter_at_line(v.native(), &iter, C.gint(line)) 9454 return (*TextIter)(&iter) 9455} 9456 9457// GetStartIter() is a wrapper around gtk_text_buffer_get_start_iter(). 9458func (v *TextBuffer) GetStartIter() *TextIter { 9459 var iter C.GtkTextIter 9460 C.gtk_text_buffer_get_start_iter(v.native(), &iter) 9461 return (*TextIter)(&iter) 9462} 9463 9464// GetEndIter() is a wrapper around gtk_text_buffer_get_end_iter(). 9465func (v *TextBuffer) GetEndIter() *TextIter { 9466 var iter C.GtkTextIter 9467 C.gtk_text_buffer_get_end_iter(v.native(), &iter) 9468 return (*TextIter)(&iter) 9469} 9470 9471// GetLineCount() is a wrapper around gtk_text_buffer_get_line_count(). 9472func (v *TextBuffer) GetLineCount() int { 9473 return int(C.gtk_text_buffer_get_line_count(v.native())) 9474} 9475 9476// GetModified() is a wrapper around gtk_text_buffer_get_modified(). 9477func (v *TextBuffer) GetModified() bool { 9478 return gobool(C.gtk_text_buffer_get_modified(v.native())) 9479} 9480 9481// GetTagTable() is a wrapper around gtk_text_buffer_get_tag_table(). 9482func (v *TextBuffer) GetTagTable() (*TextTagTable, error) { 9483 c := C.gtk_text_buffer_get_tag_table(v.native()) 9484 if c == nil { 9485 return nil, nilPtrErr 9486 } 9487 obj := glib.Take(unsafe.Pointer(c)) 9488 return wrapTextTagTable(obj), nil 9489} 9490 9491func (v *TextBuffer) GetText(start, end *TextIter, includeHiddenChars bool) (string, error) { 9492 c := C.gtk_text_buffer_get_text( 9493 v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end), gbool(includeHiddenChars), 9494 ) 9495 if c == nil { 9496 return "", nilPtrErr 9497 } 9498 gostr := goString(c) 9499 C.g_free(C.gpointer(c)) 9500 return gostr, nil 9501} 9502 9503// Insert() is a wrapper around gtk_text_buffer_insert(). 9504func (v *TextBuffer) Insert(iter *TextIter, text string) { 9505 cstr := C.CString(text) 9506 defer C.free(unsafe.Pointer(cstr)) 9507 C.gtk_text_buffer_insert(v.native(), (*C.GtkTextIter)(iter), (*C.gchar)(cstr), C.gint(len(text))) 9508} 9509 9510// InsertPixbuf() is a wrapper around gtk_text_buffer_insert_pixbuf(). 9511func (v *TextBuffer) InsertPixbuf(iter *TextIter, pixbuf *gdk.Pixbuf) { 9512 C.gtk_text_buffer_insert_pixbuf(v.native(), (*C.GtkTextIter)(iter), 9513 (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native()))) 9514} 9515 9516// InsertAtCursor() is a wrapper around gtk_text_buffer_insert_at_cursor(). 9517func (v *TextBuffer) InsertAtCursor(text string) { 9518 cstr := C.CString(text) 9519 defer C.free(unsafe.Pointer(cstr)) 9520 C.gtk_text_buffer_insert_at_cursor(v.native(), (*C.gchar)(cstr), C.gint(len(text))) 9521} 9522 9523// InsertWithTag() is a wrapper around gtk_text_buffer_insert_with_tags() that supports only one tag 9524// as cgo does not support functions with variable-argument lists (see https://github.com/golang/go/issues/975) 9525func (v *TextBuffer) InsertWithTag(iter *TextIter, text string, tag *TextTag) { 9526 cstr := C.CString(text) 9527 defer C.free(unsafe.Pointer(cstr)) 9528 C._gtk_text_buffer_insert_with_tag(v.native(), (*C.GtkTextIter)(iter), (*C.gchar)(cstr), C.gint(len(text)), tag.native()) 9529} 9530 9531// InsertWithTagByName() is a wrapper around gtk_text_buffer_insert_with_tags_by_name() that supports only one tag 9532// as cgo does not support functions with variable-argument lists (see https://github.com/golang/go/issues/975) 9533func (v *TextBuffer) InsertWithTagByName(iter *TextIter, text string, tagName string) { 9534 cstr := C.CString(text) 9535 defer C.free(unsafe.Pointer(cstr)) 9536 ctag := C.CString(tagName) 9537 defer C.free(unsafe.Pointer(ctag)) 9538 C._gtk_text_buffer_insert_with_tag_by_name(v.native(), (*C.GtkTextIter)(iter), (*C.gchar)(cstr), C.gint(len(text)), (*C.gchar)(ctag)) 9539} 9540 9541// RemoveTag() is a wrapper around gtk_text_buffer_remove_tag(). 9542func (v *TextBuffer) RemoveTag(tag *TextTag, start, end *TextIter) { 9543 C.gtk_text_buffer_remove_tag(v.native(), tag.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) 9544} 9545 9546// RemoveAllTags() is a wrapper around gtk_text_buffer_remove_all_tags(). 9547func (v *TextBuffer) RemoveAllTags(start, end *TextIter) { 9548 C.gtk_text_buffer_remove_all_tags(v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) 9549} 9550 9551// SetModified() is a wrapper around gtk_text_buffer_set_modified(). 9552func (v *TextBuffer) SetModified(setting bool) { 9553 C.gtk_text_buffer_set_modified(v.native(), gbool(setting)) 9554} 9555 9556func (v *TextBuffer) SetText(text string) { 9557 cstr := C.CString(text) 9558 defer C.free(unsafe.Pointer(cstr)) 9559 C.gtk_text_buffer_set_text(v.native(), (*C.gchar)(cstr), 9560 C.gint(len(text))) 9561} 9562 9563// GetIterAtMark() is a wrapper around gtk_text_buffer_get_iter_at_mark(). 9564func (v *TextBuffer) GetIterAtMark(mark *TextMark) *TextIter { 9565 var iter C.GtkTextIter 9566 C.gtk_text_buffer_get_iter_at_mark(v.native(), &iter, mark.native()) 9567 return (*TextIter)(&iter) 9568} 9569 9570// CreateMark() is a wrapper around gtk_text_buffer_create_mark(). 9571func (v *TextBuffer) CreateMark(mark_name string, where *TextIter, left_gravity bool) *TextMark { 9572 cstr := C.CString(mark_name) 9573 defer C.free(unsafe.Pointer(cstr)) 9574 ret := C.gtk_text_buffer_create_mark(v.native(), (*C.gchar)(cstr), (*C.GtkTextIter)(where), gbool(left_gravity)) 9575 return wrapTextMark(glib.Take(unsafe.Pointer(ret))) 9576} 9577 9578// GetMark() is a wrapper around gtk_text_buffer_get_mark(). 9579func (v *TextBuffer) GetMark(mark_name string) *TextMark { 9580 cstr := C.CString(mark_name) 9581 defer C.free(unsafe.Pointer(cstr)) 9582 ret := C.gtk_text_buffer_get_mark(v.native(), (*C.gchar)(cstr)) 9583 return wrapTextMark(glib.Take(unsafe.Pointer(ret))) 9584} 9585 9586// DeleteMark() is a wrapper around gtk_text_buffer_delete_mark() 9587func (v *TextBuffer) DeleteMark(mark *TextMark) { 9588 C.gtk_text_buffer_delete_mark(v.native(), mark.native()) 9589} 9590 9591// DeleteMarkByName() is a wrapper around gtk_text_buffer_delete_mark_by_name() 9592func (v *TextBuffer) DeleteMarkByName(name string) { 9593 cstr := C.CString(name) 9594 defer C.free(unsafe.Pointer(cstr)) 9595 C.gtk_text_buffer_delete_mark_by_name(v.native(), (*C.gchar)(cstr)) 9596} 9597 9598// PlaceCursor() is a wrapper around gtk_text_buffer_place_cursor() 9599func (v *TextBuffer) PlaceCursor(iter *TextIter) { 9600 C.gtk_text_buffer_place_cursor(v.native(), (*C.GtkTextIter)(iter)) 9601} 9602 9603// GetHasSelection() is a variant solution around gtk_text_buffer_get_has_selection(). 9604func (v *TextBuffer) GetHasSelection() bool { 9605 value, _ := v.GetProperty("has-selection") 9606 return value.(bool) 9607} 9608 9609// DeleteSelection() is a wrapper around gtk_text_buffer_delete_selection(). 9610func (v *TextBuffer) DeleteSelection(interactive, defaultEditable bool) bool { 9611 return gobool(C.gtk_text_buffer_delete_selection(v.native(), gbool(interactive), gbool(defaultEditable))) 9612} 9613 9614// GetSelectionBound() is a wrapper around gtk_text_buffer_get_selection_bound(). 9615func (v *TextBuffer) GetSelectionBound() *TextMark { 9616 ret := C.gtk_text_buffer_get_selection_bound(v.native()) 9617 return wrapTextMark(glib.Take(unsafe.Pointer(ret))) 9618} 9619 9620// GetSelectionBounds() is a wrapper around gtk_text_buffer_get_selection_bounds(). 9621func (v *TextBuffer) GetSelectionBounds() (start, end *TextIter, ok bool) { 9622 start, end = new(TextIter), new(TextIter) 9623 cbool := C.gtk_text_buffer_get_selection_bounds(v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) 9624 return start, end, gobool(cbool) 9625} 9626 9627// GetIterAtLineOffset() is a wrapper around gtk_text_buffer_get_iter_at_line_offset(). 9628func (v *TextBuffer) GetIterAtLineOffset(lineNumber, charOffset int) (iter *TextIter) { 9629 iter = new(TextIter) 9630 C.gtk_text_buffer_get_iter_at_line_offset(v.native(), (*C.GtkTextIter)(iter), (C.gint)(lineNumber), (C.gint)(charOffset)) 9631 return 9632} 9633 9634// CreateTag() is a variant solution around gtk_text_buffer_create_tag(). 9635func (v *TextBuffer) CreateTag(name string, props map[string]interface{}) (tag *TextTag) { 9636 var err error 9637 var tagTable *TextTagTable 9638 if tag, err = TextTagNew(name); err == nil { 9639 if tagTable, err = v.GetTagTable(); err == nil { 9640 tagTable.Add(tag) 9641 for p, v := range props { 9642 if err = tag.SetProperty(p, v); err != nil { 9643 err = errors.New(fmt.Sprintf("%s, %v: %v\n", err.Error(), p, v)) 9644 break 9645 } 9646 } 9647 } 9648 } 9649 if err != nil { 9650 fmt.Println(err.Error()) 9651 } 9652 return 9653} 9654 9655// RemoveTagByName() is a wrapper around gtk_text_buffer_remove_tag_by_name() 9656func (v *TextBuffer) RemoveTagByName(name string, start, end *TextIter) { 9657 cstr := C.CString(name) 9658 defer C.free(unsafe.Pointer(cstr)) 9659 C.gtk_text_buffer_remove_tag_by_name(v.native(), (*C.gchar)(cstr), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) 9660} 9661 9662// InsertMarkup() is a wrapper around gtk_text_buffer_register_serialize_tagset() 9663func (v *TextBuffer) RegisterSerializeTagset(tagsetName string) gdk.Atom { 9664 cstr := C.CString(tagsetName) 9665 if len(tagsetName) == 0 { 9666 cstr = nil 9667 } 9668 defer C.free(unsafe.Pointer(cstr)) 9669 c := C.gtk_text_buffer_register_serialize_tagset(v.native(), (*C.gchar)(cstr)) 9670 return gdk.Atom(uintptr(unsafe.Pointer(c))) 9671} 9672 9673// RegisterDeserializeTagset() is a wrapper around gtk_text_buffer_register_deserialize_tagset() 9674func (v *TextBuffer) RegisterDeserializeTagset(tagsetName string) gdk.Atom { 9675 cstr := C.CString(tagsetName) 9676 if len(tagsetName) == 0 { 9677 cstr = nil 9678 } 9679 defer C.free(unsafe.Pointer(cstr)) 9680 c := C.gtk_text_buffer_register_deserialize_tagset(v.native(), (*C.gchar)(cstr)) 9681 return gdk.Atom(uintptr(unsafe.Pointer(c))) 9682} 9683 9684// Serialize() is a wrapper around gtk_text_buffer_serialize() 9685func (v *TextBuffer) Serialize(contentBuffer *TextBuffer, format gdk.Atom, start, end *TextIter) string { 9686 var length = new(C.gsize) 9687 ptr := C.gtk_text_buffer_serialize(v.native(), contentBuffer.native(), C.GdkAtom(unsafe.Pointer(format)), 9688 (*C.GtkTextIter)(start), (*C.GtkTextIter)(end), length) 9689 return C.GoStringN((*C.char)(unsafe.Pointer(ptr)), (C.int)(*length)) 9690} 9691 9692// Deserialize() is a wrapper around gtk_text_buffer_deserialize() 9693func (v *TextBuffer) Deserialize(contentBuffer *TextBuffer, format gdk.Atom, iter *TextIter, data []byte) (ok bool, err error) { 9694 var length = (C.gsize)(len(data)) 9695 var cerr *C.GError = nil 9696 cbool := C.gtk_text_buffer_deserialize(v.native(), contentBuffer.native(), C.GdkAtom(unsafe.Pointer(format)), 9697 (*C.GtkTextIter)(iter), (*C.guint8)(unsafe.Pointer(&data[0])), length, &cerr) 9698 if !gobool(cbool) { 9699 defer C.g_error_free(cerr) 9700 return false, errors.New(goString(cerr.message)) 9701 } 9702 return gobool(cbool), nil 9703} 9704 9705// GetInsert() is a wrapper around gtk_text_buffer_get_insert(). 9706func (v *TextBuffer) GetInsert() *TextMark { 9707 ret := C.gtk_text_buffer_get_insert(v.native()) 9708 return wrapTextMark(glib.Take(unsafe.Pointer(ret))) 9709} 9710 9711// CopyClipboard() is a wrapper around gtk_text_buffer_copy_clipboard(). 9712func (v *TextBuffer) CopyClipboard(clipboard *Clipboard) { 9713 C.gtk_text_buffer_copy_clipboard(v.native(), clipboard.native()) 9714} 9715 9716// CutClipboard() is a wrapper around gtk_text_buffer_cut_clipboard(). 9717func (v *TextBuffer) CutClipboard(clipboard *Clipboard, defaultEditable bool) { 9718 C.gtk_text_buffer_cut_clipboard(v.native(), clipboard.native(), gbool(defaultEditable)) 9719} 9720 9721// PasteClipboard() is a wrapper around gtk_text_buffer_paste_clipboard(). 9722func (v *TextBuffer) PasteClipboard(clipboard *Clipboard, overrideLocation *TextIter, defaultEditable bool) { 9723 C.gtk_text_buffer_paste_clipboard(v.native(), clipboard.native(), (*C.GtkTextIter)(overrideLocation), gbool(defaultEditable)) 9724} 9725 9726// AddSelectionClipboard() is a wrapper around gtk_text_buffer_add_selection_clipboard(). 9727func (v *TextBuffer) AddSelectionClipboard(clipboard *Clipboard) { 9728 C.gtk_text_buffer_add_selection_clipboard(v.native(), clipboard.native()) 9729} 9730 9731// RemoveSelectionClipboard() is a wrapper around gtk_text_buffer_remove_selection_clipboard(). 9732func (v *TextBuffer) RemoveSelectionClipboard(clipboard *Clipboard) { 9733 C.gtk_text_buffer_remove_selection_clipboard(v.native(), clipboard.native()) 9734} 9735 9736// GetIterAtLineIndex() is a wrapper around gtk_text_buffer_get_iter_at_line_index(). 9737func (v *TextBuffer) GetIterAtLineIndex(lineNumber, charIndex int) (iter *TextIter) { 9738 iter = new(TextIter) 9739 C.gtk_text_buffer_get_iter_at_line_index(v.native(), (*C.GtkTextIter)(iter), (C.gint)(lineNumber), (C.gint)(charIndex)) 9740 return 9741} 9742 9743// InsertInteractiveAtCursor() is a wrapper around gtk_text_buffer_insert_interactive_at_cursor(). 9744func (v *TextBuffer) InsertInteractiveAtCursor(text string, editable bool) bool { 9745 cstr := C.CString(text) 9746 defer C.free(unsafe.Pointer(cstr)) 9747 9748 return gobool(C.gtk_text_buffer_insert_interactive_at_cursor( 9749 v.native(), 9750 (*C.gchar)(cstr), 9751 C.gint(len(text)), 9752 gbool(editable))) 9753} 9754 9755// InsertInteractive() is a wrapper around gtk_text_buffer_insert_interactive(). 9756func (v *TextBuffer) InsertInteractive(iter *TextIter, text string, editable bool) bool { 9757 cstr := C.CString(text) 9758 defer C.free(unsafe.Pointer(cstr)) 9759 9760 return gobool(C.gtk_text_buffer_insert_interactive( 9761 v.native(), 9762 (*C.GtkTextIter)(iter), 9763 (*C.gchar)(cstr), 9764 C.gint(len(text)), 9765 gbool(editable))) 9766} 9767 9768// InsertRangeInteractive() is a wrapper around gtk_text_buffer_insert_range_interactive(). 9769func (v *TextBuffer) InsertRangeInteractive(iter, start, end *TextIter, editable bool) bool { 9770 9771 return gobool(C.gtk_text_buffer_insert_range_interactive( 9772 v.native(), 9773 (*C.GtkTextIter)(iter), 9774 (*C.GtkTextIter)(start), 9775 (*C.GtkTextIter)(end), 9776 gbool(editable))) 9777} 9778 9779// InsertRange() is a wrapper around gtk_text_buffer_insert_range(). 9780func (v *TextBuffer) InsertRange(iter, start, end *TextIter) { 9781 9782 C.gtk_text_buffer_insert_range( 9783 v.native(), 9784 (*C.GtkTextIter)(iter), 9785 (*C.GtkTextIter)(start), 9786 (*C.GtkTextIter)(end)) 9787} 9788 9789// DeleteInteractive() is a wrapper around gtk_text_buffer_delete_interactive(). 9790func (v *TextBuffer) DeleteInteractive(start, end *TextIter, editable bool) bool { 9791 9792 return gobool(C.gtk_text_buffer_delete_interactive( 9793 v.native(), 9794 (*C.GtkTextIter)(start), 9795 (*C.GtkTextIter)(end), 9796 gbool(editable))) 9797} 9798 9799// BeginUserAction() is a wrapper around gtk_text_buffer_begin_user_action(). 9800func (v *TextBuffer) BeginUserAction() { 9801 9802 C.gtk_text_buffer_begin_user_action(v.native()) 9803} 9804 9805// EndUserAction() is a wrapper around gtk_text_buffer_end_user_action(). 9806func (v *TextBuffer) EndUserAction() { 9807 9808 C.gtk_text_buffer_end_user_action(v.native()) 9809} 9810 9811/* 9812 * GtkToggleButton 9813 */ 9814 9815// ToggleButton is a representation of GTK's GtkToggleButton. 9816type ToggleButton struct { 9817 Button 9818} 9819 9820// native returns a pointer to the underlying GtkToggleButton. 9821func (v *ToggleButton) native() *C.GtkToggleButton { 9822 if v == nil || v.GObject == nil { 9823 return nil 9824 } 9825 p := unsafe.Pointer(v.GObject) 9826 return C.toGtkToggleButton(p) 9827} 9828 9829func marshalToggleButton(p uintptr) (interface{}, error) { 9830 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 9831 obj := glib.Take(unsafe.Pointer(c)) 9832 return wrapToggleButton(obj), nil 9833} 9834 9835func wrapToggleButton(obj *glib.Object) *ToggleButton { 9836 if obj == nil { 9837 return nil 9838 } 9839 9840 actionable := wrapActionable(obj) 9841 return &ToggleButton{Button{Bin{Container{Widget{ 9842 glib.InitiallyUnowned{obj}}}}, actionable}} 9843} 9844 9845// ToggleButtonNew is a wrapper around gtk_toggle_button_new(). 9846func ToggleButtonNew() (*ToggleButton, error) { 9847 c := C.gtk_toggle_button_new() 9848 if c == nil { 9849 return nil, nilPtrErr 9850 } 9851 return wrapToggleButton(glib.Take(unsafe.Pointer(c))), nil 9852} 9853 9854// ToggleButtonNewWithLabel is a wrapper around 9855// gtk_toggle_button_new_with_label(). 9856func ToggleButtonNewWithLabel(label string) (*ToggleButton, error) { 9857 cstr := C.CString(label) 9858 defer C.free(unsafe.Pointer(cstr)) 9859 c := C.gtk_toggle_button_new_with_label((*C.gchar)(cstr)) 9860 if c == nil { 9861 return nil, nilPtrErr 9862 } 9863 return wrapToggleButton(glib.Take(unsafe.Pointer(c))), nil 9864} 9865 9866// ToggleButtonNewWithMnemonic is a wrapper around 9867// gtk_toggle_button_new_with_mnemonic(). 9868func ToggleButtonNewWithMnemonic(label string) (*ToggleButton, error) { 9869 cstr := C.CString(label) 9870 defer C.free(unsafe.Pointer(cstr)) 9871 c := C.gtk_toggle_button_new_with_mnemonic((*C.gchar)(cstr)) 9872 if c == nil { 9873 return nil, nilPtrErr 9874 } 9875 return wrapToggleButton(glib.Take(unsafe.Pointer(c))), nil 9876} 9877 9878// GetActive is a wrapper around gtk_toggle_button_get_active(). 9879func (v *ToggleButton) GetActive() bool { 9880 c := C.gtk_toggle_button_get_active(v.native()) 9881 return gobool(c) 9882} 9883 9884// SetActive is a wrapper around gtk_toggle_button_set_active(). 9885func (v *ToggleButton) SetActive(isActive bool) { 9886 C.gtk_toggle_button_set_active(v.native(), gbool(isActive)) 9887} 9888 9889// GetMode is a wrapper around gtk_toggle_button_get_mode(). 9890func (v *ToggleButton) GetMode() bool { 9891 c := C.gtk_toggle_button_get_mode(v.native()) 9892 return gobool(c) 9893} 9894 9895// SetMode is a wrapper around gtk_toggle_button_set_mode(). 9896func (v *ToggleButton) SetMode(drawIndicator bool) { 9897 C.gtk_toggle_button_set_mode(v.native(), gbool(drawIndicator)) 9898} 9899 9900// Toggled is a wrapper around gtk_toggle_button_toggled(). 9901func (v *ToggleButton) Toggled() { 9902 C.gtk_toggle_button_toggled(v.native()) 9903} 9904 9905// GetInconsistent gtk_toggle_button_get_inconsistent(). 9906func (v *ToggleButton) GetInconsistent() bool { 9907 c := C.gtk_toggle_button_get_inconsistent(v.native()) 9908 return gobool(c) 9909} 9910 9911// SetInconsistent gtk_toggle_button_set_inconsistent(). 9912func (v *ToggleButton) SetInconsistent(setting bool) { 9913 C.gtk_toggle_button_set_inconsistent(v.native(), gbool(setting)) 9914} 9915 9916/* 9917 * GtkToolbar 9918 */ 9919 9920// Toolbar is a representation of GTK's GtkToolbar. 9921type Toolbar struct { 9922 Container 9923} 9924 9925// native returns a pointer to the underlying GtkToolbar. 9926func (v *Toolbar) native() *C.GtkToolbar { 9927 if v == nil || v.GObject == nil { 9928 return nil 9929 } 9930 p := unsafe.Pointer(v.GObject) 9931 return C.toGtkToolbar(p) 9932} 9933 9934func marshalToolbar(p uintptr) (interface{}, error) { 9935 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 9936 obj := glib.Take(unsafe.Pointer(c)) 9937 return wrapToolbar(obj), nil 9938} 9939 9940func wrapToolbar(obj *glib.Object) *Toolbar { 9941 if obj == nil { 9942 return nil 9943 } 9944 9945 return &Toolbar{Container{Widget{glib.InitiallyUnowned{obj}}}} 9946} 9947 9948// ToolbarNew is a wrapper around gtk_toolbar_new(). 9949func ToolbarNew() (*Toolbar, error) { 9950 c := C.gtk_toolbar_new() 9951 if c == nil { 9952 return nil, nilPtrErr 9953 } 9954 return wrapToolbar(glib.Take(unsafe.Pointer(c))), nil 9955} 9956 9957// Insert is a wrapper around gtk_toolbar_insert(). 9958func (v *Toolbar) Insert(item IToolItem, pos int) { 9959 C.gtk_toolbar_insert(v.native(), item.toToolItem(), C.gint(pos)) 9960} 9961 9962// GetItemIndex is a wrapper around gtk_toolbar_get_item_index(). 9963func (v *Toolbar) GetItemIndex(item IToolItem) int { 9964 c := C.gtk_toolbar_get_item_index(v.native(), item.toToolItem()) 9965 return int(c) 9966} 9967 9968// GetNItems is a wrapper around gtk_toolbar_get_n_items(). 9969func (v *Toolbar) GetNItems() int { 9970 c := C.gtk_toolbar_get_n_items(v.native()) 9971 return int(c) 9972} 9973 9974// GetNthItem is a wrapper around gtk_toolbar_get_nth_item(). 9975func (v *Toolbar) GetNthItem(n int) *ToolItem { 9976 c := C.gtk_toolbar_get_nth_item(v.native(), C.gint(n)) 9977 if c == nil { 9978 return nil 9979 } 9980 return wrapToolItem(glib.Take(unsafe.Pointer(c))) 9981} 9982 9983// GetDropIndex is a wrapper around gtk_toolbar_get_drop_index(). 9984func (v *Toolbar) GetDropIndex(x, y int) int { 9985 c := C.gtk_toolbar_get_drop_index(v.native(), C.gint(x), C.gint(y)) 9986 return int(c) 9987} 9988 9989// SetDropHighlightItem is a wrapper around gtk_toolbar_set_drop_highlight_item(). 9990func (v *Toolbar) SetDropHighlightItem(toolItem IToolItem, index int) { 9991 C.gtk_toolbar_set_drop_highlight_item(v.native(), 9992 toolItem.toToolItem(), C.gint(index)) 9993} 9994 9995// SetShowArrow is a wrapper around gtk_toolbar_set_show_arrow(). 9996func (v *Toolbar) SetShowArrow(showArrow bool) { 9997 C.gtk_toolbar_set_show_arrow(v.native(), gbool(showArrow)) 9998} 9999 10000// UnsetIconSize is a wrapper around gtk_toolbar_unset_icon_size(). 10001func (v *Toolbar) UnsetIconSize() { 10002 C.gtk_toolbar_unset_icon_size(v.native()) 10003} 10004 10005// GetShowArrow is a wrapper around gtk_toolbar_get_show_arrow(). 10006func (v *Toolbar) GetShowArrow() bool { 10007 c := C.gtk_toolbar_get_show_arrow(v.native()) 10008 return gobool(c) 10009} 10010 10011// GetStyle is a wrapper around gtk_toolbar_get_style(). 10012func (v *Toolbar) GetStyle() ToolbarStyle { 10013 c := C.gtk_toolbar_get_style(v.native()) 10014 return ToolbarStyle(c) 10015} 10016 10017// GetIconSize is a wrapper around gtk_toolbar_get_icon_size(). 10018func (v *Toolbar) GetIconSize() IconSize { 10019 c := C.gtk_toolbar_get_icon_size(v.native()) 10020 return IconSize(c) 10021} 10022 10023// GetReliefStyle is a wrapper around gtk_toolbar_get_relief_style(). 10024func (v *Toolbar) GetReliefStyle() ReliefStyle { 10025 c := C.gtk_toolbar_get_relief_style(v.native()) 10026 return ReliefStyle(c) 10027} 10028 10029// SetStyle is a wrapper around gtk_toolbar_set_style(). 10030func (v *Toolbar) SetStyle(style ToolbarStyle) { 10031 C.gtk_toolbar_set_style(v.native(), C.GtkToolbarStyle(style)) 10032} 10033 10034// SetIconSize is a wrapper around gtk_toolbar_set_icon_size(). 10035func (v *Toolbar) SetIconSize(iconSize IconSize) { 10036 C.gtk_toolbar_set_icon_size(v.native(), C.GtkIconSize(iconSize)) 10037} 10038 10039// UnsetStyle is a wrapper around gtk_toolbar_unset_style(). 10040func (v *Toolbar) UnsetStyle() { 10041 C.gtk_toolbar_unset_style(v.native()) 10042} 10043 10044/* 10045 * GtkToolButton 10046 */ 10047 10048// ToolButton is a representation of GTK's GtkToolButton. 10049type ToolButton struct { 10050 ToolItem 10051} 10052 10053// native returns a pointer to the underlying GtkToolButton. 10054func (v *ToolButton) native() *C.GtkToolButton { 10055 if v == nil || v.GObject == nil { 10056 return nil 10057 } 10058 p := unsafe.Pointer(v.GObject) 10059 return C.toGtkToolButton(p) 10060} 10061 10062func marshalToolButton(p uintptr) (interface{}, error) { 10063 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 10064 obj := glib.Take(unsafe.Pointer(c)) 10065 return wrapToolButton(obj), nil 10066} 10067 10068func wrapToolButton(obj *glib.Object) *ToolButton { 10069 if obj == nil { 10070 return nil 10071 } 10072 10073 return &ToolButton{ToolItem{Bin{Container{Widget{ 10074 glib.InitiallyUnowned{obj}}}}}} 10075} 10076 10077// ToolButtonNew is a wrapper around gtk_tool_button_new(). 10078func ToolButtonNew(iconWidget IWidget, label string) (*ToolButton, error) { 10079 cstr := C.CString(label) 10080 defer C.free(unsafe.Pointer(cstr)) 10081 w := nullableWidget(iconWidget) 10082 c := C.gtk_tool_button_new(w, (*C.gchar)(cstr)) 10083 if c == nil { 10084 return nil, nilPtrErr 10085 } 10086 return wrapToolButton(glib.Take(unsafe.Pointer(c))), nil 10087} 10088 10089// SetLabel is a wrapper around gtk_tool_button_set_label(). 10090func (v *ToolButton) SetLabel(label string) { 10091 cstr := C.CString(label) 10092 defer C.free(unsafe.Pointer(cstr)) 10093 C.gtk_tool_button_set_label(v.native(), (*C.gchar)(cstr)) 10094} 10095 10096// GetLabel is a wrapper around gtk_tool_button_get_label(). 10097func (v *ToolButton) GetLabel() string { 10098 c := C.gtk_tool_button_get_label(v.native()) 10099 return goString(c) 10100} 10101 10102// SetUseUnderline is a wrapper around gtk_tool_button_set_use_underline(). 10103func (v *ToolButton) SetGetUnderline(useUnderline bool) { 10104 C.gtk_tool_button_set_use_underline(v.native(), gbool(useUnderline)) 10105} 10106 10107// GetUseUnderline is a wrapper around gtk_tool_button_get_use_underline(). 10108func (v *ToolButton) GetuseUnderline() bool { 10109 c := C.gtk_tool_button_get_use_underline(v.native()) 10110 return gobool(c) 10111} 10112 10113// SetIconName is a wrapper around gtk_tool_button_set_icon_name(). 10114func (v *ToolButton) SetIconName(iconName string) { 10115 cstr := C.CString(iconName) 10116 defer C.free(unsafe.Pointer(cstr)) 10117 C.gtk_tool_button_set_icon_name(v.native(), (*C.gchar)(cstr)) 10118} 10119 10120// GetIconName is a wrapper around gtk_tool_button_get_icon_name(). 10121func (v *ToolButton) GetIconName() string { 10122 c := C.gtk_tool_button_get_icon_name(v.native()) 10123 return goString(c) 10124} 10125 10126// SetIconWidget is a wrapper around gtk_tool_button_set_icon_widget(). 10127func (v *ToolButton) SetIconWidget(iconWidget IWidget) { 10128 C.gtk_tool_button_set_icon_widget(v.native(), iconWidget.toWidget()) 10129} 10130 10131// GetIconWidget is a wrapper around gtk_tool_button_get_icon_widget(). 10132func (v *ToolButton) GetIconWidget() (IWidget, error) { 10133 c := C.gtk_tool_button_get_icon_widget(v.native()) 10134 if c == nil { 10135 return nil, nil 10136 } 10137 return castWidget(c) 10138} 10139 10140// SetLabelWidget is a wrapper around gtk_tool_button_set_label_widget(). 10141func (v *ToolButton) SetLabelWidget(labelWidget IWidget) { 10142 C.gtk_tool_button_set_label_widget(v.native(), labelWidget.toWidget()) 10143} 10144 10145// GetLabelWidget is a wrapper around gtk_tool_button_get_label_widget(). 10146func (v *ToolButton) GetLabelWidget() (IWidget, error) { 10147 c := C.gtk_tool_button_get_label_widget(v.native()) 10148 if c == nil { 10149 return nil, nil 10150 } 10151 return castWidget(c) 10152} 10153 10154/* 10155 * GtkToggleToolButton 10156 */ 10157 10158// ToggleToolButton is a representation of GTK's GtkToggleToolButton. 10159type ToggleToolButton struct { 10160 ToolButton 10161} 10162 10163// native returns a pointer to the underlying GtkToggleToolButton. 10164func (v *ToggleToolButton) native() *C.GtkToggleToolButton { 10165 if v == nil || v.GObject == nil { 10166 return nil 10167 } 10168 p := unsafe.Pointer(v.GObject) 10169 return C.toGtkToggleToolButton(p) 10170} 10171 10172func marshalToggleToolButton(p uintptr) (interface{}, error) { 10173 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 10174 obj := glib.Take(unsafe.Pointer(c)) 10175 return wrapToggleToolButton(obj), nil 10176} 10177 10178func wrapToggleToolButton(obj *glib.Object) *ToggleToolButton { 10179 if obj == nil { 10180 return nil 10181 } 10182 10183 return &ToggleToolButton{ToolButton{ToolItem{Bin{Container{Widget{ 10184 glib.InitiallyUnowned{obj}}}}}}} 10185} 10186 10187// ToggleToolButtonNew is a wrapper around gtk_toggle_tool_button_new(). 10188func ToggleToolButtonNew() (*ToggleToolButton, error) { 10189 c := C.gtk_toggle_tool_button_new() 10190 if c == nil { 10191 return nil, nilPtrErr 10192 } 10193 return wrapToggleToolButton(glib.Take(unsafe.Pointer(c))), nil 10194} 10195 10196// GetActive is a wrapper around gtk_toggle_tool_button_get_active(). 10197func (v *ToggleToolButton) GetActive() bool { 10198 c := C.gtk_toggle_tool_button_get_active(v.native()) 10199 return gobool(c) 10200} 10201 10202// SetActive is a wrapper around gtk_toggle_tool_button_set_active(). 10203func (v *ToggleToolButton) SetActive(isActive bool) { 10204 C.gtk_toggle_tool_button_set_active(v.native(), gbool(isActive)) 10205} 10206 10207/* 10208 * GtkToolItem 10209 */ 10210 10211// ToolItem is a representation of GTK's GtkToolItem. 10212type ToolItem struct { 10213 Bin 10214} 10215 10216// IToolItem is an interface type implemented by all structs embedding 10217// a ToolItem. It is meant to be used as an argument type for wrapper 10218// functions that wrap around a C GTK function taking a GtkToolItem. 10219type IToolItem interface { 10220 toToolItem() *C.GtkToolItem 10221} 10222 10223// native returns a pointer to the underlying GtkToolItem. 10224func (v *ToolItem) native() *C.GtkToolItem { 10225 if v == nil || v.GObject == nil { 10226 return nil 10227 } 10228 p := unsafe.Pointer(v.GObject) 10229 return C.toGtkToolItem(p) 10230} 10231 10232func (v *ToolItem) toToolItem() *C.GtkToolItem { 10233 return v.native() 10234} 10235 10236func marshalToolItem(p uintptr) (interface{}, error) { 10237 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 10238 obj := glib.Take(unsafe.Pointer(c)) 10239 return wrapToolItem(obj), nil 10240} 10241 10242func wrapToolItem(obj *glib.Object) *ToolItem { 10243 if obj == nil { 10244 return nil 10245 } 10246 10247 return &ToolItem{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} 10248} 10249 10250// ToolItemNew is a wrapper around gtk_tool_item_new(). 10251func ToolItemNew() (*ToolItem, error) { 10252 c := C.gtk_tool_item_new() 10253 if c == nil { 10254 return nil, nilPtrErr 10255 } 10256 return wrapToolItem(glib.Take(unsafe.Pointer(c))), nil 10257} 10258 10259// SetHomogeneous is a wrapper around gtk_tool_item_set_homogeneous(). 10260func (v *ToolItem) SetHomogeneous(homogeneous bool) { 10261 C.gtk_tool_item_set_homogeneous(v.native(), gbool(homogeneous)) 10262} 10263 10264// GetHomogeneous is a wrapper around gtk_tool_item_get_homogeneous(). 10265func (v *ToolItem) GetHomogeneous() bool { 10266 c := C.gtk_tool_item_get_homogeneous(v.native()) 10267 return gobool(c) 10268} 10269 10270// SetExpand is a wrapper around gtk_tool_item_set_expand(). 10271func (v *ToolItem) SetExpand(expand bool) { 10272 C.gtk_tool_item_set_expand(v.native(), gbool(expand)) 10273} 10274 10275// GetExpand is a wrapper around gtk_tool_item_get_expand(). 10276func (v *ToolItem) GetExpand() bool { 10277 c := C.gtk_tool_item_get_expand(v.native()) 10278 return gobool(c) 10279} 10280 10281// SetTooltipText is a wrapper around gtk_tool_item_set_tooltip_text(). 10282func (v *ToolItem) SetTooltipText(text string) { 10283 cstr := C.CString(text) 10284 defer C.free(unsafe.Pointer(cstr)) 10285 C.gtk_tool_item_set_tooltip_text(v.native(), (*C.gchar)(cstr)) 10286} 10287 10288// SetTooltipMarkup is a wrapper around gtk_tool_item_set_tooltip_markup(). 10289func (v *ToolItem) SetTooltipMarkup(text string) { 10290 cstr := C.CString(text) 10291 defer C.free(unsafe.Pointer(cstr)) 10292 C.gtk_tool_item_set_tooltip_markup(v.native(), (*C.gchar)(cstr)) 10293} 10294 10295// SetUseDragWindow is a wrapper around gtk_tool_item_set_use_drag_window(). 10296func (v *ToolItem) SetUseDragWindow(useDragWindow bool) { 10297 C.gtk_tool_item_set_use_drag_window(v.native(), gbool(useDragWindow)) 10298} 10299 10300// GetUseDragWindow is a wrapper around gtk_tool_item_get_use_drag_window(). 10301func (v *ToolItem) GetUseDragWindow() bool { 10302 c := C.gtk_tool_item_get_use_drag_window(v.native()) 10303 return gobool(c) 10304} 10305 10306// SetVisibleHorizontal is a wrapper around gtk_tool_item_set_visible_horizontal(). 10307func (v *ToolItem) SetVisibleHorizontal(visibleHorizontal bool) { 10308 C.gtk_tool_item_set_visible_horizontal(v.native(), 10309 gbool(visibleHorizontal)) 10310} 10311 10312// GetVisibleHorizontal is a wrapper around gtk_tool_item_get_visible_horizontal(). 10313func (v *ToolItem) GetVisibleHorizontal() bool { 10314 c := C.gtk_tool_item_get_visible_horizontal(v.native()) 10315 return gobool(c) 10316} 10317 10318// SetVisibleVertical is a wrapper around gtk_tool_item_set_visible_vertical(). 10319func (v *ToolItem) SetVisibleVertical(visibleVertical bool) { 10320 C.gtk_tool_item_set_visible_vertical(v.native(), gbool(visibleVertical)) 10321} 10322 10323// GetVisibleVertical is a wrapper around gtk_tool_item_get_visible_vertical(). 10324func (v *ToolItem) GetVisibleVertical() bool { 10325 c := C.gtk_tool_item_get_visible_vertical(v.native()) 10326 return gobool(c) 10327} 10328 10329// SetIsImportant is a wrapper around gtk_tool_item_set_is_important(). 10330func (v *ToolItem) SetIsImportant(isImportant bool) { 10331 C.gtk_tool_item_set_is_important(v.native(), gbool(isImportant)) 10332} 10333 10334// GetIsImportant is a wrapper around gtk_tool_item_get_is_important(). 10335func (v *ToolItem) GetIsImportant() bool { 10336 c := C.gtk_tool_item_get_is_important(v.native()) 10337 return gobool(c) 10338} 10339 10340// TODO: gtk_tool_item_get_ellipsize_mode 10341 10342// GetIconSize is a wrapper around gtk_tool_item_get_icon_size(). 10343func (v *ToolItem) GetIconSize() IconSize { 10344 c := C.gtk_tool_item_get_icon_size(v.native()) 10345 return IconSize(c) 10346} 10347 10348// GetOrientation is a wrapper around gtk_tool_item_get_orientation(). 10349func (v *ToolItem) GetOrientation() Orientation { 10350 c := C.gtk_tool_item_get_orientation(v.native()) 10351 return Orientation(c) 10352} 10353 10354// GetToolbarStyle is a wrapper around gtk_tool_item_get_toolbar_style(). 10355func (v *ToolItem) GetToolbarStyle() ToolbarStyle { 10356 c := C.gtk_tool_item_get_toolbar_style(v.native()) 10357 return ToolbarStyle(c) 10358} 10359 10360// GetReliefStyle is a wrapper around gtk_tool_item_get_relief_style(). 10361func (v *ToolItem) GetReliefStyle() ReliefStyle { 10362 c := C.gtk_tool_item_get_relief_style(v.native()) 10363 return ReliefStyle(c) 10364} 10365 10366// GetTextAlignment is a wrapper around gtk_tool_item_get_text_alignment(). 10367func (v *ToolItem) GetTextAlignment() float32 { 10368 c := C.gtk_tool_item_get_text_alignment(v.native()) 10369 return float32(c) 10370} 10371 10372// GetTextOrientation is a wrapper around gtk_tool_item_get_text_orientation(). 10373func (v *ToolItem) GetTextOrientation() Orientation { 10374 c := C.gtk_tool_item_get_text_orientation(v.native()) 10375 return Orientation(c) 10376} 10377 10378// RetrieveProxyMenuItem is a wrapper around gtk_tool_item_retrieve_proxy_menu_item() 10379func (v *ToolItem) RetrieveProxyMenuItem() *MenuItem { 10380 c := C.gtk_tool_item_retrieve_proxy_menu_item(v.native()) 10381 if c == nil { 10382 return nil 10383 } 10384 return wrapMenuItem(glib.Take(unsafe.Pointer(c))) 10385} 10386 10387// TODO: 10388// gtk_tool_item_get_proxy_menu_item(). 10389 10390// SetProxyMenuItem is a wrapper around gtk_tool_item_set_proxy_menu_item(). 10391func (v *ToolItem) SetProxyMenuItem(menuItemId string, menuItem IMenuItem) { 10392 cstr := C.CString(menuItemId) 10393 defer C.free(unsafe.Pointer(cstr)) 10394 C.gtk_tool_item_set_proxy_menu_item(v.native(), (*C.gchar)(cstr), 10395 C.toGtkWidget(unsafe.Pointer(menuItem.toMenuItem()))) 10396} 10397 10398// RebuildMenu is a wrapper around gtk_tool_item_rebuild_menu(). 10399func (v *ToolItem) RebuildMenu() { 10400 C.gtk_tool_item_rebuild_menu(v.native()) 10401} 10402 10403// ToolbarReconfigured is a wrapper around gtk_tool_item_toolbar_reconfigured(). 10404func (v *ToolItem) ToolbarReconfigured() { 10405 C.gtk_tool_item_toolbar_reconfigured(v.native()) 10406} 10407 10408// TODO: gtk_tool_item_get_text_size_group 10409 10410/* 10411 * GtkToolItemGroup 10412 */ 10413 10414// TODO: 10415// gtk_tool_item_group_get_collapsed(). 10416// gtk_tool_item_group_get_drop_item(). 10417// gtk_tool_item_group_get_ellipsize(). 10418// gtk_tool_item_group_get_item_position(). 10419// gtk_tool_item_group_get_n_items(). 10420// gtk_tool_item_group_get_label(). 10421// gtk_tool_item_group_get_label_widget(). 10422// gtk_tool_item_group_get_nth_item(). 10423// gtk_tool_item_group_get_header_relief(). 10424// gtk_tool_item_group_insert(). 10425// gtk_tool_item_group_new(). 10426// gtk_tool_item_group_set_collapsed(). 10427// gtk_tool_item_group_set_ellipsize(). 10428// gtk_tool_item_group_set_item_position(). 10429// gtk_tool_item_group_set_label(). 10430// gtk_tool_item_group_set_label_widget(). 10431// gtk_tool_item_group_set_header_relief(). 10432 10433/* 10434 * GtkToolPalette 10435 */ 10436 10437// TODO: 10438// gtk_tool_palette_new(). 10439// gtk_tool_palette_get_exclusive(). 10440// gtk_tool_palette_set_exclusive(). 10441// gtk_tool_palette_get_expand(). 10442// gtk_tool_palette_set_expand(). 10443// gtk_tool_palette_get_group_position(). 10444// gtk_tool_palette_set_group_position(). 10445// gtk_tool_palette_get_icon_size(). 10446// gtk_tool_palette_set_icon_size(). 10447// gtk_tool_palette_unset_icon_size(). 10448// gtk_tool_palette_get_style(). 10449// gtk_tool_palette_set_style(). 10450// gtk_tool_palette_unset_style(). 10451// gtk_tool_palette_add_drag_dest(). 10452// gtk_tool_palette_get_drag_item(). 10453// gtk_tool_palette_get_drag_target_group(). 10454// gtk_tool_palette_get_drag_target_item(). 10455// gtk_tool_palette_get_drop_group(). 10456// gtk_tool_palette_get_drop_item(). 10457// gtk_tool_palette_set_drag_source(). 10458// GtkToolPaletteDragTargets 10459 10460/* 10461 * GtkTreeIter 10462 */ 10463 10464// TreeIter is a representation of GTK's GtkTreeIter. 10465type TreeIter struct { 10466 GtkTreeIter C.GtkTreeIter 10467} 10468 10469// native returns a pointer to the underlying GtkTreeIter. 10470func (v *TreeIter) native() *C.GtkTreeIter { 10471 if v == nil { 10472 return nil 10473 } 10474 return &v.GtkTreeIter 10475} 10476 10477func marshalTreeIter(p uintptr) (interface{}, error) { 10478 c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) 10479 return (*TreeIter)(unsafe.Pointer(c)), nil 10480} 10481 10482func (v *TreeIter) free() { 10483 C.gtk_tree_iter_free(v.native()) 10484} 10485 10486// Copy() is a wrapper around gtk_tree_iter_copy(). 10487// 10488// Caution: when this method is used together with selection.GetSelectedRows(), 10489// it might cause random crash issue. See issue #590 and #610. 10490func (v *TreeIter) Copy() (*TreeIter, error) { 10491 c := C.gtk_tree_iter_copy(v.native()) 10492 if c == nil { 10493 return nil, nilPtrErr 10494 } 10495 t := &TreeIter{*c} 10496 runtime.SetFinalizer(t, (*TreeIter).free) 10497 return t, nil 10498} 10499 10500/* 10501 * GtkTreeModel 10502 */ 10503 10504// TreeModel is a representation of GTK's GtkTreeModel GInterface. 10505type TreeModel struct { 10506 *glib.Object 10507} 10508 10509// ITreeModel is an interface type implemented by all structs 10510// embedding a TreeModel. It is meant to be used as an argument type 10511// for wrapper functions that wrap around a C GTK function taking a 10512// GtkTreeModel. 10513type ITreeModel interface { 10514 toTreeModel() *C.GtkTreeModel 10515 ToTreeModel() *TreeModel 10516} 10517 10518// native returns a pointer to the underlying GObject as a GtkTreeModel. 10519func (v *TreeModel) native() *C.GtkTreeModel { 10520 if v == nil || v.GObject == nil { 10521 return nil 10522 } 10523 p := unsafe.Pointer(v.GObject) 10524 return C.toGtkTreeModel(p) 10525} 10526 10527func (v *TreeModel) toTreeModel() *C.GtkTreeModel { 10528 if v == nil { 10529 return nil 10530 } 10531 return v.native() 10532} 10533 10534func marshalTreeModel(p uintptr) (interface{}, error) { 10535 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 10536 obj := glib.Take(unsafe.Pointer(c)) 10537 return wrapTreeModel(obj), nil 10538} 10539 10540func wrapTreeModel(obj *glib.Object) *TreeModel { 10541 if obj == nil { 10542 return nil 10543 } 10544 10545 return &TreeModel{obj} 10546} 10547 10548// ToTreeModel is a helper getter, e.g.: it returns *gtk.TreeStore/ListStore as a *gtk.TreeModel. 10549// In other cases, where you have a gtk.ITreeModel, use the type assertion. 10550func (v *TreeModel) ToTreeModel() *TreeModel { 10551 return v 10552} 10553 10554// GetFlags() is a wrapper around gtk_tree_model_get_flags(). 10555func (v *TreeModel) GetFlags() TreeModelFlags { 10556 c := C.gtk_tree_model_get_flags(v.native()) 10557 return TreeModelFlags(c) 10558} 10559 10560// GetNColumns() is a wrapper around gtk_tree_model_get_n_columns(). 10561func (v *TreeModel) GetNColumns() int { 10562 c := C.gtk_tree_model_get_n_columns(v.native()) 10563 return int(c) 10564} 10565 10566// GetColumnType() is a wrapper around gtk_tree_model_get_column_type(). 10567func (v *TreeModel) GetColumnType(index int) glib.Type { 10568 c := C.gtk_tree_model_get_column_type(v.native(), C.gint(index)) 10569 return glib.Type(c) 10570} 10571 10572// GetIter() is a wrapper around gtk_tree_model_get_iter(). 10573func (v *TreeModel) GetIter(path *TreePath) (*TreeIter, error) { 10574 var iter C.GtkTreeIter 10575 c := C.gtk_tree_model_get_iter(v.native(), &iter, path.native()) 10576 if !gobool(c) { 10577 return nil, errors.New("Unable to set iterator") 10578 } 10579 t := &TreeIter{iter} 10580 return t, nil 10581} 10582 10583// GetIterFromString() is a wrapper around 10584// gtk_tree_model_get_iter_from_string(). 10585func (v *TreeModel) GetIterFromString(path string) (*TreeIter, error) { 10586 var iter C.GtkTreeIter 10587 cstr := C.CString(path) 10588 defer C.free(unsafe.Pointer(cstr)) 10589 c := C.gtk_tree_model_get_iter_from_string(v.native(), &iter, 10590 (*C.gchar)(cstr)) 10591 if !gobool(c) { 10592 return nil, errors.New("Unable to set iterator") 10593 } 10594 t := &TreeIter{iter} 10595 return t, nil 10596} 10597 10598// GetIterFirst() is a wrapper around gtk_tree_model_get_iter_first(). 10599func (v *TreeModel) GetIterFirst() (*TreeIter, bool) { 10600 var iter C.GtkTreeIter 10601 c := C.gtk_tree_model_get_iter_first(v.native(), &iter) 10602 if !gobool(c) { 10603 return nil, false 10604 } 10605 t := &TreeIter{iter} 10606 return t, true 10607} 10608 10609// GetPath() is a wrapper around gtk_tree_model_get_path(). 10610func (v *TreeModel) GetPath(iter *TreeIter) (*TreePath, error) { 10611 c := C.gtk_tree_model_get_path(v.native(), iter.native()) 10612 if c == nil { 10613 return nil, nilPtrErr 10614 } 10615 p := &TreePath{c} 10616 runtime.SetFinalizer(p, (*TreePath).free) 10617 return p, nil 10618} 10619 10620// GetStringFromIter() is a wrapper around gtk_tree_model_get_string_from_iter(). 10621func (v *TreeModel) GetStringFromIter(iter *TreeIter) string { 10622 c := C.gtk_tree_model_get_string_from_iter(v.native(), iter.native()) 10623 s := goString(c) 10624 defer C.g_free((C.gpointer)(c)) 10625 return s 10626} 10627 10628// GetValue() is a wrapper around gtk_tree_model_get_value(). 10629func (v *TreeModel) GetValue(iter *TreeIter, column int) (*glib.Value, error) { 10630 val, err := glib.ValueAlloc() 10631 if err != nil { 10632 return nil, err 10633 } 10634 C.gtk_tree_model_get_value( 10635 v.native(), 10636 iter.native(), 10637 C.gint(column), 10638 (*C.GValue)(unsafe.Pointer(val.Native()))) 10639 return val, nil 10640} 10641 10642// IterHasChild() is a wrapper around gtk_tree_model_iter_has_child(). 10643func (v *TreeModel) IterHasChild(iter *TreeIter) bool { 10644 c := C.gtk_tree_model_iter_has_child(v.native(), iter.native()) 10645 return gobool(c) 10646} 10647 10648// IterNext() is a wrapper around gtk_tree_model_iter_next(). 10649func (v *TreeModel) IterNext(iter *TreeIter) bool { 10650 c := C.gtk_tree_model_iter_next(v.native(), iter.native()) 10651 return gobool(c) 10652} 10653 10654// IterPrevious is a wrapper around gtk_tree_model_iter_previous(). 10655func (v *TreeModel) IterPrevious(iter *TreeIter) bool { 10656 c := C.gtk_tree_model_iter_previous(v.native(), iter.native()) 10657 return gobool(c) 10658} 10659 10660// IterParent is a wrapper around gtk_tree_model_iter_parent(). 10661func (v *TreeModel) IterParent(iter, child *TreeIter) bool { 10662 c := C.gtk_tree_model_iter_parent(v.native(), iter.native(), child.native()) 10663 return gobool(c) 10664} 10665 10666// IterNthChild is a wrapper around gtk_tree_model_iter_nth_child(). 10667func (v *TreeModel) IterNthChild(iter *TreeIter, parent *TreeIter, n int) bool { 10668 c := C.gtk_tree_model_iter_nth_child(v.native(), iter.native(), parent.native(), C.gint(n)) 10669 return gobool(c) 10670} 10671 10672// IterChildren is a wrapper around gtk_tree_model_iter_children(). 10673func (v *TreeModel) IterChildren(iter, child *TreeIter) bool { 10674 var cIter, cChild *C.GtkTreeIter 10675 if iter != nil { 10676 cIter = iter.native() 10677 } 10678 cChild = child.native() 10679 c := C.gtk_tree_model_iter_children(v.native(), cChild, cIter) 10680 return gobool(c) 10681} 10682 10683// IterNChildren is a wrapper around gtk_tree_model_iter_n_children(). 10684func (v *TreeModel) IterNChildren(iter *TreeIter) int { 10685 var cIter *C.GtkTreeIter 10686 if iter != nil { 10687 cIter = iter.native() 10688 } 10689 c := C.gtk_tree_model_iter_n_children(v.native(), cIter) 10690 return int(c) 10691} 10692 10693// FilterNew is a wrapper around gtk_tree_model_filter_new(). 10694func (v *TreeModel) FilterNew(root *TreePath) (*TreeModelFilter, error) { 10695 c := C.gtk_tree_model_filter_new(v.native(), root.native()) 10696 if c == nil { 10697 return nil, nilPtrErr 10698 } 10699 obj := glib.Take(unsafe.Pointer(c)) 10700 return wrapTreeModelFilter(obj), nil 10701} 10702 10703// TreeModelForeachFunc defines the function prototype for the foreach function (f arg) for 10704// (* TreeModel).ForEach 10705type TreeModelForeachFunc func(model *TreeModel, path *TreePath, iter *TreeIter) bool 10706 10707// ForEach() is a wrapper around gtk_tree_model_foreach () 10708func (v *TreeModel) ForEach(f TreeModelForeachFunc) { 10709 id := callback.Assign(f) 10710 defer callback.Delete(id) 10711 10712 C._gtk_tree_model_foreach(v.toTreeModel(), C.gpointer(id)) 10713} 10714 10715/* 10716 * GtkTreeModelFilter 10717 */ 10718 10719// TreeModelFilter is a representation of GTK's GtkTreeModelFilter. 10720type TreeModelFilter struct { 10721 *glib.Object 10722 10723 // Interfaces 10724 TreeModel 10725} 10726 10727func (v *TreeModelFilter) native() *C.GtkTreeModelFilter { 10728 if v == nil || v.GObject == nil { 10729 return nil 10730 } 10731 p := unsafe.Pointer(v.GObject) 10732 return C.toGtkTreeModelFilter(p) 10733} 10734 10735func (v *TreeModelFilter) toTreeModelFilter() *C.GtkTreeModelFilter { 10736 if v == nil { 10737 return nil 10738 } 10739 return v.native() 10740} 10741 10742func marshalTreeModelFilter(p uintptr) (interface{}, error) { 10743 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 10744 obj := glib.Take(unsafe.Pointer(c)) 10745 return wrapTreeModelFilter(obj), nil 10746} 10747 10748func wrapTreeModelFilter(obj *glib.Object) *TreeModelFilter { 10749 if obj == nil { 10750 return nil 10751 } 10752 10753 tm := wrapTreeModel(obj) 10754 return &TreeModelFilter{obj, *tm} 10755} 10756 10757// SetVisibleColumn is a wrapper around gtk_tree_model_filter_set_visible_column(). 10758func (v *TreeModelFilter) SetVisibleColumn(column int) { 10759 C.gtk_tree_model_filter_set_visible_column(v.native(), C.gint(column)) 10760} 10761 10762// ConvertChildPathToPath is a wrapper around gtk_tree_model_filter_convert_child_path_to_path(). 10763func (v *TreeModelFilter) ConvertChildPathToPath(childPath *TreePath) *TreePath { 10764 path := C.gtk_tree_model_filter_convert_child_path_to_path(v.native(), childPath.native()) 10765 if path == nil { 10766 return nil 10767 } 10768 p := &TreePath{path} 10769 runtime.SetFinalizer(p, (*TreePath).free) 10770 return p 10771} 10772 10773// ConvertChildIterToIter is a wrapper around gtk_tree_model_filter_convert_child_iter_to_iter(). 10774func (v *TreeModelFilter) ConvertChildIterToIter(childIter *TreeIter) (*TreeIter, bool) { 10775 var iter C.GtkTreeIter 10776 ok := gobool(C.gtk_tree_model_filter_convert_child_iter_to_iter(v.native(), &iter, childIter.native())) 10777 t := &TreeIter{iter} 10778 return t, ok 10779} 10780 10781// ConvertIterToChildIter is a wrapper around gtk_tree_model_filter_convert_child_iter_to_iter(). 10782func (v *TreeModelFilter) ConvertIterToChildIter(filterIter *TreeIter) *TreeIter { 10783 var iter C.GtkTreeIter 10784 C.gtk_tree_model_filter_convert_iter_to_child_iter(v.native(), &iter, filterIter.native()) 10785 t := &TreeIter{iter} 10786 return t 10787} 10788 10789// ConvertPathToChildPath is a wrapper around gtk_tree_model_filter_convert_path_to_child_path(). 10790func (v *TreeModelFilter) ConvertPathToChildPath(filterPath *TreePath) *TreePath { 10791 path := C.gtk_tree_model_filter_convert_path_to_child_path(v.native(), filterPath.native()) 10792 if path == nil { 10793 return nil 10794 } 10795 p := &TreePath{path} 10796 runtime.SetFinalizer(p, (*TreePath).free) 10797 return p 10798} 10799 10800// Refilter is a wrapper around gtk_tree_model_filter_refilter(). 10801func (v *TreeModelFilter) Refilter() { 10802 C.gtk_tree_model_filter_refilter(v.native()) 10803} 10804 10805// TreeModelFilterVisibleFunc defines the function prototype for the filter visibility function (f arg) 10806// to TreeModelFilter.SetVisibleFunc. 10807type TreeModelFilterVisibleFunc func(model *TreeModel, iter *TreeIter) bool 10808 10809// SetVisibleFunc is a wrapper around gtk_tree_model_filter_set_visible_func(). 10810func (v *TreeModelFilter) SetVisibleFunc(f TreeModelFilterVisibleFunc) { 10811 C._gtk_tree_model_filter_set_visible_func(v.native(), C.gpointer(callback.Assign(f))) 10812} 10813 10814// Down() is a wrapper around gtk_tree_path_down() 10815func (v *TreePath) Down() { 10816 C.gtk_tree_path_down(v.native()) 10817} 10818 10819// IsAncestor() is a wrapper around gtk_tree_path_is_ancestor() 10820func (v *TreePath) IsAncestor(descendant *TreePath) bool { 10821 return gobool(C.gtk_tree_path_is_ancestor(v.native(), descendant.native())) 10822} 10823 10824// IsDescendant() is a wrapper around gtk_tree_path_is_descendant() 10825func (v *TreePath) IsDescendant(ancestor *TreePath) bool { 10826 return gobool(C.gtk_tree_path_is_descendant(v.native(), ancestor.native())) 10827} 10828 10829/* 10830 * GtkTreePath 10831 */ 10832 10833// TreePath is a representation of GTK's GtkTreePath. 10834type TreePath struct { 10835 GtkTreePath *C.GtkTreePath 10836} 10837 10838// Return a TreePath from the GList 10839func TreePathFromList(list *glib.List) *TreePath { 10840 if list == nil { 10841 return nil 10842 } 10843 return &TreePath{(*C.GtkTreePath)(list.Data().(unsafe.Pointer))} 10844} 10845 10846// native returns a pointer to the underlying GtkTreePath. 10847func (v *TreePath) native() *C.GtkTreePath { 10848 if v == nil { 10849 return nil 10850 } 10851 return v.GtkTreePath 10852} 10853 10854func marshalTreePath(p uintptr) (interface{}, error) { 10855 c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) 10856 return &TreePath{(*C.GtkTreePath)(unsafe.Pointer(c))}, nil 10857} 10858 10859func (v *TreePath) free() { 10860 C.gtk_tree_path_free(v.native()) 10861} 10862 10863// GetIndices is a wrapper around gtk_tree_path_get_indices_with_depth 10864func (v *TreePath) GetIndices() []int { 10865 var depth C.gint 10866 var goindices []int 10867 var ginthelp C.gint 10868 indices := uintptr(unsafe.Pointer(C.gtk_tree_path_get_indices_with_depth(v.native(), &depth))) 10869 size := unsafe.Sizeof(ginthelp) 10870 for i := 0; i < int(depth); i++ { 10871 goind := int(*((*C.gint)(unsafe.Pointer(indices)))) 10872 goindices = append(goindices, goind) 10873 indices += size 10874 } 10875 return goindices 10876} 10877 10878// String is a wrapper around gtk_tree_path_to_string(). 10879func (v *TreePath) String() string { 10880 c := C.gtk_tree_path_to_string(v.native()) 10881 return goString(c) 10882} 10883 10884// TreePathNewFromString is a wrapper around gtk_tree_path_new_from_string(). 10885func TreePathNewFromString(path string) (*TreePath, error) { 10886 cstr := C.CString(path) 10887 defer C.free(unsafe.Pointer(cstr)) 10888 c := C.gtk_tree_path_new_from_string((*C.gchar)(cstr)) 10889 if c == nil { 10890 return nil, nilPtrErr 10891 } 10892 t := &TreePath{c} 10893 runtime.SetFinalizer(t, (*TreePath).free) 10894 return t, nil 10895} 10896 10897// Next() is a wrapper around gtk_tree_path_next() 10898func (v *TreePath) Next() { 10899 C.gtk_tree_path_next(v.native()) 10900} 10901 10902// Prev() is a wrapper around gtk_tree_path_prev() 10903func (v *TreePath) Prev() bool { 10904 return gobool(C.gtk_tree_path_prev(v.native())) 10905} 10906 10907// Up() is a wrapper around gtk_tree_path_up() 10908func (v *TreePath) Up() bool { 10909 return gobool(C.gtk_tree_path_up(v.native())) 10910} 10911 10912// TreePathNewFirst() is a wrapper around gtk_tree_path_new_first(). 10913func TreePathNewFirst() (*TreePath, error) { 10914 c := C.gtk_tree_path_new_first() 10915 if c == nil { 10916 return nil, nilPtrErr 10917 } 10918 t := &TreePath{c} 10919 runtime.SetFinalizer(t, (*TreePath).free) 10920 return t, nil 10921} 10922 10923// AppendIndex() is a wrapper around gtk_tree_path_append_index(). 10924func (v *TreePath) AppendIndex(index int) { 10925 C.gtk_tree_path_append_index(v.native(), C.gint(index)) 10926} 10927 10928// PrependIndex() is a wrapper around gtk_tree_path_prepend_index(). 10929func (v *TreePath) PrependIndex(index int) { 10930 C.gtk_tree_path_prepend_index(v.native(), C.gint(index)) 10931} 10932 10933// GetDepth() is a wrapper around gtk_tree_path_get_depth(). 10934func (v *TreePath) GetDepth() int { 10935 return int(C.gtk_tree_path_get_depth(v.native())) 10936} 10937 10938// Copy() is a wrapper around gtk_tree_path_copy(). 10939func (v *TreePath) Copy() (*TreePath, error) { 10940 c := C.gtk_tree_path_copy(v.native()) 10941 if c == nil { 10942 return nil, nilPtrErr 10943 } 10944 t := &TreePath{c} 10945 runtime.SetFinalizer(t, (*TreePath).free) 10946 return t, nil 10947} 10948 10949// Compare() is a wrapper around gtk_tree_path_compare(). 10950func (v *TreePath) Compare(b *TreePath) int { 10951 return int(C.gtk_tree_path_compare(v.native(), b.native())) 10952} 10953 10954/* 10955 * GtkTreeSelection 10956 */ 10957 10958// TreeSelection is a representation of GTK's GtkTreeSelection. 10959type TreeSelection struct { 10960 *glib.Object 10961} 10962 10963// native returns a pointer to the underlying GtkTreeSelection. 10964func (v *TreeSelection) native() *C.GtkTreeSelection { 10965 if v == nil || v.GObject == nil { 10966 return nil 10967 } 10968 p := unsafe.Pointer(v.GObject) 10969 return C.toGtkTreeSelection(p) 10970} 10971 10972func marshalTreeSelection(p uintptr) (interface{}, error) { 10973 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 10974 obj := glib.Take(unsafe.Pointer(c)) 10975 return wrapTreeSelection(obj), nil 10976} 10977 10978func wrapTreeSelection(obj *glib.Object) *TreeSelection { 10979 if obj == nil { 10980 return nil 10981 } 10982 10983 return &TreeSelection{obj} 10984} 10985 10986// GetSelected() is a wrapper around gtk_tree_selection_get_selected(). 10987func (v *TreeSelection) GetSelected() (model ITreeModel, iter *TreeIter, ok bool) { 10988 var cmodel *C.GtkTreeModel 10989 var citer C.GtkTreeIter 10990 c := C.gtk_tree_selection_get_selected(v.native(), 10991 &cmodel, &citer) 10992 model = wrapTreeModel(glib.Take(unsafe.Pointer(cmodel))) 10993 iter = &TreeIter{citer} 10994 ok = gobool(c) 10995 return 10996} 10997 10998// SelectPath is a wrapper around gtk_tree_selection_select_path(). 10999func (v *TreeSelection) SelectPath(path *TreePath) { 11000 C.gtk_tree_selection_select_path(v.native(), path.native()) 11001} 11002 11003// UnselectPath is a wrapper around gtk_tree_selection_unselect_path(). 11004func (v *TreeSelection) UnselectPath(path *TreePath) { 11005 C.gtk_tree_selection_unselect_path(v.native(), path.native()) 11006} 11007 11008// GetSelectedRows is a wrapper around gtk_tree_selection_get_selected_rows(). 11009// All the elements of returned list are wrapped into (*gtk.TreePath) values. 11010// 11011// Please note that a runtime finalizer is only set on the head of the linked 11012// list, and must be kept live while accessing any item in the list, or the 11013// Go garbage collector will free the whole list. 11014func (v *TreeSelection) GetSelectedRows(model ITreeModel) *glib.List { 11015 var pcmodel **C.GtkTreeModel 11016 if model != nil { 11017 cmodel := model.toTreeModel() 11018 pcmodel = &cmodel 11019 } 11020 11021 clist := C.gtk_tree_selection_get_selected_rows(v.native(), pcmodel) 11022 if clist == nil { 11023 return nil 11024 } 11025 11026 glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) 11027 glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { 11028 return &TreePath{(*C.GtkTreePath)(ptr)} 11029 }) 11030 runtime.SetFinalizer(glist, func(glist *glib.List) { 11031 glist.FreeFull(func(item interface{}) { 11032 path := item.(*TreePath) 11033 C.gtk_tree_path_free(path.GtkTreePath) 11034 }) 11035 }) 11036 11037 return glist 11038} 11039 11040// CountSelectedRows() is a wrapper around gtk_tree_selection_count_selected_rows(). 11041func (v *TreeSelection) CountSelectedRows() int { 11042 return int(C.gtk_tree_selection_count_selected_rows(v.native())) 11043} 11044 11045// SelectIter is a wrapper around gtk_tree_selection_select_iter(). 11046func (v *TreeSelection) SelectIter(iter *TreeIter) { 11047 C.gtk_tree_selection_select_iter(v.native(), iter.native()) 11048} 11049 11050// SetMode() is a wrapper around gtk_tree_selection_set_mode(). 11051func (v *TreeSelection) SetMode(m SelectionMode) { 11052 C.gtk_tree_selection_set_mode(v.native(), C.GtkSelectionMode(m)) 11053} 11054 11055// GetMode() is a wrapper around gtk_tree_selection_get_mode(). 11056func (v *TreeSelection) GetMode() SelectionMode { 11057 return SelectionMode(C.gtk_tree_selection_get_mode(v.native())) 11058} 11059 11060// SelectAll() is a wrapper around gtk_tree_selection_select_all() 11061func (v *TreeSelection) SelectAll() { 11062 C.gtk_tree_selection_select_all(v.native()) 11063} 11064 11065// UnelectAll() is a wrapper around gtk_tree_selection_unselect_all() 11066func (v *TreeSelection) UnselectAll() { 11067 C.gtk_tree_selection_unselect_all(v.native()) 11068} 11069 11070// UnselectIter() is a wrapper around gtk_tree_selection_unselect_iter(). 11071func (v *TreeSelection) UnselectIter(iter *TreeIter) { 11072 C.gtk_tree_selection_unselect_iter(v.native(), iter.native()) 11073} 11074 11075// IterIsSelected() is a wrapper around gtk_tree_selection_iter_is_selected(). 11076func (v *TreeSelection) IterIsSelected(iter *TreeIter) bool { 11077 return gobool(C.gtk_tree_selection_iter_is_selected(v.native(), iter.native())) 11078} 11079 11080// SelectRange() is a wrapper around gtk_tree_selection_select_range(). 11081func (v *TreeSelection) SelectRange(start, end *TreePath) { 11082 C.gtk_tree_selection_select_range(v.native(), start.native(), end.native()) 11083} 11084 11085// UnselectRange() is a wrapper around gtk_tree_selection_unselect_range(). 11086func (v *TreeSelection) UnselectRange(start, end *TreePath) { 11087 C.gtk_tree_selection_unselect_range(v.native(), start.native(), end.native()) 11088} 11089 11090// PathIsSelected() is a wrapper around gtk_tree_selection_path_is_selected(). 11091func (v *TreeSelection) PathIsSelected(path *TreePath) bool { 11092 return gobool(C.gtk_tree_selection_path_is_selected(v.native(), path.native())) 11093} 11094 11095// TreeSelectionForeachFunc defines the function prototype for the selected_foreach function (f arg) for 11096// (* TreeSelection).SelectedForEach 11097type TreeSelectionForeachFunc func(model *TreeModel, path *TreePath, iter *TreeIter) 11098 11099// SelectedForEach() is a wrapper around gtk_tree_selection_selected_foreach() 11100func (v *TreeSelection) SelectedForEach(f TreeSelectionForeachFunc) { 11101 id := callback.Assign(f) 11102 defer callback.Delete(id) 11103 11104 C._gtk_tree_selection_selected_foreach(v.native(), C.gpointer(id)) 11105} 11106 11107// TreeSelectionFunc defines the function prototype for the gtk_tree_selection_set_select_function 11108// function (f arg) for (* TreeSelection).SetSelectFunction 11109type TreeSelectionFunc func(selection *TreeSelection, model *TreeModel, path *TreePath, selected bool) bool 11110 11111// SetSelectFunction() is a wrapper around gtk_tree_selection_set_select_function() 11112func (v *TreeSelection) SetSelectFunction(f TreeSelectionFunc) { 11113 C._gtk_tree_selection_set_select_function(v.native(), C.gpointer(callback.Assign(f))) 11114} 11115 11116/* 11117 * GtkTreeRowReference 11118 */ 11119 11120// TreeRowReference is a representation of GTK's GtkTreeRowReference. 11121type TreeRowReference struct { 11122 GtkTreeRowReference *C.GtkTreeRowReference 11123} 11124 11125func (v *TreeRowReference) native() *C.GtkTreeRowReference { 11126 if v == nil { 11127 return nil 11128 } 11129 return v.GtkTreeRowReference 11130} 11131 11132func (v *TreeRowReference) free() { 11133 C.gtk_tree_row_reference_free(v.native()) 11134} 11135 11136// TreeRowReferenceNew is a wrapper around gtk_tree_row_reference_new(). 11137func TreeRowReferenceNew(model *TreeModel, path *TreePath) (*TreeRowReference, error) { 11138 c := C.gtk_tree_row_reference_new(model.native(), path.native()) 11139 if c == nil { 11140 return nil, nilPtrErr 11141 } 11142 r := &TreeRowReference{c} 11143 runtime.SetFinalizer(r, (*TreeRowReference).free) 11144 return r, nil 11145} 11146 11147// GetPath is a wrapper around gtk_tree_row_reference_get_path. 11148func (v *TreeRowReference) GetPath() *TreePath { 11149 c := C.gtk_tree_row_reference_get_path(v.native()) 11150 if c == nil { 11151 return nil 11152 } 11153 t := &TreePath{c} 11154 runtime.SetFinalizer(t, (*TreePath).free) 11155 return t 11156} 11157 11158// GetModel is a wrapper around gtk_tree_row_reference_get_path. 11159func (v *TreeRowReference) GetModel() (ITreeModel, error) { 11160 c := C.gtk_tree_row_reference_get_model(v.native()) 11161 if c == nil { 11162 return nil, nilPtrErr 11163 } 11164 return castTreeModel(c) 11165} 11166 11167// Valid is a wrapper around gtk_tree_row_reference_valid. 11168func (v *TreeRowReference) Valid() bool { 11169 c := C.gtk_tree_row_reference_valid(v.native()) 11170 return gobool(c) 11171} 11172 11173/* 11174 * GtkTreeSortable 11175 */ 11176 11177// TreeSortable is a representation of GTK's GtkTreeSortable 11178type TreeSortable struct { 11179 *glib.Object 11180} 11181 11182// ITreeSortable is an interface type implemented by all structs 11183// embedding a TreeSortable. It is meant to be used as an argument type 11184// for wrapper functions that wrap around a C GTK function taking a 11185// GtkTreeSortable. 11186type ITreeSortable interface { 11187 toTreeSortable() *C.GtkTreeSortable 11188} 11189 11190// native returns a pointer to the underlying GtkTreeSortable 11191func (v *TreeSortable) native() *C.GtkTreeSortable { 11192 if v == nil || v.GObject == nil { 11193 return nil 11194 } 11195 p := unsafe.Pointer(v.GObject) 11196 return C.toGtkTreeSortable(p) 11197} 11198 11199func (v *TreeSortable) toTreeSortable() *C.GtkTreeSortable { 11200 if v == nil { 11201 return nil 11202 } 11203 return v.native() 11204} 11205 11206func marshalTreeSortable(p uintptr) (interface{}, error) { 11207 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 11208 obj := glib.Take(unsafe.Pointer(c)) 11209 return wrapTreeSortable(obj), nil 11210} 11211 11212func wrapTreeSortable(obj *glib.Object) *TreeSortable { 11213 if obj == nil { 11214 return nil 11215 } 11216 11217 return &TreeSortable{obj} 11218} 11219 11220// TreeIterCompareFunc is a representation of GtkTreeIterCompareFunc. 11221// It defines the function prototype for the sort function (f arg) for (* TreeSortable).SetSortFunc 11222type TreeIterCompareFunc func(model *TreeModel, a, b *TreeIter) int 11223 11224// GetSortColumnId() is a wrapper around gtk_tree_sortable_get_sort_column_id(). 11225func (v *TreeSortable) GetSortColumnId() (int, SortType, bool) { 11226 var column C.gint 11227 var order C.GtkSortType 11228 ok := gobool(C.gtk_tree_sortable_get_sort_column_id(v.native(), &column, &order)) 11229 return int(column), SortType(order), ok 11230} 11231 11232// SetSortColumnId() is a wrapper around gtk_tree_sortable_set_sort_column_id(). 11233func (v *TreeSortable) SetSortColumnId(column int, order SortType) { 11234 C.gtk_tree_sortable_set_sort_column_id(v.native(), C.gint(column), C.GtkSortType(order)) 11235} 11236 11237// SetSortFunc() is a wrapper around gtk_tree_sortable_set_sort_func(). 11238func (v *TreeSortable) SetSortFunc(sortColumn int, f TreeIterCompareFunc) { 11239 C._gtk_tree_sortable_set_sort_func(v.native(), C.gint(sortColumn), C.gpointer(callback.Assign(f))) 11240} 11241 11242// SetDefaultSortFunc() is a wrapper around gtk_tree_sortable_set_default_sort_func(). 11243func (v *TreeSortable) SetDefaultSortFunc(f TreeIterCompareFunc) { 11244 C._gtk_tree_sortable_set_default_sort_func(v.native(), C.gpointer(callback.Assign(f))) 11245} 11246 11247func (v *TreeSortable) HasDefaultSortFunc() bool { 11248 return gobool(C.gtk_tree_sortable_has_default_sort_func(v.native())) 11249} 11250 11251/* 11252 * GtkTreeModelSort 11253 */ 11254 11255// TreeModelSort is a representation of GTK's GtkTreeModelSort 11256type TreeModelSort struct { 11257 *glib.Object 11258 11259 // Interfaces 11260 TreeModel 11261 TreeSortable 11262} 11263 11264// native returns a pointer to the underlying GtkTreeModelSort 11265func (v *TreeModelSort) native() *C.GtkTreeModelSort { 11266 if v == nil || v.GObject == nil { 11267 return nil 11268 } 11269 p := unsafe.Pointer(v.GObject) 11270 return C.toGtkTreeModelSort(p) 11271} 11272 11273func marshalTreeModelSort(p uintptr) (interface{}, error) { 11274 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 11275 obj := glib.Take(unsafe.Pointer(c)) 11276 return wrapTreeModelSort(obj), nil 11277} 11278 11279func wrapTreeModelSort(obj *glib.Object) *TreeModelSort { 11280 if obj == nil { 11281 return nil 11282 } 11283 11284 tm := wrapTreeModel(obj) 11285 ts := wrapTreeSortable(obj) 11286 return &TreeModelSort{obj, *tm, *ts} 11287} 11288 11289func (v *TreeModelSort) toTreeModel() *C.GtkTreeModel { 11290 if v == nil { 11291 return nil 11292 } 11293 return C.toGtkTreeModel(unsafe.Pointer(v.GObject)) 11294} 11295 11296func (v *TreeModelSort) toTreeSortable() *C.GtkTreeSortable { 11297 if v == nil { 11298 return nil 11299 } 11300 return C.toGtkTreeSortable(unsafe.Pointer(v.GObject)) 11301} 11302 11303// TreeModelSortNew is a wrapper around gtk_tree_model_sort_new_with_model(): 11304func TreeModelSortNew(model ITreeModel) (*TreeModelSort, error) { 11305 var mptr *C.GtkTreeModel 11306 if model != nil { 11307 mptr = model.toTreeModel() 11308 } 11309 c := C.gtk_tree_model_sort_new_with_model(mptr) 11310 if c == nil { 11311 return nil, nilPtrErr 11312 } 11313 11314 tms := wrapTreeModelSort(glib.Take(unsafe.Pointer(c))) 11315 return tms, nil 11316} 11317 11318// GetModel is a wrapper around gtk_tree_model_sort_get_model() 11319func (v *TreeModelSort) GetModel() (ITreeModel, error) { 11320 c := C.gtk_tree_model_sort_get_model(v.native()) 11321 if c == nil { 11322 return nil, nilPtrErr 11323 } 11324 return castTreeModel(c) 11325} 11326 11327// ConvertChildPathToPath is a wrapper around gtk_tree_model_sort_convert_child_path_to_path(). 11328func (v *TreeModelSort) ConvertChildPathToPath(childPath *TreePath) *TreePath { 11329 path := C.gtk_tree_model_sort_convert_child_path_to_path(v.native(), childPath.native()) 11330 if path == nil { 11331 return nil 11332 } 11333 p := &TreePath{path} 11334 runtime.SetFinalizer(p, (*TreePath).free) 11335 return p 11336} 11337 11338// ConvertChildIterToIter is a wrapper around gtk_tree_model_sort_convert_child_iter_to_iter(). 11339func (v *TreeModelSort) ConvertChildIterToIter(childIter *TreeIter) (*TreeIter, bool) { 11340 var iter C.GtkTreeIter 11341 ok := gobool(C.gtk_tree_model_sort_convert_child_iter_to_iter(v.native(), &iter, childIter.native())) 11342 t := &TreeIter{iter} 11343 return t, ok 11344} 11345 11346// ConvertPathToChildPath is a wrapper around gtk_tree_model_sort_convert_path_to_child_path(). 11347func (v *TreeModelSort) ConvertPathToChildPath(sortPath *TreePath) *TreePath { 11348 path := C.gtk_tree_model_sort_convert_path_to_child_path(v.native(), sortPath.native()) 11349 if path == nil { 11350 return nil 11351 } 11352 p := &TreePath{path} 11353 runtime.SetFinalizer(p, (*TreePath).free) 11354 return p 11355} 11356 11357// ConvertIterToChildIter is a wrapper around gtk_tree_model_sort_convert_iter_to_child_iter(). 11358func (v *TreeModelSort) ConvertIterToChildIter(sortIter *TreeIter) *TreeIter { 11359 var iter C.GtkTreeIter 11360 C.gtk_tree_model_sort_convert_iter_to_child_iter(v.native(), &iter, sortIter.native()) 11361 t := &TreeIter{iter} 11362 return t 11363} 11364 11365// ResetDefaultSortFunc is a wrapper around gtk_tree_model_sort_reset_default_sort_func(). 11366func (v *TreeModelSort) ResetDefaultSortFunc() { 11367 C.gtk_tree_model_sort_reset_default_sort_func(v.native()) 11368} 11369 11370// ClearCache is a wrapper around gtk_tree_model_sort_clear_cache(). 11371func (v *TreeModelSort) ClearCache() { 11372 C.gtk_tree_model_sort_clear_cache(v.native()) 11373} 11374 11375// IterIsValid is a wrapper around gtk_tree_model_sort_iter_is_valid(). 11376func (v *TreeModelSort) IterIsValid(iter *TreeIter) bool { 11377 return gobool(C.gtk_tree_model_sort_iter_is_valid(v.native(), iter.native())) 11378} 11379 11380/* 11381 * GtkTreeStore 11382 */ 11383 11384// TreeStore is a representation of GTK's GtkTreeStore. 11385type TreeStore struct { 11386 *glib.Object 11387 11388 // Interfaces 11389 TreeModel 11390 TreeSortable 11391} 11392 11393// native returns a pointer to the underlying GtkTreeStore. 11394func (v *TreeStore) native() *C.GtkTreeStore { 11395 if v == nil || v.GObject == nil { 11396 return nil 11397 } 11398 p := unsafe.Pointer(v.GObject) 11399 return C.toGtkTreeStore(p) 11400} 11401 11402func marshalTreeStore(p uintptr) (interface{}, error) { 11403 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 11404 obj := glib.Take(unsafe.Pointer(c)) 11405 return wrapTreeStore(obj), nil 11406} 11407 11408func wrapTreeStore(obj *glib.Object) *TreeStore { 11409 if obj == nil { 11410 return nil 11411 } 11412 11413 tm := wrapTreeModel(obj) 11414 ts := wrapTreeSortable(obj) 11415 return &TreeStore{obj, *tm, *ts} 11416} 11417 11418func (v *TreeStore) toTreeModel() *C.GtkTreeModel { 11419 if v == nil { 11420 return nil 11421 } 11422 return C.toGtkTreeModel(unsafe.Pointer(v.GObject)) 11423} 11424 11425func (v *TreeStore) toTreeSortable() *C.GtkTreeSortable { 11426 if v == nil { 11427 return nil 11428 } 11429 return C.toGtkTreeSortable(unsafe.Pointer(v.GObject)) 11430} 11431 11432// TreeStoreNew is a wrapper around gtk_tree_store_newv(). 11433func TreeStoreNew(types ...glib.Type) (*TreeStore, error) { 11434 gtypes := C.alloc_types(C.int(len(types))) 11435 for n, val := range types { 11436 C.set_type(gtypes, C.int(n), C.GType(val)) 11437 } 11438 defer C.g_free(C.gpointer(gtypes)) 11439 c := C.gtk_tree_store_newv(C.gint(len(types)), gtypes) 11440 if c == nil { 11441 return nil, nilPtrErr 11442 } 11443 11444 ts := wrapTreeStore(glib.Take(unsafe.Pointer(c))) 11445 return ts, nil 11446} 11447 11448// Append is a wrapper around gtk_tree_store_append(). 11449func (v *TreeStore) Append(parent *TreeIter) *TreeIter { 11450 var ti C.GtkTreeIter 11451 var cParent *C.GtkTreeIter 11452 if parent != nil { 11453 cParent = parent.native() 11454 } 11455 C.gtk_tree_store_append(v.native(), &ti, cParent) 11456 iter := &TreeIter{ti} 11457 return iter 11458} 11459 11460// Prepend is a wrapper around gtk_tree_store_prepend(). 11461func (v *TreeStore) Prepend(parent *TreeIter) *TreeIter { 11462 var ti C.GtkTreeIter 11463 var cParent *C.GtkTreeIter 11464 if parent != nil { 11465 cParent = parent.native() 11466 } 11467 C.gtk_tree_store_prepend(v.native(), &ti, cParent) 11468 iter := &TreeIter{ti} 11469 return iter 11470} 11471 11472// Insert is a wrapper around gtk_tree_store_insert 11473func (v *TreeStore) Insert(parent *TreeIter, position int) *TreeIter { 11474 var ti C.GtkTreeIter 11475 var cParent *C.GtkTreeIter 11476 if parent != nil { 11477 cParent = parent.native() 11478 } 11479 C.gtk_tree_store_insert(v.native(), &ti, cParent, C.gint(position)) 11480 iter := &TreeIter{ti} 11481 return iter 11482} 11483 11484// SetValue is a wrapper around gtk_tree_store_set_value() 11485func (v *TreeStore) SetValue(iter *TreeIter, column int, value interface{}) error { 11486 switch value.(type) { 11487 case *gdk.Pixbuf: 11488 pix := value.(*gdk.Pixbuf) 11489 C._gtk_tree_store_set(v.native(), iter.native(), C.gint(column), unsafe.Pointer(pix.Native())) 11490 11491 default: 11492 gv, err := glib.GValue(value) 11493 if err != nil { 11494 return err 11495 } 11496 C.gtk_tree_store_set_value(v.native(), iter.native(), 11497 C.gint(column), 11498 (*C.GValue)(C.gpointer(gv.Native()))) 11499 } 11500 return nil 11501} 11502 11503// Remove is a wrapper around gtk_tree_store_remove(). 11504func (v *TreeStore) Remove(iter *TreeIter) bool { 11505 var ti *C.GtkTreeIter 11506 if iter != nil { 11507 ti = iter.native() 11508 } 11509 return 0 != C.gtk_tree_store_remove(v.native(), ti) 11510} 11511 11512// Clear is a wrapper around gtk_tree_store_clear(). 11513func (v *TreeStore) Clear() { 11514 C.gtk_tree_store_clear(v.native()) 11515} 11516 11517// InsertBefore() is a wrapper around gtk_tree_store_insert_before(). 11518func (v *TreeStore) InsertBefore(parent, sibling *TreeIter) *TreeIter { 11519 var ti C.GtkTreeIter 11520 C.gtk_tree_store_insert_before(v.native(), &ti, parent.native(), sibling.native()) 11521 iter := &TreeIter{ti} 11522 return iter 11523} 11524 11525// InsertAfter() is a wrapper around gtk_tree_store_insert_after(). 11526func (v *TreeStore) InsertAfter(parent, sibling *TreeIter) *TreeIter { 11527 var ti C.GtkTreeIter 11528 C.gtk_tree_store_insert_after(v.native(), &ti, parent.native(), sibling.native()) 11529 iter := &TreeIter{ti} 11530 return iter 11531} 11532 11533// InsertWithValues() is a wrapper around gtk_tree_store_insert_with_valuesv(). 11534func (v *TreeStore) InsertWithValues(iter, parent *TreeIter, position int, inColumns []int, inValues []interface{}) error { 11535 length := len(inColumns) 11536 if len(inValues) < length { 11537 length = len(inValues) 11538 } 11539 11540 cColumns := make([]C.gint, 0, length) 11541 cValues := make([]C.GValue, 0, length) 11542 11543 for i := 0; i < length; i++ { 11544 11545 value := inValues[i] 11546 var gvalue *C.GValue 11547 11548 switch value.(type) { 11549 case *gdk.Pixbuf: 11550 pix := value.(*gdk.Pixbuf) 11551 11552 if pix == nil { 11553 continue 11554 } 11555 11556 gvalue = (*C.GValue)(unsafe.Pointer(pix.Native())) 11557 11558 default: 11559 gv, err := glib.GValue(value) 11560 if err != nil { 11561 return err 11562 } 11563 gvalue = (*C.GValue)(C.gpointer(gv.Native())) 11564 } 11565 11566 cColumns = append(cColumns, C.gint(inColumns[i])) 11567 cValues = append(cValues, *gvalue) 11568 } 11569 11570 var cColumnsPointer *C.gint 11571 if len(cColumns) > 0 { 11572 cColumnsPointer = &cColumns[0] 11573 } 11574 var cValuesPointer *C.GValue 11575 if len(cValues) > 0 { 11576 cValuesPointer = &cValues[0] 11577 } 11578 11579 C.gtk_tree_store_insert_with_valuesv(v.native(), iter.native(), parent.native(), C.gint(position), cColumnsPointer, cValuesPointer, C.gint(len(cColumns))) 11580 11581 return nil 11582} 11583 11584// MoveBefore is a wrapper around gtk_tree_store_move_before(). 11585func (v *TreeStore) MoveBefore(iter, position *TreeIter) { 11586 C.gtk_tree_store_move_before(v.native(), iter.native(), 11587 position.native()) 11588} 11589 11590// MoveAfter is a wrapper around gtk_tree_store_move_after(). 11591func (v *TreeStore) MoveAfter(iter, position *TreeIter) { 11592 C.gtk_tree_store_move_after(v.native(), iter.native(), 11593 position.native()) 11594} 11595 11596// Swap is a wrapper around gtk_tree_store_swap(). 11597func (v *TreeStore) Swap(a, b *TreeIter) { 11598 C.gtk_tree_store_swap(v.native(), a.native(), b.native()) 11599} 11600 11601// SetColumnTypes is a wrapper around gtk_tree_store_set_column_types(). 11602// The size of glib.Type must match the number of columns 11603func (v *TreeStore) SetColumnTypes(types ...glib.Type) { 11604 gtypes := C.alloc_types(C.int(len(types))) 11605 for n, val := range types { 11606 C.set_type(gtypes, C.int(n), C.GType(val)) 11607 } 11608 defer C.g_free(C.gpointer(gtypes)) 11609 C.gtk_tree_store_set_column_types(v.native(), C.gint(len(types)), gtypes) 11610} 11611 11612/* 11613 * GtkViewport 11614 */ 11615 11616// Viewport is a representation of GTK's GtkViewport GInterface. 11617type Viewport struct { 11618 Bin 11619 11620 // Interfaces 11621 Scrollable 11622} 11623 11624// IViewport is an interface type implemented by all structs 11625// embedding a Viewport. It is meant to be used as an argument type 11626// for wrapper functions that wrap around a C GTK function taking a 11627// GtkViewport. 11628type IViewport interface { 11629 toViewport() *C.GtkViewport 11630} 11631 11632// native() returns a pointer to the underlying GObject as a GtkViewport. 11633func (v *Viewport) native() *C.GtkViewport { 11634 if v == nil || v.GObject == nil { 11635 return nil 11636 } 11637 p := unsafe.Pointer(v.GObject) 11638 return C.toGtkViewport(p) 11639} 11640 11641func wrapViewport(obj *glib.Object) *Viewport { 11642 if obj == nil { 11643 return nil 11644 } 11645 11646 b := wrapBin(obj) 11647 s := wrapScrollable(obj) 11648 return &Viewport{ 11649 Bin: *b, 11650 Scrollable: *s, 11651 } 11652} 11653 11654func (v *Viewport) toViewport() *C.GtkViewport { 11655 if v == nil { 11656 return nil 11657 } 11658 return v.native() 11659} 11660 11661// ViewportNew() is a wrapper around gtk_viewport_new(). 11662func ViewportNew(hadjustment, vadjustment *Adjustment) (*Viewport, error) { 11663 c := C.gtk_viewport_new(hadjustment.native(), vadjustment.native()) 11664 if c == nil { 11665 return nil, nilPtrErr 11666 } 11667 return wrapViewport(glib.Take(unsafe.Pointer(c))), nil 11668} 11669 11670// SetShadowType is a wrapper around gtk_viewport_set_shadow_type(). 11671func (v *Viewport) SetShadowType(shadowType ShadowType) { 11672 C.gtk_viewport_set_shadow_type(v.native(), C.GtkShadowType(shadowType)) 11673} 11674 11675// GetShadowType is a wrapper around gtk_viewport_get_shadow_type(). 11676func (v *Viewport) GetShadowType() ShadowType { 11677 c := C.gtk_viewport_get_shadow_type(v.native()) 11678 return ShadowType(c) 11679} 11680 11681// GetBinWindow is a wrapper around gtk_viewport_get_bin_window(). 11682func (v *Viewport) GetBinWindow() *gdk.Window { 11683 c := C.gtk_viewport_get_bin_window(v.native()) 11684 if c == nil { 11685 return nil 11686 } 11687 return &gdk.Window{glib.Take(unsafe.Pointer(c))} 11688} 11689 11690// GetViewWindow is a wrapper around gtk_viewport_get_view_window(). 11691func (v *Viewport) GetViewWindow() *gdk.Window { 11692 c := C.gtk_viewport_get_view_window(v.native()) 11693 if c == nil { 11694 return nil 11695 } 11696 return &gdk.Window{glib.Take(unsafe.Pointer(c))} 11697} 11698 11699/* 11700 * GtkVolumeButton 11701 */ 11702 11703// VolumeButton is a representation of GTK's GtkVolumeButton. 11704type VolumeButton struct { 11705 ScaleButton 11706} 11707 11708// native() returns a pointer to the underlying GtkVolumeButton. 11709func (v *VolumeButton) native() *C.GtkVolumeButton { 11710 if v == nil || v.GObject == nil { 11711 return nil 11712 } 11713 p := unsafe.Pointer(v.GObject) 11714 return C.toGtkVolumeButton(p) 11715} 11716 11717func marshalVolumeButton(p uintptr) (interface{}, error) { 11718 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 11719 obj := glib.Take(unsafe.Pointer(c)) 11720 return wrapVolumeButton(obj), nil 11721} 11722 11723func wrapVolumeButton(obj *glib.Object) *VolumeButton { 11724 if obj == nil { 11725 return nil 11726 } 11727 11728 actionable := wrapActionable(obj) 11729 return &VolumeButton{ScaleButton{Button{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}, actionable}}} 11730} 11731 11732// VolumeButtonNew is a wrapper around gtk_volume_button_new(). 11733func VolumeButtonNew() (*VolumeButton, error) { 11734 c := C.gtk_volume_button_new() 11735 if c == nil { 11736 return nil, nilPtrErr 11737 } 11738 return wrapVolumeButton(glib.Take(unsafe.Pointer(c))), nil 11739} 11740 11741type WrapFn interface{} 11742 11743var WrapMap = map[string]WrapFn{ 11744 "GtkAccelGroup": wrapAccelGroup, 11745 "GtkAccelMao": wrapAccelMap, 11746 "GtkAdjustment": wrapAdjustment, 11747 "GtkApplicationWindow": wrapApplicationWindow, 11748 "GtkAssistant": wrapAssistant, 11749 "GtkBin": wrapBin, 11750 "GtkBox": wrapBox, 11751 "GtkButton": wrapButton, 11752 "GtkButtonBox": wrapButtonBox, 11753 "GtkCalendar": wrapCalendar, 11754 "GtkCellLayout": wrapCellLayout, 11755 "GtkCellEditable": wrapCellEditable, 11756 "GtkCellRenderer": wrapCellRenderer, 11757 "GtkCellRendererSpinner": wrapCellRendererSpinner, 11758 "GtkCellRendererPixbuf": wrapCellRendererPixbuf, 11759 "GtkCellRendererText": wrapCellRendererText, 11760 "GtkCellRendererProgress": wrapCellRendererProgress, 11761 "GtkCellRendererToggle": wrapCellRendererToggle, 11762 "GtkCellRendererCombo": wrapCellRendererCombo, 11763 "GtkCellRendererAccel": wrapCellRendererAccel, 11764 "GtkCellRendererSpin": wrapCellRendererSpin, 11765 "GtkCheckButton": wrapCheckButton, 11766 "GtkCheckMenuItem": wrapCheckMenuItem, 11767 "GtkClipboard": wrapClipboard, 11768 "GtkColorButton": wrapColorButton, 11769 "GtkContainer": wrapContainer, 11770 "GtkDialog": wrapDialog, 11771 "GtkDrawingArea": wrapDrawingArea, 11772 "GtkEditable": wrapEditable, 11773 "GtkEntry": wrapEntry, 11774 "GtkEntryBuffer": wrapEntryBuffer, 11775 "GtkEntryCompletion": wrapEntryCompletion, 11776 "GtkEventBox": wrapEventBox, 11777 "GtkExpander": wrapExpander, 11778 "GtkFrame": wrapFrame, 11779 "GtkFileChooser": wrapFileChooser, 11780 "GtkFileChooserButton": wrapFileChooserButton, 11781 "GtkFileChooserDialog": wrapFileChooserDialog, 11782 "GtkFileChooserWidget": wrapFileChooserWidget, 11783 "GtkGrid": wrapGrid, 11784 "GtkIconView": wrapIconView, 11785 "GtkImage": wrapImage, 11786 "GtkLabel": wrapLabel, 11787 "GtkLayout": wrapLayout, 11788 "GtkLinkButton": wrapLinkButton, 11789 "GtkListStore": wrapListStore, 11790 "GtkMenu": wrapMenu, 11791 "GtkMenuBar": wrapMenuBar, 11792 "GtkMenuButton": wrapMenuButton, 11793 "GtkMenuItem": wrapMenuItem, 11794 "GtkMenuShell": wrapMenuShell, 11795 "GtkMessageDialog": wrapMessageDialog, 11796 "GtkNotebook": wrapNotebook, 11797 "GtkOffscreenWindow": wrapOffscreenWindow, 11798 "GtkOrientable": wrapOrientable, 11799 "GtkOverlay": wrapOverlay, 11800 "GtkPaned": wrapPaned, 11801 "GtkProgressBar": wrapProgressBar, 11802 "GtkRadioButton": wrapRadioButton, 11803 "GtkRadioMenuItem": wrapRadioMenuItem, 11804 "GtkRange": wrapRange, 11805 "GtkRecentChooser": wrapRecentChooser, 11806 "GtkRecentChooserMenu": wrapRecentChooserMenu, 11807 "GtkRecentFilter": wrapRecentFilter, 11808 "GtkRecentManager": wrapRecentManager, 11809 "GtkScaleButton": wrapScaleButton, 11810 "GtkScale": wrapScale, 11811 "GtkScrollable": wrapScrollable, 11812 "GtkScrollbar": wrapScrollbar, 11813 "GtkScrolledWindow": wrapScrolledWindow, 11814 "GtkSearchEntry": wrapSearchEntry, 11815 "GtkSeparator": wrapSeparator, 11816 "GtkSeparatorMenuItem": wrapSeparatorMenuItem, 11817 "GtkSeparatorToolItem": wrapSeparatorToolItem, 11818 "GtkSpinButton": wrapSpinButton, 11819 "GtkSpinner": wrapSpinner, 11820 "GtkStatusbar": wrapStatusbar, 11821 "GtkSwitch": wrapSwitch, 11822 "GtkTextBuffer": wrapTextBuffer, 11823 "GtkTextChildAnchor": wrapTextChildAnchor, 11824 "GtkTextTag": wrapTextTag, 11825 "GtkTextTagTable": wrapTextTagTable, 11826 "GtkTextView": wrapTextView, 11827 "GtkToggleButton": wrapToggleButton, 11828 "GtkToolbar": wrapToolbar, 11829 "GtkToolButton": wrapToolButton, 11830 "GtkToggleToolButton": wrapToggleToolButton, 11831 "GtkToolItem": wrapToolItem, 11832 "GtkTreeModel": wrapTreeModel, 11833 "GtkTreeModelFilter": wrapTreeModelFilter, 11834 "GtkTreeModelSort": wrapTreeModelSort, 11835 "GtkTreeSelection": wrapTreeSelection, 11836 "GtkTreeStore": wrapTreeStore, 11837 "GtkTreeView": wrapTreeView, 11838 "GtkTreeViewColumn": wrapTreeViewColumn, 11839 "GtkViewport": wrapViewport, 11840 "GtkVolumeButton": wrapVolumeButton, 11841 "GtkWidget": wrapWidget, 11842 "GtkWindow": wrapWindow, 11843} 11844 11845// castInternal casts the given object to the appropriate Go struct, but returns it as interface for later type assertions. 11846// The className is the results of C.object_get_class_name(c) called on the native object. 11847// The obj is the result of glib.Take(unsafe.Pointer(c)), used as a parameter for the wrapper functions. 11848func castInternal(className string, obj *glib.Object) (interface{}, error) { 11849 fn, ok := WrapMap[className] 11850 if !ok { 11851 fn, ok = glib.WrapMap[className] 11852 if !ok { 11853 return nil, errors.New("unrecognized class name '" + className + "'") 11854 } 11855 } 11856 11857 // Check that the wrapper function is actually a function 11858 rf := reflect.ValueOf(fn) 11859 if rf.Type().Kind() != reflect.Func { 11860 return nil, errors.New("wraper is not a function") 11861 } 11862 11863 // Call the wraper function with the *glib.Object as first parameter 11864 // e.g. "wrapWindow(obj)" 11865 v := reflect.ValueOf(obj) 11866 rv := rf.Call([]reflect.Value{v}) 11867 11868 // At most/max 1 return value 11869 if len(rv) != 1 { 11870 return nil, errors.New("wrapper did not return") 11871 } 11872 11873 // Needs to be a pointer of some sort 11874 if k := rv[0].Kind(); k != reflect.Ptr { 11875 return nil, fmt.Errorf("wrong return type %s", k) 11876 } 11877 11878 // Only get an interface value, type check will be done in more specific functions 11879 return rv[0].Interface(), nil 11880} 11881 11882// cast takes a native GObject and casts it to the appropriate Go struct. 11883//TODO change all wrapFns to return an IObject 11884//^- not sure about this TODO. This may make some usages of the wrapper functions quite verbose, no? 11885func cast(c *C.GObject) (glib.IObject, error) { 11886 ptr := unsafe.Pointer(c) 11887 var ( 11888 className = goString(C.object_get_class_name(C.toGObject(ptr))) 11889 obj = glib.Take(ptr) 11890 ) 11891 11892 intf, err := castInternal(className, obj) 11893 if err != nil { 11894 return nil, err 11895 } 11896 11897 ret, ok := intf.(glib.IObject) 11898 if !ok { 11899 return nil, errors.New("did not return an IObject") 11900 } 11901 11902 return ret, nil 11903} 11904 11905// castWidget takes a native GtkWidget and casts it to the appropriate Go struct. 11906func castWidget(c *C.GtkWidget) (IWidget, error) { 11907 ptr := unsafe.Pointer(c) 11908 var ( 11909 className = goString(C.object_get_class_name(C.toGObject(ptr))) 11910 obj = glib.Take(ptr) 11911 ) 11912 11913 intf, err := castInternal(className, obj) 11914 if err != nil { 11915 return nil, err 11916 } 11917 11918 ret, ok := intf.(IWidget) 11919 if !ok { 11920 return nil, fmt.Errorf("expected value of type IWidget, got %T", intf) 11921 } 11922 11923 return ret, nil 11924} 11925 11926// castCellRenderer takes a native GtkCellRenderer and casts it to the appropriate Go struct. 11927func castCellRenderer(c *C.GtkCellRenderer) (ICellRenderer, error) { 11928 ptr := unsafe.Pointer(c) 11929 var ( 11930 className = goString(C.object_get_class_name(C.toGObject(ptr))) 11931 obj = glib.Take(ptr) 11932 ) 11933 11934 intf, err := castInternal(className, obj) 11935 if err != nil { 11936 return nil, err 11937 } 11938 11939 ret, ok := intf.(ICellRenderer) 11940 if !ok { 11941 return nil, fmt.Errorf("expected value of type ICellRenderer, got %T", intf) 11942 } 11943 11944 return ret, nil 11945} 11946 11947// castTreeModel takes a native GtkCellTreeModel and casts it to the appropriate Go struct. 11948func castTreeModel(c *C.GtkTreeModel) (ITreeModel, error) { 11949 ptr := unsafe.Pointer(c) 11950 var ( 11951 className = goString(C.object_get_class_name(C.toGObject(ptr))) 11952 obj = glib.Take(ptr) 11953 ) 11954 11955 intf, err := castInternal(className, obj) 11956 if err != nil { 11957 return nil, err 11958 } 11959 11960 ret, ok := intf.(ITreeModel) 11961 if !ok { 11962 return nil, fmt.Errorf("expected value of type ITreeModel, got %T", intf) 11963 } 11964 11965 return ret, nil 11966} 11967 11968// castCellEditable takes a native GtkCellEditable and casts it to the appropriate Go struct. 11969func castCellEditable(c *C.GtkCellEditable) (ICellEditable, error) { 11970 ptr := unsafe.Pointer(c) 11971 var ( 11972 className = goString(C.object_get_class_name(C.toGObject(ptr))) 11973 obj = glib.Take(ptr) 11974 ) 11975 11976 intf, err := castInternal(className, obj) 11977 if err != nil { 11978 return nil, err 11979 } 11980 11981 ret, ok := intf.(ICellEditable) 11982 if !ok { 11983 return nil, fmt.Errorf("expected value of type ICellEditable, got %T", intf) 11984 } 11985 11986 return ret, nil 11987} 11988