pax_global_header00006660000000000000000000000064143115747300014517gustar00rootroot0000000000000052 comment=655547b6cbbc2da7d962d2c234c28fb1fbc95b60 gotk3-0.6.2/000077500000000000000000000000001431157473000125535ustar00rootroot00000000000000gotk3-0.6.2/.github/000077500000000000000000000000001431157473000141135ustar00rootroot00000000000000gotk3-0.6.2/.github/ISSUE_TEMPLATE/000077500000000000000000000000001431157473000162765ustar00rootroot00000000000000gotk3-0.6.2/.github/ISSUE_TEMPLATE/bug_report.md000066400000000000000000000010761431157473000207740ustar00rootroot00000000000000--- name: Bug report about: Create a report to help us improve title: "[BUG] title" labels: bug assignees: '' --- **Describe the bug** A clear and concise description of what the bug is. **To Reproduce** Steps to reproduce the behavior: **Expected behavior** A clear and concise description of what you expected to happen. **Error messages** If applicable, add copy the log message to help explain your problem. **Environment:** gtk3 version: '...' go version: '...' os: '...' other stuff: '...' **Additional context** Add any other context about the problem here. gotk3-0.6.2/.github/ISSUE_TEMPLATE/feature_request.md000066400000000000000000000011741431157473000220260ustar00rootroot00000000000000--- name: Feature request about: Suggest an idea for this project title: "[Feature] title" labels: enhancement, missing binding assignees: '' --- **Is your feature request related to a problem? Please describe.** A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] **Describe the solution you'd like** A clear and concise description of what you want to happen. **Describe alternatives you've considered** A clear and concise description of any alternative solutions or features you've considered. **Additional context** Add any other context or screenshots about the feature request here. gotk3-0.6.2/.github/ISSUE_TEMPLATE/project-question.md000066400000000000000000000002601431157473000221310ustar00rootroot00000000000000--- name: Project question about: Do you have a question then ask this one here title: "[Project question] title" labels: question assignees: '' --- Help us make this better gotk3-0.6.2/.github/workflows/000077500000000000000000000000001431157473000161505ustar00rootroot00000000000000gotk3-0.6.2/.github/workflows/linux.yml000066400000000000000000000014101431157473000200260ustar00rootroot00000000000000name: Build and test on Linux on: push: branches: [ master ] pull_request: branches: [ master ] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Go uses: actions/setup-go@v2 with: go-version: 1.18 - name: Install Dependencies run: | sudo apt update sudo apt install libgtk-3-dev libcairo2-dev libglib2.0-dev - name: Print versions run: | echo glib: $(pkg-config --modversion glib-2.0) echo gdk: $(pkg-config --modversion gdk-3.0) echo gtk: $(pkg-config --modversion gtk+-3.0) - name: Build run: go build --tags=glib_deprecated -v ./... # - name: Test # run: go test -v --tags=glib_deprecated -v ./... gotk3-0.6.2/.github/workflows/macos.yml000066400000000000000000000007121431157473000177750ustar00rootroot00000000000000name: Build and test on MacOS on: push: branches: [ master ] pull_request: branches: [ master ] jobs: build: runs-on: macos-latest steps: - uses: actions/checkout@v2 - name: Set up Go uses: actions/setup-go@v2 with: go-version: 1.18 - name: Install gtk run: brew install gobject-introspection gtk+3 - name: Build run: go build -v ./... - name: Test run: go test -v ./... gotk3-0.6.2/.github/workflows/windows.yml000066400000000000000000000017061431157473000203710ustar00rootroot00000000000000name: Build and test on Windows on: push: branches: [ master ] pull_request: branches: [ master ] jobs: build: runs-on: windows-latest defaults: run: shell: msys2 {0} steps: - uses: actions/checkout@v2 - name: Set up Go uses: actions/setup-go@v2 with: go-version: 1.18 - uses: msys2/setup-msys2@v2 with: msystem: MINGW64 update: true install: git make mingw-w64-x86_64-gtk3 mingw-w64-x86_64-glib2 mingw-w64-x86_64-go mingw-w64-x86_64-gcc mingw-w64-x86_64-pkg-config glib2-devel - name: Build the binary run: | # This fixes a bug in pkgconfig: invalid flag in pkg-config --libs: -Wl,-luuid sed -i -e 's/-Wl,-luuid/-luuid/g' /mingw64/lib/pkgconfig/gdk-3.0.pc - name: Build run: go build -v ./... - name: Test run: go test -v ./... gotk3-0.6.2/.gitignore000066400000000000000000000000171431157473000145410ustar00rootroot00000000000000.vscode .idea gotk3-0.6.2/.travis.yml000066400000000000000000000034341431157473000146700ustar00rootroot00000000000000language: go go_import_path: github.com/gotk3/gotk3 env: - GOARCH=amd64 jobs: include: # Testing on xenial, gtk 3.18.9 (gdk has same version), glib 2.48.0 (gio has same version), gdk-pixbuf 2.32.2 - os: linux dist: xenial go: "1.13" # Testing on bionic, gtk 3.22.30 (gdk has same version), glib 2.56.1 (gio has same version), gdk-pixbuf 2.36.11 - os: linux dist: bionic go: "1.14" # Testing on focal, gtk 3.24.14 (gdk has same version), glib 2.64.1 (gio has same version), gdk-pixbuf 2.40.0 # Majority of the go versions here for compatibility checking - os: linux dist: focal go: "1.12" - os: linux dist: focal go: "1.13" - os: linux dist: focal go: "1.14" - os: linux dist: focal go: "1.15" - os: linux dist: focal go: tip addons: apt: packages: - gtk+3.0 - libgtk-3-dev - xvfb before_install: - "export DISPLAY=:99.0" - sudo /usr/bin/Xvfb $DISPLAY &> /dev/null & - "export GTK_VERSION=$(pkg-config --modversion gtk+-3.0 | tr . _| cut -d '_' -f 1-2)" - "export Glib_VERSION=$(pkg-config --modversion glib-2.0 | tr . _| cut -d '_' -f 1-2)" - "export GDK_Pixbuf_VERSION=$(pkg-config --modversion gdk-pixbuf-2.0 | tr . _| cut -d '_' -f 1-2)" - "export Cairo_VERSION=$(pkg-config --modversion cairo)" - "export Pango_VERSION=$(pkg-config --modversion pango)" - echo "GTK/GDK version ${GTK_VERSION} Glib/Gio version ${Glib_VERSION} Gdk-Pixbuf version ${GDK_Pixbuf_VERSION} (Cairo ${Cairo_VERSION}, Pango ${Pango_VERSION})" install: - go get -t -tags "gtk_${GTK_VERSION} glib_${Glib_VERSION} gdk_pixbuf_${GDK_Pixbuf_VERSION}" ./... script: - go test -tags "gtk_${GTK_VERSION} glib_${Glib_VERSION} gdk_pixbuf_${GDK_Pixbuf_VERSION}" ./... gotk3-0.6.2/CHANGES.md000066400000000000000000000033301431157473000141440ustar00rootroot00000000000000--- ### User visible changes for gotk3 Go bindings for GTK3 --- Changes for Version after 0.6.1: * **2021-08**: Glib version 2.68 deprecated glib.Binding. **GetSource** and **GetTarget** in favor of **DupSource** and **DupTarget**. Those using glib.Binding should check the [glib changes](https://gitlab.gnome.org/GNOME/glib/-/tags/2.67.1). For those who use **_Glib versions <= 2.66_**, you now need to use the build tag `-tags "glib_2_66"`, see [#828](https://github.com/gotk3/gotk3/pull/828) Changes for next Version 0.6.0 - Breaking changes in API - General code cleanup - #685 Refactor Gtk callback setters and types enhancement missing binding - #706 Refactor internal closure handling and several API changes breaking changes - #746 Add build tag pango_1_42 for Pango - #743 Solving #741- Add possibility to use GVariant in signal handler - #740 Add binding for GtkRadioMenuItem - #738 Adds binding for gtk_cell_layout_clear_attributes() - #737 Adds bindings for gdk_pixbuf_new_from_resource() and gdk_pixbuf_new_from_resource_at_scale() - #736 Add bindings/helper methods GdkRectangle GdkPoint - #735 Add GtkMenuItem bindings - #734 Add bindings GtkMenuShell - #732 add as contributor - #731 add bindings to GtkMenu - #730 Solve GtkAccelKey issue with golang 1.16 - #728 It is not safe to reference memory returned in a signal callback. - #687 Don't merge until publication of Golang v1.16: GtkAccelKey v1.16 issue fix next version - #724 Implemented CellRenderer.SetAlignment - #723 Added SetOrientation to gkt.SpinButton - #720 Add Prgname getter and setter - #716 Add (Get/Set) methods to GdkRGBA & GdkVisual & GdkDisplayManager bind… - #715 Add some GtkRange bindings - #712 glib.Take to return nil and gtk.marshal* to allow nil gotk3-0.6.2/CONTRIBUTIONS.md000066400000000000000000000012431431157473000151370ustar00rootroot00000000000000## CONTRIBUTIONS - [conformal](https://github.com/conformal/gotk3) - [jrick](https://github.com/jrick/gotk3) - [sqp](https://github.com/sqp/gotk3) - [dradtke](https://github.com/dradtke/gotk3) - [MovingtoMars](https://github.com/MovingtoMars/gotk3) - [shish](https://github.com/shish/gotk3) - [andre](https://github.com/andre-hub/gotk3) - [raichu](https://github.com/raichu/gotk3) - [juniorz](https://github.com/juniorz) - [thanhps42](https://github.com/thanhps42) - [cubiest](https://github.com/cubiest/gotk3) - [MJacred](https://github.com/MJacred) & [founderio](https://github.com/founderio) - [hfmrow (H.F.M)](https://github.com/hfmrow/) - you? gotk3-0.6.2/LICENSE000066400000000000000000000014611431157473000135620ustar00rootroot00000000000000ISC License Copyright (c) 2013-2014 Conformal Systems LLC. Copyright (c) 2015-2018 gotk3 contributors Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. gotk3-0.6.2/README.md000066400000000000000000000173221431157473000140370ustar00rootroot00000000000000gotk3 [![GoDoc](https://godoc.org/github.com/gotk3/gotk3?status.svg)](https://godoc.org/github.com/gotk3/gotk3) ===== [![Build Status](https://travis-ci.org/gotk3/gotk3.svg?branch=master)](https://travis-ci.org/gotk3/gotk3) The gotk3 project provides Go bindings for GTK 3 and dependent projects. Each component is given its own subdirectory, which is used as the import path for the package. Partial binding support for the following libraries is currently implemented: - GTK 3 (3.12 and later) - GDK 3 (3.12 and later) - GLib 2 (2.36 and later) - Cairo (1.10 and later) Care has been taken for memory management to work seamlessly with Go's garbage collector without the need to use or understand GObject's floating references. for better understanding see [package reference documation](https://pkg.go.dev/github.com/gotk3/gotk3/gtk?tab=doc) On Linux, see which version your distribution has [here](https://pkgs.org) with the search terms: * libgtk-3 * libglib2 * libgdk-pixbuf2 ## Sample Use The following example can be found in [Examples](https://github.com/gotk3/gotk3-examples/). ```Go package main import ( "github.com/gotk3/gotk3/gtk" "log" ) func main() { // Initialize GTK without parsing any command line arguments. gtk.Init(nil) // Create a new toplevel window, set its title, and connect it to the // "destroy" signal to exit the GTK main loop when it is destroyed. win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL) if err != nil { log.Fatal("Unable to create window:", err) } win.SetTitle("Simple Example") win.Connect("destroy", func() { gtk.MainQuit() }) // Create a new label widget to show in the window. l, err := gtk.LabelNew("Hello, gotk3!") if err != nil { log.Fatal("Unable to create label:", err) } // Add the label to the window. win.Add(l) // Set the default window size. win.SetDefaultSize(800, 600) // Recursively show all widgets contained in this window. win.ShowAll() // Begin executing the GTK main loop. This blocks until // gtk.MainQuit() is run. gtk.Main() } ``` To build the example: ```shell $ go build example.go ``` To build this example with older gtk version you should use gtk_3_10 tag: ```shell $ go build -tags gtk_3_10 example.go ``` ### Example usage ```Go package main import ( "log" "os" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/gtk" ) // Simple Gtk3 Application written in go. // This application creates a window on the application callback activate. // More GtkApplication info can be found here -> https://wiki.gnome.org/HowDoI/GtkApplication func main() { // Create Gtk Application, change appID to your application domain name reversed. const appID = "org.gtk.example" application, err := gtk.ApplicationNew(appID, glib.APPLICATION_FLAGS_NONE) // Check to make sure no errors when creating Gtk Application if err != nil { log.Fatal("Could not create application.", err) } // Application signals available // startup -> sets up the application when it first starts // activate -> shows the default first window of the application (like a new document). This corresponds to the application being launched by the desktop environment. // open -> opens files and shows them in a new window. This corresponds to someone trying to open a document (or documents) using the application from the file browser, or similar. // shutdown -> performs shutdown tasks // Setup Gtk Application callback signals application.Connect("activate", func() { onActivate(application) }) // Run Gtk application os.Exit(application.Run(os.Args)) } // Callback signal from Gtk Application func onActivate(application *gtk.Application) { // Create ApplicationWindow appWindow, err := gtk.ApplicationWindowNew(application) if err != nil { log.Fatal("Could not create application window.", err) } // Set ApplicationWindow Properties appWindow.SetTitle("Basic Application.") appWindow.SetDefaultSize(400, 400) appWindow.Show() } ``` ```Go package main import ( "log" "os" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/gtk" ) // Simple Gtk3 Application written in go. // This application creates a window on the application callback activate. // More GtkApplication info can be found here -> https://wiki.gnome.org/HowDoI/GtkApplication func main() { // Create Gtk Application, change appID to your application domain name reversed. const appID = "org.gtk.example" application, err := gtk.ApplicationNew(appID, glib.APPLICATION_FLAGS_NONE) // Check to make sure no errors when creating Gtk Application if err != nil { log.Fatal("Could not create application.", err) } // Application signals available // startup -> sets up the application when it first starts // activate -> shows the default first window of the application (like a new document). This corresponds to the application being launched by the desktop environment. // open -> opens files and shows them in a new window. This corresponds to someone trying to open a document (or documents) using the application from the file browser, or similar. // shutdown -> performs shutdown tasks // Setup activate signal with a closure function. application.Connect("activate", func() { // Create ApplicationWindow appWindow, err := gtk.ApplicationWindowNew(application) if err != nil { log.Fatal("Could not create application window.", err) } // Set ApplicationWindow Properties appWindow.SetTitle("Basic Application.") appWindow.SetDefaultSize(400, 400) appWindow.Show() }) // Run Gtk application application.Run(os.Args) } ``` ## Documentation Each package's internal `go doc` style documentation can be viewed online without installing this package by using the GoDoc site (links to [cairo](http://godoc.org/github.com/gotk3/gotk3/cairo), [glib](http://godoc.org/github.com/gotk3/gotk3/glib), [gdk](http://godoc.org/github.com/gotk3/gotk3/gdk), and [gtk](http://godoc.org/github.com/gotk3/gotk3/gtk) documentation). You can also view the documentation locally once the package is installed with the `godoc` tool by running `godoc -http=":6060"` and pointing your browser to http://localhost:6060/pkg/github.com/gotk3/gotk3 ## Installation gotk3 currently requires GTK 3.6-3.24, GLib 2.36-2.46, and Cairo 1.10 or 1.12. A recent Go (1.8 or newer) is also required. For detailed instructions see the wiki pages: [installation](https://github.com/gotk3/gotk3/wiki#installation) ## Using deprecated features By default, deprecated GTK features are not included in the build. By specifying the e.g. build tag `gtk_3_20`, any feature deprecated in GTK 3.20 or earlier will NOT be available. To enable deprecated features in the build, add the tag `gtk_deprecated`. Example: ```shell $ go build -tags "gtk_3_10 gtk_deprecated" example.go ``` The same goes for * gdk-pixbuf: gdk_pixbuf_deprecated ## TODO - Add bindings for all of GTK functions - Add tests for each implemented binding - See the next steps: [wiki page](https://github.com/gotk3/gotk3/wiki/The-future-and-what-happens-next) and add [your suggestion](https://github.com/gotk3/gotk3/issues/576) ## License Package gotk3 is licensed under the liberal ISC License. Actually if you use gotk3, then gotk3 is statically linked into your application (with the ISC licence). The system libraries (e.g. GTK+, GLib) used via cgo use dynamic linking. gotk3-0.6.2/cairo/000077500000000000000000000000001431157473000136505ustar00rootroot00000000000000gotk3-0.6.2/cairo/antialias.go000066400000000000000000000014361431157473000161500ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "unsafe" ) // Antialias is a representation of Cairo's cairo_antialias_t. type Antialias int const ( ANTIALIAS_DEFAULT Antialias = C.CAIRO_ANTIALIAS_DEFAULT ANTIALIAS_NONE Antialias = C.CAIRO_ANTIALIAS_NONE ANTIALIAS_GRAY Antialias = C.CAIRO_ANTIALIAS_GRAY ANTIALIAS_SUBPIXEL Antialias = C.CAIRO_ANTIALIAS_SUBPIXEL ANTIALIAS_FAST Antialias = C.CAIRO_ANTIALIAS_FAST // (since 1.12) ANTIALIAS_GOOD Antialias = C.CAIRO_ANTIALIAS_GOOD // (since 1.12) ANTIALIAS_BEST Antialias = C.CAIRO_ANTIALIAS_BEST // (since 1.12) ) func marshalAntialias(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Antialias(c), nil } gotk3-0.6.2/cairo/cairo.go000066400000000000000000000044661431157473000153060ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // Package cairo implements Go bindings for Cairo. Supports version 1.10 and // later. package cairo // #cgo pkg-config: cairo cairo-gobject gobject-2.0 // #include // #include // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.cairo_gobject_antialias_get_type()), marshalAntialias}, {glib.Type(C.cairo_gobject_content_get_type()), marshalContent}, {glib.Type(C.cairo_gobject_fill_rule_get_type()), marshalFillRule}, {glib.Type(C.cairo_gobject_line_cap_get_type()), marshalLineCap}, {glib.Type(C.cairo_gobject_line_join_get_type()), marshalLineJoin}, {glib.Type(C.cairo_gobject_operator_get_type()), marshalOperator}, {glib.Type(C.cairo_gobject_status_get_type()), marshalStatus}, {glib.Type(C.cairo_gobject_surface_type_get_type()), marshalSurfaceType}, // Boxed {glib.Type(C.cairo_gobject_context_get_type()), marshalContext}, {glib.Type(C.cairo_gobject_surface_get_type()), marshalSurface}, } glib.RegisterGValueMarshalers(tm) } // Constants // Content is a representation of Cairo's cairo_content_t. type Content int const ( CONTENT_COLOR Content = C.CAIRO_CONTENT_COLOR CONTENT_ALPHA Content = C.CAIRO_CONTENT_ALPHA CONTENT_COLOR_ALPHA Content = C.CAIRO_CONTENT_COLOR_ALPHA ) func marshalContent(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Content(c), nil } gotk3-0.6.2/cairo/canvas.go000066400000000000000000000300521431157473000154520ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "reflect" "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) // Context is a representation of Cairo's cairo_t. type Context struct { context *C.cairo_t } // native returns a pointer to the underlying cairo_t. func (v *Context) native() *C.cairo_t { if v == nil { return nil } return v.context } func (v *Context) GetCContext() *C.cairo_t { return v.native() } // Native returns a pointer to the underlying cairo_t. func (v *Context) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalContext(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) context := (*C.cairo_t)(unsafe.Pointer(c)) return wrapContext(context), nil } func wrapContext(context *C.cairo_t) *Context { return &Context{context} } func WrapContext(p uintptr) *Context { context := (*C.cairo_t)(unsafe.Pointer(p)) return wrapContext(context) } // Closes the context. The context must not be used afterwards. func (v *Context) Close() { v.destroy() } // Create is a wrapper around cairo_create(). func Create(target *Surface) *Context { c := C.cairo_create(target.native()) ctx := wrapContext(c) runtime.SetFinalizer(ctx, func(v *Context) { glib.FinalizerStrategy(v.destroy) }) return ctx } // reference is a wrapper around cairo_reference(). func (v *Context) reference() { v.context = C.cairo_reference(v.native()) } // destroy is a wrapper around cairo_destroy(). func (v *Context) destroy() { if v.context != nil { C.cairo_destroy(v.native()) v.context = nil } } // Status is a wrapper around cairo_status(). func (v *Context) Status() Status { c := C.cairo_status(v.native()) return Status(c) } // Save is a wrapper around cairo_save(). func (v *Context) Save() { C.cairo_save(v.native()) } // Restore is a wrapper around cairo_restore(). func (v *Context) Restore() { C.cairo_restore(v.native()) } // GetTarget is a wrapper around cairo_get_target(). func (v *Context) GetTarget() *Surface { c := C.cairo_get_target(v.native()) s := wrapSurface(c) s.reference() runtime.SetFinalizer(s, func(v *Surface) { glib.FinalizerStrategy(v.destroy) }) return s } // PushGroup is a wrapper around cairo_push_group(). func (v *Context) PushGroup() { C.cairo_push_group(v.native()) } // PushGroupWithContent is a wrapper around cairo_push_group_with_content(). func (v *Context) PushGroupWithContent(content Content) { C.cairo_push_group_with_content(v.native(), C.cairo_content_t(content)) } // TODO(jrick) PopGroup (depends on Pattern) // cairo_pop_group // PopGroupToSource is a wrapper around cairo_pop_group_to_source(). func (v *Context) PopGroupToSource() { C.cairo_pop_group_to_source(v.native()) } // GetGroupTarget is a wrapper around cairo_get_group_target(). func (v *Context) GetGroupTarget() *Surface { c := C.cairo_get_group_target(v.native()) s := wrapSurface(c) s.reference() runtime.SetFinalizer(s, func(v *Surface) { glib.FinalizerStrategy(v.destroy) }) return s } // SetSource is a wrapper around cairo_set_source(). func (v *Context) SetSource(p *Pattern) { C.cairo_set_source(v.native(), p.native()) } // SetSourceRGB is a wrapper around cairo_set_source_rgb(). func (v *Context) SetSourceRGB(red, green, blue float64) { C.cairo_set_source_rgb(v.native(), C.double(red), C.double(green), C.double(blue)) } // SetSourceRGBA is a wrapper around cairo_set_source_rgba(). func (v *Context) SetSourceRGBA(red, green, blue, alpha float64) { C.cairo_set_source_rgba(v.native(), C.double(red), C.double(green), C.double(blue), C.double(alpha)) } // TODO(jrick) SetSource (depends on Pattern) // cairo_set_source // SetSourceSurface is a wrapper around cairo_set_source_surface(). func (v *Context) SetSourceSurface(surface *Surface, x, y float64) { C.cairo_set_source_surface(v.native(), surface.native(), C.double(x), C.double(y)) } // TODO(jrick) GetSource (depends on Pattern) // cairo_get_source // SetAntialias is a wrapper around cairo_set_antialias(). func (v *Context) SetAntialias(antialias Antialias) { C.cairo_set_antialias(v.native(), C.cairo_antialias_t(antialias)) } // GetAntialias is a wrapper around cairo_get_antialias(). func (v *Context) GetAntialias() Antialias { c := C.cairo_get_antialias(v.native()) return Antialias(c) } // SetDash is a wrapper around cairo_set_dash(). func (v *Context) SetDash(dashes []float64, offset float64) { header := (*reflect.SliceHeader)(unsafe.Pointer(&dashes)) cdashes := (*C.double)(unsafe.Pointer(header.Data)) C.cairo_set_dash(v.native(), cdashes, C.int(header.Len), C.double(offset)) } // GetDashCount is a wrapper around cairo_get_dash_count(). func (v *Context) GetDashCount() int { c := C.cairo_get_dash_count(v.native()) return int(c) } // GetDash is a wrapper around cairo_get_dash(). func (v *Context) GetDash() (dashes []float64, offset float64) { dashCount := v.GetDashCount() cdashes := (*C.double)(C.calloc(8, C.size_t(dashCount))) var coffset C.double C.cairo_get_dash(v.native(), cdashes, &coffset) header := (*reflect.SliceHeader)((unsafe.Pointer(&dashes))) header.Data = uintptr(unsafe.Pointer(cdashes)) header.Len = dashCount header.Cap = dashCount return dashes, float64(coffset) } // SetFillRule is a wrapper around cairo_set_fill_rule(). func (v *Context) SetFillRule(fillRule FillRule) { C.cairo_set_fill_rule(v.native(), C.cairo_fill_rule_t(fillRule)) } // GetFillRule is a wrapper around cairo_get_fill_rule(). func (v *Context) GetFillRule() FillRule { c := C.cairo_get_fill_rule(v.native()) return FillRule(c) } // SetLineCap is a wrapper around cairo_set_line_cap(). func (v *Context) SetLineCap(lineCap LineCap) { C.cairo_set_line_cap(v.native(), C.cairo_line_cap_t(lineCap)) } // GetLineCap is a wrapper around cairo_get_line_cap(). func (v *Context) GetLineCap() LineCap { c := C.cairo_get_line_cap(v.native()) return LineCap(c) } // SetLineJoin is a wrapper around cairo_set_line_join(). func (v *Context) SetLineJoin(lineJoin LineJoin) { C.cairo_set_line_join(v.native(), C.cairo_line_join_t(lineJoin)) } // GetLineJoin is a wrapper around cairo_get_line_join(). func (v *Context) GetLineJoin() LineJoin { c := C.cairo_get_line_join(v.native()) return LineJoin(c) } // SetLineWidth is a wrapper around cairo_set_line_width(). func (v *Context) SetLineWidth(width float64) { C.cairo_set_line_width(v.native(), C.double(width)) } // GetLineWidth is a wrapper cairo_get_line_width(). func (v *Context) GetLineWidth() float64 { c := C.cairo_get_line_width(v.native()) return float64(c) } // SetMiterLimit is a wrapper around cairo_set_miter_limit(). func (v *Context) SetMiterLimit(limit float64) { C.cairo_set_miter_limit(v.native(), C.double(limit)) } // GetMiterLimit is a wrapper around cairo_get_miter_limit(). func (v *Context) GetMiterLimit() float64 { c := C.cairo_get_miter_limit(v.native()) return float64(c) } // SetOperator is a wrapper around cairo_set_operator(). func (v *Context) SetOperator(op Operator) { C.cairo_set_operator(v.native(), C.cairo_operator_t(op)) } // GetOperator is a wrapper around cairo_get_operator(). func (v *Context) GetOperator() Operator { c := C.cairo_get_operator(v.native()) return Operator(c) } // SetTolerance is a wrapper around cairo_set_tolerance(). func (v *Context) SetTolerance(tolerance float64) { C.cairo_set_tolerance(v.native(), C.double(tolerance)) } // GetTolerance is a wrapper around cairo_get_tolerance(). func (v *Context) GetTolerance() float64 { c := C.cairo_get_tolerance(v.native()) return float64(c) } // Clip is a wrapper around cairo_clip(). func (v *Context) Clip() { C.cairo_clip(v.native()) } // ClipPreserve is a wrapper around cairo_clip_preserve(). func (v *Context) ClipPreserve() { C.cairo_clip_preserve(v.native()) } // ClipExtents is a wrapper around cairo_clip_extents(). func (v *Context) ClipExtents() (x1, y1, x2, y2 float64) { var cx1, cy1, cx2, cy2 C.double C.cairo_clip_extents(v.native(), &cx1, &cy1, &cx2, &cy2) return float64(cx1), float64(cy1), float64(cx2), float64(cy2) } // InClip is a wrapper around cairo_in_clip(). func (v *Context) InClip(x, y float64) bool { c := C.cairo_in_clip(v.native(), C.double(x), C.double(y)) return gobool(c) } // ResetClip is a wrapper around cairo_reset_clip(). func (v *Context) ResetClip() { C.cairo_reset_clip(v.native()) } // Rectangle is a wrapper around cairo_rectangle(). func (v *Context) Rectangle(x, y, w, h float64) { C.cairo_rectangle(v.native(), C.double(x), C.double(y), C.double(w), C.double(h)) } // Arc is a wrapper around cairo_arc(). func (v *Context) Arc(xc, yc, radius, angle1, angle2 float64) { C.cairo_arc(v.native(), C.double(xc), C.double(yc), C.double(radius), C.double(angle1), C.double(angle2)) } // ArcNegative is a wrapper around cairo_arc_negative(). func (v *Context) ArcNegative(xc, yc, radius, angle1, angle2 float64) { C.cairo_arc_negative(v.native(), C.double(xc), C.double(yc), C.double(radius), C.double(angle1), C.double(angle2)) } // LineTo is a wrapper around cairo_line_to(). func (v *Context) LineTo(x, y float64) { C.cairo_line_to(v.native(), C.double(x), C.double(y)) } // CurveTo is a wrapper around cairo_curve_to(). func (v *Context) CurveTo(x1, y1, x2, y2, x3, y3 float64) { C.cairo_curve_to(v.native(), C.double(x1), C.double(y1), C.double(x2), C.double(y2), C.double(x3), C.double(y3)) } // MoveTo is a wrapper around cairo_move_to(). func (v *Context) MoveTo(x, y float64) { C.cairo_move_to(v.native(), C.double(x), C.double(y)) } // TODO(jrick) CopyClipRectangleList (depends on RectangleList) // cairo_copy_clip_rectangle_list // Fill is a wrapper around cairo_fill(). func (v *Context) Fill() { C.cairo_fill(v.native()) } // ClosePath is a wrapper around cairo_close_path(). func (v *Context) ClosePath() { C.cairo_close_path(v.native()) } // NewPath is a wrapper around cairo_new_path(). func (v *Context) NewPath() { C.cairo_new_path(v.native()) } // GetCurrentPoint is a wrapper around cairo_get_current_point(). func (v *Context) GetCurrentPoint() (x, y float64) { C.cairo_get_current_point(v.native(), (*C.double)(&x), (*C.double)(&y)) return } // FillPreserve is a wrapper around cairo_fill_preserve(). func (v *Context) FillPreserve() { C.cairo_fill_preserve(v.native()) } // FillExtents is a wrapper around cairo_fill_extents(). func (v *Context) FillExtents() (x1, y1, x2, y2 float64) { var cx1, cy1, cx2, cy2 C.double C.cairo_fill_extents(v.native(), &cx1, &cy1, &cx2, &cy2) return float64(cx1), float64(cy1), float64(cx2), float64(cy2) } // InFill is a wrapper around cairo_in_fill(). func (v *Context) InFill(x, y float64) bool { c := C.cairo_in_fill(v.native(), C.double(x), C.double(y)) return gobool(c) } // TODO(jrick) Mask (depends on Pattern) // cairo_mask_surface // MaskSurface is a wrapper around cairo_mask_surface(). func (v *Context) MaskSurface(surface *Surface, surfaceX, surfaceY float64) { C.cairo_mask_surface(v.native(), surface.native(), C.double(surfaceX), C.double(surfaceY)) } // Paint is a wrapper around cairo_paint(). func (v *Context) Paint() { C.cairo_paint(v.native()) } // PaintWithAlpha is a wrapper around cairo_paint_with_alpha(). func (v *Context) PaintWithAlpha(alpha float64) { C.cairo_paint_with_alpha(v.native(), C.double(alpha)) } // Stroke is a wrapper around cairo_stroke(). func (v *Context) Stroke() { C.cairo_stroke(v.native()) } // StrokePreserve is a wrapper around cairo_stroke_preserve(). func (v *Context) StrokePreserve() { C.cairo_stroke_preserve(v.native()) } // StrokeExtents is a wrapper around cairo_stroke_extents(). func (v *Context) StrokeExtents() (x1, y1, x2, y2 float64) { var cx1, cy1, cx2, cy2 C.double C.cairo_stroke_extents(v.native(), &cx1, &cy1, &cx2, &cy2) return float64(cx1), float64(cy1), float64(cx2), float64(cy2) } // InStroke is a wrapper around cairo_in_stroke(). func (v *Context) InStroke(x, y float64) bool { c := C.cairo_in_stroke(v.native(), C.double(x), C.double(y)) return gobool(c) } // CopyPage is a wrapper around cairo_copy_page(). func (v *Context) CopyPage() { C.cairo_copy_page(v.native()) } // ShowPage is a wrapper around cairo_show_page(). func (v *Context) ShowPage() { C.cairo_show_page(v.native()) } gotk3-0.6.2/cairo/errors.go000066400000000000000000000001621431157473000155120ustar00rootroot00000000000000package cairo type ErrorStatus Status func (e ErrorStatus) Error() string { return StatusToString(Status(e)) } gotk3-0.6.2/cairo/fillrule.go000066400000000000000000000007251431157473000160210ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "unsafe" ) // FillRule is a representation of Cairo's cairo_fill_rule_t. type FillRule int const ( FILL_RULE_WINDING FillRule = C.CAIRO_FILL_RULE_WINDING FILL_RULE_EVEN_ODD FillRule = C.CAIRO_FILL_RULE_EVEN_ODD ) func marshalFillRule(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return FillRule(c), nil } gotk3-0.6.2/cairo/fontoptions.go000066400000000000000000000125151431157473000165650ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.cairo_gobject_subpixel_order_get_type()), marshalSubpixelOrder}, {glib.Type(C.cairo_gobject_hint_style_get_type()), marshalHintStyle}, {glib.Type(C.cairo_gobject_hint_metrics_get_type()), marshalHintMetrics}, // Boxed {glib.Type(C.cairo_gobject_font_options_get_type()), marshalFontOptions}, } glib.RegisterGValueMarshalers(tm) } // SubpixelOrder is a representation of Cairo's cairo_subpixel_order_t. type SubpixelOrder int const ( SUBPIXEL_ORDER_DEFAULT SubpixelOrder = C.CAIRO_SUBPIXEL_ORDER_DEFAULT SUBPIXEL_ORDER_RGB SubpixelOrder = C.CAIRO_SUBPIXEL_ORDER_RGB SUBPIXEL_ORDER_BGR SubpixelOrder = C.CAIRO_SUBPIXEL_ORDER_BGR SUBPIXEL_ORDER_VRGB SubpixelOrder = C.CAIRO_SUBPIXEL_ORDER_VRGB SUBPIXEL_ORDER_VBGR SubpixelOrder = C.CAIRO_SUBPIXEL_ORDER_VBGR ) func marshalSubpixelOrder(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return SubpixelOrder(c), nil } // HintStyle is a representation of Cairo's cairo_hint_style_t. type HintStyle int const ( HINT_STYLE_DEFAULT HintStyle = C.CAIRO_HINT_STYLE_DEFAULT HINT_STYLE_NONE HintStyle = C.CAIRO_HINT_STYLE_NONE HINT_STYLE_SLIGHT HintStyle = C.CAIRO_HINT_STYLE_SLIGHT HINT_STYLE_MEDIUM HintStyle = C.CAIRO_HINT_STYLE_MEDIUM HINT_STYLE_FULL HintStyle = C.CAIRO_HINT_STYLE_FULL ) func marshalHintStyle(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return HintStyle(c), nil } // HintMetrics is a representation of Cairo's cairo_hint_metrics_t. type HintMetrics int const ( HINT_METRICS_DEFAULT HintMetrics = C.CAIRO_HINT_METRICS_DEFAULT HINT_METRICS_OFF HintMetrics = C.CAIRO_HINT_METRICS_OFF HINT_METRICS_ON HintMetrics = C.CAIRO_HINT_METRICS_ON ) func marshalHintMetrics(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return HintMetrics(c), nil } // FontOptions is a representation of Cairo's cairo_font_options_t. type FontOptions struct { native *C.cairo_font_options_t } func marshalFontOptions(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return &FontOptions{ native: (*C.cairo_font_options_t)(unsafe.Pointer(c)), }, nil } // CreatFontOptions is a wrapper around cairo_font_options_create(). func CreateFontOptions() *FontOptions { native := C.cairo_font_options_create() opts := &FontOptions{native} runtime.SetFinalizer(opts, func(v *FontOptions) { glib.FinalizerStrategy(v.destroy) }) return opts } func (o *FontOptions) destroy() { C.cairo_font_options_destroy(o.native) } // Copy is a wrapper around cairo_font_options_copy(). func (o *FontOptions) Copy() *FontOptions { native := C.cairo_font_options_copy(o.native) opts := &FontOptions{native} runtime.SetFinalizer(opts, func(v *FontOptions) { glib.FinalizerStrategy(v.destroy) }) return opts } // Status is a wrapper around cairo_font_options_status(). func (o *FontOptions) Status() Status { return Status(C.cairo_font_options_status(o.native)) } // Merge is a wrapper around cairo_font_options_merge(). func (o *FontOptions) Merge(other *FontOptions) { C.cairo_font_options_merge(o.native, other.native) } // Hash is a wrapper around cairo_font_options_hash(). func (o *FontOptions) Hash() uint32 { return uint32(C.cairo_font_options_hash(o.native)) } // Equal is a wrapper around cairo_font_options_equal(). func (o *FontOptions) Equal(other *FontOptions) bool { return gobool(C.cairo_font_options_equal(o.native, other.native)) } // SetAntialias is a wrapper around cairo_font_options_set_antialias(). func (o *FontOptions) SetAntialias(antialias Antialias) { C.cairo_font_options_set_antialias(o.native, C.cairo_antialias_t(antialias)) } // GetAntialias is a wrapper around cairo_font_options_get_antialias(). func (o *FontOptions) GetAntialias() Antialias { return Antialias(C.cairo_font_options_get_antialias(o.native)) } // SetSubpixelOrder is a wrapper around cairo_font_options_set_subpixel_order(). func (o *FontOptions) SetSubpixelOrder(subpixelOrder SubpixelOrder) { C.cairo_font_options_set_subpixel_order(o.native, C.cairo_subpixel_order_t(subpixelOrder)) } // GetSubpixelOrder is a wrapper around cairo_font_options_get_subpixel_order(). func (o *FontOptions) GetSubpixelOrder() SubpixelOrder { return SubpixelOrder(C.cairo_font_options_get_subpixel_order(o.native)) } // SetHintStyle is a wrapper around cairo_font_options_set_hint_style(). func (o *FontOptions) SetHintStyle(hintStyle HintStyle) { C.cairo_font_options_set_hint_style(o.native, C.cairo_hint_style_t(hintStyle)) } // GetHintStyle is a wrapper around cairo_font_options_get_hint_style(). func (o *FontOptions) GetHintStyle() HintStyle { return HintStyle(C.cairo_font_options_get_hint_style(o.native)) } // SetHintMetrics is a wrapper around cairo_font_options_set_hint_metrics(). func (o *FontOptions) SetHintMetrics(hintMetrics HintMetrics) { C.cairo_font_options_set_hint_metrics(o.native, C.cairo_hint_metrics_t(hintMetrics)) } // GetHintMetrics is a wrapper around cairo_font_options_get_hint_metrics(). func (o *FontOptions) GetHintMetrics() HintMetrics { return HintMetrics(C.cairo_font_options_get_hint_metrics(o.native)) } gotk3-0.6.2/cairo/fontoptions_since_1_16.go000066400000000000000000000014061431157473000204710ustar00rootroot00000000000000// +build !cairo_1_9,!cairo_1_10,!cairo_1_11,!cairo_1_12,!cairo_1_13,!cairo_1_14,!cairo_1_15 package cairo // #include // #include // #include import "C" import ( "unsafe" ) // GetVariations is a wrapper around cairo_font_options_get_variations(). func (o *FontOptions) GetVariations() string { return C.GoString(C.cairo_font_options_get_variations(o.native)) } // SetVariations is a wrapper around cairo_font_options_set_variations(). func (o *FontOptions) SetVariations(variations string) { var cvariations *C.char if variations != "" { cvariations = C.CString(variations) // Cairo will call strdup on its own. defer C.free(unsafe.Pointer(cvariations)) } C.cairo_font_options_set_variations(o.native, cvariations) } gotk3-0.6.2/cairo/format.go000066400000000000000000000016141431157473000154710ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "unsafe" ) // Format is a representation of Cairo's cairo_format_t. type Format int const ( FORMAT_INVALID Format = C.CAIRO_FORMAT_INVALID FORMAT_ARGB32 Format = C.CAIRO_FORMAT_ARGB32 FORMAT_RGB24 Format = C.CAIRO_FORMAT_RGB24 FORMAT_A8 Format = C.CAIRO_FORMAT_A8 FORMAT_A1 Format = C.CAIRO_FORMAT_A1 FORMAT_RGB16_565 Format = C.CAIRO_FORMAT_RGB16_565 FORMAT_RGB30 Format = C.CAIRO_FORMAT_RGB30 ) func marshalFormat(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Format(c), nil } // FormatStrideForWidth is a wrapper for cairo_format_stride_for_width(). func FormatStrideForWidth(format Format, width int) int { c := C.cairo_format_stride_for_width(C.cairo_format_t(format), C.int(width)) return int(c) } gotk3-0.6.2/cairo/linecap.go000066400000000000000000000007631431157473000156200ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "unsafe" ) // LineCap is a representation of Cairo's cairo_line_cap_t. type LineCap int const ( LINE_CAP_BUTT LineCap = C.CAIRO_LINE_CAP_BUTT LINE_CAP_ROUND LineCap = C.CAIRO_LINE_CAP_ROUND LINE_CAP_SQUARE LineCap = C.CAIRO_LINE_CAP_SQUARE ) func marshalLineCap(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return LineCap(c), nil } gotk3-0.6.2/cairo/linejoin.go000066400000000000000000000007761431157473000160200ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "unsafe" ) // LineJoin is a representation of Cairo's cairo_line_join_t. type LineJoin int const ( LINE_JOIN_MITER LineJoin = C.CAIRO_LINE_JOIN_MITER LINE_JOIN_ROUND LineJoin = C.CAIRO_LINE_JOIN_ROUND LINE_JOIN_BEVEL LineJoin = C.CAIRO_LINE_JOIN_BEVEL ) func marshalLineJoin(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return LineJoin(c), nil } gotk3-0.6.2/cairo/matrix.go000066400000000000000000000047051431157473000155110ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "unsafe" ) // Matrix struct type Matrix struct { Xx, Yx float64 Xy, Yy float64 X0, Y0 float64 } // NewMatrix creates a new identiy matrix func NewMatrix(xx, yx, xy, yy, x0, y0 float64) *Matrix { return &Matrix{ Xx: xx, Yx: yx, Xy: xy, Yy: yy, X0: x0, Y0: y0, } } // Native returns native c pointer to a matrix func (m *Matrix) native() *C.cairo_matrix_t { return (*C.cairo_matrix_t)(unsafe.Pointer(m)) } // Native returns native c pointer to a matrix func (m *Matrix) Native() uintptr { return uintptr(unsafe.Pointer(m.native())) } // InitIdentity initializes this matrix to identity matrix func (m *Matrix) InitIdentity() { C.cairo_matrix_init_identity(m.native()) } // InitTranslate initializes a matrix with the given translation func (m *Matrix) InitTranslate(tx, ty float64) { C.cairo_matrix_init_translate(m.native(), C.double(tx), C.double(ty)) } // InitScale initializes a matrix with the give scale func (m *Matrix) InitScale(sx, sy float64) { C.cairo_matrix_init_scale(m.native(), C.double(sx), C.double(sy)) } // InitRotate initializes a matrix with the given rotation func (m *Matrix) InitRotate(radians float64) { C.cairo_matrix_init_rotate(m.native(), C.double(radians)) } // Translate translates a matrix by the given amount func (m *Matrix) Translate(tx, ty float64) { C.cairo_matrix_translate(m.native(), C.double(tx), C.double(ty)) } // Scale scales the matrix by the given amounts func (m *Matrix) Scale(sx, sy float64) { C.cairo_matrix_scale(m.native(), C.double(sx), C.double(sy)) } // Rotate rotates the matrix by the given amount func (m *Matrix) Rotate(radians float64) { C.cairo_matrix_rotate(m.native(), C.double(radians)) } // Invert inverts the matrix func (m *Matrix) Invert() { C.cairo_matrix_invert(m.native()) } // Multiply multiplies the matrix by another matrix func (m *Matrix) Multiply(a, b Matrix) { C.cairo_matrix_multiply(m.native(), a.native(), b.native()) } // TransformDistance ... func (m *Matrix) TransformDistance(dx, dy float64) (float64, float64) { C.cairo_matrix_transform_distance(m.native(), (*C.double)(unsafe.Pointer(&dx)), (*C.double)(unsafe.Pointer(&dy))) return dx, dy } // TransformPoint ... func (m *Matrix) TransformPoint(x, y float64) (float64, float64) { C.cairo_matrix_transform_point(m.native(), (*C.double)(unsafe.Pointer(&x)), (*C.double)(unsafe.Pointer(&y))) return x, y } gotk3-0.6.2/cairo/mimetype.go000066400000000000000000000005651431157473000160360ustar00rootroot00000000000000package cairo // MimeType is a representation of Cairo's CAIRO_MIME_TYPE_* // preprocessor constants. type MimeType string const ( MIME_TYPE_JP2 MimeType = "image/jp2" MIME_TYPE_JPEG MimeType = "image/jpeg" MIME_TYPE_PNG MimeType = "image/png" MIME_TYPE_URI MimeType = "image/x-uri" MIME_TYPE_UNIQUE_ID MimeType = "application/x-cairo.uuid" ) gotk3-0.6.2/cairo/operator.go000066400000000000000000000041241431157473000160330ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "unsafe" ) // Operator is a representation of Cairo's cairo_operator_t. type Operator int const ( OPERATOR_CLEAR Operator = C.CAIRO_OPERATOR_CLEAR OPERATOR_SOURCE Operator = C.CAIRO_OPERATOR_SOURCE OPERATOR_OVER Operator = C.CAIRO_OPERATOR_OVER OPERATOR_IN Operator = C.CAIRO_OPERATOR_IN OPERATOR_OUT Operator = C.CAIRO_OPERATOR_OUT OPERATOR_ATOP Operator = C.CAIRO_OPERATOR_ATOP OPERATOR_DEST Operator = C.CAIRO_OPERATOR_DEST OPERATOR_DEST_OVER Operator = C.CAIRO_OPERATOR_DEST_OVER OPERATOR_DEST_IN Operator = C.CAIRO_OPERATOR_DEST_IN OPERATOR_DEST_OUT Operator = C.CAIRO_OPERATOR_DEST_OUT OPERATOR_DEST_ATOP Operator = C.CAIRO_OPERATOR_DEST_ATOP OPERATOR_XOR Operator = C.CAIRO_OPERATOR_XOR OPERATOR_ADD Operator = C.CAIRO_OPERATOR_ADD OPERATOR_SATURATE Operator = C.CAIRO_OPERATOR_SATURATE OPERATOR_MULTIPLY Operator = C.CAIRO_OPERATOR_MULTIPLY OPERATOR_SCREEN Operator = C.CAIRO_OPERATOR_SCREEN OPERATOR_OVERLAY Operator = C.CAIRO_OPERATOR_OVERLAY OPERATOR_DARKEN Operator = C.CAIRO_OPERATOR_DARKEN OPERATOR_LIGHTEN Operator = C.CAIRO_OPERATOR_LIGHTEN OPERATOR_COLOR_DODGE Operator = C.CAIRO_OPERATOR_COLOR_DODGE OPERATOR_COLOR_BURN Operator = C.CAIRO_OPERATOR_COLOR_BURN OPERATOR_HARD_LIGHT Operator = C.CAIRO_OPERATOR_HARD_LIGHT OPERATOR_SOFT_LIGHT Operator = C.CAIRO_OPERATOR_SOFT_LIGHT OPERATOR_DIFFERENCE Operator = C.CAIRO_OPERATOR_DIFFERENCE OPERATOR_EXCLUSION Operator = C.CAIRO_OPERATOR_EXCLUSION OPERATOR_HSL_HUE Operator = C.CAIRO_OPERATOR_HSL_HUE OPERATOR_HSL_SATURATION Operator = C.CAIRO_OPERATOR_HSL_SATURATION OPERATOR_HSL_COLOR Operator = C.CAIRO_OPERATOR_HSL_COLOR OPERATOR_HSL_LUMINOSITY Operator = C.CAIRO_OPERATOR_HSL_LUMINOSITY ) func marshalOperator(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Operator(c), nil } gotk3-0.6.2/cairo/pattern.go000066400000000000000000000106041431157473000156550ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) //--------------------------------------------[ cairo_pattern_t == Pattern ]-- // Filter is a representation of Cairo's cairo_filter_t. type Filter int const ( FILTER_FAST Filter = C.CAIRO_FILTER_FAST FILTER_GOOD Filter = C.CAIRO_FILTER_GOOD FILTER_BEST Filter = C.CAIRO_FILTER_BEST FILTER_NEAREST Filter = C.CAIRO_FILTER_NEAREST FILTER_BILINEAR Filter = C.CAIRO_FILTER_BILINEAR FILTER_GAUSSIAN Filter = C.CAIRO_FILTER_GAUSSIAN ) func marshalFilter(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Filter(c), nil } // Pattern is a representation of Cairo's cairo_pattern_t. type Pattern struct { pattern *C.cairo_pattern_t } // NewPatternFromRGB is a wrapper around cairo_pattern_create_rgb(). func NewPatternFromRGB(red, green, blue float64) (*Pattern, error) { c := C.cairo_pattern_create_rgb(C.double(red), C.double(green), C.double(blue)) return newPatternFromNative(c) } // NewPatternFromRGBA is a wrapper around cairo_pattern_create_rgba(). func NewPatternFromRGBA(red, green, blue, alpha float64) (*Pattern, error) { c := C.cairo_pattern_create_rgba(C.double(red), C.double(green), C.double(blue), C.double(alpha)) return newPatternFromNative(c) } // NewPatternForSurface is a wrapper around cairo_pattern_create_for_surface(). func NewPatternForSurface(s *Surface) (*Pattern, error) { c := C.cairo_pattern_create_for_surface(s.native()) return newPatternFromNative(c) } // NewPatternLinear is a wrapper around cairo_pattern_create_linear(). func NewPatternLinear(x0, y0, x1, y1 float64) (*Pattern, error) { c := C.cairo_pattern_create_linear(C.double(x0), C.double(y0), C.double(x1), C.double(y1)) return newPatternFromNative(c) } // NewPatternRadial is a wrapper around cairo_pattern_create_radial(). func NewPatternRadial(x0, y0, r0, x1, y1, r1 float64) (*Pattern, error) { c := C.cairo_pattern_create_radial(C.double(x0), C.double(y0), C.double(r0), C.double(x1), C.double(y1), C.double(r1)) return newPatternFromNative(c) } func newPatternFromNative(patternNative *C.cairo_pattern_t) (*Pattern, error) { ptr := wrapPattern(patternNative) e := ptr.Status().ToError() if e != nil { return nil, e } runtime.SetFinalizer(ptr, func(v *Pattern) { glib.FinalizerStrategy(v.destroy) }) return ptr, nil } // native returns a pointer to the underlying cairo_pattern_t. func (v *Pattern) native() *C.cairo_pattern_t { if v == nil { return nil } return v.pattern } // Native returns a pointer to the underlying cairo_pattern_t. func (v *Pattern) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalPattern(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) pattern := (*C.cairo_pattern_t)(unsafe.Pointer(c)) return wrapPattern(pattern), nil } func wrapPattern(pattern *C.cairo_pattern_t) *Pattern { return &Pattern{pattern} } // reference is a wrapper around cairo_pattern_reference(). func (v *Pattern) reference() { v.pattern = C.cairo_pattern_reference(v.native()) } // destroy is a wrapper around cairo_pattern_destroy(). func (v *Pattern) destroy() { C.cairo_pattern_destroy(v.native()) } // Status is a wrapper around cairo_pattern_status(). func (v *Pattern) Status() Status { c := C.cairo_pattern_status(v.native()) return Status(c) } // AddColorStopRGB is a wrapper around cairo_pattern_add_color_stop_rgb(). func (v *Pattern) AddColorStopRGB(offset, red, green, blue float64) error { C.cairo_pattern_add_color_stop_rgb(v.native(), C.double(offset), C.double(red), C.double(green), C.double(blue)) return v.Status().ToError() } // AddColorStopRGBA is a wrapper around cairo_pattern_add_color_stop_rgba(). func (v *Pattern) AddColorStopRGBA(offset, red, green, blue, alpha float64) error { C.cairo_pattern_add_color_stop_rgba(v.native(), C.double(offset), C.double(red), C.double(green), C.double(blue), C.double(alpha)) return v.Status().ToError() } // PatternSetFilter is a wrapper around cairo_pattern_set_filter(). func (v *Pattern) PatternSetFilter(filter Filter) { C.cairo_pattern_set_filter(v.native(), C.cairo_filter_t(filter)) } // PatternGetFilter is a wrapper around cairo_pattern_get_filter(). func (v *Pattern) PatternGetFilter() Filter { return Filter(C.cairo_pattern_get_filter(v.native())) } gotk3-0.6.2/cairo/region.go000066400000000000000000000213451431157473000154670ustar00rootroot00000000000000// region.go package cairo // #include // #include import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.cairo_gobject_region_overlap_get_type()), marshalRegionOverlap}, // Boxed {glib.Type(C.cairo_gobject_region_get_type()), marshalRegion}, } glib.RegisterGValueMarshalers(tm) } // RegionOverlap is a representation of Cairo's cairo_region_overlap_t. type RegionOverlap int const ( REGION_OVERLAP_IN RegionOverlap = C.CAIRO_REGION_OVERLAP_IN REGION_OVERLAP_OUT RegionOverlap = C.CAIRO_REGION_OVERLAP_OUT REGION_OVERLAP_PART RegionOverlap = C.CAIRO_REGION_OVERLAP_PART ) func marshalRegionOverlap(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return RegionOverlap(c), nil } /* * Rectangle */ // Rectangle is a representation of Cairo's cairo_rectangle_int_t. type Rectangle struct { X, Y int Width, Height int } // commodity function to ceate Rectangle cairo object. func RectangleNew(x, y, width, height int) *Rectangle { r := new(Rectangle) r.X = x r.Y = y r.Width = width r.Height = height return r } func (v *Rectangle) native() *C.cairo_rectangle_int_t { r := new(C.cairo_rectangle_int_t) r.x = C.int(v.X) r.y = C.int(v.Y) r.width = C.int(v.Width) r.height = C.int(v.Height) return r } func toRectangle(cr *C.cairo_rectangle_int_t) *Rectangle { return &Rectangle{ X: int(cr.x), Y: int(cr.y), Width: int(cr.width), Height: int(cr.height)} } /* * Region */ // Region is a representation of Cairo's cairo_region_t. type Region struct { region *C.cairo_region_t } // native returns a pointer to the underlying cairo_region_t. func (v *Region) native() *C.cairo_region_t { if v == nil { return nil } return v.region } // Native returns a pointer to the underlying cairo_region_t. func (v *Region) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalRegion(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) region := (*C.cairo_region_t)(unsafe.Pointer(c)) return wrapRegion(region), nil } func wrapRegion(region *C.cairo_region_t) *Region { return &Region{region} } // newRegionFromNative that handle finalizer. func newRegionFromNative(regionNative *C.cairo_region_t) (*Region, error) { ptr := wrapRegion(regionNative) e := ptr.Status().ToError() if e != nil { return nil, e } runtime.SetFinalizer(ptr, func(v *Region) { glib.FinalizerStrategy(v.destroy) }) return ptr, nil } // RegionCreate is a wrapper around cairo_region_create(). func RegionCreate() (*Region, error) { return newRegionFromNative(C.cairo_region_create()) } // CreateRectangle is a wrapper around cairo_region_create_rectangle(). func (v *Region) CreateRectangle(rectangle *Rectangle) (*Region, error) { return newRegionFromNative(C.cairo_region_create_rectangle( rectangle.native())) } // CreateRectangles is a wrapper around cairo_region_create_rectangles(). func (v *Region) CreateRectangles(rectangles ...*Rectangle) (*Region, error) { length := len(rectangles) cRectangles := make([]C.cairo_rectangle_int_t, length) for i := 0; i < length; i++ { cRectangles[i] = *rectangles[i].native() } pRect := &cRectangles[0] return newRegionFromNative( C.cairo_region_create_rectangles( pRect, C.int(length))) } // Copy is a wrapper around cairo_region_copy(). func (v *Region) Copy() (*Region, error) { return newRegionFromNative(C.cairo_region_copy(v.native())) } // reference is a wrapper around cairo_region_reference(). func (v *Region) reference() { v.region = C.cairo_region_reference(v.native()) } // destroy is a wrapper around cairo_region_destroy(). func (v *Region) destroy() { C.cairo_region_destroy(v.native()) } // Status is a wrapper around cairo_region_status(). func (v *Region) Status() Status { c := C.cairo_region_status(v.native()) return Status(c) } // GetExtents is a wrapper around cairo_region_get_extents(). func (v *Region) GetExtents(extents *Rectangle) { C.cairo_region_get_extents(v.native(), extents.native()) } // NumRectangles is a wrapper around cairo_region_num_rectangles(). func (v *Region) NumRectangles() int { return int(C.cairo_region_num_rectangles(v.native())) } // GetRectangle is a wrapper around cairo_region_get_rectangle(). func (v *Region) GetRectangle(nth int) *Rectangle { cr := new(C.cairo_rectangle_int_t) C.cairo_region_get_rectangle(v.native(), C.int(nth), cr) return toRectangle(cr) } // IsEmpty is a wrapper around cairo_region_is_empty(). func (v *Region) IsEmpty() bool { return gobool(C.cairo_region_is_empty(v.native())) } // ContainsPoint is a wrapper around cairo_region_contains_point(). func (v *Region) ContainsPoint(x, y int) bool { return gobool(C.cairo_region_contains_point( v.native(), C.int(x), C.int(y))) } // ContainsRectangle is a wrapper around cairo_region_contains_rectangle(). func (v *Region) ContainsRectangle(rectangle *Rectangle) RegionOverlap { return RegionOverlap( C.cairo_region_contains_rectangle( v.native(), rectangle.native())) } // Equal is a wrapper around cairo_region_equal(). func (v *Region) Equal(region *Region) bool { return gobool(C.cairo_region_equal(v.native(), region.native())) } // Translate is a wrapper around cairo_region_translate(). func (v *Region) Translate(dx, dy int) { C.cairo_region_translate(v.native(), C.int(dx), C.int(dy)) } // Intersect is a wrapper around cairo_region_intersect(). // Note: contrary to the original statement, the source // 'Region' remains preserved. func (v *Region) Intersect(other *Region) (*Region, error) { dst, err := v.Copy() if err != nil { return nil, err } err = Status( C.cairo_region_intersect( dst.native(), other.native())).ToError() if err != nil { return nil, err } return dst, nil } // IntersectRectangle is a wrapper around cairo_region_intersect_rectangle(). // Note: contrary to the original statement, the source 'Region' remains preserved. func (v *Region) IntersectRectangle(rectangle *Rectangle) (*Region, error) { dst, err := v.Copy() if err != nil { return nil, err } err = Status( C.cairo_region_intersect_rectangle( dst.native(), rectangle.native())).ToError() if err != nil { return nil, err } return dst, nil } // Substract is a wrapper around cairo_region_subtract(). // Note: contrary to the original statement, the source // 'Region' remains preserved. func (v *Region) Substract(other *Region) (*Region, error) { dst, err := v.Copy() if err != nil { return nil, err } err = Status( C.cairo_region_subtract( dst.native(), other.native())).ToError() if err != nil { return nil, err } return dst, nil } // SubstractRectangle is a wrapper around cairo_region_subtract_rectangle(). // Note: contrary to the original statement, the source 'Region' remains preserved. func (v *Region) SubstractRectangle(rectangle *Rectangle) (*Region, error) { dst, err := v.Copy() if err != nil { return nil, err } err = Status( C.cairo_region_subtract_rectangle( dst.native(), rectangle.native())).ToError() if err != nil { return nil, err } return dst, nil } // Union is a wrapper around cairo_region_union(). // Note: contrary to the original statement, the source // 'Region' remains preserved. func (v *Region) Union(other *Region) (*Region, error) { dst, err := v.Copy() if err != nil { return nil, err } err = Status( C.cairo_region_union( dst.native(), other.native())).ToError() if err != nil { return nil, err } return dst, nil } // UnionRectangle is a wrapper around cairo_region_union_rectangle(). // Note: contrary to the original statement, the source 'Region' remains preserved. func (v *Region) UnionRectangle(rectangle *Rectangle) (*Region, error) { dst, err := v.Copy() if err != nil { return nil, err } err = Status( C.cairo_region_union_rectangle( dst.native(), rectangle.native())).ToError() if err != nil { return nil, err } return dst, nil } // Xor is a wrapper around cairo_region_xor(). // Note: contrary to the original statement, the source // 'Region' remains preserved. func (v *Region) Xor(other *Region) (*Region, error) { dst, err := v.Copy() if err != nil { return nil, err } err = Status( C.cairo_region_xor( dst.native(), other.native())).ToError() if err != nil { return nil, err } return dst, nil } // XorRectangle is a wrapper around cairo_region_xor_rectangle(). // Note: contrary to the original statement, the source 'Region' remains preserved. func (v *Region) XorRectangle(rectangle *Rectangle) (*Region, error) { dst, err := v.Copy() if err != nil { return nil, err } err = Status( C.cairo_region_xor_rectangle( dst.native(), rectangle.native())).ToError() if err != nil { return nil, err } return dst, nil } gotk3-0.6.2/cairo/status.go000066400000000000000000000141321431157473000155230ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "errors" "strings" "unsafe" ) // Status is a representation of Cairo's cairo_status_t. type Status int const ( STATUS_SUCCESS Status = C.CAIRO_STATUS_SUCCESS STATUS_NO_MEMORY Status = C.CAIRO_STATUS_NO_MEMORY STATUS_INVALID_RESTORE Status = C.CAIRO_STATUS_INVALID_RESTORE STATUS_INVALID_POP_GROUP Status = C.CAIRO_STATUS_INVALID_POP_GROUP STATUS_NO_CURRENT_POINT Status = C.CAIRO_STATUS_NO_CURRENT_POINT STATUS_INVALID_MATRIX Status = C.CAIRO_STATUS_INVALID_MATRIX STATUS_INVALID_STATUS Status = C.CAIRO_STATUS_INVALID_STATUS STATUS_NULL_POINTER Status = C.CAIRO_STATUS_NULL_POINTER STATUS_INVALID_STRING Status = C.CAIRO_STATUS_INVALID_STRING STATUS_INVALID_PATH_DATA Status = C.CAIRO_STATUS_INVALID_PATH_DATA STATUS_READ_ERROR Status = C.CAIRO_STATUS_READ_ERROR STATUS_WRITE_ERROR Status = C.CAIRO_STATUS_WRITE_ERROR STATUS_SURFACE_FINISHED Status = C.CAIRO_STATUS_SURFACE_FINISHED STATUS_SURFACE_TYPE_MISMATCH Status = C.CAIRO_STATUS_SURFACE_TYPE_MISMATCH STATUS_PATTERN_TYPE_MISMATCH Status = C.CAIRO_STATUS_PATTERN_TYPE_MISMATCH STATUS_INVALID_CONTENT Status = C.CAIRO_STATUS_INVALID_CONTENT STATUS_INVALID_FORMAT Status = C.CAIRO_STATUS_INVALID_FORMAT STATUS_INVALID_VISUAL Status = C.CAIRO_STATUS_INVALID_VISUAL STATUS_FILE_NOT_FOUND Status = C.CAIRO_STATUS_FILE_NOT_FOUND STATUS_INVALID_DASH Status = C.CAIRO_STATUS_INVALID_DASH STATUS_INVALID_DSC_COMMENT Status = C.CAIRO_STATUS_INVALID_DSC_COMMENT STATUS_INVALID_INDEX Status = C.CAIRO_STATUS_INVALID_INDEX STATUS_CLIP_NOT_REPRESENTABLE Status = C.CAIRO_STATUS_CLIP_NOT_REPRESENTABLE STATUS_TEMP_FILE_ERROR Status = C.CAIRO_STATUS_TEMP_FILE_ERROR STATUS_INVALID_STRIDE Status = C.CAIRO_STATUS_INVALID_STRIDE STATUS_FONT_TYPE_MISMATCH Status = C.CAIRO_STATUS_FONT_TYPE_MISMATCH STATUS_USER_FONT_IMMUTABLE Status = C.CAIRO_STATUS_USER_FONT_IMMUTABLE STATUS_USER_FONT_ERROR Status = C.CAIRO_STATUS_USER_FONT_ERROR STATUS_NEGATIVE_COUNT Status = C.CAIRO_STATUS_NEGATIVE_COUNT STATUS_INVALID_CLUSTERS Status = C.CAIRO_STATUS_INVALID_CLUSTERS STATUS_INVALID_SLANT Status = C.CAIRO_STATUS_INVALID_SLANT STATUS_INVALID_WEIGHT Status = C.CAIRO_STATUS_INVALID_WEIGHT STATUS_INVALID_SIZE Status = C.CAIRO_STATUS_INVALID_SIZE STATUS_USER_FONT_NOT_IMPLEMENTED Status = C.CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED STATUS_DEVICE_TYPE_MISMATCH Status = C.CAIRO_STATUS_DEVICE_TYPE_MISMATCH STATUS_DEVICE_ERROR Status = C.CAIRO_STATUS_DEVICE_ERROR // STATUS_INVALID_MESH_CONSTRUCTION Status = C.CAIRO_STATUS_INVALID_MESH_CONSTRUCTION (since 1.12) // STATUS_DEVICE_FINISHED Status = C.CAIRO_STATUS_DEVICE_FINISHED (since 1.12) ) var key_Status = map[Status]string{ STATUS_SUCCESS: "CAIRO_STATUS_SUCCESS", STATUS_NO_MEMORY: "CAIRO_STATUS_NO_MEMORY", STATUS_INVALID_RESTORE: "CAIRO_STATUS_INVALID_RESTORE", STATUS_INVALID_POP_GROUP: "CAIRO_STATUS_INVALID_POP_GROUP", STATUS_NO_CURRENT_POINT: "CAIRO_STATUS_NO_CURRENT_POINT", STATUS_INVALID_MATRIX: "CAIRO_STATUS_INVALID_MATRIX", STATUS_INVALID_STATUS: "CAIRO_STATUS_INVALID_STATUS", STATUS_NULL_POINTER: "CAIRO_STATUS_NULL_POINTER", STATUS_INVALID_STRING: "CAIRO_STATUS_INVALID_STRING", STATUS_INVALID_PATH_DATA: "CAIRO_STATUS_INVALID_PATH_DATA", STATUS_READ_ERROR: "CAIRO_STATUS_READ_ERROR", STATUS_WRITE_ERROR: "CAIRO_STATUS_WRITE_ERROR", STATUS_SURFACE_FINISHED: "CAIRO_STATUS_SURFACE_FINISHED", STATUS_SURFACE_TYPE_MISMATCH: "CAIRO_STATUS_SURFACE_TYPE_MISMATCH", STATUS_PATTERN_TYPE_MISMATCH: "CAIRO_STATUS_PATTERN_TYPE_MISMATCH", STATUS_INVALID_CONTENT: "CAIRO_STATUS_INVALID_CONTENT", STATUS_INVALID_FORMAT: "CAIRO_STATUS_INVALID_FORMAT", STATUS_INVALID_VISUAL: "CAIRO_STATUS_INVALID_VISUAL", STATUS_FILE_NOT_FOUND: "CAIRO_STATUS_FILE_NOT_FOUND", STATUS_INVALID_DASH: "CAIRO_STATUS_INVALID_DASH", STATUS_INVALID_DSC_COMMENT: "CAIRO_STATUS_INVALID_DSC_COMMENT", STATUS_INVALID_INDEX: "CAIRO_STATUS_INVALID_INDEX", STATUS_CLIP_NOT_REPRESENTABLE: "CAIRO_STATUS_CLIP_NOT_REPRESENTABLE", STATUS_TEMP_FILE_ERROR: "CAIRO_STATUS_TEMP_FILE_ERROR", STATUS_INVALID_STRIDE: "CAIRO_STATUS_INVALID_STRIDE", STATUS_FONT_TYPE_MISMATCH: "CAIRO_STATUS_FONT_TYPE_MISMATCH", STATUS_USER_FONT_IMMUTABLE: "CAIRO_STATUS_USER_FONT_IMMUTABLE", STATUS_USER_FONT_ERROR: "CAIRO_STATUS_USER_FONT_ERROR", STATUS_NEGATIVE_COUNT: "CAIRO_STATUS_NEGATIVE_COUNT", STATUS_INVALID_CLUSTERS: "CAIRO_STATUS_INVALID_CLUSTERS", STATUS_INVALID_SLANT: "CAIRO_STATUS_INVALID_SLANT", STATUS_INVALID_WEIGHT: "CAIRO_STATUS_INVALID_WEIGHT", STATUS_INVALID_SIZE: "CAIRO_STATUS_INVALID_SIZE", STATUS_USER_FONT_NOT_IMPLEMENTED: "CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED", STATUS_DEVICE_TYPE_MISMATCH: "CAIRO_STATUS_DEVICE_TYPE_MISMATCH", STATUS_DEVICE_ERROR: "CAIRO_STATUS_DEVICE_ERROR", } func StatusToString(status Status) string { s, ok := key_Status[status] if !ok { s = "CAIRO_STATUS_UNDEFINED" } return s } func marshalStatus(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Status(c), nil } // String returns a readable status messsage usable in texts. func (s Status) String() string { str := StatusToString(s) str = strings.Replace(str, "CAIRO_STATUS_", "", 1) str = strings.Replace(str, "_", " ", 0) return strings.ToLower(str) } // ToError returns the error for the status. Returns nil if success. func (s Status) ToError() error { if s == STATUS_SUCCESS { return nil } return errors.New(s.String()) } gotk3-0.6.2/cairo/surface.go000066400000000000000000000213151431157473000156310ustar00rootroot00000000000000package cairo // #include // #include // #include // #include import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) /* * cairo_surface_t */ // Surface is a representation of Cairo's cairo_surface_t. type Surface struct { surface *C.cairo_surface_t } func NewSurfaceFromPNG(fileName string) (*Surface, error) { cstr := C.CString(fileName) defer C.free(unsafe.Pointer(cstr)) surfaceNative := C.cairo_image_surface_create_from_png(cstr) status := Status(C.cairo_surface_status(surfaceNative)) if status != STATUS_SUCCESS { return nil, ErrorStatus(status) } return &Surface{surfaceNative}, nil } // CreateImageSurfaceForData is a wrapper around cairo_image_surface_create_for_data(). func CreateImageSurfaceForData(data []byte, format Format, width, height, stride int) (*Surface, error) { surfaceNative := C.cairo_image_surface_create_for_data((*C.uchar)(unsafe.Pointer(&data[0])), C.cairo_format_t(format), C.int(width), C.int(height), C.int(stride)) status := Status(C.cairo_surface_status(surfaceNative)) if status != STATUS_SUCCESS { return nil, ErrorStatus(status) } s := wrapSurface(surfaceNative) runtime.SetFinalizer(s, func(v *Surface) { glib.FinalizerStrategy(v.destroy) }) return s, nil } // CreateImageSurface is a wrapper around cairo_image_surface_create(). func CreateImageSurface(format Format, width, height int) *Surface { c := C.cairo_image_surface_create(C.cairo_format_t(format), C.int(width), C.int(height)) s := wrapSurface(c) runtime.SetFinalizer(s, func(v *Surface) { glib.FinalizerStrategy(v.destroy) }) return s } /// Create a new PDF surface. func CreatePDFSurface(fileName string, width float64, height float64) (*Surface, error) { cstr := C.CString(fileName) defer C.free(unsafe.Pointer(cstr)) surfaceNative := C.cairo_pdf_surface_create(cstr, C.double(width), C.double(height)) status := Status(C.cairo_surface_status(surfaceNative)) if status != STATUS_SUCCESS { return nil, ErrorStatus(status) } s := wrapSurface(surfaceNative) runtime.SetFinalizer(s, func(v *Surface) { glib.FinalizerStrategy(v.destroy) }) return s, nil } // native returns a pointer to the underlying cairo_surface_t. func (v *Surface) native() *C.cairo_surface_t { if v == nil { return nil } return v.surface } // Native returns a pointer to the underlying cairo_surface_t. func (v *Surface) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *Surface) GetCSurface() *C.cairo_surface_t { return v.native() } func marshalSurface(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return WrapSurface(uintptr(c)), nil } func wrapSurface(surface *C.cairo_surface_t) *Surface { return &Surface{surface} } // NewSurface creates a gotk3 cairo Surface from a pointer to a // C cairo_surface_t. This is primarily designed for use with other // gotk3 packages and should be avoided by applications. func NewSurface(s uintptr, needsRef bool) *Surface { surface := WrapSurface(s) if needsRef { surface.reference() } runtime.SetFinalizer(surface, func(v *Surface) { glib.FinalizerStrategy(v.destroy) }) return surface } func WrapSurface(s uintptr) *Surface { ptr := (*C.cairo_surface_t)(unsafe.Pointer(s)) return wrapSurface(ptr) } // Closes the surface. The surface must not be used afterwards. func (v *Surface) Close() { v.destroy() } // CreateSimilar is a wrapper around cairo_surface_create_similar(). func (v *Surface) CreateSimilar(content Content, width, height int) *Surface { c := C.cairo_surface_create_similar(v.native(), C.cairo_content_t(content), C.int(width), C.int(height)) s := wrapSurface(c) runtime.SetFinalizer(s, func(v *Surface) { glib.FinalizerStrategy(v.destroy) }) return s } // TODO cairo_surface_create_similar_image (since 1.12) // CreateForRectangle is a wrapper around cairo_surface_create_for_rectangle(). func (v *Surface) CreateForRectangle(x, y, width, height float64) *Surface { c := C.cairo_surface_create_for_rectangle(v.native(), C.double(x), C.double(y), C.double(width), C.double(height)) s := wrapSurface(c) runtime.SetFinalizer(s, func(v *Surface) { glib.FinalizerStrategy(v.destroy) }) return s } // reference is a wrapper around cairo_surface_reference(). func (v *Surface) reference() { v.surface = C.cairo_surface_reference(v.native()) } // destroy is a wrapper around cairo_surface_destroy(). func (v *Surface) destroy() { if v.surface != nil { C.cairo_surface_destroy(v.native()) v.surface = nil } } // Status is a wrapper around cairo_surface_status(). func (v *Surface) Status() Status { c := C.cairo_surface_status(v.native()) return Status(c) } // Flush is a wrapper around cairo_surface_flush(). func (v *Surface) Flush() { C.cairo_surface_flush(v.native()) } // TODO(jrick) GetDevice (requires Device bindings) // cairo_surface_get_device // TODO(jrick) GetFontOptions (require FontOptions bindings) // cairo_surface_get_font_options // TODO(jrick) GetContent (requires Content bindings) // cairo_surface_get_content // MarkDirty is a wrapper around cairo_surface_mark_dirty(). func (v *Surface) MarkDirty() { C.cairo_surface_mark_dirty(v.native()) } // MarkDirtyRectangle is a wrapper around cairo_surface_mark_dirty_rectangle(). func (v *Surface) MarkDirtyRectangle(x, y, width, height int) { C.cairo_surface_mark_dirty_rectangle(v.native(), C.int(x), C.int(y), C.int(width), C.int(height)) } // SetDeviceOffset is a wrapper around cairo_surface_set_device_offset(). func (v *Surface) SetDeviceOffset(x, y float64) { C.cairo_surface_set_device_offset(v.native(), C.double(x), C.double(y)) } // GetDeviceOffset is a wrapper around cairo_surface_get_device_offset(). func (v *Surface) GetDeviceOffset() (x, y float64) { var xOffset, yOffset C.double C.cairo_surface_get_device_offset(v.native(), &xOffset, &yOffset) return float64(xOffset), float64(yOffset) } // SetFallbackResolution is a wrapper around // cairo_surface_set_fallback_resolution(). func (v *Surface) SetFallbackResolution(xPPI, yPPI float64) { C.cairo_surface_set_fallback_resolution(v.native(), C.double(xPPI), C.double(yPPI)) } // GetFallbackResolution is a wrapper around cairo_surface_get_fallback_resolution(). func (v *Surface) GetFallbackResolution() (xPPI, yPPI float64) { var x, y C.double C.cairo_surface_get_fallback_resolution(v.native(), &x, &y) return float64(x), float64(y) } // GetType is a wrapper around cairo_surface_get_type(). func (v *Surface) GetType() SurfaceType { c := C.cairo_surface_get_type(v.native()) return SurfaceType(c) } // TODO(jrick) SetUserData (depends on UserDataKey and DestroyFunc) // cairo_surface_set_user_data // TODO(jrick) GetUserData (depends on UserDataKey) // cairo_surface_get_user_data // CopyPage is a wrapper around cairo_surface_copy_page(). func (v *Surface) CopyPage() { C.cairo_surface_copy_page(v.native()) } // ShowPage is a wrapper around cairo_surface_show_page(). func (v *Surface) ShowPage() { C.cairo_surface_show_page(v.native()) } // HasShowTextGlyphs is a wrapper around cairo_surface_has_show_text_glyphs(). func (v *Surface) HasShowTextGlyphs() bool { c := C.cairo_surface_has_show_text_glyphs(v.native()) return gobool(c) } // TODO(jrick) SetMimeData (depends on DestroyFunc) // cairo_surface_set_mime_data // GetMimeData is a wrapper around cairo_surface_get_mime_data(). The // returned mimetype data is returned as a Go byte slice. func (v *Surface) GetMimeData(mimeType MimeType) []byte { cstr := C.CString(string(mimeType)) defer C.free(unsafe.Pointer(cstr)) var data *C.uchar var length C.ulong C.cairo_surface_get_mime_data(v.native(), cstr, &data, &length) return C.GoBytes(unsafe.Pointer(data), C.int(length)) } // WriteToPNG is a wrapper around cairo_surface_write_png(). It writes the Cairo // surface to the given file in PNG format. func (v *Surface) WriteToPNG(fileName string) error { cstr := C.CString(fileName) defer C.free(unsafe.Pointer(cstr)) status := Status(C.cairo_surface_write_to_png(v.surface, cstr)) if status != STATUS_SUCCESS { return ErrorStatus(status) } return nil } // TODO(jrick) SupportsMimeType (since 1.12) // cairo_surface_supports_mime_type // TODO(jrick) MapToImage (since 1.12) // cairo_surface_map_to_image // TODO(jrick) UnmapImage (since 1.12) // cairo_surface_unmap_image // GetHeight is a wrapper around cairo_image_surface_get_height(). func (v *Surface) GetHeight() int { return int(C.cairo_image_surface_get_height(v.surface)) } // GetWidth is a wrapper around cairo_image_surface_get_width(). func (v *Surface) GetWidth() int { return int(C.cairo_image_surface_get_width(v.surface)) } // GetData is a wrapper around cairo_image_surface_get_data(). func (v *Surface) GetData() unsafe.Pointer { return unsafe.Pointer(C.cairo_image_surface_get_data(v.surface)) } gotk3-0.6.2/cairo/surfacetype.go000066400000000000000000000041271431157473000165350ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "unsafe" ) // SurfaceType is a representation of Cairo's cairo_surface_type_t. type SurfaceType int const ( SURFACE_TYPE_IMAGE SurfaceType = C.CAIRO_SURFACE_TYPE_IMAGE SURFACE_TYPE_PDF SurfaceType = C.CAIRO_SURFACE_TYPE_PDF SURFACE_TYPE_PS SurfaceType = C.CAIRO_SURFACE_TYPE_PS SURFACE_TYPE_XLIB SurfaceType = C.CAIRO_SURFACE_TYPE_XLIB SURFACE_TYPE_XCB SurfaceType = C.CAIRO_SURFACE_TYPE_XCB SURFACE_TYPE_GLITZ SurfaceType = C.CAIRO_SURFACE_TYPE_GLITZ SURFACE_TYPE_QUARTZ SurfaceType = C.CAIRO_SURFACE_TYPE_QUARTZ SURFACE_TYPE_WIN32 SurfaceType = C.CAIRO_SURFACE_TYPE_WIN32 SURFACE_TYPE_BEOS SurfaceType = C.CAIRO_SURFACE_TYPE_BEOS SURFACE_TYPE_DIRECTFB SurfaceType = C.CAIRO_SURFACE_TYPE_DIRECTFB SURFACE_TYPE_SVG SurfaceType = C.CAIRO_SURFACE_TYPE_SVG SURFACE_TYPE_OS2 SurfaceType = C.CAIRO_SURFACE_TYPE_OS2 SURFACE_TYPE_WIN32_PRINTING SurfaceType = C.CAIRO_SURFACE_TYPE_WIN32_PRINTING SURFACE_TYPE_QUARTZ_IMAGE SurfaceType = C.CAIRO_SURFACE_TYPE_QUARTZ_IMAGE SURFACE_TYPE_SCRIPT SurfaceType = C.CAIRO_SURFACE_TYPE_SCRIPT SURFACE_TYPE_QT SurfaceType = C.CAIRO_SURFACE_TYPE_QT SURFACE_TYPE_RECORDING SurfaceType = C.CAIRO_SURFACE_TYPE_RECORDING SURFACE_TYPE_VG SurfaceType = C.CAIRO_SURFACE_TYPE_VG SURFACE_TYPE_GL SurfaceType = C.CAIRO_SURFACE_TYPE_GL SURFACE_TYPE_DRM SurfaceType = C.CAIRO_SURFACE_TYPE_DRM SURFACE_TYPE_TEE SurfaceType = C.CAIRO_SURFACE_TYPE_TEE SURFACE_TYPE_XML SurfaceType = C.CAIRO_SURFACE_TYPE_XML SURFACE_TYPE_SKIA SurfaceType = C.CAIRO_SURFACE_TYPE_SKIA SURFACE_TYPE_SUBSURFACE SurfaceType = C.CAIRO_SURFACE_TYPE_SUBSURFACE // SURFACE_TYPE_COGL SurfaceType = C.CAIRO_SURFACE_TYPE_COGL (since 1.12) ) func marshalSurfaceType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return SurfaceType(c), nil } gotk3-0.6.2/cairo/text.go000066400000000000000000000054741431157473000151750ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" import ( "unsafe" ) // FontSlant is a representation of Cairo's cairo_font_slant_t type FontSlant int const ( FONT_SLANT_NORMAL FontSlant = C.CAIRO_FONT_SLANT_NORMAL FONT_SLANT_ITALIC FontSlant = C.CAIRO_FONT_SLANT_ITALIC FONT_SLANT_OBLIQUE FontSlant = C.CAIRO_FONT_SLANT_OBLIQUE ) // FontWeight is a representation of Cairo's cairo_font_weight_t type FontWeight int const ( FONT_WEIGHT_NORMAL FontWeight = C.CAIRO_FONT_WEIGHT_NORMAL FONT_WEIGHT_BOLD FontWeight = C.CAIRO_FONT_WEIGHT_BOLD ) func (v *Context) SelectFontFace(family string, slant FontSlant, weight FontWeight) { cstr := C.CString(family) defer C.free(unsafe.Pointer(cstr)) C.cairo_select_font_face(v.native(), (*C.char)(cstr), C.cairo_font_slant_t(slant), C.cairo_font_weight_t(weight)) } func (v *Context) SetFontSize(size float64) { C.cairo_set_font_size(v.native(), C.double(size)) } // TODO: cairo_set_font_matrix // TODO: cairo_get_font_matrix // TODO: cairo_set_font_options // TODO: cairo_get_font_options // TODO: cairo_set_font_face // TODO: cairo_get_font_face // TODO: cairo_set_scaled_font // TODO: cairo_get_scaled_font func (v *Context) ShowText(utf8 string) { cstr := C.CString(utf8) defer C.free(unsafe.Pointer(cstr)) C.cairo_show_text(v.native(), (*C.char)(cstr)) } // TODO: cairo_show_glyphs // TODO: cairo_show_text_glyphs type FontExtents struct { Ascent float64 Descent float64 Height float64 MaxXAdvance float64 MaxYAdvance float64 } func (v *Context) FontExtents() FontExtents { var extents C.cairo_font_extents_t C.cairo_font_extents(v.native(), &extents) return FontExtents{ Ascent: float64(extents.ascent), Descent: float64(extents.descent), Height: float64(extents.height), MaxXAdvance: float64(extents.max_x_advance), MaxYAdvance: float64(extents.max_y_advance), } } type TextExtents struct { XBearing float64 YBearing float64 Width float64 Height float64 XAdvance float64 YAdvance float64 } func (v *Context) TextExtents(utf8 string) TextExtents { cstr := C.CString(utf8) defer C.free(unsafe.Pointer(cstr)) var extents C.cairo_text_extents_t C.cairo_text_extents(v.native(), (*C.char)(cstr), &extents) return TextExtents{ XBearing: float64(extents.x_bearing), YBearing: float64(extents.y_bearing), Width: float64(extents.width), Height: float64(extents.height), XAdvance: float64(extents.x_advance), YAdvance: float64(extents.y_advance), } } // TODO: cairo_glyph_extents // TODO: cairo_toy_font_face_create // TODO: cairo_toy_font_face_get_family // TODO: cairo_toy_font_face_get_slant // TODO: cairo_toy_font_face_get_weight // TODO: cairo_glyph_allocate // TODO: cairo_glyph_free // TODO: cairo_text_cluster_allocate // TODO: cairo_text_cluster_free gotk3-0.6.2/cairo/translations.go000066400000000000000000000046301431157473000167230ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" // Translate is a wrapper around cairo_translate. func (v *Context) Translate(tx, ty float64) { C.cairo_translate(v.native(), C.double(tx), C.double(ty)) } // Scale is a wrapper around cairo_scale. func (v *Context) Scale(sx, sy float64) { C.cairo_scale(v.native(), C.double(sx), C.double(sy)) } // Rotate is a wrapper around cairo_rotate. func (v *Context) Rotate(angle float64) { C.cairo_rotate(v.native(), C.double(angle)) } // Transform is a wrapper around cairo_transform. func (v *Context) Transform(matrix *Matrix) { C.cairo_transform(v.native(), matrix.native()) } // SetMatrix is a wrapper around cairo_set_matrix. func (v *Context) SetMatrix(matrix *Matrix) { C.cairo_set_matrix(v.native(), matrix.native()) } // GetMatrix is a wrapper around cairo_get_matrix. func (v *Context) GetMatrix() *Matrix { var matrix C.cairo_matrix_t C.cairo_get_matrix(v.native(), &matrix) return &Matrix{ Xx: float64(matrix.xx), Yx: float64(matrix.yx), Xy: float64(matrix.xy), Yy: float64(matrix.yy), X0: float64(matrix.x0), Y0: float64(matrix.y0), } } // IdentityMatrix is a wrapper around cairo_identity_matrix(). // // Resets the current transformation matrix (CTM) by setting it equal to the // identity matrix. That is, the user-space and device-space axes will be // aligned and one user-space unit will transform to one device-space unit. func (v *Context) IdentityMatrix() { C.cairo_identity_matrix(v.native()) } // UserToDevice is a wrapper around cairo_user_to_device. func (v *Context) UserToDevice(x, y float64) (float64, float64) { C.cairo_user_to_device(v.native(), (*C.double)(&x), (*C.double)(&y)) return x, y } // UserToDeviceDistance is a wrapper around cairo_user_to_device_distance. func (v *Context) UserToDeviceDistance(dx, dy float64) (float64, float64) { C.cairo_user_to_device_distance(v.native(), (*C.double)(&dx), (*C.double)(&dy)) return dx, dy } // DeviceToUser is a wrapper around cairo_device_to_user. func (v *Context) DeviceToUser(x, y float64) (float64, float64) { C.cairo_device_to_user(v.native(), (*C.double)(&x), (*C.double)(&y)) return x, y } // DeviceToUserDistance is a wrapper around cairo_device_to_user_distance. func (v *Context) DeviceToUserDistance(x, y float64) (float64, float64) { C.cairo_device_to_user_distance(v.native(), (*C.double)(&x), (*C.double)(&y)) return x, y } gotk3-0.6.2/cairo/util.go000066400000000000000000000004441431157473000151560ustar00rootroot00000000000000package cairo // #include // #include // #include import "C" func cairobool(b bool) C.cairo_bool_t { if b { return C.cairo_bool_t(1) } return C.cairo_bool_t(0) } func gobool(b C.cairo_bool_t) bool { if b != 0 { return true } return false } gotk3-0.6.2/gdk/000077500000000000000000000000001431157473000133205ustar00rootroot00000000000000gotk3-0.6.2/gdk/gdk.go000066400000000000000000002123551431157473000144240ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // Go bindings for GDK 3. Supports version 3.6 and later. package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" import "C" import ( "errors" "runtime" "unsafe" "github.com/gotk3/gotk3/cairo" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.gdk_drag_action_get_type()), marshalDragAction}, {glib.Type(C.gdk_colorspace_get_type()), marshalColorspace}, {glib.Type(C.gdk_event_type_get_type()), marshalEventType}, {glib.Type(C.gdk_interp_type_get_type()), marshalInterpType}, {glib.Type(C.gdk_modifier_type_get_type()), marshalModifierType}, {glib.Type(C.gdk_event_mask_get_type()), marshalEventMask}, {glib.Type(C.gdk_gravity_get_type()), marshalGravity}, {glib.Type(C.gdk_visual_type_get_type()), marshalVisualType}, // Objects/Interfaces {glib.Type(C.gdk_device_get_type()), marshalDevice}, {glib.Type(C.gdk_display_manager_get_type()), marshalDisplayManager}, {glib.Type(C.gdk_cursor_get_type()), marshalCursor}, {glib.Type(C.gdk_device_manager_get_type()), marshalDeviceManager}, {glib.Type(C.gdk_display_get_type()), marshalDisplay}, {glib.Type(C.gdk_drag_context_get_type()), marshalDragContext}, {glib.Type(C.gdk_rgba_get_type()), marshalRGBA}, {glib.Type(C.gdk_screen_get_type()), marshalScreen}, {glib.Type(C.gdk_visual_get_type()), marshalVisual}, {glib.Type(C.gdk_window_get_type()), marshalWindow}, // Boxed {glib.Type(C.gdk_event_get_type()), marshalEvent}, } glib.RegisterGValueMarshalers(tm) } /* * Type conversions */ func gbool(b bool) C.gboolean { if b { return C.gboolean(1) } return C.gboolean(0) } func gobool(b C.gboolean) bool { if b != 0 { return true } return false } /* * Unexported vars */ var nilPtrErr = errors.New("cgo returned unexpected nil pointer") /* * Constants */ // VisualType is a representation of GDK's GdkVisualType. type VisualType int const ( VISUAL_STATIC_GRAY VisualType = C.GDK_VISUAL_STATIC_GRAY VISUAL_GRAYSCALE VisualType = C.GDK_VISUAL_GRAYSCALE VISUAL_STATIC_COLOR VisualType = C.GDK_VISUAL_STATIC_COLOR ISUAL_PSEUDO_COLOR VisualType = C.GDK_VISUAL_PSEUDO_COLOR VISUAL_TRUE_COLOR VisualType = C.GDK_VISUAL_TRUE_COLOR VISUAL_DIRECT_COLOR VisualType = C.GDK_VISUAL_DIRECT_COLOR ) func marshalVisualType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return VisualType(c), nil } // DragAction is a representation of GDK's GdkDragAction. type DragAction int const ( ACTION_DEFAULT DragAction = C.GDK_ACTION_DEFAULT ACTION_COPY DragAction = C.GDK_ACTION_COPY ACTION_MOVE DragAction = C.GDK_ACTION_MOVE ACTION_LINK DragAction = C.GDK_ACTION_LINK ACTION_PRIVATE DragAction = C.GDK_ACTION_PRIVATE ACTION_ASK DragAction = C.GDK_ACTION_ASK ) func marshalDragAction(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return DragAction(c), nil } // Colorspace is a representation of GDK's GdkColorspace. type Colorspace int const ( COLORSPACE_RGB Colorspace = C.GDK_COLORSPACE_RGB ) func marshalColorspace(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Colorspace(c), nil } // InterpType is a representation of GDK's GdkInterpType. type InterpType int const ( INTERP_NEAREST InterpType = C.GDK_INTERP_NEAREST INTERP_TILES InterpType = C.GDK_INTERP_TILES INTERP_BILINEAR InterpType = C.GDK_INTERP_BILINEAR INTERP_HYPER InterpType = C.GDK_INTERP_HYPER ) func marshalInterpType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return InterpType(c), nil } // ModifierType is a representation of GDK's GdkModifierType. type ModifierType uint const ( SHIFT_MASK ModifierType = C.GDK_SHIFT_MASK LOCK_MASK = C.GDK_LOCK_MASK CONTROL_MASK = C.GDK_CONTROL_MASK MOD1_MASK = C.GDK_MOD1_MASK MOD2_MASK = C.GDK_MOD2_MASK MOD3_MASK = C.GDK_MOD3_MASK MOD4_MASK = C.GDK_MOD4_MASK MOD5_MASK = C.GDK_MOD5_MASK BUTTON1_MASK = C.GDK_BUTTON1_MASK BUTTON2_MASK = C.GDK_BUTTON2_MASK BUTTON3_MASK = C.GDK_BUTTON3_MASK BUTTON4_MASK = C.GDK_BUTTON4_MASK BUTTON5_MASK = C.GDK_BUTTON5_MASK SUPER_MASK = C.GDK_SUPER_MASK HYPER_MASK = C.GDK_HYPER_MASK META_MASK = C.GDK_META_MASK RELEASE_MASK = C.GDK_RELEASE_MASK MODIFIER_MASK = C.GDK_MODIFIER_MASK ) func marshalModifierType(p uintptr) (interface{}, error) { c := C.g_value_get_flags((*C.GValue)(unsafe.Pointer(p))) return ModifierType(c), nil } // Selections const ( SELECTION_PRIMARY Atom = 1 SELECTION_SECONDARY Atom = 2 SELECTION_CLIPBOARD Atom = 69 TARGET_BITMAP Atom = 5 TARGET_COLORMAP Atom = 7 TARGET_DRAWABLE Atom = 17 TARGET_PIXMAP Atom = 20 TARGET_STRING Atom = 31 SELECTION_TYPE_ATOM Atom = 4 SELECTION_TYPE_BITMAP Atom = 5 SELECTION_TYPE_COLORMAP Atom = 7 SELECTION_TYPE_DRAWABLE Atom = 17 SELECTION_TYPE_INTEGER Atom = 19 SELECTION_TYPE_PIXMAP Atom = 20 SELECTION_TYPE_WINDOW Atom = 33 SELECTION_TYPE_STRING Atom = 31 ) // added by terrak // EventMask is a representation of GDK's GdkEventMask. type EventMask int const ( EXPOSURE_MASK EventMask = C.GDK_EXPOSURE_MASK POINTER_MOTION_MASK EventMask = C.GDK_POINTER_MOTION_MASK POINTER_MOTION_HINT_MASK EventMask = C.GDK_POINTER_MOTION_HINT_MASK BUTTON_MOTION_MASK EventMask = C.GDK_BUTTON_MOTION_MASK BUTTON1_MOTION_MASK EventMask = C.GDK_BUTTON1_MOTION_MASK BUTTON2_MOTION_MASK EventMask = C.GDK_BUTTON2_MOTION_MASK BUTTON3_MOTION_MASK EventMask = C.GDK_BUTTON3_MOTION_MASK BUTTON_PRESS_MASK EventMask = C.GDK_BUTTON_PRESS_MASK BUTTON_RELEASE_MASK EventMask = C.GDK_BUTTON_RELEASE_MASK KEY_PRESS_MASK EventMask = C.GDK_KEY_PRESS_MASK KEY_RELEASE_MASK EventMask = C.GDK_KEY_RELEASE_MASK ENTER_NOTIFY_MASK EventMask = C.GDK_ENTER_NOTIFY_MASK LEAVE_NOTIFY_MASK EventMask = C.GDK_LEAVE_NOTIFY_MASK FOCUS_CHANGE_MASK EventMask = C.GDK_FOCUS_CHANGE_MASK STRUCTURE_MASK EventMask = C.GDK_STRUCTURE_MASK PROPERTY_CHANGE_MASK EventMask = C.GDK_PROPERTY_CHANGE_MASK VISIBILITY_NOTIFY_MASK EventMask = C.GDK_VISIBILITY_NOTIFY_MASK PROXIMITY_IN_MASK EventMask = C.GDK_PROXIMITY_IN_MASK PROXIMITY_OUT_MASK EventMask = C.GDK_PROXIMITY_OUT_MASK SUBSTRUCTURE_MASK EventMask = C.GDK_SUBSTRUCTURE_MASK SCROLL_MASK EventMask = C.GDK_SCROLL_MASK TOUCH_MASK EventMask = C.GDK_TOUCH_MASK SMOOTH_SCROLL_MASK EventMask = C.GDK_SMOOTH_SCROLL_MASK ALL_EVENTS_MASK EventMask = C.GDK_ALL_EVENTS_MASK ) func marshalEventMask(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return EventMask(c), nil } // added by lazyshot // ScrollDirection is a representation of GDK's GdkScrollDirection type ScrollDirection int const ( SCROLL_UP ScrollDirection = C.GDK_SCROLL_UP SCROLL_DOWN ScrollDirection = C.GDK_SCROLL_DOWN SCROLL_LEFT ScrollDirection = C.GDK_SCROLL_LEFT SCROLL_RIGHT ScrollDirection = C.GDK_SCROLL_RIGHT SCROLL_SMOOTH ScrollDirection = C.GDK_SCROLL_SMOOTH ) // WindowEdge is a representation of GDK's GdkWindowEdge type WindowEdge int const ( WINDOW_EDGE_NORTH_WEST WindowEdge = C.GDK_WINDOW_EDGE_NORTH_WEST WINDOW_EDGE_NORTH WindowEdge = C.GDK_WINDOW_EDGE_NORTH WINDOW_EDGE_NORTH_EAST WindowEdge = C.GDK_WINDOW_EDGE_NORTH_EAST WINDOW_EDGE_WEST WindowEdge = C.GDK_WINDOW_EDGE_WEST WINDOW_EDGE_EAST WindowEdge = C.GDK_WINDOW_EDGE_EAST WINDOW_EDGE_SOUTH_WEST WindowEdge = C.GDK_WINDOW_EDGE_SOUTH_WEST WINDOW_EDGE_SOUTH WindowEdge = C.GDK_WINDOW_EDGE_SOUTH WINDOW_EDGE_SOUTH_EAST WindowEdge = C.GDK_WINDOW_EDGE_SOUTH_EAST ) // WindowState is a representation of GDK's GdkWindowState type WindowState int const ( WINDOW_STATE_WITHDRAWN WindowState = C.GDK_WINDOW_STATE_WITHDRAWN WINDOW_STATE_ICONIFIED WindowState = C.GDK_WINDOW_STATE_ICONIFIED WINDOW_STATE_MAXIMIZED WindowState = C.GDK_WINDOW_STATE_MAXIMIZED WINDOW_STATE_STICKY WindowState = C.GDK_WINDOW_STATE_STICKY WINDOW_STATE_FULLSCREEN WindowState = C.GDK_WINDOW_STATE_FULLSCREEN WINDOW_STATE_ABOVE WindowState = C.GDK_WINDOW_STATE_ABOVE WINDOW_STATE_BELOW WindowState = C.GDK_WINDOW_STATE_BELOW WINDOW_STATE_FOCUSED WindowState = C.GDK_WINDOW_STATE_FOCUSED WINDOW_STATE_TILED WindowState = C.GDK_WINDOW_STATE_TILED ) // WindowTypeHint is a representation of GDK's GdkWindowTypeHint type WindowTypeHint int const ( WINDOW_TYPE_HINT_NORMAL WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_NORMAL WINDOW_TYPE_HINT_DIALOG WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_DIALOG WINDOW_TYPE_HINT_MENU WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_MENU WINDOW_TYPE_HINT_TOOLBAR WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_TOOLBAR WINDOW_TYPE_HINT_SPLASHSCREEN WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_SPLASHSCREEN WINDOW_TYPE_HINT_UTILITY WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_UTILITY WINDOW_TYPE_HINT_DOCK WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_DOCK WINDOW_TYPE_HINT_DESKTOP WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_DESKTOP WINDOW_TYPE_HINT_DROPDOWN_MENU WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU WINDOW_TYPE_HINT_POPUP_MENU WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_POPUP_MENU WINDOW_TYPE_HINT_TOOLTIP WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_TOOLTIP WINDOW_TYPE_HINT_NOTIFICATION WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_NOTIFICATION WINDOW_TYPE_HINT_COMBO WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_COMBO WINDOW_TYPE_HINT_DND WindowTypeHint = C.GDK_WINDOW_TYPE_HINT_DND ) // WindowHints is a representation of GDK's GdkWindowHints type WindowHints int const ( HINT_POS WindowHints = C.GDK_HINT_POS HINT_MIN_SIZE WindowHints = C.GDK_HINT_MIN_SIZE HINT_MAX_SIZE WindowHints = C.GDK_HINT_MAX_SIZE HINT_BASE_SIZE WindowHints = C.GDK_HINT_BASE_SIZE HINT_ASPECT WindowHints = C.GDK_HINT_ASPECT HINT_RESIZE_INC WindowHints = C.GDK_HINT_RESIZE_INC HINT_WIN_GRAVITY WindowHints = C.GDK_HINT_WIN_GRAVITY HINT_USER_POS WindowHints = C.GDK_HINT_USER_POS HINT_USER_SIZE WindowHints = C.GDK_HINT_USER_SIZE ) // CURRENT_TIME is a representation of GDK_CURRENT_TIME const CURRENT_TIME = C.GDK_CURRENT_TIME // GrabStatus is a representation of GdkGrabStatus type GrabStatus int const ( GRAB_SUCCESS GrabStatus = C.GDK_GRAB_SUCCESS GRAB_ALREADY_GRABBED GrabStatus = C.GDK_GRAB_ALREADY_GRABBED GRAB_INVALID_TIME GrabStatus = C.GDK_GRAB_INVALID_TIME GRAB_NOT_VIEWABLE GrabStatus = C.GDK_GRAB_NOT_VIEWABLE GRAB_FROZEN GrabStatus = C.GDK_GRAB_FROZEN ) // GrabOwnership is a representation of GdkGrabOwnership type GrabOwnership int const ( OWNERSHIP_NONE GrabOwnership = C.GDK_OWNERSHIP_NONE OWNERSHIP_WINDOW GrabOwnership = C.GDK_OWNERSHIP_WINDOW OWNERSHIP_APPLICATION GrabOwnership = C.GDK_OWNERSHIP_APPLICATION ) // TODO: // GdkInputSource // GdkInputMode // GdkAxisUse // GdkAxisFlags // GdkDeviceToolType // DeviceType is a representation of GdkDeviceType type DeviceType int const ( DEVICE_TYPE_MASTER DeviceType = C.GDK_DEVICE_TYPE_MASTER DEVICE_TYPE_SLAVE DeviceType = C.GDK_DEVICE_TYPE_SLAVE DEVICE_TYPE_FLOATING DeviceType = C.GDK_DEVICE_TYPE_FLOATING ) // TODO: // GdkColorspace // GdkVisualType // GdkTimeCoord // EventPropagation constants const ( GDK_EVENT_PROPAGATE bool = C.GDK_EVENT_PROPAGATE != 0 GDK_EVENT_STOP bool = C.GDK_EVENT_STOP != 0 ) // Button constants type Button uint const ( BUTTON_PRIMARY Button = C.GDK_BUTTON_PRIMARY BUTTON_MIDDLE Button = C.GDK_BUTTON_MIDDLE BUTTON_SECONDARY Button = C.GDK_BUTTON_SECONDARY ) // CrossingMode is a representation of GDK's GdkCrossingMode. type CrossingMode int const ( CROSSING_NORMAL CrossingMode = C.GDK_CROSSING_NORMAL CROSSING_GRAB CrossingMode = C.GDK_CROSSING_GRAB CROSSING_UNGRAB CrossingMode = C.GDK_CROSSING_UNGRAB CROSSING_GTK_GRAB CrossingMode = C.GDK_CROSSING_GTK_GRAB CROSSING_GTK_UNGRAB CrossingMode = C.GDK_CROSSING_GTK_UNGRAB CROSSING_STATE_CHANGED CrossingMode = C.GDK_CROSSING_STATE_CHANGED CROSSING_TOUCH_BEGIN CrossingMode = C.GDK_CROSSING_TOUCH_BEGIN CROSSING_TOUCH_END CrossingMode = C.GDK_CROSSING_TOUCH_END CROSSING_DEVICE_SWITCH CrossingMode = C.GDK_CROSSING_DEVICE_SWITCH ) // NotifyType is a representation of GDK's GdkNotifyType. type NotifyType int const ( NOTIFY_ANCESTOR NotifyType = C.GDK_NOTIFY_ANCESTOR NOTIFY_VIRTUAL NotifyType = C.GDK_NOTIFY_VIRTUAL NOTIFY_INFERIOR NotifyType = C.GDK_NOTIFY_INFERIOR NOTIFY_NONLINEAR NotifyType = C.GDK_NOTIFY_NONLINEAR NOTIFY_NONLINEAR_VIRTUAL NotifyType = C.GDK_NOTIFY_NONLINEAR_VIRTUAL NOTIFY_UNKNOWN NotifyType = C.GDK_NOTIFY_UNKNOWN ) // EventType is a representation of GDK's GdkEventType. // Do not confuse these event types with the signals that GTK+ widgets emit type EventType int func marshalEventType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return EventType(c), nil } const ( EVENT_NOTHING EventType = C.GDK_NOTHING EVENT_DELETE EventType = C.GDK_DELETE EVENT_DESTROY EventType = C.GDK_DESTROY EVENT_EXPOSE EventType = C.GDK_EXPOSE EVENT_MOTION_NOTIFY EventType = C.GDK_MOTION_NOTIFY EVENT_BUTTON_PRESS EventType = C.GDK_BUTTON_PRESS EVENT_2BUTTON_PRESS EventType = C.GDK_2BUTTON_PRESS EVENT_DOUBLE_BUTTON_PRESS EventType = C.GDK_DOUBLE_BUTTON_PRESS EVENT_3BUTTON_PRESS EventType = C.GDK_3BUTTON_PRESS EVENT_TRIPLE_BUTTON_PRESS EventType = C.GDK_TRIPLE_BUTTON_PRESS EVENT_BUTTON_RELEASE EventType = C.GDK_BUTTON_RELEASE EVENT_KEY_PRESS EventType = C.GDK_KEY_PRESS EVENT_KEY_RELEASE EventType = C.GDK_KEY_RELEASE EVENT_ENTER_NOTIFY EventType = C.GDK_ENTER_NOTIFY EVENT_LEAVE_NOTIFY EventType = C.GDK_LEAVE_NOTIFY EVENT_FOCUS_CHANGE EventType = C.GDK_FOCUS_CHANGE EVENT_CONFIGURE EventType = C.GDK_CONFIGURE EVENT_MAP EventType = C.GDK_MAP EVENT_UNMAP EventType = C.GDK_UNMAP EVENT_PROPERTY_NOTIFY EventType = C.GDK_PROPERTY_NOTIFY EVENT_SELECTION_CLEAR EventType = C.GDK_SELECTION_CLEAR EVENT_SELECTION_REQUEST EventType = C.GDK_SELECTION_REQUEST EVENT_SELECTION_NOTIFY EventType = C.GDK_SELECTION_NOTIFY EVENT_PROXIMITY_IN EventType = C.GDK_PROXIMITY_IN EVENT_PROXIMITY_OUT EventType = C.GDK_PROXIMITY_OUT EVENT_DRAG_ENTER EventType = C.GDK_DRAG_ENTER EVENT_DRAG_LEAVE EventType = C.GDK_DRAG_LEAVE EVENT_DRAG_MOTION EventType = C.GDK_DRAG_MOTION EVENT_DRAG_STATUS EventType = C.GDK_DRAG_STATUS EVENT_DROP_START EventType = C.GDK_DROP_START EVENT_DROP_FINISHED EventType = C.GDK_DROP_FINISHED EVENT_CLIENT_EVENT EventType = C.GDK_CLIENT_EVENT EVENT_VISIBILITY_NOTIFY EventType = C.GDK_VISIBILITY_NOTIFY EVENT_SCROLL EventType = C.GDK_SCROLL EVENT_WINDOW_STATE EventType = C.GDK_WINDOW_STATE EVENT_SETTING EventType = C.GDK_SETTING EVENT_OWNER_CHANGE EventType = C.GDK_OWNER_CHANGE EVENT_GRAB_BROKEN EventType = C.GDK_GRAB_BROKEN EVENT_DAMAGE EventType = C.GDK_DAMAGE EVENT_TOUCH_BEGIN EventType = C.GDK_TOUCH_BEGIN EVENT_TOUCH_UPDATE EventType = C.GDK_TOUCH_UPDATE EVENT_TOUCH_END EventType = C.GDK_TOUCH_END EVENT_TOUCH_CANCEL EventType = C.GDK_TOUCH_CANCEL EVENT_LAST EventType = C.GDK_EVENT_LAST ) /* * General */ // TODO: // gdk_init(). // gdk_init_check(). // gdk_parse_args(). // gdk_get_display_arg_name(). // gdk_notify_startup_complete(). // gdk_notify_startup_complete_with_id(). // gdk_get_program_class(). // gdk_set_program_class(). // gdk_get_display(). deprecated since version 3.8 // gdk_flush(). deprecated // gdk_screen_width(). deprecated since version 3.22 // gdk_screen_height(). deprecated since version 3.22 // gdk_screen_width_mm(). deprecated since version 3.22 // gdk_screen_height_mm(). deprecated since version 3.22 // gdk_set_double_click_time(). deprecated // gdk_beep(). deprecated // gdk_error_trap_push(). deprecated // gdk_error_trap_pop(). deprecated // gdk_error_trap_pop_ignored(). deprecated // SetAllowedBackends is a wrapper around gdk_set_allowed_backends func SetAllowedBackends(backends string) { cstr := C.CString(backends) defer C.free(unsafe.Pointer(cstr)) C.gdk_set_allowed_backends((*C.gchar)(cstr)) } /* * GdkAtom */ // Atom is a representation of GDK's GdkAtom. type Atom uintptr // native returns the underlying GdkAtom. func (v Atom) native() C.GdkAtom { return C.toGdkAtom(unsafe.Pointer(uintptr(v))) } func (v Atom) Name() string { c := C.gdk_atom_name(v.native()) defer C.g_free(C.gpointer(c)) return C.GoString((*C.char)(c)) } // GdkAtomIntern is a wrapper around gdk_atom_intern func GdkAtomIntern(atomName string, onlyIfExists bool) Atom { cstr := C.CString(atomName) defer C.free(unsafe.Pointer(cstr)) c := C.gdk_atom_intern((*C.gchar)(cstr), gbool(onlyIfExists)) return Atom(uintptr(unsafe.Pointer(c))) } /* * GdkDevice */ // Device is a representation of GDK's GdkDevice. type Device struct { *glib.Object } // native returns a pointer to the underlying GdkDevice. func (v *Device) native() *C.GdkDevice { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkDevice(p) } // Native returns a pointer to the underlying GdkDevice. func (v *Device) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalDevice(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Device{obj}, nil } func toDevice(d *C.GdkDevice) (*Device, error) { obj := &glib.Object{glib.ToGObject(unsafe.Pointer(d))} return &Device{obj}, nil } func (v *Device) GetPosition(screen **Screen, x, y *int) error { cs := (**C.GdkScreen)(unsafe.Pointer(uintptr(0))) if screen != nil { var cval *C.GdkScreen cs = &cval } cx := (*C.gint)(unsafe.Pointer(uintptr(0))) if x != nil { var cval C.gint cx = &cval } cy := (*C.gint)(unsafe.Pointer(uintptr(0))) if y != nil { var cval C.gint cy = &cval } C.gdk_device_get_position(v.native(), cs, cx, cy) if cs != (**C.GdkScreen)(unsafe.Pointer(uintptr(0))) { ms, err := toScreen(*cs) if err != nil { return err } *screen = ms } if cx != (*C.gint)(unsafe.Pointer(uintptr(0))) { *x = int(*cx) } if cy != (*C.gint)(unsafe.Pointer(uintptr(0))) { *y = int(*cy) } return nil } // TODO: // gdk_device_get_name(). // gdk_device_get_source(). // gdk_device_set_mode(). // gdk_device_get_mode(). // gdk_device_set_key(). // gdk_device_get_key(). // gdk_device_set_axis_use(). // gdk_device_get_axis_use(). // gdk_device_get_associated_device(). // gdk_device_list_slave_devices(). // gdk_device_get_device_type(). // gdk_device_get_display(). // gdk_device_get_has_cursor(). // gdk_device_get_n_axes(). // gdk_device_get_n_keys(). // gdk_device_warp(). // gdk_device_get_state(). // gdk_device_get_window_at_position(). // gdk_device_get_window_at_position_double(). // gdk_device_get_history(). // gdk_device_free_history(). // gdk_device_get_axis(). // gdk_device_list_axes(). // gdk_device_get_axis_value(). /* * GdkCursor */ // Cursor is a representation of GdkCursor. type Cursor struct { *glib.Object } // CursorNewFromName is a wrapper around gdk_cursor_new_from_name(). func CursorNewFromName(display *Display, name string) (*Cursor, error) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) c := C.gdk_cursor_new_from_name(display.native(), (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return &Cursor{glib.Take(unsafe.Pointer(c))}, nil } // native returns a pointer to the underlying GdkCursor. func (v *Cursor) native() *C.GdkCursor { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkCursor(p) } // Native returns a pointer to the underlying GdkCursor. func (v *Cursor) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalCursor(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Cursor{obj}, nil } /* * GdkDeviceManager */ // DeviceManager is a representation of GDK's GdkDeviceManager. type DeviceManager struct { *glib.Object } // native returns a pointer to the underlying GdkDeviceManager. func (v *DeviceManager) native() *C.GdkDeviceManager { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkDeviceManager(p) } // Native returns a pointer to the underlying GdkDeviceManager. func (v *DeviceManager) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalDeviceManager(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &DeviceManager{obj}, nil } // GetDisplay() is a wrapper around gdk_device_manager_get_display(). func (v *DeviceManager) GetDisplay() (*Display, error) { c := C.gdk_device_manager_get_display(v.native()) if c == nil { return nil, nilPtrErr } return &Display{glib.Take(unsafe.Pointer(c))}, nil } /* * GdkDisplay */ // Display is a representation of GDK's GdkDisplay. type Display struct { *glib.Object } // native returns a pointer to the underlying GdkDisplay. func (v *Display) native() *C.GdkDisplay { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkDisplay(p) } // Native returns a pointer to the underlying GdkDisplay. func (v *Display) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalDisplay(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Display{obj}, nil } func toDisplay(s *C.GdkDisplay) (*Display, error) { if s == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(s))} return &Display{obj}, nil } // DisplayOpen is a wrapper around gdk_display_open(). func DisplayOpen(displayName string) (*Display, error) { cstr := C.CString(displayName) defer C.free(unsafe.Pointer(cstr)) c := C.gdk_display_open((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return &Display{glib.Take(unsafe.Pointer(c))}, nil } // DisplayGetDefault is a wrapper around gdk_display_get_default(). func DisplayGetDefault() (*Display, error) { c := C.gdk_display_get_default() if c == nil { return nil, nilPtrErr } return &Display{glib.Take(unsafe.Pointer(c))}, nil } // GetName is a wrapper around gdk_display_get_name(). func (v *Display) GetName() (string, error) { c := C.gdk_display_get_name(v.native()) if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // GetDefaultScreen is a wrapper around gdk_display_get_default_screen(). func (v *Display) GetDefaultScreen() (*Screen, error) { c := C.gdk_display_get_default_screen(v.native()) if c == nil { return nil, nilPtrErr } return &Screen{glib.Take(unsafe.Pointer(c))}, nil } // DeviceIsGrabbed is a wrapper around gdk_display_device_is_grabbed(). func (v *Display) DeviceIsGrabbed(device *Device) bool { c := C.gdk_display_device_is_grabbed(v.native(), device.native()) return gobool(c) } // Beep is a wrapper around gdk_display_beep(). func (v *Display) Beep() { C.gdk_display_beep(v.native()) } // Sync is a wrapper around gdk_display_sync(). func (v *Display) Sync() { C.gdk_display_sync(v.native()) } // Flush is a wrapper around gdk_display_flush(). func (v *Display) Flush() { C.gdk_display_flush(v.native()) } // Close is a wrapper around gdk_display_close(). func (v *Display) Close() { C.gdk_display_close(v.native()) } // IsClosed is a wrapper around gdk_display_is_closed(). func (v *Display) IsClosed() bool { c := C.gdk_display_is_closed(v.native()) return gobool(c) } // GetEvent is a wrapper around gdk_display_get_event(). func (v *Display) GetEvent() (*Event, error) { c := C.gdk_display_get_event(v.native()) if c == nil { return nil, nilPtrErr } //The finalizer is not on the glib.Object but on the event. e := &Event{c} runtime.SetFinalizer(e, func(v *Event) { glib.FinalizerStrategy(v.free) }) return e, nil } // PeekEvent is a wrapper around gdk_display_peek_event(). func (v *Display) PeekEvent() (*Event, error) { c := C.gdk_display_peek_event(v.native()) if c == nil { return nil, nilPtrErr } //The finalizer is not on the glib.Object but on the event. e := &Event{c} runtime.SetFinalizer(e, func(v *Event) { glib.FinalizerStrategy(v.free) }) return e, nil } // PutEvent is a wrapper around gdk_display_put_event(). func (v *Display) PutEvent(event *Event) { C.gdk_display_put_event(v.native(), event.native()) } // HasPending is a wrapper around gdk_display_has_pending(). func (v *Display) HasPending() bool { c := C.gdk_display_has_pending(v.native()) return gobool(c) } // SetDoubleClickTime is a wrapper around gdk_display_set_double_click_time(). func (v *Display) SetDoubleClickTime(msec uint) { C.gdk_display_set_double_click_time(v.native(), C.guint(msec)) } // SetDoubleClickDistance is a wrapper around gdk_display_set_double_click_distance(). func (v *Display) SetDoubleClickDistance(distance uint) { C.gdk_display_set_double_click_distance(v.native(), C.guint(distance)) } // SupportsColorCursor is a wrapper around gdk_display_supports_cursor_color(). func (v *Display) SupportsColorCursor() bool { c := C.gdk_display_supports_cursor_color(v.native()) return gobool(c) } // SupportsCursorAlpha is a wrapper around gdk_display_supports_cursor_alpha(). func (v *Display) SupportsCursorAlpha() bool { c := C.gdk_display_supports_cursor_alpha(v.native()) return gobool(c) } // GetDefaultCursorSize is a wrapper around gdk_display_get_default_cursor_size(). func (v *Display) GetDefaultCursorSize() uint { c := C.gdk_display_get_default_cursor_size(v.native()) return uint(c) } // GetMaximalCursorSize is a wrapper around gdk_display_get_maximal_cursor_size(). func (v *Display) GetMaximalCursorSize() (width, height uint) { var w, h C.guint C.gdk_display_get_maximal_cursor_size(v.native(), &w, &h) return uint(w), uint(h) } // GetDefaultGroup is a wrapper around gdk_display_get_default_group(). func (v *Display) GetDefaultGroup() (*Window, error) { c := C.gdk_display_get_default_group(v.native()) if c == nil { return nil, nilPtrErr } return &Window{glib.Take(unsafe.Pointer(c))}, nil } // SupportsSelectionNotification is a wrapper around gdk_display_supports_selection_notification(). func (v *Display) SupportsSelectionNotification() bool { c := C.gdk_display_supports_selection_notification(v.native()) return gobool(c) } // RequestSelectionNotification is a wrapper around gdk_display_request_selection_notification(). func (v *Display) RequestSelectionNotification(selection Atom) bool { c := C.gdk_display_request_selection_notification(v.native(), selection.native()) return gobool(c) } // SupportsClipboardPersistence is a wrapper around gdk_display_supports_clipboard_persistence(). func (v *Display) SupportsClipboardPersistence() bool { c := C.gdk_display_supports_clipboard_persistence(v.native()) return gobool(c) } // TODO: // gdk_display_store_clipboard(). // func (v *Display) StoreClipboard(clipboardWindow *Window, time uint32, targets ...Atom) { // panic("Not implemented") // } // SupportsShapes is a wrapper around gdk_display_supports_shapes(). func (v *Display) SupportsShapes() bool { c := C.gdk_display_supports_shapes(v.native()) return gobool(c) } // SupportsInputShapes is a wrapper around gdk_display_supports_input_shapes(). func (v *Display) SupportsInputShapes() bool { c := C.gdk_display_supports_input_shapes(v.native()) return gobool(c) } // TODO: // gdk_display_get_app_launch_context(). // func (v *Display) GetAppLaunchContext() { // panic("Not implemented") // } // NotifyStartupComplete is a wrapper around gdk_display_notify_startup_complete(). func (v *Display) NotifyStartupComplete(startupID string) { cstr := C.CString(startupID) defer C.free(unsafe.Pointer(cstr)) C.gdk_display_notify_startup_complete(v.native(), (*C.gchar)(cstr)) } /* * GdkDisplayManager */ // DisplayManager is a representation of GDK's GdkDisplayManager. type DisplayManager struct { *glib.Object } // native returns a pointer to the underlying GdkDisplayManager. func (v *DisplayManager) native() *C.GdkDisplayManager { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkDisplayManager(p) } // Native returns a pointer to the underlying GdkDisplayManager. func (v *DisplayManager) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalDisplayManager(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &DisplayManager{obj}, nil } func wrapDisplayManager(obj *glib.Object) *DisplayManager { if obj == nil { return nil } return &DisplayManager{obj} } // DisplayManagerGet is a wrapper around gdk_display_manager_get(). func DisplayManagerGet() (*DisplayManager, error) { c := C.gdk_display_manager_get() if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &DisplayManager{obj}, nil } // GetDefaultDisplay is a wrapper around gdk_display_manager_get_default_display(). func (v *DisplayManager) GetDefaultDisplay() (*Display, error) { c := C.gdk_display_manager_get_default_display(v.native()) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Display{obj}, nil } // SetDefaultDisplay is a wrapper around gdk_display_manager_set_default_display(). func (v *DisplayManager) SetDefaultDisplay(display *Display) { C.gdk_display_manager_set_default_display(v.native(), display.native()) } // ListDisplays is a wrapper around gdk_display_manager_list_displays(). func (v *DisplayManager) ListDisplays() *[]Display { clist := C.gdk_display_manager_list_displays(v.native()) if clist == nil { return nil } dlist := glib.WrapSList(uintptr(unsafe.Pointer(clist))) defer dlist.Free() var displays = make([]Display, 0, dlist.Length()) for ; dlist.DataRaw() != nil; dlist = dlist.Next() { d := (*C.GdkDisplay)(dlist.DataRaw()) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(d))} displays = append(displays, Display{obj}) } return &displays } // OpenDisplay is a representation of gdk_display_manager_open_display(). func (v *DisplayManager) OpenDisplay(name string) (*Display, error) { cstr := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr)) c := C.gdk_display_manager_open_display(v.native(), cstr) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Display{obj}, nil } /* * GdkKeymap */ type Keymap struct { *glib.Object } // native returns a pointer to the underlying GdkKeymap. func (v *Keymap) native() *C.GdkKeymap { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkKeymap(p) } // Native returns a pointer to the underlying GdkKeymap. func (v *Keymap) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalKeymap(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Keymap{obj}, nil } func wrapKeymap(obj *glib.Object) *Keymap { return &Keymap{obj} } // GetKeymap is a wrapper around gdk_keymap_get_for_display(). func (v *Display) GetKeymap() (*Keymap, error) { c := C.gdk_keymap_get_for_display(v.native()) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Keymap{obj}, nil } // TranslateKeyboardState is a wrapper around gdk_keymap_translate_keyboard_state(). func (v *Keymap) TranslateKeyboardState(hardwareKeycode uint, state ModifierType, group int) (bool, *uint, *int, *int, *ModifierType) { var cKeyval C.guint var keyval *uint var cEffectiveGroup, cLevel C.gint var effectiveGroup, level *int var cConsumedModifiers C.GdkModifierType var consumedModifiers *ModifierType c := C.gdk_keymap_translate_keyboard_state( v.native(), C.guint(hardwareKeycode), C.GdkModifierType(state), C.gint(group), &cKeyval, &cEffectiveGroup, &cLevel, &cConsumedModifiers, ) if &cKeyval == nil { keyval = nil } else { *keyval = uint(cKeyval) } if &cEffectiveGroup == nil { effectiveGroup = nil } else { *effectiveGroup = int(cEffectiveGroup) } if &cLevel == nil { level = nil } else { *level = int(cLevel) } if &cConsumedModifiers == nil { consumedModifiers = nil } else { *consumedModifiers = ModifierType(cConsumedModifiers) } return gobool(c), keyval, effectiveGroup, level, consumedModifiers } // HaveBidiLayouts is a wrapper around gdk_keymap_have_bidi_layouts(). func (v *Keymap) HaveBidiLayouts() bool { return gobool(C.gdk_keymap_have_bidi_layouts(v.native())) } // GetCapsLockState is a wrapper around gdk_keymap_get_caps_lock_state(). func (v *Keymap) GetCapsLockState() bool { return gobool(C.gdk_keymap_get_caps_lock_state(v.native())) } // GetNumLockState is a wrapper around gdk_keymap_get_num_lock_state(). func (v *Keymap) GetNumLockState() bool { return gobool(C.gdk_keymap_get_num_lock_state(v.native())) } // GetModifierState is a wrapper around gdk_keymap_get_modifier_state(). func (v *Keymap) GetModifierState() uint { return uint(C.gdk_keymap_get_modifier_state(v.native())) } // TODO: // gdk_keymap_get_default(). deprecated since 3.22 // gdk_keymap_get_direction(). // gdk_keymap_add_virtual_modifiers(). // gdk_keymap_map_virtual_modifiers(). // gdk_keymap_get_modifier_mask(). /* * GdkKeymapKey */ // TODO: // gdk_keymap_lookup_key(). // gdk_keymap_get_entries_for_keyval(). // gdk_keymap_get_entries_for_keycode(). /* * GDK Keyval */ // KeyvalFromName() is a wrapper around gdk_keyval_from_name(). func KeyvalFromName(keyvalName string) uint { str := (*C.gchar)(C.CString(keyvalName)) defer C.free(unsafe.Pointer(str)) return uint(C.gdk_keyval_from_name(str)) } // KeyvalConvertCase is a wrapper around gdk_keyval_convert_case(). func KeyvalConvertCase(v uint) (lower, upper uint) { var l, u C.guint l = 0 u = 0 C.gdk_keyval_convert_case(C.guint(v), &l, &u) return uint(l), uint(u) } // KeyvalIsLower is a wrapper around gdk_keyval_is_lower(). func KeyvalIsLower(v uint) bool { return gobool(C.gdk_keyval_is_lower(C.guint(v))) } // KeyvalIsUpper is a wrapper around gdk_keyval_is_upper(). func KeyvalIsUpper(v uint) bool { return gobool(C.gdk_keyval_is_upper(C.guint(v))) } // KeyvalToLower is a wrapper around gdk_keyval_to_lower(). func KeyvalToLower(v uint) uint { return uint(C.gdk_keyval_to_lower(C.guint(v))) } // KeyvalToUpper is a wrapper around gdk_keyval_to_upper(). func KeyvalToUpper(v uint) uint { return uint(C.gdk_keyval_to_upper(C.guint(v))) } // KeyvalToUnicode is a wrapper around gdk_keyval_to_unicode(). func KeyvalToUnicode(v uint) rune { return rune(C.gdk_keyval_to_unicode(C.guint(v))) } // UnicodeToKeyval is a wrapper around gdk_unicode_to_keyval(). func UnicodeToKeyval(v rune) uint { return uint(C.gdk_unicode_to_keyval(C.guint32(v))) } // KeyValName is a wrapper around gdk_keyval_name(). func KeyValName(keyval uint) string { return C.GoString(C.gdk_keyval_name(C.guint(keyval))) } /* * GdkDragContext */ // DragContext is a representation of GDK's GdkDragContext. type DragContext struct { *glib.Object } // native returns a pointer to the underlying GdkDragContext. func (v *DragContext) native() *C.GdkDragContext { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkDragContext(p) } // Native returns a pointer to the underlying GdkDragContext. func (v *DragContext) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalDragContext(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &DragContext{obj}, nil } func (v *DragContext) ListTargets() *glib.List { clist := C.gdk_drag_context_list_targets(v.native()) if clist == nil { return nil } return glib.WrapList(uintptr(unsafe.Pointer(clist))) } /* * GdkEvent */ // Event is a representation of GDK's GdkEvent. type Event struct { GdkEvent *C.GdkEvent } // native returns a pointer to the underlying GdkEvent. func (v *Event) native() *C.GdkEvent { if v == nil { return nil } return v.GdkEvent } // Native returns a pointer to the underlying GdkEvent. func (v *Event) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalEvent(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return &Event{(*C.GdkEvent)(unsafe.Pointer(c))}, nil } func (v *Event) free() { C.gdk_event_free(v.native()) } /* * GdkEventButton */ // EventButton is a representation of GDK's GdkEventButton. type EventButton struct { *Event } func EventButtonNew() *EventButton { ee := (*C.GdkEvent)(unsafe.Pointer(&C.GdkEventButton{})) ev := Event{ee} return &EventButton{&ev} } // EventButtonNewFromEvent returns an EventButton from an Event. // // Using widget.Connect() for a key related signal such as // "button-press-event" results in a *Event being passed as // the callback's second argument. The argument is actually a // *EventButton. EventButtonNewFromEvent provides a means of creating // an EventKey from the Event. func EventButtonNewFromEvent(event *Event) *EventButton { ee := (*C.GdkEvent)(unsafe.Pointer(event.native())) ev := Event{ee} return &EventButton{&ev} } // Native returns a pointer to the underlying GdkEventButton. func (v *EventButton) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *EventButton) native() *C.GdkEventButton { return (*C.GdkEventButton)(unsafe.Pointer(v.Event.native())) } func (v *EventButton) X() float64 { c := v.native().x return float64(c) } func (v *EventButton) Y() float64 { c := v.native().y return float64(c) } // XRoot returns the x coordinate of the pointer relative to the root of the screen. func (v *EventButton) XRoot() float64 { c := v.native().x_root return float64(c) } // YRoot returns the y coordinate of the pointer relative to the root of the screen. func (v *EventButton) YRoot() float64 { c := v.native().y_root return float64(c) } func (v *EventButton) Button() Button { c := v.native().button return Button(c) } func (v *EventButton) State() uint { c := v.native().state return uint(c) } // Time returns the time of the event in milliseconds. func (v *EventButton) Time() uint32 { c := v.native().time return uint32(c) } func (v *EventButton) Type() EventType { c := v.native()._type return EventType(c) } func (v *EventButton) MotionVal() (float64, float64) { x := v.native().x y := v.native().y return float64(x), float64(y) } func (v *EventButton) MotionValRoot() (float64, float64) { x := v.native().x_root y := v.native().y_root return float64(x), float64(y) } /* * GdkEventTouch */ // EventTouch is a representation of GDK's GdkEventTouch type EventTouch struct { *Event } func EventTouchNew() *EventTouch { ee := (*C.GdkEvent)(unsafe.Pointer(&C.GdkEventTouch{})) ev := Event{ee} return &EventTouch{&ev} } // EventTouchNewFromEvent returns an EventTouch from an Event. // // Using widget.Connect() for a key related signal such as // "touch-event" results in a *Event being passed as // the callback's second argument. The argument is actually a // *EventTouch. EventTouchNewFromEvent provides a means of creating // an EventTouch from the Event. func EventTouchNewFromEvent(event *Event) *EventTouch { ee := (*C.GdkEvent)(unsafe.Pointer(event.native())) ev := Event{ee} return &EventTouch{&ev} } // Native returns a pointer to the underlying GdkEventTouch. func (v *EventTouch) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *EventTouch) native() *C.GdkEventTouch { return (*C.GdkEventTouch)(unsafe.Pointer(v.Event.native())) } func (v *EventTouch) Type() EventType { c := v.native()._type return EventType(c) } /*TODO GdkWindow *window */ func (v *EventTouch) Time() uint32 { c := v.native().time return uint32(c) } func (v *EventTouch) X() float64 { c := v.native().x return float64(c) } func (v *EventTouch) Y() float64 { c := v.native().y return float64(c) } /*TODO gdouble *axes */ func (v *EventTouch) State() uint { c := v.native().state return uint(c) } /*TODO GdkEventSequence *sequence */ func (v *EventTouch) EmulatingPointer() uint { c := v.native().emulating_pointer return uint(c) } /*TODO GdkDevice *device */ func (v *EventTouch) XRoot() float64 { c := v.native().x_root return float64(c) } func (v *EventTouch) YRoot() float64 { c := v.native().y_root return float64(c) } /* * GdkEventKey */ // EventKey is a representation of GDK's GdkEventKey. type EventKey struct { *Event } func EventKeyNew() *EventKey { ee := (*C.GdkEvent)(unsafe.Pointer(&C.GdkEventKey{})) ev := Event{ee} return &EventKey{&ev} } // EventKeyNewFromEvent returns an EventKey from an Event. // // Using widget.Connect() for a key related signal such as // "key-press-event" results in a *Event being passed as // the callback's second argument. The argument is actually a // *EventKey. EventKeyNewFromEvent provides a means of creating // an EventKey from the Event. func EventKeyNewFromEvent(event *Event) *EventKey { ee := (*C.GdkEvent)(unsafe.Pointer(event.native())) ev := Event{ee} return &EventKey{&ev} } // Native returns a pointer to the underlying GdkEventKey. func (v *EventKey) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *EventKey) native() *C.GdkEventKey { return (*C.GdkEventKey)(unsafe.Pointer(v.Event.native())) } func (v *EventKey) KeyVal() uint { c := v.native().keyval return uint(c) } func (v *EventKey) HardwareKeyCode() uint16 { c := v.native().hardware_keycode return uint16(c) } func (v *EventKey) Type() EventType { c := v.native()._type return EventType(c) } func (v *EventKey) State() uint { c := v.native().state return uint(c) } /* * GdkEventMotion */ type EventMotion struct { *Event } func EventMotionNew() *EventMotion { ee := (*C.GdkEvent)(unsafe.Pointer(&C.GdkEventMotion{})) ev := Event{ee} return &EventMotion{&ev} } // EventMotionNewFromEvent returns an EventMotion from an Event. // // Using widget.Connect() for a key related signal such as // "button-press-event" results in a *Event being passed as // the callback's second argument. The argument is actually a // *EventMotion. EventMotionNewFromEvent provides a means of creating // an EventKey from the Event. func EventMotionNewFromEvent(event *Event) *EventMotion { ee := (*C.GdkEvent)(unsafe.Pointer(event.native())) ev := Event{ee} return &EventMotion{&ev} } // Native returns a pointer to the underlying GdkEventMotion. func (v *EventMotion) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *EventMotion) native() *C.GdkEventMotion { return (*C.GdkEventMotion)(unsafe.Pointer(v.Event.native())) } func (v *EventMotion) MotionVal() (float64, float64) { x := v.native().x y := v.native().y return float64(x), float64(y) } func (v *EventMotion) MotionValRoot() (float64, float64) { x := v.native().x_root y := v.native().y_root return float64(x), float64(y) } // Time returns the time of the event in milliseconds. func (v *EventMotion) Time() uint32 { c := v.native().time return uint32(c) } func (v *EventMotion) Type() EventType { c := v.native()._type return EventType(c) } // A bit-mask representing the state of the modifier keys (e.g. Control, Shift // and Alt) and the pointer buttons. See gdk.ModifierType constants. func (v *EventMotion) State() ModifierType { c := v.native().state return ModifierType(c) } /* * GdkEventCrossing */ // EventCrossing is a representation of GDK's GdkEventCrossing. type EventCrossing struct { *Event } func EventCrossingNew() *EventCrossing { ee := (*C.GdkEvent)(unsafe.Pointer(&C.GdkEventCrossing{})) ev := Event{ee} return &EventCrossing{&ev} } // EventCrossingNewFromEvent returns an EventCrossing from an Event. // // Using widget.Connect() for a key related signal such as // "enter-notify-event" results in a *Event being passed as // the callback's second argument. The argument is actually a // *EventCrossing. EventCrossingNewFromEvent provides a means of creating // an EventCrossing from the Event. func EventCrossingNewFromEvent(event *Event) *EventCrossing { ee := (*C.GdkEvent)(unsafe.Pointer(event.native())) ev := Event{ee} return &EventCrossing{&ev} } // Native returns a pointer to the underlying GdkEventCrossing. func (v *EventCrossing) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *EventCrossing) native() *C.GdkEventCrossing { return (*C.GdkEventCrossing)(unsafe.Pointer(v.Event.native())) } func (v *EventCrossing) X() float64 { c := v.native().x return float64(c) } func (v *EventCrossing) Y() float64 { c := v.native().y return float64(c) } // XRoot returns the x coordinate of the pointer relative to the root of the screen. func (v *EventCrossing) XRoot() float64 { c := v.native().x_root return float64(c) } // YRoot returns the y coordinate of the pointer relative to the root of the screen. func (v *EventCrossing) YRoot() float64 { c := v.native().y_root return float64(c) } func (v *EventCrossing) State() uint { c := v.native().state return uint(c) } // Time returns the time of the event in milliseconds. func (v *EventCrossing) Time() uint32 { c := v.native().time return uint32(c) } func (v *EventCrossing) Type() EventType { c := v.native()._type return EventType(c) } func (v *EventCrossing) MotionVal() (float64, float64) { x := v.native().x y := v.native().y return float64(x), float64(y) } func (v *EventCrossing) MotionValRoot() (float64, float64) { x := v.native().x_root y := v.native().y_root return float64(x), float64(y) } func (v *EventCrossing) Mode() CrossingMode { c := v.native().mode return CrossingMode(c) } func (v *EventCrossing) Detail() NotifyType { c := v.native().detail return NotifyType(c) } func (v *EventCrossing) Focus() bool { c := v.native().focus return gobool(c) } /* * GdkEventScroll */ // EventScroll is a representation of GDK's GdkEventScroll. type EventScroll struct { *Event } func EventScrollNew() *EventScroll { ee := (*C.GdkEvent)(unsafe.Pointer(&C.GdkEventScroll{})) ev := Event{ee} return &EventScroll{&ev} } // EventScrollNewFromEvent returns an EventScroll from an Event. // // Using widget.Connect() for a key related signal such as // "button-press-event" results in a *Event being passed as // the callback's second argument. The argument is actually a // *EventScroll. EventScrollNewFromEvent provides a means of creating // an EventKey from the Event. func EventScrollNewFromEvent(event *Event) *EventScroll { ee := (*C.GdkEvent)(unsafe.Pointer(event.native())) ev := Event{ee} return &EventScroll{&ev} } // Native returns a pointer to the underlying GdkEventScroll. func (v *EventScroll) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *EventScroll) native() *C.GdkEventScroll { return (*C.GdkEventScroll)(unsafe.Pointer(v.Event.native())) } func (v *EventScroll) DeltaX() float64 { return float64(v.native().delta_x) } func (v *EventScroll) DeltaY() float64 { return float64(v.native().delta_y) } func (v *EventScroll) X() float64 { return float64(v.native().x) } func (v *EventScroll) Y() float64 { return float64(v.native().y) } func (v *EventScroll) Type() EventType { c := v.native()._type return EventType(c) } func (v *EventScroll) Direction() ScrollDirection { c := v.native().direction return ScrollDirection(c) } // A bit-mask representing the state of the modifier keys (e.g. Control, Shift // and Alt) and the pointer buttons. See gdk.ModifierType constants. func (v *EventScroll) State() ModifierType { c := v.native().state return ModifierType(c) } /* * GdkEventWindowState */ // EventWindowState is a representation of GDK's GdkEventWindowState. type EventWindowState struct { *Event } func EventWindowStateNew() *EventWindowState { ee := (*C.GdkEvent)(unsafe.Pointer(&C.GdkEventWindowState{})) ev := Event{ee} return &EventWindowState{&ev} } // EventWindowStateNewFromEvent returns an EventWindowState from an Event. // // Using widget.Connect() for the // "window-state-event" signal results in a *Event being passed as // the callback's second argument. The argument is actually a // *EventWindowState. EventWindowStateNewFromEvent provides a means of creating // an EventWindowState from the Event. func EventWindowStateNewFromEvent(event *Event) *EventWindowState { ee := (*C.GdkEvent)(unsafe.Pointer(event.native())) ev := Event{ee} return &EventWindowState{&ev} } // Native returns a pointer to the underlying GdkEventWindowState. func (v *EventWindowState) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *EventWindowState) native() *C.GdkEventWindowState { return (*C.GdkEventWindowState)(unsafe.Pointer(v.Event.native())) } func (v *EventWindowState) Type() EventType { c := v.native()._type return EventType(c) } func (v *EventWindowState) ChangedMask() WindowState { c := v.native().changed_mask return WindowState(c) } func (v *EventWindowState) NewWindowState() WindowState { c := v.native().new_window_state return WindowState(c) } /* * GdkEventConfigure */ // EventConfigure is a representation of GDK's GdkEventConfigure. type EventConfigure struct { *Event } func EventConfigureNew() *EventConfigure { ee := (*C.GdkEvent)(unsafe.Pointer(&C.GdkEventConfigure{})) ev := Event{ee} return &EventConfigure{&ev} } // EventConfigureNewFromEvent returns an EventConfigure from an Event. // // Using widget.Connect() for the // "configure-event" signal results in a *Event being passed as // the callback's second argument. The argument is actually a // *EventConfigure. EventConfigureNewFromEvent provides a means of creating // an EventConfigure from the Event. func EventConfigureNewFromEvent(event *Event) *EventConfigure { ee := (*C.GdkEvent)(unsafe.Pointer(event.native())) ev := Event{ee} return &EventConfigure{&ev} } // Native returns a pointer to the underlying GdkEventConfigure. func (v *EventConfigure) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *EventConfigure) native() *C.GdkEventConfigure { return (*C.GdkEventConfigure)(unsafe.Pointer(v.Event.native())) } func (v *EventConfigure) Type() EventType { c := v.native()._type return EventType(c) } func (v *EventConfigure) X() int { c := v.native().x return int(c) } func (v *EventConfigure) Y() int { c := v.native().y return int(c) } func (v *EventConfigure) Width() int { c := v.native().width return int(c) } func (v *EventConfigure) Height() int { c := v.native().height return int(c) } /* * GdkGravity */ type Gravity int const ( GDK_GRAVITY_NORTH_WEST = C.GDK_GRAVITY_NORTH_WEST GDK_GRAVITY_NORTH = C.GDK_GRAVITY_NORTH GDK_GRAVITY_NORTH_EAST = C.GDK_GRAVITY_NORTH_EAST GDK_GRAVITY_WEST = C.GDK_GRAVITY_WEST GDK_GRAVITY_CENTER = C.GDK_GRAVITY_CENTER GDK_GRAVITY_EAST = C.GDK_GRAVITY_EAST GDK_GRAVITY_SOUTH_WEST = C.GDK_GRAVITY_SOUTH_WEST GDK_GRAVITY_SOUTH = C.GDK_GRAVITY_SOUTH GDK_GRAVITY_SOUTH_EAST = C.GDK_GRAVITY_SOUTH_EAST GDK_GRAVITY_STATIC = C.GDK_GRAVITY_STATIC ) func marshalGravity(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Gravity(c), nil } /* * GdkRGBA */ // To create a GdkRGBA you have to use NewRGBA function. type RGBA struct { rgba *C.GdkRGBA } func marshalRGBA(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return WrapRGBA(unsafe.Pointer(c)), nil } func WrapRGBA(p unsafe.Pointer) *RGBA { return wrapRGBA((*C.GdkRGBA)(p)) } func wrapRGBA(cRgba *C.GdkRGBA) *RGBA { if cRgba == nil { return nil } return &RGBA{cRgba} } func NewRGBA(values ...float64) *RGBA { cRgba := new(C.GdkRGBA) for i, value := range values { switch i { case 0: cRgba.red = C.gdouble(value) case 1: cRgba.green = C.gdouble(value) case 2: cRgba.blue = C.gdouble(value) case 3: cRgba.alpha = C.gdouble(value) } } return wrapRGBA(cRgba) } func (c *RGBA) Floats() []float64 { return []float64{ float64(c.rgba.red), float64(c.rgba.green), float64(c.rgba.blue), float64(c.rgba.alpha)} } func (c *RGBA) Native() uintptr { return uintptr(unsafe.Pointer(c.rgba)) } // SetColors sets all colors values in the RGBA. func (c *RGBA) SetColors(r, g, b, a float64) { c.rgba.red = C.gdouble(r) c.rgba.green = C.gdouble(g) c.rgba.blue = C.gdouble(b) c.rgba.alpha = C.gdouble(a) } /* * The following methods (Get/Set) are made for * more convenient use of the GdkRGBA object */ // GetRed get red value from the RGBA. func (c *RGBA) GetRed() float64 { return float64(c.rgba.red) } // GetGreen get green value from the RGBA. func (c *RGBA) GetGreen() float64 { return float64(c.rgba.green) } // GetBlue get blue value from the RGBA. func (c *RGBA) GetBlue() float64 { return float64(c.rgba.blue) } // GetAlpha get alpha value from the RGBA. func (c *RGBA) GetAlpha() float64 { return float64(c.rgba.alpha) } // SetRed set red value in the RGBA. func (c *RGBA) SetRed(red float64) { c.rgba.red = C.gdouble(red) } // SetGreen set green value in the RGBA. func (c *RGBA) SetGreen(green float64) { c.rgba.green = C.gdouble(green) } // SetBlue set blue value in the RGBA. func (c *RGBA) SetBlue(blue float64) { c.rgba.blue = C.gdouble(blue) } // SetAlpha set alpha value in the RGBA. func (c *RGBA) SetAlpha(alpha float64) { c.rgba.alpha = C.gdouble(alpha) } // Parse is a representation of gdk_rgba_parse(). func (c *RGBA) Parse(spec string) bool { cstr := (*C.gchar)(C.CString(spec)) defer C.free(unsafe.Pointer(cstr)) return gobool(C.gdk_rgba_parse(c.rgba, cstr)) } // String is a representation of gdk_rgba_to_string(). func (c *RGBA) String() string { return C.GoString((*C.char)(C.gdk_rgba_to_string(c.rgba))) } // free is a representation of gdk_rgba_free(). func (c *RGBA) free() { C.gdk_rgba_free(c.rgba) } // Copy is a representation of gdk_rgba_copy(). func (c *RGBA) Copy() (*RGBA, error) { cRgba := C.gdk_rgba_copy(c.rgba) if c == nil { return nil, nilPtrErr } obj := wrapRGBA(cRgba) runtime.SetFinalizer(obj, func(v *RGBA) { glib.FinalizerStrategy(v.free) }) return obj, nil } // Equal is a representation of gdk_rgba_equal(). func (c *RGBA) Equal(rgba *RGBA) bool { return gobool(C.gdk_rgba_equal( C.gconstpointer(c.rgba), C.gconstpointer(rgba.rgba))) } // Hash is a representation of gdk_rgba_hash(). func (c *RGBA) Hash() uint { return uint(C.gdk_rgba_hash(C.gconstpointer(c.rgba))) } /* * GdkPoint */ // Point is a representation of GDK's GdkPoint type. type Point struct { GdkPoint C.GdkPoint } func WrapPoint(p uintptr) *Point { return wrapPoint((*C.GdkPoint)(unsafe.Pointer(p))) } func wrapPoint(obj *C.GdkPoint) *Point { if obj == nil { return nil } return &Point{*obj} } // Native() returns a pointer to the underlying GdkPoint. func (v *Point) native() *C.GdkPoint { return &v.GdkPoint } // PointNew helper function to create a GdkPoint func PointNew(x, y int) *Point { var p C.GdkPoint p.x = C.gint(x) p.y = C.gint(y) return &Point{p} } // GetPointInt helper function to get GdkPoint values func (v *Point) GetPointInt() (x, y int) { return int(v.native().x), int(v.native().y) } // SetPointInt helper function to set GdkPoint values func (v *Point) SetPointInt(x, y int) { v.native().x = C.gint(x) v.native().y = C.gint(y) } // GetX returns x field of the underlying GdkPoint. func (v *Point) GetX() int { return int(v.native().x) } // SetX sets x field of the underlying GdkPoint. func (v *Point) SetX(x int) { v.native().x = C.gint(x) } // GetY returns y field of the underlying GdkPoint. func (v *Point) GetY() int { return int(v.native().y) } // SetY sets y field of the underlying GdkPoint. func (v *Point) SetY(y int) { v.native().y = C.gint(y) } /* * GdkRectangle */ // Rectangle is a representation of GDK's GdkRectangle type. type Rectangle struct { GdkRectangle C.GdkRectangle } func WrapRectangle(p uintptr) *Rectangle { return wrapRectangle((*C.GdkRectangle)(unsafe.Pointer(p))) } func wrapRectangle(obj *C.GdkRectangle) *Rectangle { if obj == nil { return nil } return &Rectangle{*obj} } // Native() returns a pointer to the underlying GdkRectangle. func (r *Rectangle) native() *C.GdkRectangle { return &r.GdkRectangle } // RectangleIntersect is a wrapper around gdk_rectangle_intersect(). func (v *Rectangle) RectangleIntersect(rect *Rectangle) (*Rectangle, bool) { r := new(C.GdkRectangle) c := C.gdk_rectangle_intersect(v.native(), rect.native(), r) return wrapRectangle(r), gobool(c) } // RectangleUnion is a wrapper around gdk_rectangle_union(). func (v *Rectangle) RectangleUnion(rect *Rectangle) *Rectangle { r := new(C.GdkRectangle) C.gdk_rectangle_union(v.native(), rect.native(), r) return wrapRectangle(r) } // RectangleNew helper function to create a GdkRectanlge func RectangleNew(x, y, width, height int) *Rectangle { var r C.GdkRectangle r.x = C.int(x) r.y = C.int(y) r.width = C.int(width) r.height = C.int(height) return &Rectangle{r} } // SetRectangleInt helper function to set GdkRectanlge values func (v *Rectangle) SetRectangleInt(x, y, width, height int) { v.native().x = C.int(x) v.native().y = C.int(y) v.native().width = C.int(width) v.native().height = C.int(height) } // GetRectangleInt helper function to get GdkRectanlge values func (v *Rectangle) GetRectangleInt() (x, y, width, height int) { return int(v.native().x), int(v.native().y), int(v.native().width), int(v.native().height) } // GetX returns x field of the underlying GdkRectangle. func (r *Rectangle) GetX() int { return int(r.native().x) } // SetX sets x field of the underlying GdkRectangle. func (r *Rectangle) SetX(x int) { r.native().x = C.int(x) } // GetY returns y field of the underlying GdkRectangle. func (r *Rectangle) GetY() int { return int(r.native().y) } // SetY sets y field of the underlying GdkRectangle. func (r *Rectangle) SetY(y int) { r.native().y = C.int(y) } // GetWidth returns width field of the underlying GdkRectangle. func (r *Rectangle) GetWidth() int { return int(r.native().width) } // SetWidth sets width field of the underlying GdkRectangle. func (r *Rectangle) SetWidth(width int) { r.native().width = C.int(width) } // GetHeight returns height field of the underlying GdkRectangle. func (r *Rectangle) GetHeight() int { return int(r.native().height) } // SetHeight sets height field of the underlying GdkRectangle. func (r *Rectangle) SetHeight(height int) { r.native().height = C.int(height) } /* * GdkGeometry */ type Geometry struct { GdkGeometry C.GdkGeometry } func WrapGeometry(p uintptr) *Geometry { return wrapGeometry((*C.GdkGeometry)(unsafe.Pointer(p))) } func wrapGeometry(obj *C.GdkGeometry) *Geometry { if obj == nil { return nil } return &Geometry{*obj} } // native returns a pointer to the underlying GdkGeometry. func (r *Geometry) native() *C.GdkGeometry { return &r.GdkGeometry } // GetMinWidth returns min_width field of the underlying GdkGeometry. func (r *Geometry) GetMinWidth() int { return int(r.native().min_width) } // SetMinWidth sets min_width field of the underlying GdkGeometry. func (r *Geometry) SetMinWidth(minWidth int) { r.native().min_width = C.gint(minWidth) } // GetMinHeight returns min_height field of the underlying GdkGeometry. func (r *Geometry) GetMinHeight() int { return int(r.native().min_height) } // SetMinHeight sets min_height field of the underlying GdkGeometry. func (r *Geometry) SetMinHeight(minHeight int) { r.native().min_height = C.gint(minHeight) } // GetMaxWidth returns max_width field of the underlying GdkGeometry. func (r *Geometry) GetMaxWidth() int { return int(r.native().max_width) } // SetMaxWidth sets max_width field of the underlying GdkGeometry. func (r *Geometry) SetMaxWidth(maxWidth int) { r.native().max_width = C.gint(maxWidth) } // GetMaxHeight returns max_height field of the underlying GdkGeometry. func (r *Geometry) GetMaxHeight() int { return int(r.native().max_height) } // SetMaxHeight sets max_height field of the underlying GdkGeometry. func (r *Geometry) SetMaxHeight(maxHeight int) { r.native().max_height = C.gint(maxHeight) } // GetBaseWidth returns base_width field of the underlying GdkGeometry. func (r *Geometry) GetBaseWidth() int { return int(r.native().base_width) } // SetBaseWidth sets base_width field of the underlying GdkGeometry. func (r *Geometry) SetBaseWidth(baseWidth int) { r.native().base_width = C.gint(baseWidth) } // GetBaseHeight returns base_height field of the underlying GdkGeometry. func (r *Geometry) GetBaseHeight() int { return int(r.native().base_height) } // SetBaseHeight sets base_height field of the underlying GdkGeometry. func (r *Geometry) SetBaseHeight(baseHeight int) { r.native().base_height = C.gint(baseHeight) } // GetWidthInc returns width_inc field of the underlying GdkGeometry. func (r *Geometry) GetWidthInc() int { return int(r.native().width_inc) } // SetWidthInc sets width_inc field of the underlying GdkGeometry. func (r *Geometry) SetWidthInc(widthInc int) { r.native().width_inc = C.gint(widthInc) } // GetHeightInc returns height_inc field of the underlying GdkGeometry. func (r *Geometry) GetHeightInc() int { return int(r.native().height_inc) } // SetHeightInc sets height_inc field of the underlying GdkGeometry. func (r *Geometry) SetHeightInc(heightInc int) { r.native().height_inc = C.gint(heightInc) } // GetMinAspect returns min_aspect field of the underlying GdkGeometry. func (r *Geometry) GetMinAspect() float64 { return float64(r.native().min_aspect) } // SetMinAspect sets min_aspect field of the underlying GdkGeometry. func (r *Geometry) SetMinAspect(minAspect float64) { r.native().min_aspect = C.gdouble(minAspect) } // GetMaxAspect returns max_aspect field of the underlying GdkGeometry. func (r *Geometry) GetMaxAspect() float64 { return float64(r.native().max_aspect) } // SetMaxAspect sets max_aspect field of the underlying GdkGeometry. func (r *Geometry) SetMaxAspect(maxAspect float64) { r.native().max_aspect = C.gdouble(maxAspect) } // GetWinGravity returns win_gravity field of the underlying GdkGeometry. func (r *Geometry) GetWinGravity() Gravity { return Gravity(r.native().win_gravity) } // SetWinGravity sets win_gravity field of the underlying GdkGeometry. func (r *Geometry) SetWinGravity(winGravity Gravity) { r.native().win_gravity = C.GdkGravity(winGravity) } /* * GdkVisual */ // Visual is a representation of GDK's GdkVisual. type Visual struct { *glib.Object } func (v *Visual) native() *C.GdkVisual { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkVisual(p) } func (v *Visual) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalVisual(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Visual{obj}, nil } // GetBluePixelDetails is a wrapper around gdk_visual_get_blue_pixel_details(). func (v *Visual) GetBluePixelDetails() (*uint32, *int, *int) { var ( m *uint32 = nil s, p *int = nil, nil mask C.guint32 shift, precision C.gint ) C.gdk_visual_get_blue_pixel_details(v.native(), &mask, &shift, &precision) if &mask != nil { m = new(uint32) *m = uint32(mask) } if &shift != nil { s = new(int) *s = int(shift) } if &precision != nil { p = new(int) *p = int(precision) } return m, s, p } // GetDepth is a wrapper around gdk_visual_get_depth(). func (v *Visual) GetDepth() int { return int(C.gdk_visual_get_depth(v.native())) } // GetGreenPixelDetails is a wrapper around gdk_visual_get_green_pixel_details(). func (v *Visual) GetGreenPixelDetails() (*uint32, *int, *int) { var ( m *uint32 = nil s, p *int = nil, nil mask C.guint32 shift, precision C.gint ) C.gdk_visual_get_green_pixel_details(v.native(), &mask, &shift, &precision) if &mask != nil { m = new(uint32) *m = uint32(mask) } if &shift != nil { s = new(int) *s = int(shift) } if &precision != nil { p = new(int) *p = int(precision) } return m, s, p } // GetRedPixelDetails is a wrapper around gdk_visual_get_red_pixel_details(). func (v *Visual) GetRedPixelDetails() (*uint32, *int, *int) { var ( m *uint32 = nil s, p *int = nil, nil mask C.guint32 shift, precision C.gint ) C.gdk_visual_get_red_pixel_details(v.native(), &mask, &shift, &precision) if &mask != nil { m = new(uint32) *m = uint32(mask) } if &shift != nil { s = new(int) *s = int(shift) } if &precision != nil { p = new(int) *p = int(precision) } return m, s, p } // GetVisualType is a wrapper around gdk_visual_get_visual_type(). func (v *Visual) GetVisualType() VisualType { return VisualType(C.gdk_visual_get_visual_type(v.native())) } // GetScreen is a wrapper around gdk_visual_get_screen(). func (v *Visual) GetScreen() (*Screen, error) { return toScreen(C.gdk_visual_get_screen(v.native())) } /* * GdkWindow */ // Window is a representation of GDK's GdkWindow. type Window struct { *glib.Object } // SetCursor is a wrapper around gdk_window_set_cursor(). func (v *Window) SetCursor(cursor *Cursor) { C.gdk_window_set_cursor(v.native(), cursor.native()) } // native returns a pointer to the underlying GdkWindow. func (v *Window) native() *C.GdkWindow { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkWindow(p) } // Native returns a pointer to the underlying GdkWindow. func (v *Window) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } // WindowGetWidth is a wrapper around gdk_window_get_width() func (v *Window) WindowGetWidth() (width int) { return int(C.gdk_window_get_width(v.native())) } // WindowGetHeight is a wrapper around gdk_window_get_height() func (v *Window) WindowGetHeight() (height int) { return int(C.gdk_window_get_height(v.native())) } // CreateSimilarSurface is a wrapper around gdk_window_create_similar_surface(). func (v *Window) CreateSimilarSurface(content cairo.Content, w, h int) (*cairo.Surface, error) { surface := C.gdk_window_create_similar_surface(v.native(), C.cairo_content_t(content), C.gint(w), C.gint(h)) status := cairo.Status(C.cairo_surface_status(surface)) if status != cairo.STATUS_SUCCESS { return nil, cairo.ErrorStatus(status) } return cairo.NewSurface(uintptr(unsafe.Pointer(surface)), false), nil } //PixbufGetFromWindow is a wrapper around gdk_pixbuf_get_from_window() func (v *Window) PixbufGetFromWindow(x, y, w, h int) (*Pixbuf, error) { c := C.gdk_pixbuf_get_from_window(v.native(), C.gint(x), C.gint(y), C.gint(w), C.gint(h)) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // GetDevicePosition is a wrapper around gdk_window_get_device_position() func (v *Window) GetDevicePosition(d *Device) (*Window, int, int, ModifierType) { var x C.gint var y C.gint var mt C.GdkModifierType underneathWindow := C.gdk_window_get_device_position(v.native(), d.native(), &x, &y, &mt) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(underneathWindow))} rw := &Window{obj} runtime.SetFinalizer(rw, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return rw, int(x), int(y), ModifierType(mt) } // SetOverrideRedirect is a wrapper around gdk_window_set_override_redirect(). func (v *Window) SetOverrideRedirect(overrideRedirect bool) { C.gdk_window_set_override_redirect(v.native(), gbool(overrideRedirect)) } func PixbufGetFromSurface(surface *cairo.Surface, src_x, src_y, width, height int) (*Pixbuf, error) { c := C.gdk_pixbuf_get_from_surface((*C.cairo_surface_t)(unsafe.Pointer(surface.Native())), C.gint(src_x), C.gint(src_y), C.gint(width), C.gint(height)) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } func marshalWindow(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Window{obj}, nil } func toWindow(s *C.GdkWindow) (*Window, error) { if s == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(s))} return &Window{obj}, nil } gotk3-0.6.2/gdk/gdk.go.h000066400000000000000000000033671431157473000146530ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include // Type Casting static GdkAtom toGdkAtom(void *p) { return ((GdkAtom)p); } static GdkDevice *toGdkDevice(void *p) { return (GDK_DEVICE(p)); } static GdkCursor *toGdkCursor(void *p) { return (GDK_CURSOR(p)); } static GdkDeviceManager *toGdkDeviceManager(void *p) { return (GDK_DEVICE_MANAGER(p)); } static GdkDisplay *toGdkDisplay(void *p) { return (GDK_DISPLAY(p)); } static GdkDisplayManager *toGdkDisplayManager(void *p) { return (GDK_DISPLAY_MANAGER(p)); } static GdkKeymap *toGdkKeymap(void *p) { return (GDK_KEYMAP(p)); } static GdkDragContext *toGdkDragContext(void *p) { return (GDK_DRAG_CONTEXT(p)); } static GdkScreen *toGdkScreen(void *p) { return (GDK_SCREEN(p)); } static GdkVisual *toGdkVisual(void *p) { return (GDK_VISUAL(p)); } static GdkWindow *toGdkWindow(void *p) { return (GDK_WINDOW(p)); } static inline gchar **next_gcharptr(gchar **s) { return (s + 1); } gotk3-0.6.2/gdk/gdk_deprecated_since_3_10.go000066400000000000000000000026251431157473000205040ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // This file includes wrappers for symbols deprecated beginning with GTK 3.10, // and should only be included in a build targeted intended to target GTK // 3.8 or earlier. To target an earlier build build, use the build tag // gtk_MAJOR_MINOR. For example, to target GTK 3.8, run // 'go build -tags gtk_3_8'. // +build gtk_3_6 gtk_3_8 gtk_deprecated package gdk // #include import "C" // GetNScreens is a wrapper around gdk_display_get_n_screens(). func (v *Display) GetNScreens() int { c := C.gdk_display_get_n_screens(v.native()) return int(c) } gotk3-0.6.2/gdk/gdk_deprecated_since_3_16.go000066400000000000000000000004661431157473000205130ustar00rootroot00000000000000//+build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14 gtk_deprecated package gdk // #include import "C" // SupportsComposite() is a wrapper around gdk_display_supports_composite(). func (v *Display) SupportsComposite() bool { c := C.gdk_display_supports_composite(v.native()) return gobool(c) } gotk3-0.6.2/gdk/gdk_deprecated_since_3_20.go000066400000000000000000000042201431157473000204760ustar00rootroot00000000000000//+build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14 gtk_3_16 gtk_3_18 gtk_deprecated package gdk // #include import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) // Grab() is a wrapper around gdk_device_grab(). func (v *Device) Grab(w *Window, ownership GrabOwnership, owner_events bool, event_mask EventMask, cursor *Cursor, time uint32) GrabStatus { ret := C.gdk_device_grab( v.native(), w.native(), C.GdkGrabOwnership(ownership), gbool(owner_events), C.GdkEventMask(event_mask), cursor.native(), C.guint32(time), ) return GrabStatus(ret) } // GetClientPointer() is a wrapper around gdk_device_manager_get_client_pointer(). func (v *DeviceManager) GetClientPointer() (*Device, error) { c := C.gdk_device_manager_get_client_pointer(v.native()) if c == nil { return nil, nilPtrErr } return &Device{glib.Take(unsafe.Pointer(c))}, nil } // ListDevices() is a wrapper around gdk_device_manager_list_devices(). func (v *DeviceManager) ListDevices(tp DeviceType) *glib.List { clist := C.gdk_device_manager_list_devices(v.native(), C.GdkDeviceType(tp)) if clist == nil { return nil } //TODO: WrapList should set the finalizer glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return &Device{&glib.Object{glib.ToGObject(ptr)}} }) runtime.SetFinalizer(glist, func(glist *glib.List) { glib.FinalizerStrategy(glist.Free) }) return glist } // Ungrab() is a wrapper around gdk_device_ungrab(). func (v *Device) Ungrab(time uint32) { C.gdk_device_ungrab(v.native(), C.guint32(time)) } // GetDeviceManager() is a wrapper around gdk_display_get_device_manager(). func (v *Display) GetDeviceManager() (*DeviceManager, error) { c := C.gdk_display_get_device_manager(v.native()) if c == nil { return nil, nilPtrErr } return &DeviceManager{glib.Take(unsafe.Pointer(c))}, nil } // GetScreen() is a wrapper around gdk_display_get_screen(). func (v *Display) GetScreen(screenNum int) (*Screen, error) { c := C.gdk_display_get_screen(v.native(), C.gint(screenNum)) if c == nil { return nil, nilPtrErr } return &Screen{glib.Take(unsafe.Pointer(c))}, nil } gotk3-0.6.2/gdk/gdk_deprecated_since_3_22.go000066400000000000000000000064371431157473000205140ustar00rootroot00000000000000//+build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14 gtk_3_16 gtk_3_18 gtk_3_20 gtk_deprecated package gdk // #include import "C" /* * Constants */ // TODO: // GdkByteOrder /* * GdkScreen */ // GetActiveWindow is a wrapper around gdk_screen_get_active_window(). func (v *Screen) GetActiveWindow() (*Window, error) { return toWindow(C.gdk_screen_get_active_window(v.native())) } // GetHeight is a wrapper around gdk_screen_get_height(). func (v *Screen) GetHeight() int { c := C.gdk_screen_get_height(v.native()) return int(c) } // GetHeightMM is a wrapper around gdk_screen_get_height_mm(). func (v *Screen) GetHeightMM() int { return int(C.gdk_screen_get_height_mm(v.native())) } // GetMonitorAtPoint is a wrapper around gdk_screen_get_monitor_at_point(). func (v *Screen) GetMonitorAtPoint(x, y int) int { return int(C.gdk_screen_get_monitor_at_point(v.native(), C.gint(x), C.gint(y))) } // GetMonitorAtWindow is a wrapper around gdk_screen_get_monitor_at_window(). func (v *Screen) GetMonitorAtWindow(w *Window) int { return int(C.gdk_screen_get_monitor_at_window(v.native(), w.native())) } // GetMonitorHeightMM is a wrapper around gdk_screen_get_monitor_height_mm(). func (v *Screen) GetMonitorHeightMM(m int) int { return int(C.gdk_screen_get_monitor_height_mm(v.native(), C.gint(m))) } // GetMonitorPlugName is a wrapper around gdk_screen_get_monitor_plug_name(). func (v *Screen) GetMonitorPlugName(m int) (string, error) { return toString(C.gdk_screen_get_monitor_plug_name(v.native(), C.gint(m))) } // GetMonitorScaleFactor is a wrapper around gdk_screen_get_monitor_scale_factor(). func (v *Screen) GetMonitorScaleFactor(m int) int { return int(C.gdk_screen_get_monitor_scale_factor(v.native(), C.gint(m))) } // GetMonitorWidthMM is a wrapper around gdk_screen_get_monitor_width_mm(). func (v *Screen) GetMonitorWidthMM(m int) int { return int(C.gdk_screen_get_monitor_width_mm(v.native(), C.gint(m))) } // GetNMonitors is a wrapper around gdk_screen_get_n_monitors(). func (v *Screen) GetNMonitors() int { return int(C.gdk_screen_get_n_monitors(v.native())) } // GetNumber is a wrapper around gdk_screen_get_number(). func (v *Screen) GetNumber() int { return int(C.gdk_screen_get_number(v.native())) } // GetPrimaryMonitor is a wrapper around gdk_screen_get_primary_monitor(). func (v *Screen) GetPrimaryMonitor() int { return int(C.gdk_screen_get_primary_monitor(v.native())) } // GetWidth is a wrapper around gdk_screen_get_width(). func (v *Screen) GetWidth() int { c := C.gdk_screen_get_width(v.native()) return int(c) } // GetWidthMM is a wrapper around gdk_screen_get_width_mm(). func (v *Screen) GetWidthMM() int { return int(C.gdk_screen_get_width_mm(v.native())) } // MakeDisplayName is a wrapper around gdk_screen_make_display_name(). func (v *Screen) MakeDisplayName() (string, error) { return toString(C.gdk_screen_make_display_name(v.native())) } /* * GdkVisuals */ // TODO: // gdk_query_depths(). // gdk_query_visual_types(). // gdk_list_visuals(). // gdk_visual_get_bits_per_rgb(). // gdk_visual_get_byte_order(). // gdk_visual_get_colormap_size(). // gdk_visual_get_best_depth(). // gdk_visual_get_best_type(). // gdk_visual_get_system(). // gdk_visual_get_best(). // gdk_visual_get_best_with_depth(). // gdk_visual_get_best_with_type(). // gdk_visual_get_best_with_both(). gotk3-0.6.2/gdk/gdk_since_3_10.go000066400000000000000000000031401431157473000163150ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8 // Supports building with gtk 3.10+ package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/cairo" "github.com/gotk3/gotk3/glib" ) // TODO: // gdk_device_get_position_double(). // GetScaleFactor is a wrapper around gdk_window_get_scale_factor(). func (v *Window) GetScaleFactor() int { return int(C.gdk_window_get_scale_factor(v.native())) } // CreateSimilarImageSurface is a wrapper around gdk_window_create_similar_image_surface(). func (v *Window) CreateSimilarImageSurface(format cairo.Format, w, h, scale int) (*cairo.Surface, error) { surface := C.gdk_window_create_similar_image_surface(v.native(), C.cairo_format_t(format), C.gint(w), C.gint(h), C.gint(scale)) status := cairo.Status(C.cairo_surface_status(surface)) if status != cairo.STATUS_SUCCESS { return nil, cairo.ErrorStatus(status) } return cairo.NewSurface(uintptr(unsafe.Pointer(surface)), false), nil } // CairoSurfaceCreateFromPixbuf is a wrapper around gdk_cairo_surface_create_from_pixbuf(). func CairoSurfaceCreateFromPixbuf(pixbuf *Pixbuf, scale int, window *Window) (*cairo.Surface, error) { v := C.gdk_cairo_surface_create_from_pixbuf(pixbuf.native(), C.gint(scale), window.native()) status := cairo.Status(C.cairo_surface_status(v)) if status != cairo.STATUS_SUCCESS { return nil, cairo.ErrorStatus(status) } surface := cairo.WrapSurface(uintptr(unsafe.Pointer(v))) runtime.SetFinalizer(surface, func(v *cairo.Surface) { glib.FinalizerStrategy(v.Close) }) return surface, nil } gotk3-0.6.2/gdk/gdk_since_3_12.go000066400000000000000000000002101431157473000163120ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10 // Supports building with gtk 3.12+ package gdk // TODO: // gdk_device_get_last_event_window(). gotk3-0.6.2/gdk/gdk_since_3_16.go000066400000000000000000000127461431157473000163370ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14 // Supports building with gtk 3.16+ /* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package gdk // #include // #include "gdk_since_3_16.go.h" import "C" import ( "errors" "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gdk_gl_context_get_type()), marshalGLContext}, } glib.RegisterGValueMarshalers(tm) } /* * Constants */ const ( GRAB_FAILED GrabStatus = C.GDK_GRAB_FAILED ) /* * GdkDevice */ // TODO: // gdk_device_get_vendor_id(). // gdk_device_get_product_id(). /* * GdkGLContext */ // GLContext is a representation of GDK's GdkGLContext. type GLContext struct { *glib.Object } // native returns a pointer to the underlying GdkGLContext. func (v *GLContext) native() *C.GdkGLContext { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkGLContext(p) } // Native returns a pointer to the underlying GdkGLContext. func (v *GLContext) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalGLContext(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &GLContext{obj}, nil } // GetDisplay is a wrapper around gdk_gl_context_get_display(). func (v *GLContext) GetDisplay() (*Display, error) { c := C.gdk_gl_context_get_display(v.native()) if c == nil { return nil, nilPtrErr } return &Display{glib.Take(unsafe.Pointer(c))}, nil } // GetWindow is a wrapper around gdk_gl_context_get_window(). func (v *GLContext) GetSurface() (*Window, error) { c := C.gdk_gl_context_get_window(v.native()) if c == nil { return nil, nilPtrErr } return &Window{glib.Take(unsafe.Pointer(c))}, nil } // GetSharedContext is a wrapper around gdk_gl_context_get_shared_context(). func (v *GLContext) GetSharedContext() (*GLContext, error) { c := C.gdk_gl_context_get_shared_context(v.native()) if c == nil { return nil, nilPtrErr } return &GLContext{glib.Take(unsafe.Pointer(c))}, nil } // MajorVersion is a representation of OpenGL major version. type MajorVersion int // MinorVersion is a representation of OpenGL minor version. type MinorVersion int // GetVersion is a wrapper around gdk_gl_context_get_version(). func (v *GLContext) GetVersion() (MajorVersion, MinorVersion) { var major, minor int C.gdk_gl_context_get_version(v.native(), (*C.int)(unsafe.Pointer(&major)), (*C.int)(unsafe.Pointer(&minor))) return MajorVersion(major), MinorVersion(minor) } // GetRequiredVersion is a wrapper around gdk_gl_context_get_required_version(). func (v *GLContext) GetRequiredVersion() (MajorVersion, MinorVersion) { var major, minor int C.gdk_gl_context_get_required_version(v.native(), (*C.int)(unsafe.Pointer(&major)), (*C.int)(unsafe.Pointer(&minor))) return MajorVersion(major), MinorVersion(minor) } // SetRequiredVersion is a wrapper around gdk_gl_context_set_required_version(). func (v *GLContext) SetRequiredVersion(major, minor int) { C.gdk_gl_context_set_required_version(v.native(), (C.int)(major), (C.int)(minor)) } // GetDebugEnabled is a wrapper around gdk_gl_context_get_debug_enabled(). func (v *GLContext) GetDebugEnabled() bool { return gobool(C.gdk_gl_context_get_debug_enabled(v.native())) } // SetDebugEnabled is a wrapper around gdk_gl_context_set_debug_enabled(). func (v *GLContext) SetDebugEnabled(enabled bool) { C.gdk_gl_context_set_debug_enabled(v.native(), gbool(enabled)) } // GetForwardCompatible is a wrapper around gdk_gl_context_get_forward_compatible(). func (v *GLContext) GetForwardCompatible() bool { return gobool(C.gdk_gl_context_get_forward_compatible(v.native())) } // SetForwardCompatible is a wrapper around gdk_gl_context_set_forward_compatible(). func (v *GLContext) SetForwardCompatible(compatible bool) { C.gdk_gl_context_set_forward_compatible(v.native(), gbool(compatible)) } // Realize is a wrapper around gdk_gl_context_realize(). func (v *GLContext) Realize() (bool, error) { var err *C.GError r := gobool(C.gdk_gl_context_realize(v.native(), &err)) if !r { defer C.g_error_free(err) return r, errors.New(C.GoString((*C.char)(err.message))) } return r, nil } // MakeCurrent is a wrapper around gdk_gl_context_make_current(). func (v *GLContext) MakeCurrent() { C.gdk_gl_context_make_current(v.native()) } // GetCurrent is a wrapper around gdk_gl_context_get_current(). func GetCurrent() (*GLContext, error) { c := C.gdk_gl_context_get_current() if c == nil { return nil, nilPtrErr } return &GLContext{glib.Take(unsafe.Pointer(c))}, nil } // ClearCurrent is a wrapper around gdk_gl_context_clear_current(). func ClearCurrent() { C.gdk_gl_context_clear_current() } gotk3-0.6.2/gdk/gdk_since_3_16.go.h000066400000000000000000000017261431157473000165610ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include // Type Casting static GdkGLContext *toGdkGLContext(void *p) { return (GDK_GL_CONTEXT(p)); }gotk3-0.6.2/gdk/gdk_since_3_18.go000066400000000000000000000014561431157473000163350ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16 // Supports building with gtk 3.18+ package gdk // #include import "C" /* * GdkKeymap */ // GetScrollLockState is a wrapper around gdk_keymap_get_scroll_lock_state(). func (v *Keymap) GetScrollLockState() bool { return gobool(C.gdk_keymap_get_scroll_lock_state(v.native())) } /* * GdkWindow */ // SetPassThrough is a wrapper around gdk_window_set_pass_through(). func (v *Window) SetPassThrough(passThrough bool) { C.gdk_window_set_pass_through(v.native(), gbool(passThrough)) } // GetPassThrough is a wrapper around gdk_window_get_pass_through(). func (v *Window) GetPassThrough() bool { return gobool(C.gdk_window_get_pass_through(v.native())) } gotk3-0.6.2/gdk/gdk_since_3_20.go000066400000000000000000000032371431157473000163250ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18 // Supports building with gtk 3.20+ package gdk import ( "unsafe" "github.com/gotk3/gotk3/glib" ) // #include // #include "gdk_since_3_20.go.h" import "C" /* * GdkGLContext */ // IsLegacy is a wrapper around gdk_gl_context_is_legacy(). func (v *GLContext) IsLegacy() bool { return gobool(C.gdk_gl_context_is_legacy(v.native())) } /* * GdkDisplay */ func (v *Display) GetDefaultSeat() (*Seat, error) { return toSeat(C.gdk_display_get_default_seat(v.native())) } // gdk_display_list_seats(). /* * GdkDevice */ // TODO: // gdk_device_get_axes(). // gdk_device_get_seat(). /* * GdkSeat */ type Seat struct { *glib.Object } func (v *Seat) native() *C.GdkSeat { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkSeat(p) } // Native returns a pointer to the underlying GdkCursor. func (v *Seat) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalSeat(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Seat{obj}, nil } func toSeat(s *C.GdkSeat) (*Seat, error) { if s == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(s))} return &Seat{obj}, nil } func (v *Seat) GetPointer() (*Device, error) { return toDevice(C.gdk_seat_get_pointer(v.native())) } /* * GdkRectangle */ // RectangleEqual is a wrapper around gdk_rectangle_equal(). func (v *Rectangle) RectangleEqual(rect *Rectangle) bool { return gobool(C.gdk_rectangle_equal(v.native(), rect.native())) } gotk3-0.6.2/gdk/gdk_since_3_20.go.h000066400000000000000000000016711431157473000165530ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ //#include static GdkSeat *toGdkSeat(void *p) { return ((GdkSeat *)p); }gotk3-0.6.2/gdk/gdk_since_3_22.go000066400000000000000000000156351431157473000163340ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18,!gtk_3_20 // Supports building with gtk 3.22+ // Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. package gdk // #include // #include "gdk_since_3_22.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gdk_subpixel_layout_get_type()), marshalSubpixelLayout}, } glib.RegisterGValueMarshalers(tm) } /* * Constants */ // TODO: // GdkSeatCapabilities // SubpixelLayout is a representation of GDK's GdkSubpixelLayout. type SubpixelLayout int const ( SUBPIXEL_LAYOUT_UNKNOWN SubpixelLayout = C.GDK_SUBPIXEL_LAYOUT_UNKNOWN SUBPIXEL_LAYOUT_NONE SubpixelLayout = C.GDK_SUBPIXEL_LAYOUT_NONE SUBPIXEL_LAYOUT_HORIZONTAL_RGB SubpixelLayout = C.GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB SUBPIXEL_LAYOUT_HORIZONTAL_BGR SubpixelLayout = C.GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR SUBPIXEL_LAYOUT_VERTICAL_RGB SubpixelLayout = C.GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB SUBPIXEL_LAYOUT_VERTICAL_BGR SubpixelLayout = C.GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR ) func marshalSubpixelLayout(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return SubpixelLayout(c), nil } /* * GdkDisplay */ // GetNMonitors is a wrapper around gdk_display_get_n_monitors(). func (v *Display) GetNMonitors() int { c := C.gdk_display_get_n_monitors(v.native()) return int(c) } // GetPrimaryMonitor is a wrapper around gdk_display_get_primary_monitor(). func (v *Display) GetPrimaryMonitor() (*Monitor, error) { c := C.gdk_display_get_primary_monitor(v.native()) if c == nil { return nil, nilPtrErr } return &Monitor{glib.Take(unsafe.Pointer(c))}, nil } // GetMonitor is a wrapper around gdk_display_get_monitor(). func (v *Display) GetMonitor(num int) (*Monitor, error) { c := C.gdk_display_get_monitor(v.native(), C.int(num)) if c == nil { return nil, nilPtrErr } return &Monitor{glib.Take(unsafe.Pointer(c))}, nil } // GetMonitorAtWindow is a wrapper around gdk_display_get_monitor_at_window(). func (v *Display) GetMonitorAtWindow(w *Window) (*Monitor, error) { c := C.gdk_display_get_monitor_at_window(v.native(), w.native()) if c == nil { return nil, nilPtrErr } return &Monitor{glib.Take(unsafe.Pointer(c))}, nil } // GetMonitorAtPoint is a wrapper around gdk_display_get_monitor_at_point(). func (v *Display) GetMonitorAtPoint(x int, y int) (*Monitor, error) { c := C.gdk_display_get_monitor_at_point(v.native(), C.int(x), C.int(y)) if c == nil { return nil, nilPtrErr } return &Monitor{glib.Take(unsafe.Pointer(c))}, nil } /* * GdkSeat */ // TODO: // GdkSeatGrabPrepareFunc // gdk_seat_get_display(). // gdk_seat_grab(). // gdk_seat_ungrab(). // gdk_seat_get_capabilities(). // gdk_seat_get_pointer(). // gdk_seat_get_keyboard(). // gdk_seat_get_slaves(). /* * GdkMonitor */ // Monitor is a representation of GDK's GdkMonitor. type Monitor struct { *glib.Object } // native returns a pointer to the underlying GdkMonitor. func (v *Monitor) native() *C.GdkMonitor { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkMonitor(p) } // Native returns a pointer to the underlying GdkMonitor. func (v *Monitor) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalMonitor(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Monitor{obj}, nil } func toMonitor(s *C.GdkMonitor) (*Monitor, error) { if s == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(s))} return &Monitor{obj}, nil } // GetDisplay is a wrapper around gdk_monitor_get_display(). func (v *Monitor) GetDisplay() (*Display, error) { return toDisplay(C.gdk_monitor_get_display(v.native())) } // GetGeometry is a wrapper around gdk_monitor_get_geometry(). func (v *Monitor) GetGeometry() *Rectangle { var rect C.GdkRectangle C.gdk_monitor_get_geometry(v.native(), &rect) return wrapRectangle(&rect) } // GetWorkarea is a wrapper around gdk_monitor_get_workarea(). func (v *Monitor) GetWorkarea() *Rectangle { var rect C.GdkRectangle C.gdk_monitor_get_workarea(v.native(), &rect) return wrapRectangle(&rect) } // GetWidthMM is a wrapper around gdk_monitor_get_width_mm(). func (v *Monitor) GetWidthMM() int { return int(C.gdk_monitor_get_width_mm(v.native())) } // GetHeightMM is a wrapper around gdk_monitor_get_height_mm(). func (v *Monitor) GetHeightMM() int { return int(C.gdk_monitor_get_height_mm(v.native())) } // GetManufacturer is a wrapper around gdk_monitor_get_manufacturer(). func (v *Monitor) GetManufacturer() string { // transfer none: don't free data after the code is done. return C.GoString(C.gdk_monitor_get_manufacturer(v.native())) } // GetModel is a wrapper around gdk_monitor_get_model(). func (v *Monitor) GetModel() string { // transfer none: don't free data after the code is done. return C.GoString(C.gdk_monitor_get_model(v.native())) } // GetScaleFactor is a wrapper around gdk_monitor_get_scale_factor(). func (v *Monitor) GetScaleFactor() int { return int(C.gdk_monitor_get_scale_factor(v.native())) } // GetRefreshRate is a wrapper around gdk_monitor_get_refresh_rate(). func (v *Monitor) GetRefreshRate() int { return int(C.gdk_monitor_get_refresh_rate(v.native())) } // GetSubpixelLayout is a wrapper around gdk_monitor_get_subpixel_layout(). func (v *Monitor) GetSubpixelLayout() SubpixelLayout { return SubpixelLayout(C.gdk_monitor_get_subpixel_layout(v.native())) } // IsPrimary is a wrapper around gdk_monitor_is_primary(). func (v *Monitor) IsPrimary() bool { return gobool(C.gdk_monitor_is_primary(v.native())) } /* * GdkDevice */ // TODO: // gdk_device_get_axes(). // gdk_device_tool_get_serial(). // gdk_device_tool_get_tool_type(). /* * GdkGLContext */ // GetUseES is a wrapper around gdk_gl_context_get_use_es(). func (v *GLContext) GetUseES() bool { return gobool(C.gdk_gl_context_get_use_es(v.native())) } // SetUseES is a wrapper around gdk_gl_context_set_use_es(). func (v *GLContext) SetUseES(es int) { C.gdk_gl_context_set_use_es(v.native(), (C.int)(es)) } gotk3-0.6.2/gdk/gdk_since_3_22.go.h000066400000000000000000000017221431157473000165520ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ //#include // Type Casting static GdkMonitor *toGdkMonitor(void *p) { return (GDK_MONITOR(p)); } gotk3-0.6.2/gdk/gdk_since_3_8.go000066400000000000000000000162361431157473000162560ustar00rootroot00000000000000// +build !gtk_3_6 // Supports building with gtk 3.8+ /* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package gdk // #include // #include "gdk_since_3_8.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.gdk_frame_clock_phase_get_type()), marshalClockPhase}, // Objects/Interfaces {glib.Type(C.gdk_frame_clock_get_type()), marshalFrameClock}, {glib.Type(C.gdk_frame_timings_get_type()), marshalFrameTimings}, } glib.RegisterGValueMarshalers(tm) } // ClockPhase is a representation of GDK's GdkFrameClockPhase. type ClockPhase int const ( PHASE_NONE ClockPhase = C.GDK_FRAME_CLOCK_PHASE_NONE PHASE_FLUSH_EVENTS ClockPhase = C.GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS PHASE_BEFORE_PAINT ClockPhase = C.GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT PHASE_UPDATE ClockPhase = C.GDK_FRAME_CLOCK_PHASE_UPDATE PHASE_LAYOUT ClockPhase = C.GDK_FRAME_CLOCK_PHASE_LAYOUT PHASE_PAINT ClockPhase = C.GDK_FRAME_CLOCK_PHASE_PAINT PHASE_RESUME_EVENTS ClockPhase = C.GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS PHASE_AFTER_PAINT ClockPhase = C.GDK_FRAME_CLOCK_PHASE_AFTER_PAINT ) func marshalClockPhase(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ClockPhase(c), nil } /* * GdkFrameClock */ // FrameClock is a representation of GDK's GdkFrameClock. type FrameClock struct { *glib.Object } // native returns a pointer to the underlying GdkFrameClock. func (v *FrameClock) native() *C.GdkFrameClock { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkFrameClock(p) } // Native returns a pointer to the underlying GdkFrameClock. func (v *FrameClock) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalFrameClock(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return WrapFrameClock(unsafe.Pointer(c)), nil } func WrapFrameClock(ptr unsafe.Pointer) *FrameClock { obj := &glib.Object{glib.ToGObject(ptr)} return &FrameClock{obj} } // BeginUpdating is a wrapper around gdk_frame_clock_begin_updating(). func (v *FrameClock) BeginUpdating() { C.gdk_frame_clock_begin_updating(v.native()) } // EndUpdating is a wrapper around gdk_frame_clock_end_updating(). func (v *FrameClock) EndUpdating() { C.gdk_frame_clock_end_updating(v.native()) } // GetFrameTime is a wrapper around gdk_frame_clock_get_frame_time(). func (v *FrameClock) GetFrameTime() int64 { return int64(C.gdk_frame_clock_get_frame_time(v.native())) } // GetFrameCounter is a wrapper around gdk_frame_clock_get_frame_counter(). func (v *FrameClock) GetFrameCounter() int64 { return int64(C.gdk_frame_clock_get_frame_counter(v.native())) } // GetHistoryStart is a wrapper around gdk_frame_clock_get_history_start(). func (v *FrameClock) GetHistoryStart() int64 { return int64(C.gdk_frame_clock_get_history_start(v.native())) } // GetTimings is a wrapper around gdk_frame_clock_get_timings(). func (v *FrameClock) GetTimings(frameCounter int64) (*FrameTimings, error) { c := C.gdk_frame_clock_get_timings(v.native(), C.gint64(frameCounter)) if c == nil { return nil, nilPtrErr } return wrapFrameTimings(unsafe.Pointer(c)), nil } // GetCurrentTimings is a wrapper around dk_frame_clock_get_current_timings(). func (v *FrameClock) GetCurrentTimings() (*FrameTimings, error) { c := C.gdk_frame_clock_get_current_timings(v.native()) if c == nil { return nil, nilPtrErr } return wrapFrameTimings(unsafe.Pointer(c)), nil } // GetRefreshInfo is a wrapper around gdk_frame_clock_get_refresh_info(). func (v *FrameClock) GetRefreshInfo(baseTime int64) (int64, int64) { var cr, cp (*C.gint64) defer C.free(unsafe.Pointer(cr)) defer C.free(unsafe.Pointer(cp)) b := C.gint64(baseTime) C.gdk_frame_clock_get_refresh_info(v.native(), b, cr, cp) r, p := int64(*cr), int64(*cp) return r, p } // RequestPhase is a wrapper around gdk_frame_clock_request_phase(). func (v *FrameClock) RequestPhase(phase ClockPhase) { C.gdk_frame_clock_request_phase(v.native(), C.GdkFrameClockPhase(phase)) } /* * GdkFrameTimings */ // FrameTimings is a representation of GDK's GdkFrameTimings. type FrameTimings struct { *glib.Object } // native returns a pointer to the underlying GdkFrameTimings. func (v *FrameTimings) native() *C.GdkFrameTimings { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkFrameTimings(p) } // Native returns a pointer to the underlying GdkFrameTimings. func (v *FrameTimings) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func wrapFrameTimings(ptr unsafe.Pointer) *FrameTimings { obj := &glib.Object{glib.ToGObject(ptr)} return &FrameTimings{obj} } func marshalFrameTimings(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapFrameTimings(unsafe.Pointer(c)), nil } // Ref is a wrapper around gdk_frame_timings_ref(). func (v *FrameTimings) Ref() { c := C.gdk_frame_timings_ref(v.native()) v = wrapFrameTimings(unsafe.Pointer(c)) } // Unref is a wrapper around gdk_frame_timings_unref(). func (v *FrameTimings) Unref() { C.gdk_frame_timings_unref(v.native()) } // GetFrameCounter is a wrapper around gdk_frame_timings_get_frame_counter(). func (v *FrameTimings) GetFrameCounter() int64 { return int64(C.gdk_frame_timings_get_frame_counter(v.native())) } // GetComplete is a wrapper around gdk_frame_timings_get_complete(). func (v *FrameTimings) GetComplete() bool { return gobool(C.gdk_frame_timings_get_complete(v.native())) } // GetFrameTime is a wrapper around gdk_frame_timings_get_frame_time(). func (v *FrameTimings) GetFrameTime() int64 { return int64(C.gdk_frame_timings_get_frame_time(v.native())) } // GetPresentationTime is a wrapper around gdk_frame_timings_get_presentation_time(). func (v *FrameTimings) GetPresentationTime() int64 { return int64(C.gdk_frame_timings_get_presentation_time(v.native())) } // GetRefreshInterval is a wrapper around gdk_frame_timings_get_refresh_interval(). func (v *FrameTimings) GetRefreshInterval() int64 { return int64(C.gdk_frame_timings_get_refresh_interval(v.native())) } // GetPredictedPresentationTime is a wrapper around gdk_frame_timings_get_predicted_presentation_time(). func (v *FrameTimings) GetPredictedPresentationTime() int64 { return int64(C.gdk_frame_timings_get_predicted_presentation_time(v.native())) } gotk3-0.6.2/gdk/gdk_since_3_8.go.h000066400000000000000000000020621431157473000164740ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include // Type Casting static GdkFrameClock *toGdkFrameClock(void *p) { return (GDK_FRAME_CLOCK(p)); } static GdkFrameTimings *toGdkFrameTimings(void *p) { return ((GdkFrameTimings *)p); }gotk3-0.6.2/gdk/keys.go000066400000000000000000004270141431157473000146320ustar00rootroot00000000000000package gdk // #include // #include "gdk.go.h" import "C" const ( KEY_VoidSymbol = uint(C.GDK_KEY_VoidSymbol) KEY_BackSpace = uint(C.GDK_KEY_BackSpace) KEY_Tab = uint(C.GDK_KEY_Tab) KEY_Linefeed = uint(C.GDK_KEY_Linefeed) KEY_Clear = uint(C.GDK_KEY_Clear) KEY_Return = uint(C.GDK_KEY_Return) KEY_Pause = uint(C.GDK_KEY_Pause) KEY_Scroll_Lock = uint(C.GDK_KEY_Scroll_Lock) KEY_Sys_Req = uint(C.GDK_KEY_Sys_Req) KEY_Escape = uint(C.GDK_KEY_Escape) KEY_Delete = uint(C.GDK_KEY_Delete) KEY_Multi_key = uint(C.GDK_KEY_Multi_key) KEY_Codeinput = uint(C.GDK_KEY_Codeinput) KEY_SingleCandidate = uint(C.GDK_KEY_SingleCandidate) KEY_MultipleCandidate = uint(C.GDK_KEY_MultipleCandidate) KEY_PreviousCandidate = uint(C.GDK_KEY_PreviousCandidate) KEY_Kanji = uint(C.GDK_KEY_Kanji) KEY_Muhenkan = uint(C.GDK_KEY_Muhenkan) KEY_Henkan_Mode = uint(C.GDK_KEY_Henkan_Mode) KEY_Henkan = uint(C.GDK_KEY_Henkan) KEY_Romaji = uint(C.GDK_KEY_Romaji) KEY_Hiragana = uint(C.GDK_KEY_Hiragana) KEY_Katakana = uint(C.GDK_KEY_Katakana) KEY_Hiragana_Katakana = uint(C.GDK_KEY_Hiragana_Katakana) KEY_Zenkaku = uint(C.GDK_KEY_Zenkaku) KEY_Hankaku = uint(C.GDK_KEY_Hankaku) KEY_Zenkaku_Hankaku = uint(C.GDK_KEY_Zenkaku_Hankaku) KEY_Touroku = uint(C.GDK_KEY_Touroku) KEY_Massyo = uint(C.GDK_KEY_Massyo) KEY_Kana_Lock = uint(C.GDK_KEY_Kana_Lock) KEY_Kana_Shift = uint(C.GDK_KEY_Kana_Shift) KEY_Eisu_Shift = uint(C.GDK_KEY_Eisu_Shift) KEY_Eisu_toggle = uint(C.GDK_KEY_Eisu_toggle) KEY_Kanji_Bangou = uint(C.GDK_KEY_Kanji_Bangou) KEY_Zen_Koho = uint(C.GDK_KEY_Zen_Koho) KEY_Mae_Koho = uint(C.GDK_KEY_Mae_Koho) KEY_Home = uint(C.GDK_KEY_Home) KEY_Left = uint(C.GDK_KEY_Left) KEY_Up = uint(C.GDK_KEY_Up) KEY_Right = uint(C.GDK_KEY_Right) KEY_Down = uint(C.GDK_KEY_Down) KEY_Prior = uint(C.GDK_KEY_Prior) KEY_Page_Up = uint(C.GDK_KEY_Page_Up) KEY_Next = uint(C.GDK_KEY_Next) KEY_Page_Down = uint(C.GDK_KEY_Page_Down) KEY_End = uint(C.GDK_KEY_End) KEY_Begin = uint(C.GDK_KEY_Begin) KEY_Select = uint(C.GDK_KEY_Select) KEY_Print = uint(C.GDK_KEY_Print) KEY_Execute = uint(C.GDK_KEY_Execute) KEY_Insert = uint(C.GDK_KEY_Insert) KEY_Undo = uint(C.GDK_KEY_Undo) KEY_Redo = uint(C.GDK_KEY_Redo) KEY_Menu = uint(C.GDK_KEY_Menu) KEY_Find = uint(C.GDK_KEY_Find) KEY_Cancel = uint(C.GDK_KEY_Cancel) KEY_Help = uint(C.GDK_KEY_Help) KEY_Break = uint(C.GDK_KEY_Break) KEY_Mode_switch = uint(C.GDK_KEY_Mode_switch) KEY_script_switch = uint(C.GDK_KEY_script_switch) KEY_Num_Lock = uint(C.GDK_KEY_Num_Lock) KEY_KP_Space = uint(C.GDK_KEY_KP_Space) KEY_KP_Tab = uint(C.GDK_KEY_KP_Tab) KEY_KP_Enter = uint(C.GDK_KEY_KP_Enter) KEY_KP_F1 = uint(C.GDK_KEY_KP_F1) KEY_KP_F2 = uint(C.GDK_KEY_KP_F2) KEY_KP_F3 = uint(C.GDK_KEY_KP_F3) KEY_KP_F4 = uint(C.GDK_KEY_KP_F4) KEY_KP_Home = uint(C.GDK_KEY_KP_Home) KEY_KP_Left = uint(C.GDK_KEY_KP_Left) KEY_KP_Up = uint(C.GDK_KEY_KP_Up) KEY_KP_Right = uint(C.GDK_KEY_KP_Right) KEY_KP_Down = uint(C.GDK_KEY_KP_Down) KEY_KP_Prior = uint(C.GDK_KEY_KP_Prior) KEY_KP_Page_Up = uint(C.GDK_KEY_KP_Page_Up) KEY_KP_Next = uint(C.GDK_KEY_KP_Next) KEY_KP_Page_Down = uint(C.GDK_KEY_KP_Page_Down) KEY_KP_End = uint(C.GDK_KEY_KP_End) KEY_KP_Begin = uint(C.GDK_KEY_KP_Begin) KEY_KP_Insert = uint(C.GDK_KEY_KP_Insert) KEY_KP_Delete = uint(C.GDK_KEY_KP_Delete) KEY_KP_Equal = uint(C.GDK_KEY_KP_Equal) KEY_KP_Multiply = uint(C.GDK_KEY_KP_Multiply) KEY_KP_Add = uint(C.GDK_KEY_KP_Add) KEY_KP_Separator = uint(C.GDK_KEY_KP_Separator) KEY_KP_Subtract = uint(C.GDK_KEY_KP_Subtract) KEY_KP_Decimal = uint(C.GDK_KEY_KP_Decimal) KEY_KP_Divide = uint(C.GDK_KEY_KP_Divide) KEY_KP_0 = uint(C.GDK_KEY_KP_0) KEY_KP_1 = uint(C.GDK_KEY_KP_1) KEY_KP_2 = uint(C.GDK_KEY_KP_2) KEY_KP_3 = uint(C.GDK_KEY_KP_3) KEY_KP_4 = uint(C.GDK_KEY_KP_4) KEY_KP_5 = uint(C.GDK_KEY_KP_5) KEY_KP_6 = uint(C.GDK_KEY_KP_6) KEY_KP_7 = uint(C.GDK_KEY_KP_7) KEY_KP_8 = uint(C.GDK_KEY_KP_8) KEY_KP_9 = uint(C.GDK_KEY_KP_9) KEY_F1 = uint(C.GDK_KEY_F1) KEY_F2 = uint(C.GDK_KEY_F2) KEY_F3 = uint(C.GDK_KEY_F3) KEY_F4 = uint(C.GDK_KEY_F4) KEY_F5 = uint(C.GDK_KEY_F5) KEY_F6 = uint(C.GDK_KEY_F6) KEY_F7 = uint(C.GDK_KEY_F7) KEY_F8 = uint(C.GDK_KEY_F8) KEY_F9 = uint(C.GDK_KEY_F9) KEY_F10 = uint(C.GDK_KEY_F10) KEY_F11 = uint(C.GDK_KEY_F11) KEY_L1 = uint(C.GDK_KEY_L1) KEY_F12 = uint(C.GDK_KEY_F12) KEY_L2 = uint(C.GDK_KEY_L2) KEY_F13 = uint(C.GDK_KEY_F13) KEY_L3 = uint(C.GDK_KEY_L3) KEY_F14 = uint(C.GDK_KEY_F14) KEY_L4 = uint(C.GDK_KEY_L4) KEY_F15 = uint(C.GDK_KEY_F15) KEY_L5 = uint(C.GDK_KEY_L5) KEY_F16 = uint(C.GDK_KEY_F16) KEY_L6 = uint(C.GDK_KEY_L6) KEY_F17 = uint(C.GDK_KEY_F17) KEY_L7 = uint(C.GDK_KEY_L7) KEY_F18 = uint(C.GDK_KEY_F18) KEY_L8 = uint(C.GDK_KEY_L8) KEY_F19 = uint(C.GDK_KEY_F19) KEY_L9 = uint(C.GDK_KEY_L9) KEY_F20 = uint(C.GDK_KEY_F20) KEY_L10 = uint(C.GDK_KEY_L10) KEY_F21 = uint(C.GDK_KEY_F21) KEY_R1 = uint(C.GDK_KEY_R1) KEY_F22 = uint(C.GDK_KEY_F22) KEY_R2 = uint(C.GDK_KEY_R2) KEY_F23 = uint(C.GDK_KEY_F23) KEY_R3 = uint(C.GDK_KEY_R3) KEY_F24 = uint(C.GDK_KEY_F24) KEY_R4 = uint(C.GDK_KEY_R4) KEY_F25 = uint(C.GDK_KEY_F25) KEY_R5 = uint(C.GDK_KEY_R5) KEY_F26 = uint(C.GDK_KEY_F26) KEY_R6 = uint(C.GDK_KEY_R6) KEY_F27 = uint(C.GDK_KEY_F27) KEY_R7 = uint(C.GDK_KEY_R7) KEY_F28 = uint(C.GDK_KEY_F28) KEY_R8 = uint(C.GDK_KEY_R8) KEY_F29 = uint(C.GDK_KEY_F29) KEY_R9 = uint(C.GDK_KEY_R9) KEY_F30 = uint(C.GDK_KEY_F30) KEY_R10 = uint(C.GDK_KEY_R10) KEY_F31 = uint(C.GDK_KEY_F31) KEY_R11 = uint(C.GDK_KEY_R11) KEY_F32 = uint(C.GDK_KEY_F32) KEY_R12 = uint(C.GDK_KEY_R12) KEY_F33 = uint(C.GDK_KEY_F33) KEY_R13 = uint(C.GDK_KEY_R13) KEY_F34 = uint(C.GDK_KEY_F34) KEY_R14 = uint(C.GDK_KEY_R14) KEY_F35 = uint(C.GDK_KEY_F35) KEY_R15 = uint(C.GDK_KEY_R15) KEY_Shift_L = uint(C.GDK_KEY_Shift_L) KEY_Shift_R = uint(C.GDK_KEY_Shift_R) KEY_Control_L = uint(C.GDK_KEY_Control_L) KEY_Control_R = uint(C.GDK_KEY_Control_R) KEY_Caps_Lock = uint(C.GDK_KEY_Caps_Lock) KEY_Shift_Lock = uint(C.GDK_KEY_Shift_Lock) KEY_Meta_L = uint(C.GDK_KEY_Meta_L) KEY_Meta_R = uint(C.GDK_KEY_Meta_R) KEY_Alt_L = uint(C.GDK_KEY_Alt_L) KEY_Alt_R = uint(C.GDK_KEY_Alt_R) KEY_Super_L = uint(C.GDK_KEY_Super_L) KEY_Super_R = uint(C.GDK_KEY_Super_R) KEY_Hyper_L = uint(C.GDK_KEY_Hyper_L) KEY_Hyper_R = uint(C.GDK_KEY_Hyper_R) KEY_ISO_Lock = uint(C.GDK_KEY_ISO_Lock) KEY_ISO_Level2_Latch = uint(C.GDK_KEY_ISO_Level2_Latch) KEY_ISO_Level3_Shift = uint(C.GDK_KEY_ISO_Level3_Shift) KEY_ISO_Level3_Latch = uint(C.GDK_KEY_ISO_Level3_Latch) KEY_ISO_Level3_Lock = uint(C.GDK_KEY_ISO_Level3_Lock) KEY_ISO_Level5_Shift = uint(C.GDK_KEY_ISO_Level5_Shift) KEY_ISO_Level5_Latch = uint(C.GDK_KEY_ISO_Level5_Latch) KEY_ISO_Level5_Lock = uint(C.GDK_KEY_ISO_Level5_Lock) KEY_ISO_Group_Shift = uint(C.GDK_KEY_ISO_Group_Shift) KEY_ISO_Group_Latch = uint(C.GDK_KEY_ISO_Group_Latch) KEY_ISO_Group_Lock = uint(C.GDK_KEY_ISO_Group_Lock) KEY_ISO_Next_Group = uint(C.GDK_KEY_ISO_Next_Group) KEY_ISO_Next_Group_Lock = uint(C.GDK_KEY_ISO_Next_Group_Lock) KEY_ISO_Prev_Group = uint(C.GDK_KEY_ISO_Prev_Group) KEY_ISO_Prev_Group_Lock = uint(C.GDK_KEY_ISO_Prev_Group_Lock) KEY_ISO_First_Group = uint(C.GDK_KEY_ISO_First_Group) KEY_ISO_First_Group_Lock = uint(C.GDK_KEY_ISO_First_Group_Lock) KEY_ISO_Last_Group = uint(C.GDK_KEY_ISO_Last_Group) KEY_ISO_Last_Group_Lock = uint(C.GDK_KEY_ISO_Last_Group_Lock) KEY_ISO_Left_Tab = uint(C.GDK_KEY_ISO_Left_Tab) KEY_ISO_Move_Line_Up = uint(C.GDK_KEY_ISO_Move_Line_Up) KEY_ISO_Move_Line_Down = uint(C.GDK_KEY_ISO_Move_Line_Down) KEY_ISO_Partial_Line_Up = uint(C.GDK_KEY_ISO_Partial_Line_Up) KEY_ISO_Partial_Line_Down = uint(C.GDK_KEY_ISO_Partial_Line_Down) KEY_ISO_Partial_Space_Left = uint(C.GDK_KEY_ISO_Partial_Space_Left) KEY_ISO_Partial_Space_Right = uint(C.GDK_KEY_ISO_Partial_Space_Right) KEY_ISO_Set_Margin_Left = uint(C.GDK_KEY_ISO_Set_Margin_Left) KEY_ISO_Set_Margin_Right = uint(C.GDK_KEY_ISO_Set_Margin_Right) KEY_ISO_Release_Margin_Left = uint(C.GDK_KEY_ISO_Release_Margin_Left) KEY_ISO_Release_Margin_Right = uint(C.GDK_KEY_ISO_Release_Margin_Right) KEY_ISO_Release_Both_Margins = uint(C.GDK_KEY_ISO_Release_Both_Margins) KEY_ISO_Fast_Cursor_Left = uint(C.GDK_KEY_ISO_Fast_Cursor_Left) KEY_ISO_Fast_Cursor_Right = uint(C.GDK_KEY_ISO_Fast_Cursor_Right) KEY_ISO_Fast_Cursor_Up = uint(C.GDK_KEY_ISO_Fast_Cursor_Up) KEY_ISO_Fast_Cursor_Down = uint(C.GDK_KEY_ISO_Fast_Cursor_Down) KEY_ISO_Continuous_Underline = uint(C.GDK_KEY_ISO_Continuous_Underline) KEY_ISO_Discontinuous_Underline = uint(C.GDK_KEY_ISO_Discontinuous_Underline) KEY_ISO_Emphasize = uint(C.GDK_KEY_ISO_Emphasize) KEY_ISO_Center_Object = uint(C.GDK_KEY_ISO_Center_Object) KEY_ISO_Enter = uint(C.GDK_KEY_ISO_Enter) KEY_dead_grave = uint(C.GDK_KEY_dead_grave) KEY_dead_acute = uint(C.GDK_KEY_dead_acute) KEY_dead_circumflex = uint(C.GDK_KEY_dead_circumflex) KEY_dead_tilde = uint(C.GDK_KEY_dead_tilde) KEY_dead_perispomeni = uint(C.GDK_KEY_dead_perispomeni) KEY_dead_macron = uint(C.GDK_KEY_dead_macron) KEY_dead_breve = uint(C.GDK_KEY_dead_breve) KEY_dead_abovedot = uint(C.GDK_KEY_dead_abovedot) KEY_dead_diaeresis = uint(C.GDK_KEY_dead_diaeresis) KEY_dead_abovering = uint(C.GDK_KEY_dead_abovering) KEY_dead_doubleacute = uint(C.GDK_KEY_dead_doubleacute) KEY_dead_caron = uint(C.GDK_KEY_dead_caron) KEY_dead_cedilla = uint(C.GDK_KEY_dead_cedilla) KEY_dead_ogonek = uint(C.GDK_KEY_dead_ogonek) KEY_dead_iota = uint(C.GDK_KEY_dead_iota) KEY_dead_voiced_sound = uint(C.GDK_KEY_dead_voiced_sound) KEY_dead_semivoiced_sound = uint(C.GDK_KEY_dead_semivoiced_sound) KEY_dead_belowdot = uint(C.GDK_KEY_dead_belowdot) KEY_dead_hook = uint(C.GDK_KEY_dead_hook) KEY_dead_horn = uint(C.GDK_KEY_dead_horn) KEY_dead_stroke = uint(C.GDK_KEY_dead_stroke) KEY_dead_abovecomma = uint(C.GDK_KEY_dead_abovecomma) KEY_dead_psili = uint(C.GDK_KEY_dead_psili) KEY_dead_abovereversedcomma = uint(C.GDK_KEY_dead_abovereversedcomma) KEY_dead_dasia = uint(C.GDK_KEY_dead_dasia) KEY_dead_doublegrave = uint(C.GDK_KEY_dead_doublegrave) KEY_dead_belowring = uint(C.GDK_KEY_dead_belowring) KEY_dead_belowmacron = uint(C.GDK_KEY_dead_belowmacron) KEY_dead_belowcircumflex = uint(C.GDK_KEY_dead_belowcircumflex) KEY_dead_belowtilde = uint(C.GDK_KEY_dead_belowtilde) KEY_dead_belowbreve = uint(C.GDK_KEY_dead_belowbreve) KEY_dead_belowdiaeresis = uint(C.GDK_KEY_dead_belowdiaeresis) KEY_dead_invertedbreve = uint(C.GDK_KEY_dead_invertedbreve) KEY_dead_belowcomma = uint(C.GDK_KEY_dead_belowcomma) KEY_dead_currency = uint(C.GDK_KEY_dead_currency) KEY_dead_a = uint(C.GDK_KEY_dead_a) KEY_dead_A = uint(C.GDK_KEY_dead_A) KEY_dead_e = uint(C.GDK_KEY_dead_e) KEY_dead_E = uint(C.GDK_KEY_dead_E) KEY_dead_i = uint(C.GDK_KEY_dead_i) KEY_dead_I = uint(C.GDK_KEY_dead_I) KEY_dead_o = uint(C.GDK_KEY_dead_o) KEY_dead_O = uint(C.GDK_KEY_dead_O) KEY_dead_u = uint(C.GDK_KEY_dead_u) KEY_dead_U = uint(C.GDK_KEY_dead_U) KEY_dead_small_schwa = uint(C.GDK_KEY_dead_small_schwa) KEY_dead_capital_schwa = uint(C.GDK_KEY_dead_capital_schwa) KEY_dead_greek = uint(C.GDK_KEY_dead_greek) KEY_First_Virtual_Screen = uint(C.GDK_KEY_First_Virtual_Screen) KEY_Prev_Virtual_Screen = uint(C.GDK_KEY_Prev_Virtual_Screen) KEY_Next_Virtual_Screen = uint(C.GDK_KEY_Next_Virtual_Screen) KEY_Last_Virtual_Screen = uint(C.GDK_KEY_Last_Virtual_Screen) KEY_Terminate_Server = uint(C.GDK_KEY_Terminate_Server) KEY_AccessX_Enable = uint(C.GDK_KEY_AccessX_Enable) KEY_AccessX_Feedback_Enable = uint(C.GDK_KEY_AccessX_Feedback_Enable) KEY_RepeatKeys_Enable = uint(C.GDK_KEY_RepeatKeys_Enable) KEY_SlowKeys_Enable = uint(C.GDK_KEY_SlowKeys_Enable) KEY_BounceKeys_Enable = uint(C.GDK_KEY_BounceKeys_Enable) KEY_StickyKeys_Enable = uint(C.GDK_KEY_StickyKeys_Enable) KEY_MouseKeys_Enable = uint(C.GDK_KEY_MouseKeys_Enable) KEY_MouseKeys_Accel_Enable = uint(C.GDK_KEY_MouseKeys_Accel_Enable) KEY_Overlay1_Enable = uint(C.GDK_KEY_Overlay1_Enable) KEY_Overlay2_Enable = uint(C.GDK_KEY_Overlay2_Enable) KEY_AudibleBell_Enable = uint(C.GDK_KEY_AudibleBell_Enable) KEY_Pointer_Left = uint(C.GDK_KEY_Pointer_Left) KEY_Pointer_Right = uint(C.GDK_KEY_Pointer_Right) KEY_Pointer_Up = uint(C.GDK_KEY_Pointer_Up) KEY_Pointer_Down = uint(C.GDK_KEY_Pointer_Down) KEY_Pointer_UpLeft = uint(C.GDK_KEY_Pointer_UpLeft) KEY_Pointer_UpRight = uint(C.GDK_KEY_Pointer_UpRight) KEY_Pointer_DownLeft = uint(C.GDK_KEY_Pointer_DownLeft) KEY_Pointer_DownRight = uint(C.GDK_KEY_Pointer_DownRight) KEY_Pointer_Button_Dflt = uint(C.GDK_KEY_Pointer_Button_Dflt) KEY_Pointer_Button1 = uint(C.GDK_KEY_Pointer_Button1) KEY_Pointer_Button2 = uint(C.GDK_KEY_Pointer_Button2) KEY_Pointer_Button3 = uint(C.GDK_KEY_Pointer_Button3) KEY_Pointer_Button4 = uint(C.GDK_KEY_Pointer_Button4) KEY_Pointer_Button5 = uint(C.GDK_KEY_Pointer_Button5) KEY_Pointer_DblClick_Dflt = uint(C.GDK_KEY_Pointer_DblClick_Dflt) KEY_Pointer_DblClick1 = uint(C.GDK_KEY_Pointer_DblClick1) KEY_Pointer_DblClick2 = uint(C.GDK_KEY_Pointer_DblClick2) KEY_Pointer_DblClick3 = uint(C.GDK_KEY_Pointer_DblClick3) KEY_Pointer_DblClick4 = uint(C.GDK_KEY_Pointer_DblClick4) KEY_Pointer_DblClick5 = uint(C.GDK_KEY_Pointer_DblClick5) KEY_Pointer_Drag_Dflt = uint(C.GDK_KEY_Pointer_Drag_Dflt) KEY_Pointer_Drag1 = uint(C.GDK_KEY_Pointer_Drag1) KEY_Pointer_Drag2 = uint(C.GDK_KEY_Pointer_Drag2) KEY_Pointer_Drag3 = uint(C.GDK_KEY_Pointer_Drag3) KEY_Pointer_Drag4 = uint(C.GDK_KEY_Pointer_Drag4) KEY_Pointer_Drag5 = uint(C.GDK_KEY_Pointer_Drag5) KEY_Pointer_EnableKeys = uint(C.GDK_KEY_Pointer_EnableKeys) KEY_Pointer_Accelerate = uint(C.GDK_KEY_Pointer_Accelerate) KEY_Pointer_DfltBtnNext = uint(C.GDK_KEY_Pointer_DfltBtnNext) KEY_Pointer_DfltBtnPrev = uint(C.GDK_KEY_Pointer_DfltBtnPrev) KEY_ch = uint(C.GDK_KEY_ch) KEY_Ch = uint(C.GDK_KEY_Ch) KEY_CH = uint(C.GDK_KEY_CH) KEY_c_h = uint(C.GDK_KEY_c_h) KEY_C_h = uint(C.GDK_KEY_C_h) KEY_C_H = uint(C.GDK_KEY_C_H) KEY_3270_Duplicate = uint(C.GDK_KEY_3270_Duplicate) KEY_3270_FieldMark = uint(C.GDK_KEY_3270_FieldMark) KEY_3270_Right2 = uint(C.GDK_KEY_3270_Right2) KEY_3270_Left2 = uint(C.GDK_KEY_3270_Left2) KEY_3270_BackTab = uint(C.GDK_KEY_3270_BackTab) KEY_3270_EraseEOF = uint(C.GDK_KEY_3270_EraseEOF) KEY_3270_EraseInput = uint(C.GDK_KEY_3270_EraseInput) KEY_3270_Reset = uint(C.GDK_KEY_3270_Reset) KEY_3270_Quit = uint(C.GDK_KEY_3270_Quit) KEY_3270_PA1 = uint(C.GDK_KEY_3270_PA1) KEY_3270_PA2 = uint(C.GDK_KEY_3270_PA2) KEY_3270_PA3 = uint(C.GDK_KEY_3270_PA3) KEY_3270_Test = uint(C.GDK_KEY_3270_Test) KEY_3270_Attn = uint(C.GDK_KEY_3270_Attn) KEY_3270_CursorBlink = uint(C.GDK_KEY_3270_CursorBlink) KEY_3270_AltCursor = uint(C.GDK_KEY_3270_AltCursor) KEY_3270_KeyClick = uint(C.GDK_KEY_3270_KeyClick) KEY_3270_Jump = uint(C.GDK_KEY_3270_Jump) KEY_3270_Ident = uint(C.GDK_KEY_3270_Ident) KEY_3270_Rule = uint(C.GDK_KEY_3270_Rule) KEY_3270_Copy = uint(C.GDK_KEY_3270_Copy) KEY_3270_Play = uint(C.GDK_KEY_3270_Play) KEY_3270_Setup = uint(C.GDK_KEY_3270_Setup) KEY_3270_Record = uint(C.GDK_KEY_3270_Record) KEY_3270_ChangeScreen = uint(C.GDK_KEY_3270_ChangeScreen) KEY_3270_DeleteWord = uint(C.GDK_KEY_3270_DeleteWord) KEY_3270_ExSelect = uint(C.GDK_KEY_3270_ExSelect) KEY_3270_CursorSelect = uint(C.GDK_KEY_3270_CursorSelect) KEY_3270_PrintScreen = uint(C.GDK_KEY_3270_PrintScreen) KEY_3270_Enter = uint(C.GDK_KEY_3270_Enter) KEY_space = uint(C.GDK_KEY_space) KEY_exclam = uint(C.GDK_KEY_exclam) KEY_quotedbl = uint(C.GDK_KEY_quotedbl) KEY_numbersign = uint(C.GDK_KEY_numbersign) KEY_dollar = uint(C.GDK_KEY_dollar) KEY_percent = uint(C.GDK_KEY_percent) KEY_ampersand = uint(C.GDK_KEY_ampersand) KEY_apostrophe = uint(C.GDK_KEY_apostrophe) KEY_quoteright = uint(C.GDK_KEY_quoteright) KEY_parenleft = uint(C.GDK_KEY_parenleft) KEY_parenright = uint(C.GDK_KEY_parenright) KEY_asterisk = uint(C.GDK_KEY_asterisk) KEY_plus = uint(C.GDK_KEY_plus) KEY_comma = uint(C.GDK_KEY_comma) KEY_minus = uint(C.GDK_KEY_minus) KEY_period = uint(C.GDK_KEY_period) KEY_slash = uint(C.GDK_KEY_slash) KEY_0 = uint(C.GDK_KEY_0) KEY_1 = uint(C.GDK_KEY_1) KEY_2 = uint(C.GDK_KEY_2) KEY_3 = uint(C.GDK_KEY_3) KEY_4 = uint(C.GDK_KEY_4) KEY_5 = uint(C.GDK_KEY_5) KEY_6 = uint(C.GDK_KEY_6) KEY_7 = uint(C.GDK_KEY_7) KEY_8 = uint(C.GDK_KEY_8) KEY_9 = uint(C.GDK_KEY_9) KEY_colon = uint(C.GDK_KEY_colon) KEY_semicolon = uint(C.GDK_KEY_semicolon) KEY_less = uint(C.GDK_KEY_less) KEY_equal = uint(C.GDK_KEY_equal) KEY_greater = uint(C.GDK_KEY_greater) KEY_question = uint(C.GDK_KEY_question) KEY_at = uint(C.GDK_KEY_at) KEY_A = uint(C.GDK_KEY_A) KEY_B = uint(C.GDK_KEY_B) KEY_C = uint(C.GDK_KEY_C) KEY_D = uint(C.GDK_KEY_D) KEY_E = uint(C.GDK_KEY_E) KEY_F = uint(C.GDK_KEY_F) KEY_G = uint(C.GDK_KEY_G) KEY_H = uint(C.GDK_KEY_H) KEY_I = uint(C.GDK_KEY_I) KEY_J = uint(C.GDK_KEY_J) KEY_K = uint(C.GDK_KEY_K) KEY_L = uint(C.GDK_KEY_L) KEY_M = uint(C.GDK_KEY_M) KEY_N = uint(C.GDK_KEY_N) KEY_O = uint(C.GDK_KEY_O) KEY_P = uint(C.GDK_KEY_P) KEY_Q = uint(C.GDK_KEY_Q) KEY_R = uint(C.GDK_KEY_R) KEY_S = uint(C.GDK_KEY_S) KEY_T = uint(C.GDK_KEY_T) KEY_U = uint(C.GDK_KEY_U) KEY_V = uint(C.GDK_KEY_V) KEY_W = uint(C.GDK_KEY_W) KEY_X = uint(C.GDK_KEY_X) KEY_Y = uint(C.GDK_KEY_Y) KEY_Z = uint(C.GDK_KEY_Z) KEY_bracketleft = uint(C.GDK_KEY_bracketleft) KEY_backslash = uint(C.GDK_KEY_backslash) KEY_bracketright = uint(C.GDK_KEY_bracketright) KEY_asciicircum = uint(C.GDK_KEY_asciicircum) KEY_underscore = uint(C.GDK_KEY_underscore) KEY_grave = uint(C.GDK_KEY_grave) KEY_quoteleft = uint(C.GDK_KEY_quoteleft) KEY_a = uint(C.GDK_KEY_a) KEY_b = uint(C.GDK_KEY_b) KEY_c = uint(C.GDK_KEY_c) KEY_d = uint(C.GDK_KEY_d) KEY_e = uint(C.GDK_KEY_e) KEY_f = uint(C.GDK_KEY_f) KEY_g = uint(C.GDK_KEY_g) KEY_h = uint(C.GDK_KEY_h) KEY_i = uint(C.GDK_KEY_i) KEY_j = uint(C.GDK_KEY_j) KEY_k = uint(C.GDK_KEY_k) KEY_l = uint(C.GDK_KEY_l) KEY_m = uint(C.GDK_KEY_m) KEY_n = uint(C.GDK_KEY_n) KEY_o = uint(C.GDK_KEY_o) KEY_p = uint(C.GDK_KEY_p) KEY_q = uint(C.GDK_KEY_q) KEY_r = uint(C.GDK_KEY_r) KEY_s = uint(C.GDK_KEY_s) KEY_t = uint(C.GDK_KEY_t) KEY_u = uint(C.GDK_KEY_u) KEY_v = uint(C.GDK_KEY_v) KEY_w = uint(C.GDK_KEY_w) KEY_x = uint(C.GDK_KEY_x) KEY_y = uint(C.GDK_KEY_y) KEY_z = uint(C.GDK_KEY_z) KEY_braceleft = uint(C.GDK_KEY_braceleft) KEY_bar = uint(C.GDK_KEY_bar) KEY_braceright = uint(C.GDK_KEY_braceright) KEY_asciitilde = uint(C.GDK_KEY_asciitilde) KEY_nobreakspace = uint(C.GDK_KEY_nobreakspace) KEY_exclamdown = uint(C.GDK_KEY_exclamdown) KEY_cent = uint(C.GDK_KEY_cent) KEY_sterling = uint(C.GDK_KEY_sterling) KEY_currency = uint(C.GDK_KEY_currency) KEY_yen = uint(C.GDK_KEY_yen) KEY_brokenbar = uint(C.GDK_KEY_brokenbar) KEY_section = uint(C.GDK_KEY_section) KEY_diaeresis = uint(C.GDK_KEY_diaeresis) KEY_copyright = uint(C.GDK_KEY_copyright) KEY_ordfeminine = uint(C.GDK_KEY_ordfeminine) KEY_guillemotleft = uint(C.GDK_KEY_guillemotleft) KEY_notsign = uint(C.GDK_KEY_notsign) KEY_hyphen = uint(C.GDK_KEY_hyphen) KEY_registered = uint(C.GDK_KEY_registered) KEY_macron = uint(C.GDK_KEY_macron) KEY_degree = uint(C.GDK_KEY_degree) KEY_plusminus = uint(C.GDK_KEY_plusminus) KEY_twosuperior = uint(C.GDK_KEY_twosuperior) KEY_threesuperior = uint(C.GDK_KEY_threesuperior) KEY_acute = uint(C.GDK_KEY_acute) KEY_mu = uint(C.GDK_KEY_mu) KEY_paragraph = uint(C.GDK_KEY_paragraph) KEY_periodcentered = uint(C.GDK_KEY_periodcentered) KEY_cedilla = uint(C.GDK_KEY_cedilla) KEY_onesuperior = uint(C.GDK_KEY_onesuperior) KEY_masculine = uint(C.GDK_KEY_masculine) KEY_guillemotright = uint(C.GDK_KEY_guillemotright) KEY_onequarter = uint(C.GDK_KEY_onequarter) KEY_onehalf = uint(C.GDK_KEY_onehalf) KEY_threequarters = uint(C.GDK_KEY_threequarters) KEY_questiondown = uint(C.GDK_KEY_questiondown) KEY_Agrave = uint(C.GDK_KEY_Agrave) KEY_Aacute = uint(C.GDK_KEY_Aacute) KEY_Acircumflex = uint(C.GDK_KEY_Acircumflex) KEY_Atilde = uint(C.GDK_KEY_Atilde) KEY_Adiaeresis = uint(C.GDK_KEY_Adiaeresis) KEY_Aring = uint(C.GDK_KEY_Aring) KEY_AE = uint(C.GDK_KEY_AE) KEY_Ccedilla = uint(C.GDK_KEY_Ccedilla) KEY_Egrave = uint(C.GDK_KEY_Egrave) KEY_Eacute = uint(C.GDK_KEY_Eacute) KEY_Ecircumflex = uint(C.GDK_KEY_Ecircumflex) KEY_Ediaeresis = uint(C.GDK_KEY_Ediaeresis) KEY_Igrave = uint(C.GDK_KEY_Igrave) KEY_Iacute = uint(C.GDK_KEY_Iacute) KEY_Icircumflex = uint(C.GDK_KEY_Icircumflex) KEY_Idiaeresis = uint(C.GDK_KEY_Idiaeresis) KEY_ETH = uint(C.GDK_KEY_ETH) KEY_Eth = uint(C.GDK_KEY_Eth) KEY_Ntilde = uint(C.GDK_KEY_Ntilde) KEY_Ograve = uint(C.GDK_KEY_Ograve) KEY_Oacute = uint(C.GDK_KEY_Oacute) KEY_Ocircumflex = uint(C.GDK_KEY_Ocircumflex) KEY_Otilde = uint(C.GDK_KEY_Otilde) KEY_Odiaeresis = uint(C.GDK_KEY_Odiaeresis) KEY_multiply = uint(C.GDK_KEY_multiply) KEY_Oslash = uint(C.GDK_KEY_Oslash) KEY_Ooblique = uint(C.GDK_KEY_Ooblique) KEY_Ugrave = uint(C.GDK_KEY_Ugrave) KEY_Uacute = uint(C.GDK_KEY_Uacute) KEY_Ucircumflex = uint(C.GDK_KEY_Ucircumflex) KEY_Udiaeresis = uint(C.GDK_KEY_Udiaeresis) KEY_Yacute = uint(C.GDK_KEY_Yacute) KEY_THORN = uint(C.GDK_KEY_THORN) KEY_Thorn = uint(C.GDK_KEY_Thorn) KEY_ssharp = uint(C.GDK_KEY_ssharp) KEY_agrave = uint(C.GDK_KEY_agrave) KEY_aacute = uint(C.GDK_KEY_aacute) KEY_acircumflex = uint(C.GDK_KEY_acircumflex) KEY_atilde = uint(C.GDK_KEY_atilde) KEY_adiaeresis = uint(C.GDK_KEY_adiaeresis) KEY_aring = uint(C.GDK_KEY_aring) KEY_ae = uint(C.GDK_KEY_ae) KEY_ccedilla = uint(C.GDK_KEY_ccedilla) KEY_egrave = uint(C.GDK_KEY_egrave) KEY_eacute = uint(C.GDK_KEY_eacute) KEY_ecircumflex = uint(C.GDK_KEY_ecircumflex) KEY_ediaeresis = uint(C.GDK_KEY_ediaeresis) KEY_igrave = uint(C.GDK_KEY_igrave) KEY_iacute = uint(C.GDK_KEY_iacute) KEY_icircumflex = uint(C.GDK_KEY_icircumflex) KEY_idiaeresis = uint(C.GDK_KEY_idiaeresis) KEY_eth = uint(C.GDK_KEY_eth) KEY_ntilde = uint(C.GDK_KEY_ntilde) KEY_ograve = uint(C.GDK_KEY_ograve) KEY_oacute = uint(C.GDK_KEY_oacute) KEY_ocircumflex = uint(C.GDK_KEY_ocircumflex) KEY_otilde = uint(C.GDK_KEY_otilde) KEY_odiaeresis = uint(C.GDK_KEY_odiaeresis) KEY_division = uint(C.GDK_KEY_division) KEY_oslash = uint(C.GDK_KEY_oslash) KEY_ooblique = uint(C.GDK_KEY_ooblique) KEY_ugrave = uint(C.GDK_KEY_ugrave) KEY_uacute = uint(C.GDK_KEY_uacute) KEY_ucircumflex = uint(C.GDK_KEY_ucircumflex) KEY_udiaeresis = uint(C.GDK_KEY_udiaeresis) KEY_yacute = uint(C.GDK_KEY_yacute) KEY_thorn = uint(C.GDK_KEY_thorn) KEY_ydiaeresis = uint(C.GDK_KEY_ydiaeresis) KEY_Aogonek = uint(C.GDK_KEY_Aogonek) KEY_breve = uint(C.GDK_KEY_breve) KEY_Lstroke = uint(C.GDK_KEY_Lstroke) KEY_Lcaron = uint(C.GDK_KEY_Lcaron) KEY_Sacute = uint(C.GDK_KEY_Sacute) KEY_Scaron = uint(C.GDK_KEY_Scaron) KEY_Scedilla = uint(C.GDK_KEY_Scedilla) KEY_Tcaron = uint(C.GDK_KEY_Tcaron) KEY_Zacute = uint(C.GDK_KEY_Zacute) KEY_Zcaron = uint(C.GDK_KEY_Zcaron) KEY_Zabovedot = uint(C.GDK_KEY_Zabovedot) KEY_aogonek = uint(C.GDK_KEY_aogonek) KEY_ogonek = uint(C.GDK_KEY_ogonek) KEY_lstroke = uint(C.GDK_KEY_lstroke) KEY_lcaron = uint(C.GDK_KEY_lcaron) KEY_sacute = uint(C.GDK_KEY_sacute) KEY_caron = uint(C.GDK_KEY_caron) KEY_scaron = uint(C.GDK_KEY_scaron) KEY_scedilla = uint(C.GDK_KEY_scedilla) KEY_tcaron = uint(C.GDK_KEY_tcaron) KEY_zacute = uint(C.GDK_KEY_zacute) KEY_doubleacute = uint(C.GDK_KEY_doubleacute) KEY_zcaron = uint(C.GDK_KEY_zcaron) KEY_zabovedot = uint(C.GDK_KEY_zabovedot) KEY_Racute = uint(C.GDK_KEY_Racute) KEY_Abreve = uint(C.GDK_KEY_Abreve) KEY_Lacute = uint(C.GDK_KEY_Lacute) KEY_Cacute = uint(C.GDK_KEY_Cacute) KEY_Ccaron = uint(C.GDK_KEY_Ccaron) KEY_Eogonek = uint(C.GDK_KEY_Eogonek) KEY_Ecaron = uint(C.GDK_KEY_Ecaron) KEY_Dcaron = uint(C.GDK_KEY_Dcaron) KEY_Dstroke = uint(C.GDK_KEY_Dstroke) KEY_Nacute = uint(C.GDK_KEY_Nacute) KEY_Ncaron = uint(C.GDK_KEY_Ncaron) KEY_Odoubleacute = uint(C.GDK_KEY_Odoubleacute) KEY_Rcaron = uint(C.GDK_KEY_Rcaron) KEY_Uring = uint(C.GDK_KEY_Uring) KEY_Udoubleacute = uint(C.GDK_KEY_Udoubleacute) KEY_Tcedilla = uint(C.GDK_KEY_Tcedilla) KEY_racute = uint(C.GDK_KEY_racute) KEY_abreve = uint(C.GDK_KEY_abreve) KEY_lacute = uint(C.GDK_KEY_lacute) KEY_cacute = uint(C.GDK_KEY_cacute) KEY_ccaron = uint(C.GDK_KEY_ccaron) KEY_eogonek = uint(C.GDK_KEY_eogonek) KEY_ecaron = uint(C.GDK_KEY_ecaron) KEY_dcaron = uint(C.GDK_KEY_dcaron) KEY_dstroke = uint(C.GDK_KEY_dstroke) KEY_nacute = uint(C.GDK_KEY_nacute) KEY_ncaron = uint(C.GDK_KEY_ncaron) KEY_odoubleacute = uint(C.GDK_KEY_odoubleacute) KEY_rcaron = uint(C.GDK_KEY_rcaron) KEY_uring = uint(C.GDK_KEY_uring) KEY_udoubleacute = uint(C.GDK_KEY_udoubleacute) KEY_tcedilla = uint(C.GDK_KEY_tcedilla) KEY_abovedot = uint(C.GDK_KEY_abovedot) KEY_Hstroke = uint(C.GDK_KEY_Hstroke) KEY_Hcircumflex = uint(C.GDK_KEY_Hcircumflex) KEY_Iabovedot = uint(C.GDK_KEY_Iabovedot) KEY_Gbreve = uint(C.GDK_KEY_Gbreve) KEY_Jcircumflex = uint(C.GDK_KEY_Jcircumflex) KEY_hstroke = uint(C.GDK_KEY_hstroke) KEY_hcircumflex = uint(C.GDK_KEY_hcircumflex) KEY_idotless = uint(C.GDK_KEY_idotless) KEY_gbreve = uint(C.GDK_KEY_gbreve) KEY_jcircumflex = uint(C.GDK_KEY_jcircumflex) KEY_Cabovedot = uint(C.GDK_KEY_Cabovedot) KEY_Ccircumflex = uint(C.GDK_KEY_Ccircumflex) KEY_Gabovedot = uint(C.GDK_KEY_Gabovedot) KEY_Gcircumflex = uint(C.GDK_KEY_Gcircumflex) KEY_Ubreve = uint(C.GDK_KEY_Ubreve) KEY_Scircumflex = uint(C.GDK_KEY_Scircumflex) KEY_cabovedot = uint(C.GDK_KEY_cabovedot) KEY_ccircumflex = uint(C.GDK_KEY_ccircumflex) KEY_gabovedot = uint(C.GDK_KEY_gabovedot) KEY_gcircumflex = uint(C.GDK_KEY_gcircumflex) KEY_ubreve = uint(C.GDK_KEY_ubreve) KEY_scircumflex = uint(C.GDK_KEY_scircumflex) KEY_kra = uint(C.GDK_KEY_kra) KEY_kappa = uint(C.GDK_KEY_kappa) KEY_Rcedilla = uint(C.GDK_KEY_Rcedilla) KEY_Itilde = uint(C.GDK_KEY_Itilde) KEY_Lcedilla = uint(C.GDK_KEY_Lcedilla) KEY_Emacron = uint(C.GDK_KEY_Emacron) KEY_Gcedilla = uint(C.GDK_KEY_Gcedilla) KEY_Tslash = uint(C.GDK_KEY_Tslash) KEY_rcedilla = uint(C.GDK_KEY_rcedilla) KEY_itilde = uint(C.GDK_KEY_itilde) KEY_lcedilla = uint(C.GDK_KEY_lcedilla) KEY_emacron = uint(C.GDK_KEY_emacron) KEY_gcedilla = uint(C.GDK_KEY_gcedilla) KEY_tslash = uint(C.GDK_KEY_tslash) KEY_ENG = uint(C.GDK_KEY_ENG) KEY_eng = uint(C.GDK_KEY_eng) KEY_Amacron = uint(C.GDK_KEY_Amacron) KEY_Iogonek = uint(C.GDK_KEY_Iogonek) KEY_Eabovedot = uint(C.GDK_KEY_Eabovedot) KEY_Imacron = uint(C.GDK_KEY_Imacron) KEY_Ncedilla = uint(C.GDK_KEY_Ncedilla) KEY_Omacron = uint(C.GDK_KEY_Omacron) KEY_Kcedilla = uint(C.GDK_KEY_Kcedilla) KEY_Uogonek = uint(C.GDK_KEY_Uogonek) KEY_Utilde = uint(C.GDK_KEY_Utilde) KEY_Umacron = uint(C.GDK_KEY_Umacron) KEY_amacron = uint(C.GDK_KEY_amacron) KEY_iogonek = uint(C.GDK_KEY_iogonek) KEY_eabovedot = uint(C.GDK_KEY_eabovedot) KEY_imacron = uint(C.GDK_KEY_imacron) KEY_ncedilla = uint(C.GDK_KEY_ncedilla) KEY_omacron = uint(C.GDK_KEY_omacron) KEY_kcedilla = uint(C.GDK_KEY_kcedilla) KEY_uogonek = uint(C.GDK_KEY_uogonek) KEY_utilde = uint(C.GDK_KEY_utilde) KEY_umacron = uint(C.GDK_KEY_umacron) KEY_Wcircumflex = uint(C.GDK_KEY_Wcircumflex) KEY_wcircumflex = uint(C.GDK_KEY_wcircumflex) KEY_Ycircumflex = uint(C.GDK_KEY_Ycircumflex) KEY_ycircumflex = uint(C.GDK_KEY_ycircumflex) KEY_Babovedot = uint(C.GDK_KEY_Babovedot) KEY_babovedot = uint(C.GDK_KEY_babovedot) KEY_Dabovedot = uint(C.GDK_KEY_Dabovedot) KEY_dabovedot = uint(C.GDK_KEY_dabovedot) KEY_Fabovedot = uint(C.GDK_KEY_Fabovedot) KEY_fabovedot = uint(C.GDK_KEY_fabovedot) KEY_Mabovedot = uint(C.GDK_KEY_Mabovedot) KEY_mabovedot = uint(C.GDK_KEY_mabovedot) KEY_Pabovedot = uint(C.GDK_KEY_Pabovedot) KEY_pabovedot = uint(C.GDK_KEY_pabovedot) KEY_Sabovedot = uint(C.GDK_KEY_Sabovedot) KEY_sabovedot = uint(C.GDK_KEY_sabovedot) KEY_Tabovedot = uint(C.GDK_KEY_Tabovedot) KEY_tabovedot = uint(C.GDK_KEY_tabovedot) KEY_Wgrave = uint(C.GDK_KEY_Wgrave) KEY_wgrave = uint(C.GDK_KEY_wgrave) KEY_Wacute = uint(C.GDK_KEY_Wacute) KEY_wacute = uint(C.GDK_KEY_wacute) KEY_Wdiaeresis = uint(C.GDK_KEY_Wdiaeresis) KEY_wdiaeresis = uint(C.GDK_KEY_wdiaeresis) KEY_Ygrave = uint(C.GDK_KEY_Ygrave) KEY_ygrave = uint(C.GDK_KEY_ygrave) KEY_OE = uint(C.GDK_KEY_OE) KEY_oe = uint(C.GDK_KEY_oe) KEY_Ydiaeresis = uint(C.GDK_KEY_Ydiaeresis) KEY_overline = uint(C.GDK_KEY_overline) KEY_kana_fullstop = uint(C.GDK_KEY_kana_fullstop) KEY_kana_openingbracket = uint(C.GDK_KEY_kana_openingbracket) KEY_kana_closingbracket = uint(C.GDK_KEY_kana_closingbracket) KEY_kana_comma = uint(C.GDK_KEY_kana_comma) KEY_kana_conjunctive = uint(C.GDK_KEY_kana_conjunctive) KEY_kana_middledot = uint(C.GDK_KEY_kana_middledot) KEY_kana_WO = uint(C.GDK_KEY_kana_WO) KEY_kana_a = uint(C.GDK_KEY_kana_a) KEY_kana_i = uint(C.GDK_KEY_kana_i) KEY_kana_u = uint(C.GDK_KEY_kana_u) KEY_kana_e = uint(C.GDK_KEY_kana_e) KEY_kana_o = uint(C.GDK_KEY_kana_o) KEY_kana_ya = uint(C.GDK_KEY_kana_ya) KEY_kana_yu = uint(C.GDK_KEY_kana_yu) KEY_kana_yo = uint(C.GDK_KEY_kana_yo) KEY_kana_tsu = uint(C.GDK_KEY_kana_tsu) KEY_kana_tu = uint(C.GDK_KEY_kana_tu) KEY_prolongedsound = uint(C.GDK_KEY_prolongedsound) KEY_kana_A = uint(C.GDK_KEY_kana_A) KEY_kana_I = uint(C.GDK_KEY_kana_I) KEY_kana_U = uint(C.GDK_KEY_kana_U) KEY_kana_E = uint(C.GDK_KEY_kana_E) KEY_kana_O = uint(C.GDK_KEY_kana_O) KEY_kana_KA = uint(C.GDK_KEY_kana_KA) KEY_kana_KI = uint(C.GDK_KEY_kana_KI) KEY_kana_KU = uint(C.GDK_KEY_kana_KU) KEY_kana_KE = uint(C.GDK_KEY_kana_KE) KEY_kana_KO = uint(C.GDK_KEY_kana_KO) KEY_kana_SA = uint(C.GDK_KEY_kana_SA) KEY_kana_SHI = uint(C.GDK_KEY_kana_SHI) KEY_kana_SU = uint(C.GDK_KEY_kana_SU) KEY_kana_SE = uint(C.GDK_KEY_kana_SE) KEY_kana_SO = uint(C.GDK_KEY_kana_SO) KEY_kana_TA = uint(C.GDK_KEY_kana_TA) KEY_kana_CHI = uint(C.GDK_KEY_kana_CHI) KEY_kana_TI = uint(C.GDK_KEY_kana_TI) KEY_kana_TSU = uint(C.GDK_KEY_kana_TSU) KEY_kana_TU = uint(C.GDK_KEY_kana_TU) KEY_kana_TE = uint(C.GDK_KEY_kana_TE) KEY_kana_TO = uint(C.GDK_KEY_kana_TO) KEY_kana_NA = uint(C.GDK_KEY_kana_NA) KEY_kana_NI = uint(C.GDK_KEY_kana_NI) KEY_kana_NU = uint(C.GDK_KEY_kana_NU) KEY_kana_NE = uint(C.GDK_KEY_kana_NE) KEY_kana_NO = uint(C.GDK_KEY_kana_NO) KEY_kana_HA = uint(C.GDK_KEY_kana_HA) KEY_kana_HI = uint(C.GDK_KEY_kana_HI) KEY_kana_FU = uint(C.GDK_KEY_kana_FU) KEY_kana_HU = uint(C.GDK_KEY_kana_HU) KEY_kana_HE = uint(C.GDK_KEY_kana_HE) KEY_kana_HO = uint(C.GDK_KEY_kana_HO) KEY_kana_MA = uint(C.GDK_KEY_kana_MA) KEY_kana_MI = uint(C.GDK_KEY_kana_MI) KEY_kana_MU = uint(C.GDK_KEY_kana_MU) KEY_kana_ME = uint(C.GDK_KEY_kana_ME) KEY_kana_MO = uint(C.GDK_KEY_kana_MO) KEY_kana_YA = uint(C.GDK_KEY_kana_YA) KEY_kana_YU = uint(C.GDK_KEY_kana_YU) KEY_kana_YO = uint(C.GDK_KEY_kana_YO) KEY_kana_RA = uint(C.GDK_KEY_kana_RA) KEY_kana_RI = uint(C.GDK_KEY_kana_RI) KEY_kana_RU = uint(C.GDK_KEY_kana_RU) KEY_kana_RE = uint(C.GDK_KEY_kana_RE) KEY_kana_RO = uint(C.GDK_KEY_kana_RO) KEY_kana_WA = uint(C.GDK_KEY_kana_WA) KEY_kana_N = uint(C.GDK_KEY_kana_N) KEY_voicedsound = uint(C.GDK_KEY_voicedsound) KEY_semivoicedsound = uint(C.GDK_KEY_semivoicedsound) KEY_kana_switch = uint(C.GDK_KEY_kana_switch) KEY_Farsi_0 = uint(C.GDK_KEY_Farsi_0) KEY_Farsi_1 = uint(C.GDK_KEY_Farsi_1) KEY_Farsi_2 = uint(C.GDK_KEY_Farsi_2) KEY_Farsi_3 = uint(C.GDK_KEY_Farsi_3) KEY_Farsi_4 = uint(C.GDK_KEY_Farsi_4) KEY_Farsi_5 = uint(C.GDK_KEY_Farsi_5) KEY_Farsi_6 = uint(C.GDK_KEY_Farsi_6) KEY_Farsi_7 = uint(C.GDK_KEY_Farsi_7) KEY_Farsi_8 = uint(C.GDK_KEY_Farsi_8) KEY_Farsi_9 = uint(C.GDK_KEY_Farsi_9) KEY_Arabic_percent = uint(C.GDK_KEY_Arabic_percent) KEY_Arabic_superscript_alef = uint(C.GDK_KEY_Arabic_superscript_alef) KEY_Arabic_tteh = uint(C.GDK_KEY_Arabic_tteh) KEY_Arabic_peh = uint(C.GDK_KEY_Arabic_peh) KEY_Arabic_tcheh = uint(C.GDK_KEY_Arabic_tcheh) KEY_Arabic_ddal = uint(C.GDK_KEY_Arabic_ddal) KEY_Arabic_rreh = uint(C.GDK_KEY_Arabic_rreh) KEY_Arabic_comma = uint(C.GDK_KEY_Arabic_comma) KEY_Arabic_fullstop = uint(C.GDK_KEY_Arabic_fullstop) KEY_Arabic_0 = uint(C.GDK_KEY_Arabic_0) KEY_Arabic_1 = uint(C.GDK_KEY_Arabic_1) KEY_Arabic_2 = uint(C.GDK_KEY_Arabic_2) KEY_Arabic_3 = uint(C.GDK_KEY_Arabic_3) KEY_Arabic_4 = uint(C.GDK_KEY_Arabic_4) KEY_Arabic_5 = uint(C.GDK_KEY_Arabic_5) KEY_Arabic_6 = uint(C.GDK_KEY_Arabic_6) KEY_Arabic_7 = uint(C.GDK_KEY_Arabic_7) KEY_Arabic_8 = uint(C.GDK_KEY_Arabic_8) KEY_Arabic_9 = uint(C.GDK_KEY_Arabic_9) KEY_Arabic_semicolon = uint(C.GDK_KEY_Arabic_semicolon) KEY_Arabic_question_mark = uint(C.GDK_KEY_Arabic_question_mark) KEY_Arabic_hamza = uint(C.GDK_KEY_Arabic_hamza) KEY_Arabic_maddaonalef = uint(C.GDK_KEY_Arabic_maddaonalef) KEY_Arabic_hamzaonalef = uint(C.GDK_KEY_Arabic_hamzaonalef) KEY_Arabic_hamzaonwaw = uint(C.GDK_KEY_Arabic_hamzaonwaw) KEY_Arabic_hamzaunderalef = uint(C.GDK_KEY_Arabic_hamzaunderalef) KEY_Arabic_hamzaonyeh = uint(C.GDK_KEY_Arabic_hamzaonyeh) KEY_Arabic_alef = uint(C.GDK_KEY_Arabic_alef) KEY_Arabic_beh = uint(C.GDK_KEY_Arabic_beh) KEY_Arabic_tehmarbuta = uint(C.GDK_KEY_Arabic_tehmarbuta) KEY_Arabic_teh = uint(C.GDK_KEY_Arabic_teh) KEY_Arabic_theh = uint(C.GDK_KEY_Arabic_theh) KEY_Arabic_jeem = uint(C.GDK_KEY_Arabic_jeem) KEY_Arabic_hah = uint(C.GDK_KEY_Arabic_hah) KEY_Arabic_khah = uint(C.GDK_KEY_Arabic_khah) KEY_Arabic_dal = uint(C.GDK_KEY_Arabic_dal) KEY_Arabic_thal = uint(C.GDK_KEY_Arabic_thal) KEY_Arabic_ra = uint(C.GDK_KEY_Arabic_ra) KEY_Arabic_zain = uint(C.GDK_KEY_Arabic_zain) KEY_Arabic_seen = uint(C.GDK_KEY_Arabic_seen) KEY_Arabic_sheen = uint(C.GDK_KEY_Arabic_sheen) KEY_Arabic_sad = uint(C.GDK_KEY_Arabic_sad) KEY_Arabic_dad = uint(C.GDK_KEY_Arabic_dad) KEY_Arabic_tah = uint(C.GDK_KEY_Arabic_tah) KEY_Arabic_zah = uint(C.GDK_KEY_Arabic_zah) KEY_Arabic_ain = uint(C.GDK_KEY_Arabic_ain) KEY_Arabic_ghain = uint(C.GDK_KEY_Arabic_ghain) KEY_Arabic_tatweel = uint(C.GDK_KEY_Arabic_tatweel) KEY_Arabic_feh = uint(C.GDK_KEY_Arabic_feh) KEY_Arabic_qaf = uint(C.GDK_KEY_Arabic_qaf) KEY_Arabic_kaf = uint(C.GDK_KEY_Arabic_kaf) KEY_Arabic_lam = uint(C.GDK_KEY_Arabic_lam) KEY_Arabic_meem = uint(C.GDK_KEY_Arabic_meem) KEY_Arabic_noon = uint(C.GDK_KEY_Arabic_noon) KEY_Arabic_ha = uint(C.GDK_KEY_Arabic_ha) KEY_Arabic_heh = uint(C.GDK_KEY_Arabic_heh) KEY_Arabic_waw = uint(C.GDK_KEY_Arabic_waw) KEY_Arabic_alefmaksura = uint(C.GDK_KEY_Arabic_alefmaksura) KEY_Arabic_yeh = uint(C.GDK_KEY_Arabic_yeh) KEY_Arabic_fathatan = uint(C.GDK_KEY_Arabic_fathatan) KEY_Arabic_dammatan = uint(C.GDK_KEY_Arabic_dammatan) KEY_Arabic_kasratan = uint(C.GDK_KEY_Arabic_kasratan) KEY_Arabic_fatha = uint(C.GDK_KEY_Arabic_fatha) KEY_Arabic_damma = uint(C.GDK_KEY_Arabic_damma) KEY_Arabic_kasra = uint(C.GDK_KEY_Arabic_kasra) KEY_Arabic_shadda = uint(C.GDK_KEY_Arabic_shadda) KEY_Arabic_sukun = uint(C.GDK_KEY_Arabic_sukun) KEY_Arabic_madda_above = uint(C.GDK_KEY_Arabic_madda_above) KEY_Arabic_hamza_above = uint(C.GDK_KEY_Arabic_hamza_above) KEY_Arabic_hamza_below = uint(C.GDK_KEY_Arabic_hamza_below) KEY_Arabic_jeh = uint(C.GDK_KEY_Arabic_jeh) KEY_Arabic_veh = uint(C.GDK_KEY_Arabic_veh) KEY_Arabic_keheh = uint(C.GDK_KEY_Arabic_keheh) KEY_Arabic_gaf = uint(C.GDK_KEY_Arabic_gaf) KEY_Arabic_noon_ghunna = uint(C.GDK_KEY_Arabic_noon_ghunna) KEY_Arabic_heh_doachashmee = uint(C.GDK_KEY_Arabic_heh_doachashmee) KEY_Farsi_yeh = uint(C.GDK_KEY_Farsi_yeh) KEY_Arabic_farsi_yeh = uint(C.GDK_KEY_Arabic_farsi_yeh) KEY_Arabic_yeh_baree = uint(C.GDK_KEY_Arabic_yeh_baree) KEY_Arabic_heh_goal = uint(C.GDK_KEY_Arabic_heh_goal) KEY_Arabic_switch = uint(C.GDK_KEY_Arabic_switch) KEY_Cyrillic_GHE_bar = uint(C.GDK_KEY_Cyrillic_GHE_bar) KEY_Cyrillic_ghe_bar = uint(C.GDK_KEY_Cyrillic_ghe_bar) KEY_Cyrillic_ZHE_descender = uint(C.GDK_KEY_Cyrillic_ZHE_descender) KEY_Cyrillic_zhe_descender = uint(C.GDK_KEY_Cyrillic_zhe_descender) KEY_Cyrillic_KA_descender = uint(C.GDK_KEY_Cyrillic_KA_descender) KEY_Cyrillic_ka_descender = uint(C.GDK_KEY_Cyrillic_ka_descender) KEY_Cyrillic_KA_vertstroke = uint(C.GDK_KEY_Cyrillic_KA_vertstroke) KEY_Cyrillic_ka_vertstroke = uint(C.GDK_KEY_Cyrillic_ka_vertstroke) KEY_Cyrillic_EN_descender = uint(C.GDK_KEY_Cyrillic_EN_descender) KEY_Cyrillic_en_descender = uint(C.GDK_KEY_Cyrillic_en_descender) KEY_Cyrillic_U_straight = uint(C.GDK_KEY_Cyrillic_U_straight) KEY_Cyrillic_u_straight = uint(C.GDK_KEY_Cyrillic_u_straight) KEY_Cyrillic_U_straight_bar = uint(C.GDK_KEY_Cyrillic_U_straight_bar) KEY_Cyrillic_u_straight_bar = uint(C.GDK_KEY_Cyrillic_u_straight_bar) KEY_Cyrillic_HA_descender = uint(C.GDK_KEY_Cyrillic_HA_descender) KEY_Cyrillic_ha_descender = uint(C.GDK_KEY_Cyrillic_ha_descender) KEY_Cyrillic_CHE_descender = uint(C.GDK_KEY_Cyrillic_CHE_descender) KEY_Cyrillic_che_descender = uint(C.GDK_KEY_Cyrillic_che_descender) KEY_Cyrillic_CHE_vertstroke = uint(C.GDK_KEY_Cyrillic_CHE_vertstroke) KEY_Cyrillic_che_vertstroke = uint(C.GDK_KEY_Cyrillic_che_vertstroke) KEY_Cyrillic_SHHA = uint(C.GDK_KEY_Cyrillic_SHHA) KEY_Cyrillic_shha = uint(C.GDK_KEY_Cyrillic_shha) KEY_Cyrillic_SCHWA = uint(C.GDK_KEY_Cyrillic_SCHWA) KEY_Cyrillic_schwa = uint(C.GDK_KEY_Cyrillic_schwa) KEY_Cyrillic_I_macron = uint(C.GDK_KEY_Cyrillic_I_macron) KEY_Cyrillic_i_macron = uint(C.GDK_KEY_Cyrillic_i_macron) KEY_Cyrillic_O_bar = uint(C.GDK_KEY_Cyrillic_O_bar) KEY_Cyrillic_o_bar = uint(C.GDK_KEY_Cyrillic_o_bar) KEY_Cyrillic_U_macron = uint(C.GDK_KEY_Cyrillic_U_macron) KEY_Cyrillic_u_macron = uint(C.GDK_KEY_Cyrillic_u_macron) KEY_Serbian_dje = uint(C.GDK_KEY_Serbian_dje) KEY_Macedonia_gje = uint(C.GDK_KEY_Macedonia_gje) KEY_Cyrillic_io = uint(C.GDK_KEY_Cyrillic_io) KEY_Ukrainian_ie = uint(C.GDK_KEY_Ukrainian_ie) KEY_Ukranian_je = uint(C.GDK_KEY_Ukranian_je) KEY_Macedonia_dse = uint(C.GDK_KEY_Macedonia_dse) KEY_Ukrainian_i = uint(C.GDK_KEY_Ukrainian_i) KEY_Ukranian_i = uint(C.GDK_KEY_Ukranian_i) KEY_Ukrainian_yi = uint(C.GDK_KEY_Ukrainian_yi) KEY_Ukranian_yi = uint(C.GDK_KEY_Ukranian_yi) KEY_Cyrillic_je = uint(C.GDK_KEY_Cyrillic_je) KEY_Serbian_je = uint(C.GDK_KEY_Serbian_je) KEY_Cyrillic_lje = uint(C.GDK_KEY_Cyrillic_lje) KEY_Serbian_lje = uint(C.GDK_KEY_Serbian_lje) KEY_Cyrillic_nje = uint(C.GDK_KEY_Cyrillic_nje) KEY_Serbian_nje = uint(C.GDK_KEY_Serbian_nje) KEY_Serbian_tshe = uint(C.GDK_KEY_Serbian_tshe) KEY_Macedonia_kje = uint(C.GDK_KEY_Macedonia_kje) KEY_Ukrainian_ghe_with_upturn = uint(C.GDK_KEY_Ukrainian_ghe_with_upturn) KEY_Byelorussian_shortu = uint(C.GDK_KEY_Byelorussian_shortu) KEY_Cyrillic_dzhe = uint(C.GDK_KEY_Cyrillic_dzhe) KEY_Serbian_dze = uint(C.GDK_KEY_Serbian_dze) KEY_numerosign = uint(C.GDK_KEY_numerosign) KEY_Serbian_DJE = uint(C.GDK_KEY_Serbian_DJE) KEY_Macedonia_GJE = uint(C.GDK_KEY_Macedonia_GJE) KEY_Cyrillic_IO = uint(C.GDK_KEY_Cyrillic_IO) KEY_Ukrainian_IE = uint(C.GDK_KEY_Ukrainian_IE) KEY_Ukranian_JE = uint(C.GDK_KEY_Ukranian_JE) KEY_Macedonia_DSE = uint(C.GDK_KEY_Macedonia_DSE) KEY_Ukrainian_I = uint(C.GDK_KEY_Ukrainian_I) KEY_Ukranian_I = uint(C.GDK_KEY_Ukranian_I) KEY_Ukrainian_YI = uint(C.GDK_KEY_Ukrainian_YI) KEY_Ukranian_YI = uint(C.GDK_KEY_Ukranian_YI) KEY_Cyrillic_JE = uint(C.GDK_KEY_Cyrillic_JE) KEY_Serbian_JE = uint(C.GDK_KEY_Serbian_JE) KEY_Cyrillic_LJE = uint(C.GDK_KEY_Cyrillic_LJE) KEY_Serbian_LJE = uint(C.GDK_KEY_Serbian_LJE) KEY_Cyrillic_NJE = uint(C.GDK_KEY_Cyrillic_NJE) KEY_Serbian_NJE = uint(C.GDK_KEY_Serbian_NJE) KEY_Serbian_TSHE = uint(C.GDK_KEY_Serbian_TSHE) KEY_Macedonia_KJE = uint(C.GDK_KEY_Macedonia_KJE) KEY_Ukrainian_GHE_WITH_UPTURN = uint(C.GDK_KEY_Ukrainian_GHE_WITH_UPTURN) KEY_Byelorussian_SHORTU = uint(C.GDK_KEY_Byelorussian_SHORTU) KEY_Cyrillic_DZHE = uint(C.GDK_KEY_Cyrillic_DZHE) KEY_Serbian_DZE = uint(C.GDK_KEY_Serbian_DZE) KEY_Cyrillic_yu = uint(C.GDK_KEY_Cyrillic_yu) KEY_Cyrillic_a = uint(C.GDK_KEY_Cyrillic_a) KEY_Cyrillic_be = uint(C.GDK_KEY_Cyrillic_be) KEY_Cyrillic_tse = uint(C.GDK_KEY_Cyrillic_tse) KEY_Cyrillic_de = uint(C.GDK_KEY_Cyrillic_de) KEY_Cyrillic_ie = uint(C.GDK_KEY_Cyrillic_ie) KEY_Cyrillic_ef = uint(C.GDK_KEY_Cyrillic_ef) KEY_Cyrillic_ghe = uint(C.GDK_KEY_Cyrillic_ghe) KEY_Cyrillic_ha = uint(C.GDK_KEY_Cyrillic_ha) KEY_Cyrillic_i = uint(C.GDK_KEY_Cyrillic_i) KEY_Cyrillic_shorti = uint(C.GDK_KEY_Cyrillic_shorti) KEY_Cyrillic_ka = uint(C.GDK_KEY_Cyrillic_ka) KEY_Cyrillic_el = uint(C.GDK_KEY_Cyrillic_el) KEY_Cyrillic_em = uint(C.GDK_KEY_Cyrillic_em) KEY_Cyrillic_en = uint(C.GDK_KEY_Cyrillic_en) KEY_Cyrillic_o = uint(C.GDK_KEY_Cyrillic_o) KEY_Cyrillic_pe = uint(C.GDK_KEY_Cyrillic_pe) KEY_Cyrillic_ya = uint(C.GDK_KEY_Cyrillic_ya) KEY_Cyrillic_er = uint(C.GDK_KEY_Cyrillic_er) KEY_Cyrillic_es = uint(C.GDK_KEY_Cyrillic_es) KEY_Cyrillic_te = uint(C.GDK_KEY_Cyrillic_te) KEY_Cyrillic_u = uint(C.GDK_KEY_Cyrillic_u) KEY_Cyrillic_zhe = uint(C.GDK_KEY_Cyrillic_zhe) KEY_Cyrillic_ve = uint(C.GDK_KEY_Cyrillic_ve) KEY_Cyrillic_softsign = uint(C.GDK_KEY_Cyrillic_softsign) KEY_Cyrillic_yeru = uint(C.GDK_KEY_Cyrillic_yeru) KEY_Cyrillic_ze = uint(C.GDK_KEY_Cyrillic_ze) KEY_Cyrillic_sha = uint(C.GDK_KEY_Cyrillic_sha) KEY_Cyrillic_e = uint(C.GDK_KEY_Cyrillic_e) KEY_Cyrillic_shcha = uint(C.GDK_KEY_Cyrillic_shcha) KEY_Cyrillic_che = uint(C.GDK_KEY_Cyrillic_che) KEY_Cyrillic_hardsign = uint(C.GDK_KEY_Cyrillic_hardsign) KEY_Cyrillic_YU = uint(C.GDK_KEY_Cyrillic_YU) KEY_Cyrillic_A = uint(C.GDK_KEY_Cyrillic_A) KEY_Cyrillic_BE = uint(C.GDK_KEY_Cyrillic_BE) KEY_Cyrillic_TSE = uint(C.GDK_KEY_Cyrillic_TSE) KEY_Cyrillic_DE = uint(C.GDK_KEY_Cyrillic_DE) KEY_Cyrillic_IE = uint(C.GDK_KEY_Cyrillic_IE) KEY_Cyrillic_EF = uint(C.GDK_KEY_Cyrillic_EF) KEY_Cyrillic_GHE = uint(C.GDK_KEY_Cyrillic_GHE) KEY_Cyrillic_HA = uint(C.GDK_KEY_Cyrillic_HA) KEY_Cyrillic_I = uint(C.GDK_KEY_Cyrillic_I) KEY_Cyrillic_SHORTI = uint(C.GDK_KEY_Cyrillic_SHORTI) KEY_Cyrillic_KA = uint(C.GDK_KEY_Cyrillic_KA) KEY_Cyrillic_EL = uint(C.GDK_KEY_Cyrillic_EL) KEY_Cyrillic_EM = uint(C.GDK_KEY_Cyrillic_EM) KEY_Cyrillic_EN = uint(C.GDK_KEY_Cyrillic_EN) KEY_Cyrillic_O = uint(C.GDK_KEY_Cyrillic_O) KEY_Cyrillic_PE = uint(C.GDK_KEY_Cyrillic_PE) KEY_Cyrillic_YA = uint(C.GDK_KEY_Cyrillic_YA) KEY_Cyrillic_ER = uint(C.GDK_KEY_Cyrillic_ER) KEY_Cyrillic_ES = uint(C.GDK_KEY_Cyrillic_ES) KEY_Cyrillic_TE = uint(C.GDK_KEY_Cyrillic_TE) KEY_Cyrillic_U = uint(C.GDK_KEY_Cyrillic_U) KEY_Cyrillic_ZHE = uint(C.GDK_KEY_Cyrillic_ZHE) KEY_Cyrillic_VE = uint(C.GDK_KEY_Cyrillic_VE) KEY_Cyrillic_SOFTSIGN = uint(C.GDK_KEY_Cyrillic_SOFTSIGN) KEY_Cyrillic_YERU = uint(C.GDK_KEY_Cyrillic_YERU) KEY_Cyrillic_ZE = uint(C.GDK_KEY_Cyrillic_ZE) KEY_Cyrillic_SHA = uint(C.GDK_KEY_Cyrillic_SHA) KEY_Cyrillic_E = uint(C.GDK_KEY_Cyrillic_E) KEY_Cyrillic_SHCHA = uint(C.GDK_KEY_Cyrillic_SHCHA) KEY_Cyrillic_CHE = uint(C.GDK_KEY_Cyrillic_CHE) KEY_Cyrillic_HARDSIGN = uint(C.GDK_KEY_Cyrillic_HARDSIGN) KEY_Greek_ALPHAaccent = uint(C.GDK_KEY_Greek_ALPHAaccent) KEY_Greek_EPSILONaccent = uint(C.GDK_KEY_Greek_EPSILONaccent) KEY_Greek_ETAaccent = uint(C.GDK_KEY_Greek_ETAaccent) KEY_Greek_IOTAaccent = uint(C.GDK_KEY_Greek_IOTAaccent) KEY_Greek_IOTAdieresis = uint(C.GDK_KEY_Greek_IOTAdieresis) KEY_Greek_IOTAdiaeresis = uint(C.GDK_KEY_Greek_IOTAdiaeresis) KEY_Greek_OMICRONaccent = uint(C.GDK_KEY_Greek_OMICRONaccent) KEY_Greek_UPSILONaccent = uint(C.GDK_KEY_Greek_UPSILONaccent) KEY_Greek_UPSILONdieresis = uint(C.GDK_KEY_Greek_UPSILONdieresis) KEY_Greek_OMEGAaccent = uint(C.GDK_KEY_Greek_OMEGAaccent) KEY_Greek_accentdieresis = uint(C.GDK_KEY_Greek_accentdieresis) KEY_Greek_horizbar = uint(C.GDK_KEY_Greek_horizbar) KEY_Greek_alphaaccent = uint(C.GDK_KEY_Greek_alphaaccent) KEY_Greek_epsilonaccent = uint(C.GDK_KEY_Greek_epsilonaccent) KEY_Greek_etaaccent = uint(C.GDK_KEY_Greek_etaaccent) KEY_Greek_iotaaccent = uint(C.GDK_KEY_Greek_iotaaccent) KEY_Greek_iotadieresis = uint(C.GDK_KEY_Greek_iotadieresis) KEY_Greek_iotaaccentdieresis = uint(C.GDK_KEY_Greek_iotaaccentdieresis) KEY_Greek_omicronaccent = uint(C.GDK_KEY_Greek_omicronaccent) KEY_Greek_upsilonaccent = uint(C.GDK_KEY_Greek_upsilonaccent) KEY_Greek_upsilondieresis = uint(C.GDK_KEY_Greek_upsilondieresis) KEY_Greek_upsilonaccentdieresis = uint(C.GDK_KEY_Greek_upsilonaccentdieresis) KEY_Greek_omegaaccent = uint(C.GDK_KEY_Greek_omegaaccent) KEY_Greek_ALPHA = uint(C.GDK_KEY_Greek_ALPHA) KEY_Greek_BETA = uint(C.GDK_KEY_Greek_BETA) KEY_Greek_GAMMA = uint(C.GDK_KEY_Greek_GAMMA) KEY_Greek_DELTA = uint(C.GDK_KEY_Greek_DELTA) KEY_Greek_EPSILON = uint(C.GDK_KEY_Greek_EPSILON) KEY_Greek_ZETA = uint(C.GDK_KEY_Greek_ZETA) KEY_Greek_ETA = uint(C.GDK_KEY_Greek_ETA) KEY_Greek_THETA = uint(C.GDK_KEY_Greek_THETA) KEY_Greek_IOTA = uint(C.GDK_KEY_Greek_IOTA) KEY_Greek_KAPPA = uint(C.GDK_KEY_Greek_KAPPA) KEY_Greek_LAMDA = uint(C.GDK_KEY_Greek_LAMDA) KEY_Greek_LAMBDA = uint(C.GDK_KEY_Greek_LAMBDA) KEY_Greek_MU = uint(C.GDK_KEY_Greek_MU) KEY_Greek_NU = uint(C.GDK_KEY_Greek_NU) KEY_Greek_XI = uint(C.GDK_KEY_Greek_XI) KEY_Greek_OMICRON = uint(C.GDK_KEY_Greek_OMICRON) KEY_Greek_PI = uint(C.GDK_KEY_Greek_PI) KEY_Greek_RHO = uint(C.GDK_KEY_Greek_RHO) KEY_Greek_SIGMA = uint(C.GDK_KEY_Greek_SIGMA) KEY_Greek_TAU = uint(C.GDK_KEY_Greek_TAU) KEY_Greek_UPSILON = uint(C.GDK_KEY_Greek_UPSILON) KEY_Greek_PHI = uint(C.GDK_KEY_Greek_PHI) KEY_Greek_CHI = uint(C.GDK_KEY_Greek_CHI) KEY_Greek_PSI = uint(C.GDK_KEY_Greek_PSI) KEY_Greek_OMEGA = uint(C.GDK_KEY_Greek_OMEGA) KEY_Greek_alpha = uint(C.GDK_KEY_Greek_alpha) KEY_Greek_beta = uint(C.GDK_KEY_Greek_beta) KEY_Greek_gamma = uint(C.GDK_KEY_Greek_gamma) KEY_Greek_delta = uint(C.GDK_KEY_Greek_delta) KEY_Greek_epsilon = uint(C.GDK_KEY_Greek_epsilon) KEY_Greek_zeta = uint(C.GDK_KEY_Greek_zeta) KEY_Greek_eta = uint(C.GDK_KEY_Greek_eta) KEY_Greek_theta = uint(C.GDK_KEY_Greek_theta) KEY_Greek_iota = uint(C.GDK_KEY_Greek_iota) KEY_Greek_kappa = uint(C.GDK_KEY_Greek_kappa) KEY_Greek_lamda = uint(C.GDK_KEY_Greek_lamda) KEY_Greek_lambda = uint(C.GDK_KEY_Greek_lambda) KEY_Greek_mu = uint(C.GDK_KEY_Greek_mu) KEY_Greek_nu = uint(C.GDK_KEY_Greek_nu) KEY_Greek_xi = uint(C.GDK_KEY_Greek_xi) KEY_Greek_omicron = uint(C.GDK_KEY_Greek_omicron) KEY_Greek_pi = uint(C.GDK_KEY_Greek_pi) KEY_Greek_rho = uint(C.GDK_KEY_Greek_rho) KEY_Greek_sigma = uint(C.GDK_KEY_Greek_sigma) KEY_Greek_finalsmallsigma = uint(C.GDK_KEY_Greek_finalsmallsigma) KEY_Greek_tau = uint(C.GDK_KEY_Greek_tau) KEY_Greek_upsilon = uint(C.GDK_KEY_Greek_upsilon) KEY_Greek_phi = uint(C.GDK_KEY_Greek_phi) KEY_Greek_chi = uint(C.GDK_KEY_Greek_chi) KEY_Greek_psi = uint(C.GDK_KEY_Greek_psi) KEY_Greek_omega = uint(C.GDK_KEY_Greek_omega) KEY_Greek_switch = uint(C.GDK_KEY_Greek_switch) KEY_leftradical = uint(C.GDK_KEY_leftradical) KEY_topleftradical = uint(C.GDK_KEY_topleftradical) KEY_horizconnector = uint(C.GDK_KEY_horizconnector) KEY_topintegral = uint(C.GDK_KEY_topintegral) KEY_botintegral = uint(C.GDK_KEY_botintegral) KEY_vertconnector = uint(C.GDK_KEY_vertconnector) KEY_topleftsqbracket = uint(C.GDK_KEY_topleftsqbracket) KEY_botleftsqbracket = uint(C.GDK_KEY_botleftsqbracket) KEY_toprightsqbracket = uint(C.GDK_KEY_toprightsqbracket) KEY_botrightsqbracket = uint(C.GDK_KEY_botrightsqbracket) KEY_topleftparens = uint(C.GDK_KEY_topleftparens) KEY_botleftparens = uint(C.GDK_KEY_botleftparens) KEY_toprightparens = uint(C.GDK_KEY_toprightparens) KEY_botrightparens = uint(C.GDK_KEY_botrightparens) KEY_leftmiddlecurlybrace = uint(C.GDK_KEY_leftmiddlecurlybrace) KEY_rightmiddlecurlybrace = uint(C.GDK_KEY_rightmiddlecurlybrace) KEY_topleftsummation = uint(C.GDK_KEY_topleftsummation) KEY_botleftsummation = uint(C.GDK_KEY_botleftsummation) KEY_topvertsummationconnector = uint(C.GDK_KEY_topvertsummationconnector) KEY_botvertsummationconnector = uint(C.GDK_KEY_botvertsummationconnector) KEY_toprightsummation = uint(C.GDK_KEY_toprightsummation) KEY_botrightsummation = uint(C.GDK_KEY_botrightsummation) KEY_rightmiddlesummation = uint(C.GDK_KEY_rightmiddlesummation) KEY_lessthanequal = uint(C.GDK_KEY_lessthanequal) KEY_notequal = uint(C.GDK_KEY_notequal) KEY_greaterthanequal = uint(C.GDK_KEY_greaterthanequal) KEY_integral = uint(C.GDK_KEY_integral) KEY_therefore = uint(C.GDK_KEY_therefore) KEY_variation = uint(C.GDK_KEY_variation) KEY_infinity = uint(C.GDK_KEY_infinity) KEY_nabla = uint(C.GDK_KEY_nabla) KEY_approximate = uint(C.GDK_KEY_approximate) KEY_similarequal = uint(C.GDK_KEY_similarequal) KEY_ifonlyif = uint(C.GDK_KEY_ifonlyif) KEY_implies = uint(C.GDK_KEY_implies) KEY_identical = uint(C.GDK_KEY_identical) KEY_radical = uint(C.GDK_KEY_radical) KEY_includedin = uint(C.GDK_KEY_includedin) KEY_includes = uint(C.GDK_KEY_includes) KEY_intersection = uint(C.GDK_KEY_intersection) KEY_union = uint(C.GDK_KEY_union) KEY_logicaland = uint(C.GDK_KEY_logicaland) KEY_logicalor = uint(C.GDK_KEY_logicalor) KEY_partialderivative = uint(C.GDK_KEY_partialderivative) KEY_function = uint(C.GDK_KEY_function) KEY_leftarrow = uint(C.GDK_KEY_leftarrow) KEY_uparrow = uint(C.GDK_KEY_uparrow) KEY_rightarrow = uint(C.GDK_KEY_rightarrow) KEY_downarrow = uint(C.GDK_KEY_downarrow) KEY_blank = uint(C.GDK_KEY_blank) KEY_soliddiamond = uint(C.GDK_KEY_soliddiamond) KEY_checkerboard = uint(C.GDK_KEY_checkerboard) KEY_ht = uint(C.GDK_KEY_ht) KEY_ff = uint(C.GDK_KEY_ff) KEY_cr = uint(C.GDK_KEY_cr) KEY_lf = uint(C.GDK_KEY_lf) KEY_nl = uint(C.GDK_KEY_nl) KEY_vt = uint(C.GDK_KEY_vt) KEY_lowrightcorner = uint(C.GDK_KEY_lowrightcorner) KEY_uprightcorner = uint(C.GDK_KEY_uprightcorner) KEY_upleftcorner = uint(C.GDK_KEY_upleftcorner) KEY_lowleftcorner = uint(C.GDK_KEY_lowleftcorner) KEY_crossinglines = uint(C.GDK_KEY_crossinglines) KEY_horizlinescan1 = uint(C.GDK_KEY_horizlinescan1) KEY_horizlinescan3 = uint(C.GDK_KEY_horizlinescan3) KEY_horizlinescan5 = uint(C.GDK_KEY_horizlinescan5) KEY_horizlinescan7 = uint(C.GDK_KEY_horizlinescan7) KEY_horizlinescan9 = uint(C.GDK_KEY_horizlinescan9) KEY_leftt = uint(C.GDK_KEY_leftt) KEY_rightt = uint(C.GDK_KEY_rightt) KEY_bott = uint(C.GDK_KEY_bott) KEY_topt = uint(C.GDK_KEY_topt) KEY_vertbar = uint(C.GDK_KEY_vertbar) KEY_emspace = uint(C.GDK_KEY_emspace) KEY_enspace = uint(C.GDK_KEY_enspace) KEY_em3space = uint(C.GDK_KEY_em3space) KEY_em4space = uint(C.GDK_KEY_em4space) KEY_digitspace = uint(C.GDK_KEY_digitspace) KEY_punctspace = uint(C.GDK_KEY_punctspace) KEY_thinspace = uint(C.GDK_KEY_thinspace) KEY_hairspace = uint(C.GDK_KEY_hairspace) KEY_emdash = uint(C.GDK_KEY_emdash) KEY_endash = uint(C.GDK_KEY_endash) KEY_signifblank = uint(C.GDK_KEY_signifblank) KEY_ellipsis = uint(C.GDK_KEY_ellipsis) KEY_doubbaselinedot = uint(C.GDK_KEY_doubbaselinedot) KEY_onethird = uint(C.GDK_KEY_onethird) KEY_twothirds = uint(C.GDK_KEY_twothirds) KEY_onefifth = uint(C.GDK_KEY_onefifth) KEY_twofifths = uint(C.GDK_KEY_twofifths) KEY_threefifths = uint(C.GDK_KEY_threefifths) KEY_fourfifths = uint(C.GDK_KEY_fourfifths) KEY_onesixth = uint(C.GDK_KEY_onesixth) KEY_fivesixths = uint(C.GDK_KEY_fivesixths) KEY_careof = uint(C.GDK_KEY_careof) KEY_figdash = uint(C.GDK_KEY_figdash) KEY_leftanglebracket = uint(C.GDK_KEY_leftanglebracket) KEY_decimalpoint = uint(C.GDK_KEY_decimalpoint) KEY_rightanglebracket = uint(C.GDK_KEY_rightanglebracket) KEY_marker = uint(C.GDK_KEY_marker) KEY_oneeighth = uint(C.GDK_KEY_oneeighth) KEY_threeeighths = uint(C.GDK_KEY_threeeighths) KEY_fiveeighths = uint(C.GDK_KEY_fiveeighths) KEY_seveneighths = uint(C.GDK_KEY_seveneighths) KEY_trademark = uint(C.GDK_KEY_trademark) KEY_signaturemark = uint(C.GDK_KEY_signaturemark) KEY_trademarkincircle = uint(C.GDK_KEY_trademarkincircle) KEY_leftopentriangle = uint(C.GDK_KEY_leftopentriangle) KEY_rightopentriangle = uint(C.GDK_KEY_rightopentriangle) KEY_emopencircle = uint(C.GDK_KEY_emopencircle) KEY_emopenrectangle = uint(C.GDK_KEY_emopenrectangle) KEY_leftsinglequotemark = uint(C.GDK_KEY_leftsinglequotemark) KEY_rightsinglequotemark = uint(C.GDK_KEY_rightsinglequotemark) KEY_leftdoublequotemark = uint(C.GDK_KEY_leftdoublequotemark) KEY_rightdoublequotemark = uint(C.GDK_KEY_rightdoublequotemark) KEY_prescription = uint(C.GDK_KEY_prescription) KEY_permille = uint(C.GDK_KEY_permille) KEY_minutes = uint(C.GDK_KEY_minutes) KEY_seconds = uint(C.GDK_KEY_seconds) KEY_latincross = uint(C.GDK_KEY_latincross) KEY_hexagram = uint(C.GDK_KEY_hexagram) KEY_filledrectbullet = uint(C.GDK_KEY_filledrectbullet) KEY_filledlefttribullet = uint(C.GDK_KEY_filledlefttribullet) KEY_filledrighttribullet = uint(C.GDK_KEY_filledrighttribullet) KEY_emfilledcircle = uint(C.GDK_KEY_emfilledcircle) KEY_emfilledrect = uint(C.GDK_KEY_emfilledrect) KEY_enopencircbullet = uint(C.GDK_KEY_enopencircbullet) KEY_enopensquarebullet = uint(C.GDK_KEY_enopensquarebullet) KEY_openrectbullet = uint(C.GDK_KEY_openrectbullet) KEY_opentribulletup = uint(C.GDK_KEY_opentribulletup) KEY_opentribulletdown = uint(C.GDK_KEY_opentribulletdown) KEY_openstar = uint(C.GDK_KEY_openstar) KEY_enfilledcircbullet = uint(C.GDK_KEY_enfilledcircbullet) KEY_enfilledsqbullet = uint(C.GDK_KEY_enfilledsqbullet) KEY_filledtribulletup = uint(C.GDK_KEY_filledtribulletup) KEY_filledtribulletdown = uint(C.GDK_KEY_filledtribulletdown) KEY_leftpointer = uint(C.GDK_KEY_leftpointer) KEY_rightpointer = uint(C.GDK_KEY_rightpointer) KEY_club = uint(C.GDK_KEY_club) KEY_diamond = uint(C.GDK_KEY_diamond) KEY_heart = uint(C.GDK_KEY_heart) KEY_maltesecross = uint(C.GDK_KEY_maltesecross) KEY_dagger = uint(C.GDK_KEY_dagger) KEY_doubledagger = uint(C.GDK_KEY_doubledagger) KEY_checkmark = uint(C.GDK_KEY_checkmark) KEY_ballotcross = uint(C.GDK_KEY_ballotcross) KEY_musicalsharp = uint(C.GDK_KEY_musicalsharp) KEY_musicalflat = uint(C.GDK_KEY_musicalflat) KEY_malesymbol = uint(C.GDK_KEY_malesymbol) KEY_femalesymbol = uint(C.GDK_KEY_femalesymbol) KEY_telephone = uint(C.GDK_KEY_telephone) KEY_telephonerecorder = uint(C.GDK_KEY_telephonerecorder) KEY_phonographcopyright = uint(C.GDK_KEY_phonographcopyright) KEY_caret = uint(C.GDK_KEY_caret) KEY_singlelowquotemark = uint(C.GDK_KEY_singlelowquotemark) KEY_doublelowquotemark = uint(C.GDK_KEY_doublelowquotemark) KEY_cursor = uint(C.GDK_KEY_cursor) KEY_leftcaret = uint(C.GDK_KEY_leftcaret) KEY_rightcaret = uint(C.GDK_KEY_rightcaret) KEY_downcaret = uint(C.GDK_KEY_downcaret) KEY_upcaret = uint(C.GDK_KEY_upcaret) KEY_overbar = uint(C.GDK_KEY_overbar) KEY_downtack = uint(C.GDK_KEY_downtack) KEY_upshoe = uint(C.GDK_KEY_upshoe) KEY_downstile = uint(C.GDK_KEY_downstile) KEY_underbar = uint(C.GDK_KEY_underbar) KEY_jot = uint(C.GDK_KEY_jot) KEY_quad = uint(C.GDK_KEY_quad) KEY_uptack = uint(C.GDK_KEY_uptack) KEY_circle = uint(C.GDK_KEY_circle) KEY_upstile = uint(C.GDK_KEY_upstile) KEY_downshoe = uint(C.GDK_KEY_downshoe) KEY_rightshoe = uint(C.GDK_KEY_rightshoe) KEY_leftshoe = uint(C.GDK_KEY_leftshoe) KEY_lefttack = uint(C.GDK_KEY_lefttack) KEY_righttack = uint(C.GDK_KEY_righttack) KEY_hebrew_doublelowline = uint(C.GDK_KEY_hebrew_doublelowline) KEY_hebrew_aleph = uint(C.GDK_KEY_hebrew_aleph) KEY_hebrew_bet = uint(C.GDK_KEY_hebrew_bet) KEY_hebrew_beth = uint(C.GDK_KEY_hebrew_beth) KEY_hebrew_gimel = uint(C.GDK_KEY_hebrew_gimel) KEY_hebrew_gimmel = uint(C.GDK_KEY_hebrew_gimmel) KEY_hebrew_dalet = uint(C.GDK_KEY_hebrew_dalet) KEY_hebrew_daleth = uint(C.GDK_KEY_hebrew_daleth) KEY_hebrew_he = uint(C.GDK_KEY_hebrew_he) KEY_hebrew_waw = uint(C.GDK_KEY_hebrew_waw) KEY_hebrew_zain = uint(C.GDK_KEY_hebrew_zain) KEY_hebrew_zayin = uint(C.GDK_KEY_hebrew_zayin) KEY_hebrew_chet = uint(C.GDK_KEY_hebrew_chet) KEY_hebrew_het = uint(C.GDK_KEY_hebrew_het) KEY_hebrew_tet = uint(C.GDK_KEY_hebrew_tet) KEY_hebrew_teth = uint(C.GDK_KEY_hebrew_teth) KEY_hebrew_yod = uint(C.GDK_KEY_hebrew_yod) KEY_hebrew_finalkaph = uint(C.GDK_KEY_hebrew_finalkaph) KEY_hebrew_kaph = uint(C.GDK_KEY_hebrew_kaph) KEY_hebrew_lamed = uint(C.GDK_KEY_hebrew_lamed) KEY_hebrew_finalmem = uint(C.GDK_KEY_hebrew_finalmem) KEY_hebrew_mem = uint(C.GDK_KEY_hebrew_mem) KEY_hebrew_finalnun = uint(C.GDK_KEY_hebrew_finalnun) KEY_hebrew_nun = uint(C.GDK_KEY_hebrew_nun) KEY_hebrew_samech = uint(C.GDK_KEY_hebrew_samech) KEY_hebrew_samekh = uint(C.GDK_KEY_hebrew_samekh) KEY_hebrew_ayin = uint(C.GDK_KEY_hebrew_ayin) KEY_hebrew_finalpe = uint(C.GDK_KEY_hebrew_finalpe) KEY_hebrew_pe = uint(C.GDK_KEY_hebrew_pe) KEY_hebrew_finalzade = uint(C.GDK_KEY_hebrew_finalzade) KEY_hebrew_finalzadi = uint(C.GDK_KEY_hebrew_finalzadi) KEY_hebrew_zade = uint(C.GDK_KEY_hebrew_zade) KEY_hebrew_zadi = uint(C.GDK_KEY_hebrew_zadi) KEY_hebrew_qoph = uint(C.GDK_KEY_hebrew_qoph) KEY_hebrew_kuf = uint(C.GDK_KEY_hebrew_kuf) KEY_hebrew_resh = uint(C.GDK_KEY_hebrew_resh) KEY_hebrew_shin = uint(C.GDK_KEY_hebrew_shin) KEY_hebrew_taw = uint(C.GDK_KEY_hebrew_taw) KEY_hebrew_taf = uint(C.GDK_KEY_hebrew_taf) KEY_Hebrew_switch = uint(C.GDK_KEY_Hebrew_switch) KEY_Thai_kokai = uint(C.GDK_KEY_Thai_kokai) KEY_Thai_khokhai = uint(C.GDK_KEY_Thai_khokhai) KEY_Thai_khokhuat = uint(C.GDK_KEY_Thai_khokhuat) KEY_Thai_khokhwai = uint(C.GDK_KEY_Thai_khokhwai) KEY_Thai_khokhon = uint(C.GDK_KEY_Thai_khokhon) KEY_Thai_khorakhang = uint(C.GDK_KEY_Thai_khorakhang) KEY_Thai_ngongu = uint(C.GDK_KEY_Thai_ngongu) KEY_Thai_chochan = uint(C.GDK_KEY_Thai_chochan) KEY_Thai_choching = uint(C.GDK_KEY_Thai_choching) KEY_Thai_chochang = uint(C.GDK_KEY_Thai_chochang) KEY_Thai_soso = uint(C.GDK_KEY_Thai_soso) KEY_Thai_chochoe = uint(C.GDK_KEY_Thai_chochoe) KEY_Thai_yoying = uint(C.GDK_KEY_Thai_yoying) KEY_Thai_dochada = uint(C.GDK_KEY_Thai_dochada) KEY_Thai_topatak = uint(C.GDK_KEY_Thai_topatak) KEY_Thai_thothan = uint(C.GDK_KEY_Thai_thothan) KEY_Thai_thonangmontho = uint(C.GDK_KEY_Thai_thonangmontho) KEY_Thai_thophuthao = uint(C.GDK_KEY_Thai_thophuthao) KEY_Thai_nonen = uint(C.GDK_KEY_Thai_nonen) KEY_Thai_dodek = uint(C.GDK_KEY_Thai_dodek) KEY_Thai_totao = uint(C.GDK_KEY_Thai_totao) KEY_Thai_thothung = uint(C.GDK_KEY_Thai_thothung) KEY_Thai_thothahan = uint(C.GDK_KEY_Thai_thothahan) KEY_Thai_thothong = uint(C.GDK_KEY_Thai_thothong) KEY_Thai_nonu = uint(C.GDK_KEY_Thai_nonu) KEY_Thai_bobaimai = uint(C.GDK_KEY_Thai_bobaimai) KEY_Thai_popla = uint(C.GDK_KEY_Thai_popla) KEY_Thai_phophung = uint(C.GDK_KEY_Thai_phophung) KEY_Thai_fofa = uint(C.GDK_KEY_Thai_fofa) KEY_Thai_phophan = uint(C.GDK_KEY_Thai_phophan) KEY_Thai_fofan = uint(C.GDK_KEY_Thai_fofan) KEY_Thai_phosamphao = uint(C.GDK_KEY_Thai_phosamphao) KEY_Thai_moma = uint(C.GDK_KEY_Thai_moma) KEY_Thai_yoyak = uint(C.GDK_KEY_Thai_yoyak) KEY_Thai_rorua = uint(C.GDK_KEY_Thai_rorua) KEY_Thai_ru = uint(C.GDK_KEY_Thai_ru) KEY_Thai_loling = uint(C.GDK_KEY_Thai_loling) KEY_Thai_lu = uint(C.GDK_KEY_Thai_lu) KEY_Thai_wowaen = uint(C.GDK_KEY_Thai_wowaen) KEY_Thai_sosala = uint(C.GDK_KEY_Thai_sosala) KEY_Thai_sorusi = uint(C.GDK_KEY_Thai_sorusi) KEY_Thai_sosua = uint(C.GDK_KEY_Thai_sosua) KEY_Thai_hohip = uint(C.GDK_KEY_Thai_hohip) KEY_Thai_lochula = uint(C.GDK_KEY_Thai_lochula) KEY_Thai_oang = uint(C.GDK_KEY_Thai_oang) KEY_Thai_honokhuk = uint(C.GDK_KEY_Thai_honokhuk) KEY_Thai_paiyannoi = uint(C.GDK_KEY_Thai_paiyannoi) KEY_Thai_saraa = uint(C.GDK_KEY_Thai_saraa) KEY_Thai_maihanakat = uint(C.GDK_KEY_Thai_maihanakat) KEY_Thai_saraaa = uint(C.GDK_KEY_Thai_saraaa) KEY_Thai_saraam = uint(C.GDK_KEY_Thai_saraam) KEY_Thai_sarai = uint(C.GDK_KEY_Thai_sarai) KEY_Thai_saraii = uint(C.GDK_KEY_Thai_saraii) KEY_Thai_saraue = uint(C.GDK_KEY_Thai_saraue) KEY_Thai_sarauee = uint(C.GDK_KEY_Thai_sarauee) KEY_Thai_sarau = uint(C.GDK_KEY_Thai_sarau) KEY_Thai_sarauu = uint(C.GDK_KEY_Thai_sarauu) KEY_Thai_phinthu = uint(C.GDK_KEY_Thai_phinthu) KEY_Thai_maihanakat_maitho = uint(C.GDK_KEY_Thai_maihanakat_maitho) KEY_Thai_baht = uint(C.GDK_KEY_Thai_baht) KEY_Thai_sarae = uint(C.GDK_KEY_Thai_sarae) KEY_Thai_saraae = uint(C.GDK_KEY_Thai_saraae) KEY_Thai_sarao = uint(C.GDK_KEY_Thai_sarao) KEY_Thai_saraaimaimuan = uint(C.GDK_KEY_Thai_saraaimaimuan) KEY_Thai_saraaimaimalai = uint(C.GDK_KEY_Thai_saraaimaimalai) KEY_Thai_lakkhangyao = uint(C.GDK_KEY_Thai_lakkhangyao) KEY_Thai_maiyamok = uint(C.GDK_KEY_Thai_maiyamok) KEY_Thai_maitaikhu = uint(C.GDK_KEY_Thai_maitaikhu) KEY_Thai_maiek = uint(C.GDK_KEY_Thai_maiek) KEY_Thai_maitho = uint(C.GDK_KEY_Thai_maitho) KEY_Thai_maitri = uint(C.GDK_KEY_Thai_maitri) KEY_Thai_maichattawa = uint(C.GDK_KEY_Thai_maichattawa) KEY_Thai_thanthakhat = uint(C.GDK_KEY_Thai_thanthakhat) KEY_Thai_nikhahit = uint(C.GDK_KEY_Thai_nikhahit) KEY_Thai_leksun = uint(C.GDK_KEY_Thai_leksun) KEY_Thai_leknung = uint(C.GDK_KEY_Thai_leknung) KEY_Thai_leksong = uint(C.GDK_KEY_Thai_leksong) KEY_Thai_leksam = uint(C.GDK_KEY_Thai_leksam) KEY_Thai_leksi = uint(C.GDK_KEY_Thai_leksi) KEY_Thai_lekha = uint(C.GDK_KEY_Thai_lekha) KEY_Thai_lekhok = uint(C.GDK_KEY_Thai_lekhok) KEY_Thai_lekchet = uint(C.GDK_KEY_Thai_lekchet) KEY_Thai_lekpaet = uint(C.GDK_KEY_Thai_lekpaet) KEY_Thai_lekkao = uint(C.GDK_KEY_Thai_lekkao) KEY_Hangul = uint(C.GDK_KEY_Hangul) KEY_Hangul_Start = uint(C.GDK_KEY_Hangul_Start) KEY_Hangul_End = uint(C.GDK_KEY_Hangul_End) KEY_Hangul_Hanja = uint(C.GDK_KEY_Hangul_Hanja) KEY_Hangul_Jamo = uint(C.GDK_KEY_Hangul_Jamo) KEY_Hangul_Romaja = uint(C.GDK_KEY_Hangul_Romaja) KEY_Hangul_Codeinput = uint(C.GDK_KEY_Hangul_Codeinput) KEY_Hangul_Jeonja = uint(C.GDK_KEY_Hangul_Jeonja) KEY_Hangul_Banja = uint(C.GDK_KEY_Hangul_Banja) KEY_Hangul_PreHanja = uint(C.GDK_KEY_Hangul_PreHanja) KEY_Hangul_PostHanja = uint(C.GDK_KEY_Hangul_PostHanja) KEY_Hangul_SingleCandidate = uint(C.GDK_KEY_Hangul_SingleCandidate) KEY_Hangul_MultipleCandidate = uint(C.GDK_KEY_Hangul_MultipleCandidate) KEY_Hangul_PreviousCandidate = uint(C.GDK_KEY_Hangul_PreviousCandidate) KEY_Hangul_Special = uint(C.GDK_KEY_Hangul_Special) KEY_Hangul_switch = uint(C.GDK_KEY_Hangul_switch) KEY_Hangul_Kiyeog = uint(C.GDK_KEY_Hangul_Kiyeog) KEY_Hangul_SsangKiyeog = uint(C.GDK_KEY_Hangul_SsangKiyeog) KEY_Hangul_KiyeogSios = uint(C.GDK_KEY_Hangul_KiyeogSios) KEY_Hangul_Nieun = uint(C.GDK_KEY_Hangul_Nieun) KEY_Hangul_NieunJieuj = uint(C.GDK_KEY_Hangul_NieunJieuj) KEY_Hangul_NieunHieuh = uint(C.GDK_KEY_Hangul_NieunHieuh) KEY_Hangul_Dikeud = uint(C.GDK_KEY_Hangul_Dikeud) KEY_Hangul_SsangDikeud = uint(C.GDK_KEY_Hangul_SsangDikeud) KEY_Hangul_Rieul = uint(C.GDK_KEY_Hangul_Rieul) KEY_Hangul_RieulKiyeog = uint(C.GDK_KEY_Hangul_RieulKiyeog) KEY_Hangul_RieulMieum = uint(C.GDK_KEY_Hangul_RieulMieum) KEY_Hangul_RieulPieub = uint(C.GDK_KEY_Hangul_RieulPieub) KEY_Hangul_RieulSios = uint(C.GDK_KEY_Hangul_RieulSios) KEY_Hangul_RieulTieut = uint(C.GDK_KEY_Hangul_RieulTieut) KEY_Hangul_RieulPhieuf = uint(C.GDK_KEY_Hangul_RieulPhieuf) KEY_Hangul_RieulHieuh = uint(C.GDK_KEY_Hangul_RieulHieuh) KEY_Hangul_Mieum = uint(C.GDK_KEY_Hangul_Mieum) KEY_Hangul_Pieub = uint(C.GDK_KEY_Hangul_Pieub) KEY_Hangul_SsangPieub = uint(C.GDK_KEY_Hangul_SsangPieub) KEY_Hangul_PieubSios = uint(C.GDK_KEY_Hangul_PieubSios) KEY_Hangul_Sios = uint(C.GDK_KEY_Hangul_Sios) KEY_Hangul_SsangSios = uint(C.GDK_KEY_Hangul_SsangSios) KEY_Hangul_Ieung = uint(C.GDK_KEY_Hangul_Ieung) KEY_Hangul_Jieuj = uint(C.GDK_KEY_Hangul_Jieuj) KEY_Hangul_SsangJieuj = uint(C.GDK_KEY_Hangul_SsangJieuj) KEY_Hangul_Cieuc = uint(C.GDK_KEY_Hangul_Cieuc) KEY_Hangul_Khieuq = uint(C.GDK_KEY_Hangul_Khieuq) KEY_Hangul_Tieut = uint(C.GDK_KEY_Hangul_Tieut) KEY_Hangul_Phieuf = uint(C.GDK_KEY_Hangul_Phieuf) KEY_Hangul_Hieuh = uint(C.GDK_KEY_Hangul_Hieuh) KEY_Hangul_A = uint(C.GDK_KEY_Hangul_A) KEY_Hangul_AE = uint(C.GDK_KEY_Hangul_AE) KEY_Hangul_YA = uint(C.GDK_KEY_Hangul_YA) KEY_Hangul_YAE = uint(C.GDK_KEY_Hangul_YAE) KEY_Hangul_EO = uint(C.GDK_KEY_Hangul_EO) KEY_Hangul_E = uint(C.GDK_KEY_Hangul_E) KEY_Hangul_YEO = uint(C.GDK_KEY_Hangul_YEO) KEY_Hangul_YE = uint(C.GDK_KEY_Hangul_YE) KEY_Hangul_O = uint(C.GDK_KEY_Hangul_O) KEY_Hangul_WA = uint(C.GDK_KEY_Hangul_WA) KEY_Hangul_WAE = uint(C.GDK_KEY_Hangul_WAE) KEY_Hangul_OE = uint(C.GDK_KEY_Hangul_OE) KEY_Hangul_YO = uint(C.GDK_KEY_Hangul_YO) KEY_Hangul_U = uint(C.GDK_KEY_Hangul_U) KEY_Hangul_WEO = uint(C.GDK_KEY_Hangul_WEO) KEY_Hangul_WE = uint(C.GDK_KEY_Hangul_WE) KEY_Hangul_WI = uint(C.GDK_KEY_Hangul_WI) KEY_Hangul_YU = uint(C.GDK_KEY_Hangul_YU) KEY_Hangul_EU = uint(C.GDK_KEY_Hangul_EU) KEY_Hangul_YI = uint(C.GDK_KEY_Hangul_YI) KEY_Hangul_I = uint(C.GDK_KEY_Hangul_I) KEY_Hangul_J_Kiyeog = uint(C.GDK_KEY_Hangul_J_Kiyeog) KEY_Hangul_J_SsangKiyeog = uint(C.GDK_KEY_Hangul_J_SsangKiyeog) KEY_Hangul_J_KiyeogSios = uint(C.GDK_KEY_Hangul_J_KiyeogSios) KEY_Hangul_J_Nieun = uint(C.GDK_KEY_Hangul_J_Nieun) KEY_Hangul_J_NieunJieuj = uint(C.GDK_KEY_Hangul_J_NieunJieuj) KEY_Hangul_J_NieunHieuh = uint(C.GDK_KEY_Hangul_J_NieunHieuh) KEY_Hangul_J_Dikeud = uint(C.GDK_KEY_Hangul_J_Dikeud) KEY_Hangul_J_Rieul = uint(C.GDK_KEY_Hangul_J_Rieul) KEY_Hangul_J_RieulKiyeog = uint(C.GDK_KEY_Hangul_J_RieulKiyeog) KEY_Hangul_J_RieulMieum = uint(C.GDK_KEY_Hangul_J_RieulMieum) KEY_Hangul_J_RieulPieub = uint(C.GDK_KEY_Hangul_J_RieulPieub) KEY_Hangul_J_RieulSios = uint(C.GDK_KEY_Hangul_J_RieulSios) KEY_Hangul_J_RieulTieut = uint(C.GDK_KEY_Hangul_J_RieulTieut) KEY_Hangul_J_RieulPhieuf = uint(C.GDK_KEY_Hangul_J_RieulPhieuf) KEY_Hangul_J_RieulHieuh = uint(C.GDK_KEY_Hangul_J_RieulHieuh) KEY_Hangul_J_Mieum = uint(C.GDK_KEY_Hangul_J_Mieum) KEY_Hangul_J_Pieub = uint(C.GDK_KEY_Hangul_J_Pieub) KEY_Hangul_J_PieubSios = uint(C.GDK_KEY_Hangul_J_PieubSios) KEY_Hangul_J_Sios = uint(C.GDK_KEY_Hangul_J_Sios) KEY_Hangul_J_SsangSios = uint(C.GDK_KEY_Hangul_J_SsangSios) KEY_Hangul_J_Ieung = uint(C.GDK_KEY_Hangul_J_Ieung) KEY_Hangul_J_Jieuj = uint(C.GDK_KEY_Hangul_J_Jieuj) KEY_Hangul_J_Cieuc = uint(C.GDK_KEY_Hangul_J_Cieuc) KEY_Hangul_J_Khieuq = uint(C.GDK_KEY_Hangul_J_Khieuq) KEY_Hangul_J_Tieut = uint(C.GDK_KEY_Hangul_J_Tieut) KEY_Hangul_J_Phieuf = uint(C.GDK_KEY_Hangul_J_Phieuf) KEY_Hangul_J_Hieuh = uint(C.GDK_KEY_Hangul_J_Hieuh) KEY_Hangul_RieulYeorinHieuh = uint(C.GDK_KEY_Hangul_RieulYeorinHieuh) KEY_Hangul_SunkyeongeumMieum = uint(C.GDK_KEY_Hangul_SunkyeongeumMieum) KEY_Hangul_SunkyeongeumPieub = uint(C.GDK_KEY_Hangul_SunkyeongeumPieub) KEY_Hangul_PanSios = uint(C.GDK_KEY_Hangul_PanSios) KEY_Hangul_KkogjiDalrinIeung = uint(C.GDK_KEY_Hangul_KkogjiDalrinIeung) KEY_Hangul_SunkyeongeumPhieuf = uint(C.GDK_KEY_Hangul_SunkyeongeumPhieuf) KEY_Hangul_YeorinHieuh = uint(C.GDK_KEY_Hangul_YeorinHieuh) KEY_Hangul_AraeA = uint(C.GDK_KEY_Hangul_AraeA) KEY_Hangul_AraeAE = uint(C.GDK_KEY_Hangul_AraeAE) KEY_Hangul_J_PanSios = uint(C.GDK_KEY_Hangul_J_PanSios) KEY_Hangul_J_KkogjiDalrinIeung = uint(C.GDK_KEY_Hangul_J_KkogjiDalrinIeung) KEY_Hangul_J_YeorinHieuh = uint(C.GDK_KEY_Hangul_J_YeorinHieuh) KEY_Korean_Won = uint(C.GDK_KEY_Korean_Won) KEY_Armenian_ligature_ew = uint(C.GDK_KEY_Armenian_ligature_ew) KEY_Armenian_full_stop = uint(C.GDK_KEY_Armenian_full_stop) KEY_Armenian_verjaket = uint(C.GDK_KEY_Armenian_verjaket) KEY_Armenian_separation_mark = uint(C.GDK_KEY_Armenian_separation_mark) KEY_Armenian_but = uint(C.GDK_KEY_Armenian_but) KEY_Armenian_hyphen = uint(C.GDK_KEY_Armenian_hyphen) KEY_Armenian_yentamna = uint(C.GDK_KEY_Armenian_yentamna) KEY_Armenian_exclam = uint(C.GDK_KEY_Armenian_exclam) KEY_Armenian_amanak = uint(C.GDK_KEY_Armenian_amanak) KEY_Armenian_accent = uint(C.GDK_KEY_Armenian_accent) KEY_Armenian_shesht = uint(C.GDK_KEY_Armenian_shesht) KEY_Armenian_question = uint(C.GDK_KEY_Armenian_question) KEY_Armenian_paruyk = uint(C.GDK_KEY_Armenian_paruyk) KEY_Armenian_AYB = uint(C.GDK_KEY_Armenian_AYB) KEY_Armenian_ayb = uint(C.GDK_KEY_Armenian_ayb) KEY_Armenian_BEN = uint(C.GDK_KEY_Armenian_BEN) KEY_Armenian_ben = uint(C.GDK_KEY_Armenian_ben) KEY_Armenian_GIM = uint(C.GDK_KEY_Armenian_GIM) KEY_Armenian_gim = uint(C.GDK_KEY_Armenian_gim) KEY_Armenian_DA = uint(C.GDK_KEY_Armenian_DA) KEY_Armenian_da = uint(C.GDK_KEY_Armenian_da) KEY_Armenian_YECH = uint(C.GDK_KEY_Armenian_YECH) KEY_Armenian_yech = uint(C.GDK_KEY_Armenian_yech) KEY_Armenian_ZA = uint(C.GDK_KEY_Armenian_ZA) KEY_Armenian_za = uint(C.GDK_KEY_Armenian_za) KEY_Armenian_E = uint(C.GDK_KEY_Armenian_E) KEY_Armenian_e = uint(C.GDK_KEY_Armenian_e) KEY_Armenian_AT = uint(C.GDK_KEY_Armenian_AT) KEY_Armenian_at = uint(C.GDK_KEY_Armenian_at) KEY_Armenian_TO = uint(C.GDK_KEY_Armenian_TO) KEY_Armenian_to = uint(C.GDK_KEY_Armenian_to) KEY_Armenian_ZHE = uint(C.GDK_KEY_Armenian_ZHE) KEY_Armenian_zhe = uint(C.GDK_KEY_Armenian_zhe) KEY_Armenian_INI = uint(C.GDK_KEY_Armenian_INI) KEY_Armenian_ini = uint(C.GDK_KEY_Armenian_ini) KEY_Armenian_LYUN = uint(C.GDK_KEY_Armenian_LYUN) KEY_Armenian_lyun = uint(C.GDK_KEY_Armenian_lyun) KEY_Armenian_KHE = uint(C.GDK_KEY_Armenian_KHE) KEY_Armenian_khe = uint(C.GDK_KEY_Armenian_khe) KEY_Armenian_TSA = uint(C.GDK_KEY_Armenian_TSA) KEY_Armenian_tsa = uint(C.GDK_KEY_Armenian_tsa) KEY_Armenian_KEN = uint(C.GDK_KEY_Armenian_KEN) KEY_Armenian_ken = uint(C.GDK_KEY_Armenian_ken) KEY_Armenian_HO = uint(C.GDK_KEY_Armenian_HO) KEY_Armenian_ho = uint(C.GDK_KEY_Armenian_ho) KEY_Armenian_DZA = uint(C.GDK_KEY_Armenian_DZA) KEY_Armenian_dza = uint(C.GDK_KEY_Armenian_dza) KEY_Armenian_GHAT = uint(C.GDK_KEY_Armenian_GHAT) KEY_Armenian_ghat = uint(C.GDK_KEY_Armenian_ghat) KEY_Armenian_TCHE = uint(C.GDK_KEY_Armenian_TCHE) KEY_Armenian_tche = uint(C.GDK_KEY_Armenian_tche) KEY_Armenian_MEN = uint(C.GDK_KEY_Armenian_MEN) KEY_Armenian_men = uint(C.GDK_KEY_Armenian_men) KEY_Armenian_HI = uint(C.GDK_KEY_Armenian_HI) KEY_Armenian_hi = uint(C.GDK_KEY_Armenian_hi) KEY_Armenian_NU = uint(C.GDK_KEY_Armenian_NU) KEY_Armenian_nu = uint(C.GDK_KEY_Armenian_nu) KEY_Armenian_SHA = uint(C.GDK_KEY_Armenian_SHA) KEY_Armenian_sha = uint(C.GDK_KEY_Armenian_sha) KEY_Armenian_VO = uint(C.GDK_KEY_Armenian_VO) KEY_Armenian_vo = uint(C.GDK_KEY_Armenian_vo) KEY_Armenian_CHA = uint(C.GDK_KEY_Armenian_CHA) KEY_Armenian_cha = uint(C.GDK_KEY_Armenian_cha) KEY_Armenian_PE = uint(C.GDK_KEY_Armenian_PE) KEY_Armenian_pe = uint(C.GDK_KEY_Armenian_pe) KEY_Armenian_JE = uint(C.GDK_KEY_Armenian_JE) KEY_Armenian_je = uint(C.GDK_KEY_Armenian_je) KEY_Armenian_RA = uint(C.GDK_KEY_Armenian_RA) KEY_Armenian_ra = uint(C.GDK_KEY_Armenian_ra) KEY_Armenian_SE = uint(C.GDK_KEY_Armenian_SE) KEY_Armenian_se = uint(C.GDK_KEY_Armenian_se) KEY_Armenian_VEV = uint(C.GDK_KEY_Armenian_VEV) KEY_Armenian_vev = uint(C.GDK_KEY_Armenian_vev) KEY_Armenian_TYUN = uint(C.GDK_KEY_Armenian_TYUN) KEY_Armenian_tyun = uint(C.GDK_KEY_Armenian_tyun) KEY_Armenian_RE = uint(C.GDK_KEY_Armenian_RE) KEY_Armenian_re = uint(C.GDK_KEY_Armenian_re) KEY_Armenian_TSO = uint(C.GDK_KEY_Armenian_TSO) KEY_Armenian_tso = uint(C.GDK_KEY_Armenian_tso) KEY_Armenian_VYUN = uint(C.GDK_KEY_Armenian_VYUN) KEY_Armenian_vyun = uint(C.GDK_KEY_Armenian_vyun) KEY_Armenian_PYUR = uint(C.GDK_KEY_Armenian_PYUR) KEY_Armenian_pyur = uint(C.GDK_KEY_Armenian_pyur) KEY_Armenian_KE = uint(C.GDK_KEY_Armenian_KE) KEY_Armenian_ke = uint(C.GDK_KEY_Armenian_ke) KEY_Armenian_O = uint(C.GDK_KEY_Armenian_O) KEY_Armenian_o = uint(C.GDK_KEY_Armenian_o) KEY_Armenian_FE = uint(C.GDK_KEY_Armenian_FE) KEY_Armenian_fe = uint(C.GDK_KEY_Armenian_fe) KEY_Armenian_apostrophe = uint(C.GDK_KEY_Armenian_apostrophe) KEY_Georgian_an = uint(C.GDK_KEY_Georgian_an) KEY_Georgian_ban = uint(C.GDK_KEY_Georgian_ban) KEY_Georgian_gan = uint(C.GDK_KEY_Georgian_gan) KEY_Georgian_don = uint(C.GDK_KEY_Georgian_don) KEY_Georgian_en = uint(C.GDK_KEY_Georgian_en) KEY_Georgian_vin = uint(C.GDK_KEY_Georgian_vin) KEY_Georgian_zen = uint(C.GDK_KEY_Georgian_zen) KEY_Georgian_tan = uint(C.GDK_KEY_Georgian_tan) KEY_Georgian_in = uint(C.GDK_KEY_Georgian_in) KEY_Georgian_kan = uint(C.GDK_KEY_Georgian_kan) KEY_Georgian_las = uint(C.GDK_KEY_Georgian_las) KEY_Georgian_man = uint(C.GDK_KEY_Georgian_man) KEY_Georgian_nar = uint(C.GDK_KEY_Georgian_nar) KEY_Georgian_on = uint(C.GDK_KEY_Georgian_on) KEY_Georgian_par = uint(C.GDK_KEY_Georgian_par) KEY_Georgian_zhar = uint(C.GDK_KEY_Georgian_zhar) KEY_Georgian_rae = uint(C.GDK_KEY_Georgian_rae) KEY_Georgian_san = uint(C.GDK_KEY_Georgian_san) KEY_Georgian_tar = uint(C.GDK_KEY_Georgian_tar) KEY_Georgian_un = uint(C.GDK_KEY_Georgian_un) KEY_Georgian_phar = uint(C.GDK_KEY_Georgian_phar) KEY_Georgian_khar = uint(C.GDK_KEY_Georgian_khar) KEY_Georgian_ghan = uint(C.GDK_KEY_Georgian_ghan) KEY_Georgian_qar = uint(C.GDK_KEY_Georgian_qar) KEY_Georgian_shin = uint(C.GDK_KEY_Georgian_shin) KEY_Georgian_chin = uint(C.GDK_KEY_Georgian_chin) KEY_Georgian_can = uint(C.GDK_KEY_Georgian_can) KEY_Georgian_jil = uint(C.GDK_KEY_Georgian_jil) KEY_Georgian_cil = uint(C.GDK_KEY_Georgian_cil) KEY_Georgian_char = uint(C.GDK_KEY_Georgian_char) KEY_Georgian_xan = uint(C.GDK_KEY_Georgian_xan) KEY_Georgian_jhan = uint(C.GDK_KEY_Georgian_jhan) KEY_Georgian_hae = uint(C.GDK_KEY_Georgian_hae) KEY_Georgian_he = uint(C.GDK_KEY_Georgian_he) KEY_Georgian_hie = uint(C.GDK_KEY_Georgian_hie) KEY_Georgian_we = uint(C.GDK_KEY_Georgian_we) KEY_Georgian_har = uint(C.GDK_KEY_Georgian_har) KEY_Georgian_hoe = uint(C.GDK_KEY_Georgian_hoe) KEY_Georgian_fi = uint(C.GDK_KEY_Georgian_fi) KEY_Xabovedot = uint(C.GDK_KEY_Xabovedot) KEY_Ibreve = uint(C.GDK_KEY_Ibreve) KEY_Zstroke = uint(C.GDK_KEY_Zstroke) KEY_Gcaron = uint(C.GDK_KEY_Gcaron) KEY_Ocaron = uint(C.GDK_KEY_Ocaron) KEY_Obarred = uint(C.GDK_KEY_Obarred) KEY_xabovedot = uint(C.GDK_KEY_xabovedot) KEY_ibreve = uint(C.GDK_KEY_ibreve) KEY_zstroke = uint(C.GDK_KEY_zstroke) KEY_gcaron = uint(C.GDK_KEY_gcaron) KEY_ocaron = uint(C.GDK_KEY_ocaron) KEY_obarred = uint(C.GDK_KEY_obarred) KEY_SCHWA = uint(C.GDK_KEY_SCHWA) KEY_schwa = uint(C.GDK_KEY_schwa) KEY_EZH = uint(C.GDK_KEY_EZH) KEY_ezh = uint(C.GDK_KEY_ezh) KEY_Lbelowdot = uint(C.GDK_KEY_Lbelowdot) KEY_lbelowdot = uint(C.GDK_KEY_lbelowdot) KEY_Abelowdot = uint(C.GDK_KEY_Abelowdot) KEY_abelowdot = uint(C.GDK_KEY_abelowdot) KEY_Ahook = uint(C.GDK_KEY_Ahook) KEY_ahook = uint(C.GDK_KEY_ahook) KEY_Acircumflexacute = uint(C.GDK_KEY_Acircumflexacute) KEY_acircumflexacute = uint(C.GDK_KEY_acircumflexacute) KEY_Acircumflexgrave = uint(C.GDK_KEY_Acircumflexgrave) KEY_acircumflexgrave = uint(C.GDK_KEY_acircumflexgrave) KEY_Acircumflexhook = uint(C.GDK_KEY_Acircumflexhook) KEY_acircumflexhook = uint(C.GDK_KEY_acircumflexhook) KEY_Acircumflextilde = uint(C.GDK_KEY_Acircumflextilde) KEY_acircumflextilde = uint(C.GDK_KEY_acircumflextilde) KEY_Acircumflexbelowdot = uint(C.GDK_KEY_Acircumflexbelowdot) KEY_acircumflexbelowdot = uint(C.GDK_KEY_acircumflexbelowdot) KEY_Abreveacute = uint(C.GDK_KEY_Abreveacute) KEY_abreveacute = uint(C.GDK_KEY_abreveacute) KEY_Abrevegrave = uint(C.GDK_KEY_Abrevegrave) KEY_abrevegrave = uint(C.GDK_KEY_abrevegrave) KEY_Abrevehook = uint(C.GDK_KEY_Abrevehook) KEY_abrevehook = uint(C.GDK_KEY_abrevehook) KEY_Abrevetilde = uint(C.GDK_KEY_Abrevetilde) KEY_abrevetilde = uint(C.GDK_KEY_abrevetilde) KEY_Abrevebelowdot = uint(C.GDK_KEY_Abrevebelowdot) KEY_abrevebelowdot = uint(C.GDK_KEY_abrevebelowdot) KEY_Ebelowdot = uint(C.GDK_KEY_Ebelowdot) KEY_ebelowdot = uint(C.GDK_KEY_ebelowdot) KEY_Ehook = uint(C.GDK_KEY_Ehook) KEY_ehook = uint(C.GDK_KEY_ehook) KEY_Etilde = uint(C.GDK_KEY_Etilde) KEY_etilde = uint(C.GDK_KEY_etilde) KEY_Ecircumflexacute = uint(C.GDK_KEY_Ecircumflexacute) KEY_ecircumflexacute = uint(C.GDK_KEY_ecircumflexacute) KEY_Ecircumflexgrave = uint(C.GDK_KEY_Ecircumflexgrave) KEY_ecircumflexgrave = uint(C.GDK_KEY_ecircumflexgrave) KEY_Ecircumflexhook = uint(C.GDK_KEY_Ecircumflexhook) KEY_ecircumflexhook = uint(C.GDK_KEY_ecircumflexhook) KEY_Ecircumflextilde = uint(C.GDK_KEY_Ecircumflextilde) KEY_ecircumflextilde = uint(C.GDK_KEY_ecircumflextilde) KEY_Ecircumflexbelowdot = uint(C.GDK_KEY_Ecircumflexbelowdot) KEY_ecircumflexbelowdot = uint(C.GDK_KEY_ecircumflexbelowdot) KEY_Ihook = uint(C.GDK_KEY_Ihook) KEY_ihook = uint(C.GDK_KEY_ihook) KEY_Ibelowdot = uint(C.GDK_KEY_Ibelowdot) KEY_ibelowdot = uint(C.GDK_KEY_ibelowdot) KEY_Obelowdot = uint(C.GDK_KEY_Obelowdot) KEY_obelowdot = uint(C.GDK_KEY_obelowdot) KEY_Ohook = uint(C.GDK_KEY_Ohook) KEY_ohook = uint(C.GDK_KEY_ohook) KEY_Ocircumflexacute = uint(C.GDK_KEY_Ocircumflexacute) KEY_ocircumflexacute = uint(C.GDK_KEY_ocircumflexacute) KEY_Ocircumflexgrave = uint(C.GDK_KEY_Ocircumflexgrave) KEY_ocircumflexgrave = uint(C.GDK_KEY_ocircumflexgrave) KEY_Ocircumflexhook = uint(C.GDK_KEY_Ocircumflexhook) KEY_ocircumflexhook = uint(C.GDK_KEY_ocircumflexhook) KEY_Ocircumflextilde = uint(C.GDK_KEY_Ocircumflextilde) KEY_ocircumflextilde = uint(C.GDK_KEY_ocircumflextilde) KEY_Ocircumflexbelowdot = uint(C.GDK_KEY_Ocircumflexbelowdot) KEY_ocircumflexbelowdot = uint(C.GDK_KEY_ocircumflexbelowdot) KEY_Ohornacute = uint(C.GDK_KEY_Ohornacute) KEY_ohornacute = uint(C.GDK_KEY_ohornacute) KEY_Ohorngrave = uint(C.GDK_KEY_Ohorngrave) KEY_ohorngrave = uint(C.GDK_KEY_ohorngrave) KEY_Ohornhook = uint(C.GDK_KEY_Ohornhook) KEY_ohornhook = uint(C.GDK_KEY_ohornhook) KEY_Ohorntilde = uint(C.GDK_KEY_Ohorntilde) KEY_ohorntilde = uint(C.GDK_KEY_ohorntilde) KEY_Ohornbelowdot = uint(C.GDK_KEY_Ohornbelowdot) KEY_ohornbelowdot = uint(C.GDK_KEY_ohornbelowdot) KEY_Ubelowdot = uint(C.GDK_KEY_Ubelowdot) KEY_ubelowdot = uint(C.GDK_KEY_ubelowdot) KEY_Uhook = uint(C.GDK_KEY_Uhook) KEY_uhook = uint(C.GDK_KEY_uhook) KEY_Uhornacute = uint(C.GDK_KEY_Uhornacute) KEY_uhornacute = uint(C.GDK_KEY_uhornacute) KEY_Uhorngrave = uint(C.GDK_KEY_Uhorngrave) KEY_uhorngrave = uint(C.GDK_KEY_uhorngrave) KEY_Uhornhook = uint(C.GDK_KEY_Uhornhook) KEY_uhornhook = uint(C.GDK_KEY_uhornhook) KEY_Uhorntilde = uint(C.GDK_KEY_Uhorntilde) KEY_uhorntilde = uint(C.GDK_KEY_uhorntilde) KEY_Uhornbelowdot = uint(C.GDK_KEY_Uhornbelowdot) KEY_uhornbelowdot = uint(C.GDK_KEY_uhornbelowdot) KEY_Ybelowdot = uint(C.GDK_KEY_Ybelowdot) KEY_ybelowdot = uint(C.GDK_KEY_ybelowdot) KEY_Yhook = uint(C.GDK_KEY_Yhook) KEY_yhook = uint(C.GDK_KEY_yhook) KEY_Ytilde = uint(C.GDK_KEY_Ytilde) KEY_ytilde = uint(C.GDK_KEY_ytilde) KEY_Ohorn = uint(C.GDK_KEY_Ohorn) KEY_ohorn = uint(C.GDK_KEY_ohorn) KEY_Uhorn = uint(C.GDK_KEY_Uhorn) KEY_uhorn = uint(C.GDK_KEY_uhorn) KEY_EcuSign = uint(C.GDK_KEY_EcuSign) KEY_ColonSign = uint(C.GDK_KEY_ColonSign) KEY_CruzeiroSign = uint(C.GDK_KEY_CruzeiroSign) KEY_FFrancSign = uint(C.GDK_KEY_FFrancSign) KEY_LiraSign = uint(C.GDK_KEY_LiraSign) KEY_MillSign = uint(C.GDK_KEY_MillSign) KEY_NairaSign = uint(C.GDK_KEY_NairaSign) KEY_PesetaSign = uint(C.GDK_KEY_PesetaSign) KEY_RupeeSign = uint(C.GDK_KEY_RupeeSign) KEY_WonSign = uint(C.GDK_KEY_WonSign) KEY_NewSheqelSign = uint(C.GDK_KEY_NewSheqelSign) KEY_DongSign = uint(C.GDK_KEY_DongSign) KEY_EuroSign = uint(C.GDK_KEY_EuroSign) KEY_zerosuperior = uint(C.GDK_KEY_zerosuperior) KEY_foursuperior = uint(C.GDK_KEY_foursuperior) KEY_fivesuperior = uint(C.GDK_KEY_fivesuperior) KEY_sixsuperior = uint(C.GDK_KEY_sixsuperior) KEY_sevensuperior = uint(C.GDK_KEY_sevensuperior) KEY_eightsuperior = uint(C.GDK_KEY_eightsuperior) KEY_ninesuperior = uint(C.GDK_KEY_ninesuperior) KEY_zerosubscript = uint(C.GDK_KEY_zerosubscript) KEY_onesubscript = uint(C.GDK_KEY_onesubscript) KEY_twosubscript = uint(C.GDK_KEY_twosubscript) KEY_threesubscript = uint(C.GDK_KEY_threesubscript) KEY_foursubscript = uint(C.GDK_KEY_foursubscript) KEY_fivesubscript = uint(C.GDK_KEY_fivesubscript) KEY_sixsubscript = uint(C.GDK_KEY_sixsubscript) KEY_sevensubscript = uint(C.GDK_KEY_sevensubscript) KEY_eightsubscript = uint(C.GDK_KEY_eightsubscript) KEY_ninesubscript = uint(C.GDK_KEY_ninesubscript) KEY_partdifferential = uint(C.GDK_KEY_partdifferential) KEY_emptyset = uint(C.GDK_KEY_emptyset) KEY_elementof = uint(C.GDK_KEY_elementof) KEY_notelementof = uint(C.GDK_KEY_notelementof) KEY_containsas = uint(C.GDK_KEY_containsas) KEY_squareroot = uint(C.GDK_KEY_squareroot) KEY_cuberoot = uint(C.GDK_KEY_cuberoot) KEY_fourthroot = uint(C.GDK_KEY_fourthroot) KEY_dintegral = uint(C.GDK_KEY_dintegral) KEY_tintegral = uint(C.GDK_KEY_tintegral) KEY_because = uint(C.GDK_KEY_because) KEY_approxeq = uint(C.GDK_KEY_approxeq) KEY_notapproxeq = uint(C.GDK_KEY_notapproxeq) KEY_notidentical = uint(C.GDK_KEY_notidentical) KEY_stricteq = uint(C.GDK_KEY_stricteq) KEY_braille_dot_1 = uint(C.GDK_KEY_braille_dot_1) KEY_braille_dot_2 = uint(C.GDK_KEY_braille_dot_2) KEY_braille_dot_3 = uint(C.GDK_KEY_braille_dot_3) KEY_braille_dot_4 = uint(C.GDK_KEY_braille_dot_4) KEY_braille_dot_5 = uint(C.GDK_KEY_braille_dot_5) KEY_braille_dot_6 = uint(C.GDK_KEY_braille_dot_6) KEY_braille_dot_7 = uint(C.GDK_KEY_braille_dot_7) KEY_braille_dot_8 = uint(C.GDK_KEY_braille_dot_8) KEY_braille_dot_9 = uint(C.GDK_KEY_braille_dot_9) KEY_braille_dot_10 = uint(C.GDK_KEY_braille_dot_10) KEY_braille_blank = uint(C.GDK_KEY_braille_blank) KEY_braille_dots_1 = uint(C.GDK_KEY_braille_dots_1) KEY_braille_dots_2 = uint(C.GDK_KEY_braille_dots_2) KEY_braille_dots_12 = uint(C.GDK_KEY_braille_dots_12) KEY_braille_dots_3 = uint(C.GDK_KEY_braille_dots_3) KEY_braille_dots_13 = uint(C.GDK_KEY_braille_dots_13) KEY_braille_dots_23 = uint(C.GDK_KEY_braille_dots_23) KEY_braille_dots_123 = uint(C.GDK_KEY_braille_dots_123) KEY_braille_dots_4 = uint(C.GDK_KEY_braille_dots_4) KEY_braille_dots_14 = uint(C.GDK_KEY_braille_dots_14) KEY_braille_dots_24 = uint(C.GDK_KEY_braille_dots_24) KEY_braille_dots_124 = uint(C.GDK_KEY_braille_dots_124) KEY_braille_dots_34 = uint(C.GDK_KEY_braille_dots_34) KEY_braille_dots_134 = uint(C.GDK_KEY_braille_dots_134) KEY_braille_dots_234 = uint(C.GDK_KEY_braille_dots_234) KEY_braille_dots_1234 = uint(C.GDK_KEY_braille_dots_1234) KEY_braille_dots_5 = uint(C.GDK_KEY_braille_dots_5) KEY_braille_dots_15 = uint(C.GDK_KEY_braille_dots_15) KEY_braille_dots_25 = uint(C.GDK_KEY_braille_dots_25) KEY_braille_dots_125 = uint(C.GDK_KEY_braille_dots_125) KEY_braille_dots_35 = uint(C.GDK_KEY_braille_dots_35) KEY_braille_dots_135 = uint(C.GDK_KEY_braille_dots_135) KEY_braille_dots_235 = uint(C.GDK_KEY_braille_dots_235) KEY_braille_dots_1235 = uint(C.GDK_KEY_braille_dots_1235) KEY_braille_dots_45 = uint(C.GDK_KEY_braille_dots_45) KEY_braille_dots_145 = uint(C.GDK_KEY_braille_dots_145) KEY_braille_dots_245 = uint(C.GDK_KEY_braille_dots_245) KEY_braille_dots_1245 = uint(C.GDK_KEY_braille_dots_1245) KEY_braille_dots_345 = uint(C.GDK_KEY_braille_dots_345) KEY_braille_dots_1345 = uint(C.GDK_KEY_braille_dots_1345) KEY_braille_dots_2345 = uint(C.GDK_KEY_braille_dots_2345) KEY_braille_dots_12345 = uint(C.GDK_KEY_braille_dots_12345) KEY_braille_dots_6 = uint(C.GDK_KEY_braille_dots_6) KEY_braille_dots_16 = uint(C.GDK_KEY_braille_dots_16) KEY_braille_dots_26 = uint(C.GDK_KEY_braille_dots_26) KEY_braille_dots_126 = uint(C.GDK_KEY_braille_dots_126) KEY_braille_dots_36 = uint(C.GDK_KEY_braille_dots_36) KEY_braille_dots_136 = uint(C.GDK_KEY_braille_dots_136) KEY_braille_dots_236 = uint(C.GDK_KEY_braille_dots_236) KEY_braille_dots_1236 = uint(C.GDK_KEY_braille_dots_1236) KEY_braille_dots_46 = uint(C.GDK_KEY_braille_dots_46) KEY_braille_dots_146 = uint(C.GDK_KEY_braille_dots_146) KEY_braille_dots_246 = uint(C.GDK_KEY_braille_dots_246) KEY_braille_dots_1246 = uint(C.GDK_KEY_braille_dots_1246) KEY_braille_dots_346 = uint(C.GDK_KEY_braille_dots_346) KEY_braille_dots_1346 = uint(C.GDK_KEY_braille_dots_1346) KEY_braille_dots_2346 = uint(C.GDK_KEY_braille_dots_2346) KEY_braille_dots_12346 = uint(C.GDK_KEY_braille_dots_12346) KEY_braille_dots_56 = uint(C.GDK_KEY_braille_dots_56) KEY_braille_dots_156 = uint(C.GDK_KEY_braille_dots_156) KEY_braille_dots_256 = uint(C.GDK_KEY_braille_dots_256) KEY_braille_dots_1256 = uint(C.GDK_KEY_braille_dots_1256) KEY_braille_dots_356 = uint(C.GDK_KEY_braille_dots_356) KEY_braille_dots_1356 = uint(C.GDK_KEY_braille_dots_1356) KEY_braille_dots_2356 = uint(C.GDK_KEY_braille_dots_2356) KEY_braille_dots_12356 = uint(C.GDK_KEY_braille_dots_12356) KEY_braille_dots_456 = uint(C.GDK_KEY_braille_dots_456) KEY_braille_dots_1456 = uint(C.GDK_KEY_braille_dots_1456) KEY_braille_dots_2456 = uint(C.GDK_KEY_braille_dots_2456) KEY_braille_dots_12456 = uint(C.GDK_KEY_braille_dots_12456) KEY_braille_dots_3456 = uint(C.GDK_KEY_braille_dots_3456) KEY_braille_dots_13456 = uint(C.GDK_KEY_braille_dots_13456) KEY_braille_dots_23456 = uint(C.GDK_KEY_braille_dots_23456) KEY_braille_dots_123456 = uint(C.GDK_KEY_braille_dots_123456) KEY_braille_dots_7 = uint(C.GDK_KEY_braille_dots_7) KEY_braille_dots_17 = uint(C.GDK_KEY_braille_dots_17) KEY_braille_dots_27 = uint(C.GDK_KEY_braille_dots_27) KEY_braille_dots_127 = uint(C.GDK_KEY_braille_dots_127) KEY_braille_dots_37 = uint(C.GDK_KEY_braille_dots_37) KEY_braille_dots_137 = uint(C.GDK_KEY_braille_dots_137) KEY_braille_dots_237 = uint(C.GDK_KEY_braille_dots_237) KEY_braille_dots_1237 = uint(C.GDK_KEY_braille_dots_1237) KEY_braille_dots_47 = uint(C.GDK_KEY_braille_dots_47) KEY_braille_dots_147 = uint(C.GDK_KEY_braille_dots_147) KEY_braille_dots_247 = uint(C.GDK_KEY_braille_dots_247) KEY_braille_dots_1247 = uint(C.GDK_KEY_braille_dots_1247) KEY_braille_dots_347 = uint(C.GDK_KEY_braille_dots_347) KEY_braille_dots_1347 = uint(C.GDK_KEY_braille_dots_1347) KEY_braille_dots_2347 = uint(C.GDK_KEY_braille_dots_2347) KEY_braille_dots_12347 = uint(C.GDK_KEY_braille_dots_12347) KEY_braille_dots_57 = uint(C.GDK_KEY_braille_dots_57) KEY_braille_dots_157 = uint(C.GDK_KEY_braille_dots_157) KEY_braille_dots_257 = uint(C.GDK_KEY_braille_dots_257) KEY_braille_dots_1257 = uint(C.GDK_KEY_braille_dots_1257) KEY_braille_dots_357 = uint(C.GDK_KEY_braille_dots_357) KEY_braille_dots_1357 = uint(C.GDK_KEY_braille_dots_1357) KEY_braille_dots_2357 = uint(C.GDK_KEY_braille_dots_2357) KEY_braille_dots_12357 = uint(C.GDK_KEY_braille_dots_12357) KEY_braille_dots_457 = uint(C.GDK_KEY_braille_dots_457) KEY_braille_dots_1457 = uint(C.GDK_KEY_braille_dots_1457) KEY_braille_dots_2457 = uint(C.GDK_KEY_braille_dots_2457) KEY_braille_dots_12457 = uint(C.GDK_KEY_braille_dots_12457) KEY_braille_dots_3457 = uint(C.GDK_KEY_braille_dots_3457) KEY_braille_dots_13457 = uint(C.GDK_KEY_braille_dots_13457) KEY_braille_dots_23457 = uint(C.GDK_KEY_braille_dots_23457) KEY_braille_dots_123457 = uint(C.GDK_KEY_braille_dots_123457) KEY_braille_dots_67 = uint(C.GDK_KEY_braille_dots_67) KEY_braille_dots_167 = uint(C.GDK_KEY_braille_dots_167) KEY_braille_dots_267 = uint(C.GDK_KEY_braille_dots_267) KEY_braille_dots_1267 = uint(C.GDK_KEY_braille_dots_1267) KEY_braille_dots_367 = uint(C.GDK_KEY_braille_dots_367) KEY_braille_dots_1367 = uint(C.GDK_KEY_braille_dots_1367) KEY_braille_dots_2367 = uint(C.GDK_KEY_braille_dots_2367) KEY_braille_dots_12367 = uint(C.GDK_KEY_braille_dots_12367) KEY_braille_dots_467 = uint(C.GDK_KEY_braille_dots_467) KEY_braille_dots_1467 = uint(C.GDK_KEY_braille_dots_1467) KEY_braille_dots_2467 = uint(C.GDK_KEY_braille_dots_2467) KEY_braille_dots_12467 = uint(C.GDK_KEY_braille_dots_12467) KEY_braille_dots_3467 = uint(C.GDK_KEY_braille_dots_3467) KEY_braille_dots_13467 = uint(C.GDK_KEY_braille_dots_13467) KEY_braille_dots_23467 = uint(C.GDK_KEY_braille_dots_23467) KEY_braille_dots_123467 = uint(C.GDK_KEY_braille_dots_123467) KEY_braille_dots_567 = uint(C.GDK_KEY_braille_dots_567) KEY_braille_dots_1567 = uint(C.GDK_KEY_braille_dots_1567) KEY_braille_dots_2567 = uint(C.GDK_KEY_braille_dots_2567) KEY_braille_dots_12567 = uint(C.GDK_KEY_braille_dots_12567) KEY_braille_dots_3567 = uint(C.GDK_KEY_braille_dots_3567) KEY_braille_dots_13567 = uint(C.GDK_KEY_braille_dots_13567) KEY_braille_dots_23567 = uint(C.GDK_KEY_braille_dots_23567) KEY_braille_dots_123567 = uint(C.GDK_KEY_braille_dots_123567) KEY_braille_dots_4567 = uint(C.GDK_KEY_braille_dots_4567) KEY_braille_dots_14567 = uint(C.GDK_KEY_braille_dots_14567) KEY_braille_dots_24567 = uint(C.GDK_KEY_braille_dots_24567) KEY_braille_dots_124567 = uint(C.GDK_KEY_braille_dots_124567) KEY_braille_dots_34567 = uint(C.GDK_KEY_braille_dots_34567) KEY_braille_dots_134567 = uint(C.GDK_KEY_braille_dots_134567) KEY_braille_dots_234567 = uint(C.GDK_KEY_braille_dots_234567) KEY_braille_dots_1234567 = uint(C.GDK_KEY_braille_dots_1234567) KEY_braille_dots_8 = uint(C.GDK_KEY_braille_dots_8) KEY_braille_dots_18 = uint(C.GDK_KEY_braille_dots_18) KEY_braille_dots_28 = uint(C.GDK_KEY_braille_dots_28) KEY_braille_dots_128 = uint(C.GDK_KEY_braille_dots_128) KEY_braille_dots_38 = uint(C.GDK_KEY_braille_dots_38) KEY_braille_dots_138 = uint(C.GDK_KEY_braille_dots_138) KEY_braille_dots_238 = uint(C.GDK_KEY_braille_dots_238) KEY_braille_dots_1238 = uint(C.GDK_KEY_braille_dots_1238) KEY_braille_dots_48 = uint(C.GDK_KEY_braille_dots_48) KEY_braille_dots_148 = uint(C.GDK_KEY_braille_dots_148) KEY_braille_dots_248 = uint(C.GDK_KEY_braille_dots_248) KEY_braille_dots_1248 = uint(C.GDK_KEY_braille_dots_1248) KEY_braille_dots_348 = uint(C.GDK_KEY_braille_dots_348) KEY_braille_dots_1348 = uint(C.GDK_KEY_braille_dots_1348) KEY_braille_dots_2348 = uint(C.GDK_KEY_braille_dots_2348) KEY_braille_dots_12348 = uint(C.GDK_KEY_braille_dots_12348) KEY_braille_dots_58 = uint(C.GDK_KEY_braille_dots_58) KEY_braille_dots_158 = uint(C.GDK_KEY_braille_dots_158) KEY_braille_dots_258 = uint(C.GDK_KEY_braille_dots_258) KEY_braille_dots_1258 = uint(C.GDK_KEY_braille_dots_1258) KEY_braille_dots_358 = uint(C.GDK_KEY_braille_dots_358) KEY_braille_dots_1358 = uint(C.GDK_KEY_braille_dots_1358) KEY_braille_dots_2358 = uint(C.GDK_KEY_braille_dots_2358) KEY_braille_dots_12358 = uint(C.GDK_KEY_braille_dots_12358) KEY_braille_dots_458 = uint(C.GDK_KEY_braille_dots_458) KEY_braille_dots_1458 = uint(C.GDK_KEY_braille_dots_1458) KEY_braille_dots_2458 = uint(C.GDK_KEY_braille_dots_2458) KEY_braille_dots_12458 = uint(C.GDK_KEY_braille_dots_12458) KEY_braille_dots_3458 = uint(C.GDK_KEY_braille_dots_3458) KEY_braille_dots_13458 = uint(C.GDK_KEY_braille_dots_13458) KEY_braille_dots_23458 = uint(C.GDK_KEY_braille_dots_23458) KEY_braille_dots_123458 = uint(C.GDK_KEY_braille_dots_123458) KEY_braille_dots_68 = uint(C.GDK_KEY_braille_dots_68) KEY_braille_dots_168 = uint(C.GDK_KEY_braille_dots_168) KEY_braille_dots_268 = uint(C.GDK_KEY_braille_dots_268) KEY_braille_dots_1268 = uint(C.GDK_KEY_braille_dots_1268) KEY_braille_dots_368 = uint(C.GDK_KEY_braille_dots_368) KEY_braille_dots_1368 = uint(C.GDK_KEY_braille_dots_1368) KEY_braille_dots_2368 = uint(C.GDK_KEY_braille_dots_2368) KEY_braille_dots_12368 = uint(C.GDK_KEY_braille_dots_12368) KEY_braille_dots_468 = uint(C.GDK_KEY_braille_dots_468) KEY_braille_dots_1468 = uint(C.GDK_KEY_braille_dots_1468) KEY_braille_dots_2468 = uint(C.GDK_KEY_braille_dots_2468) KEY_braille_dots_12468 = uint(C.GDK_KEY_braille_dots_12468) KEY_braille_dots_3468 = uint(C.GDK_KEY_braille_dots_3468) KEY_braille_dots_13468 = uint(C.GDK_KEY_braille_dots_13468) KEY_braille_dots_23468 = uint(C.GDK_KEY_braille_dots_23468) KEY_braille_dots_123468 = uint(C.GDK_KEY_braille_dots_123468) KEY_braille_dots_568 = uint(C.GDK_KEY_braille_dots_568) KEY_braille_dots_1568 = uint(C.GDK_KEY_braille_dots_1568) KEY_braille_dots_2568 = uint(C.GDK_KEY_braille_dots_2568) KEY_braille_dots_12568 = uint(C.GDK_KEY_braille_dots_12568) KEY_braille_dots_3568 = uint(C.GDK_KEY_braille_dots_3568) KEY_braille_dots_13568 = uint(C.GDK_KEY_braille_dots_13568) KEY_braille_dots_23568 = uint(C.GDK_KEY_braille_dots_23568) KEY_braille_dots_123568 = uint(C.GDK_KEY_braille_dots_123568) KEY_braille_dots_4568 = uint(C.GDK_KEY_braille_dots_4568) KEY_braille_dots_14568 = uint(C.GDK_KEY_braille_dots_14568) KEY_braille_dots_24568 = uint(C.GDK_KEY_braille_dots_24568) KEY_braille_dots_124568 = uint(C.GDK_KEY_braille_dots_124568) KEY_braille_dots_34568 = uint(C.GDK_KEY_braille_dots_34568) KEY_braille_dots_134568 = uint(C.GDK_KEY_braille_dots_134568) KEY_braille_dots_234568 = uint(C.GDK_KEY_braille_dots_234568) KEY_braille_dots_1234568 = uint(C.GDK_KEY_braille_dots_1234568) KEY_braille_dots_78 = uint(C.GDK_KEY_braille_dots_78) KEY_braille_dots_178 = uint(C.GDK_KEY_braille_dots_178) KEY_braille_dots_278 = uint(C.GDK_KEY_braille_dots_278) KEY_braille_dots_1278 = uint(C.GDK_KEY_braille_dots_1278) KEY_braille_dots_378 = uint(C.GDK_KEY_braille_dots_378) KEY_braille_dots_1378 = uint(C.GDK_KEY_braille_dots_1378) KEY_braille_dots_2378 = uint(C.GDK_KEY_braille_dots_2378) KEY_braille_dots_12378 = uint(C.GDK_KEY_braille_dots_12378) KEY_braille_dots_478 = uint(C.GDK_KEY_braille_dots_478) KEY_braille_dots_1478 = uint(C.GDK_KEY_braille_dots_1478) KEY_braille_dots_2478 = uint(C.GDK_KEY_braille_dots_2478) KEY_braille_dots_12478 = uint(C.GDK_KEY_braille_dots_12478) KEY_braille_dots_3478 = uint(C.GDK_KEY_braille_dots_3478) KEY_braille_dots_13478 = uint(C.GDK_KEY_braille_dots_13478) KEY_braille_dots_23478 = uint(C.GDK_KEY_braille_dots_23478) KEY_braille_dots_123478 = uint(C.GDK_KEY_braille_dots_123478) KEY_braille_dots_578 = uint(C.GDK_KEY_braille_dots_578) KEY_braille_dots_1578 = uint(C.GDK_KEY_braille_dots_1578) KEY_braille_dots_2578 = uint(C.GDK_KEY_braille_dots_2578) KEY_braille_dots_12578 = uint(C.GDK_KEY_braille_dots_12578) KEY_braille_dots_3578 = uint(C.GDK_KEY_braille_dots_3578) KEY_braille_dots_13578 = uint(C.GDK_KEY_braille_dots_13578) KEY_braille_dots_23578 = uint(C.GDK_KEY_braille_dots_23578) KEY_braille_dots_123578 = uint(C.GDK_KEY_braille_dots_123578) KEY_braille_dots_4578 = uint(C.GDK_KEY_braille_dots_4578) KEY_braille_dots_14578 = uint(C.GDK_KEY_braille_dots_14578) KEY_braille_dots_24578 = uint(C.GDK_KEY_braille_dots_24578) KEY_braille_dots_124578 = uint(C.GDK_KEY_braille_dots_124578) KEY_braille_dots_34578 = uint(C.GDK_KEY_braille_dots_34578) KEY_braille_dots_134578 = uint(C.GDK_KEY_braille_dots_134578) KEY_braille_dots_234578 = uint(C.GDK_KEY_braille_dots_234578) KEY_braille_dots_1234578 = uint(C.GDK_KEY_braille_dots_1234578) KEY_braille_dots_678 = uint(C.GDK_KEY_braille_dots_678) KEY_braille_dots_1678 = uint(C.GDK_KEY_braille_dots_1678) KEY_braille_dots_2678 = uint(C.GDK_KEY_braille_dots_2678) KEY_braille_dots_12678 = uint(C.GDK_KEY_braille_dots_12678) KEY_braille_dots_3678 = uint(C.GDK_KEY_braille_dots_3678) KEY_braille_dots_13678 = uint(C.GDK_KEY_braille_dots_13678) KEY_braille_dots_23678 = uint(C.GDK_KEY_braille_dots_23678) KEY_braille_dots_123678 = uint(C.GDK_KEY_braille_dots_123678) KEY_braille_dots_4678 = uint(C.GDK_KEY_braille_dots_4678) KEY_braille_dots_14678 = uint(C.GDK_KEY_braille_dots_14678) KEY_braille_dots_24678 = uint(C.GDK_KEY_braille_dots_24678) KEY_braille_dots_124678 = uint(C.GDK_KEY_braille_dots_124678) KEY_braille_dots_34678 = uint(C.GDK_KEY_braille_dots_34678) KEY_braille_dots_134678 = uint(C.GDK_KEY_braille_dots_134678) KEY_braille_dots_234678 = uint(C.GDK_KEY_braille_dots_234678) KEY_braille_dots_1234678 = uint(C.GDK_KEY_braille_dots_1234678) KEY_braille_dots_5678 = uint(C.GDK_KEY_braille_dots_5678) KEY_braille_dots_15678 = uint(C.GDK_KEY_braille_dots_15678) KEY_braille_dots_25678 = uint(C.GDK_KEY_braille_dots_25678) KEY_braille_dots_125678 = uint(C.GDK_KEY_braille_dots_125678) KEY_braille_dots_35678 = uint(C.GDK_KEY_braille_dots_35678) KEY_braille_dots_135678 = uint(C.GDK_KEY_braille_dots_135678) KEY_braille_dots_235678 = uint(C.GDK_KEY_braille_dots_235678) KEY_braille_dots_1235678 = uint(C.GDK_KEY_braille_dots_1235678) KEY_braille_dots_45678 = uint(C.GDK_KEY_braille_dots_45678) KEY_braille_dots_145678 = uint(C.GDK_KEY_braille_dots_145678) KEY_braille_dots_245678 = uint(C.GDK_KEY_braille_dots_245678) KEY_braille_dots_1245678 = uint(C.GDK_KEY_braille_dots_1245678) KEY_braille_dots_345678 = uint(C.GDK_KEY_braille_dots_345678) KEY_braille_dots_1345678 = uint(C.GDK_KEY_braille_dots_1345678) KEY_braille_dots_2345678 = uint(C.GDK_KEY_braille_dots_2345678) KEY_braille_dots_12345678 = uint(C.GDK_KEY_braille_dots_12345678) KEY_Sinh_ng = uint(C.GDK_KEY_Sinh_ng) KEY_Sinh_h2 = uint(C.GDK_KEY_Sinh_h2) KEY_Sinh_a = uint(C.GDK_KEY_Sinh_a) KEY_Sinh_aa = uint(C.GDK_KEY_Sinh_aa) KEY_Sinh_ae = uint(C.GDK_KEY_Sinh_ae) KEY_Sinh_aee = uint(C.GDK_KEY_Sinh_aee) KEY_Sinh_i = uint(C.GDK_KEY_Sinh_i) KEY_Sinh_ii = uint(C.GDK_KEY_Sinh_ii) KEY_Sinh_u = uint(C.GDK_KEY_Sinh_u) KEY_Sinh_uu = uint(C.GDK_KEY_Sinh_uu) KEY_Sinh_ri = uint(C.GDK_KEY_Sinh_ri) KEY_Sinh_rii = uint(C.GDK_KEY_Sinh_rii) KEY_Sinh_lu = uint(C.GDK_KEY_Sinh_lu) KEY_Sinh_luu = uint(C.GDK_KEY_Sinh_luu) KEY_Sinh_e = uint(C.GDK_KEY_Sinh_e) KEY_Sinh_ee = uint(C.GDK_KEY_Sinh_ee) KEY_Sinh_ai = uint(C.GDK_KEY_Sinh_ai) KEY_Sinh_o = uint(C.GDK_KEY_Sinh_o) KEY_Sinh_oo = uint(C.GDK_KEY_Sinh_oo) KEY_Sinh_au = uint(C.GDK_KEY_Sinh_au) KEY_Sinh_ka = uint(C.GDK_KEY_Sinh_ka) KEY_Sinh_kha = uint(C.GDK_KEY_Sinh_kha) KEY_Sinh_ga = uint(C.GDK_KEY_Sinh_ga) KEY_Sinh_gha = uint(C.GDK_KEY_Sinh_gha) KEY_Sinh_ng2 = uint(C.GDK_KEY_Sinh_ng2) KEY_Sinh_nga = uint(C.GDK_KEY_Sinh_nga) KEY_Sinh_ca = uint(C.GDK_KEY_Sinh_ca) KEY_Sinh_cha = uint(C.GDK_KEY_Sinh_cha) KEY_Sinh_ja = uint(C.GDK_KEY_Sinh_ja) KEY_Sinh_jha = uint(C.GDK_KEY_Sinh_jha) KEY_Sinh_nya = uint(C.GDK_KEY_Sinh_nya) KEY_Sinh_jnya = uint(C.GDK_KEY_Sinh_jnya) KEY_Sinh_nja = uint(C.GDK_KEY_Sinh_nja) KEY_Sinh_tta = uint(C.GDK_KEY_Sinh_tta) KEY_Sinh_ttha = uint(C.GDK_KEY_Sinh_ttha) KEY_Sinh_dda = uint(C.GDK_KEY_Sinh_dda) KEY_Sinh_ddha = uint(C.GDK_KEY_Sinh_ddha) KEY_Sinh_nna = uint(C.GDK_KEY_Sinh_nna) KEY_Sinh_ndda = uint(C.GDK_KEY_Sinh_ndda) KEY_Sinh_tha = uint(C.GDK_KEY_Sinh_tha) KEY_Sinh_thha = uint(C.GDK_KEY_Sinh_thha) KEY_Sinh_dha = uint(C.GDK_KEY_Sinh_dha) KEY_Sinh_dhha = uint(C.GDK_KEY_Sinh_dhha) KEY_Sinh_na = uint(C.GDK_KEY_Sinh_na) KEY_Sinh_ndha = uint(C.GDK_KEY_Sinh_ndha) KEY_Sinh_pa = uint(C.GDK_KEY_Sinh_pa) KEY_Sinh_pha = uint(C.GDK_KEY_Sinh_pha) KEY_Sinh_ba = uint(C.GDK_KEY_Sinh_ba) KEY_Sinh_bha = uint(C.GDK_KEY_Sinh_bha) KEY_Sinh_ma = uint(C.GDK_KEY_Sinh_ma) KEY_Sinh_mba = uint(C.GDK_KEY_Sinh_mba) KEY_Sinh_ya = uint(C.GDK_KEY_Sinh_ya) KEY_Sinh_ra = uint(C.GDK_KEY_Sinh_ra) KEY_Sinh_la = uint(C.GDK_KEY_Sinh_la) KEY_Sinh_va = uint(C.GDK_KEY_Sinh_va) KEY_Sinh_sha = uint(C.GDK_KEY_Sinh_sha) KEY_Sinh_ssha = uint(C.GDK_KEY_Sinh_ssha) KEY_Sinh_sa = uint(C.GDK_KEY_Sinh_sa) KEY_Sinh_ha = uint(C.GDK_KEY_Sinh_ha) KEY_Sinh_lla = uint(C.GDK_KEY_Sinh_lla) KEY_Sinh_fa = uint(C.GDK_KEY_Sinh_fa) KEY_Sinh_al = uint(C.GDK_KEY_Sinh_al) KEY_Sinh_aa2 = uint(C.GDK_KEY_Sinh_aa2) KEY_Sinh_ae2 = uint(C.GDK_KEY_Sinh_ae2) KEY_Sinh_aee2 = uint(C.GDK_KEY_Sinh_aee2) KEY_Sinh_i2 = uint(C.GDK_KEY_Sinh_i2) KEY_Sinh_ii2 = uint(C.GDK_KEY_Sinh_ii2) KEY_Sinh_u2 = uint(C.GDK_KEY_Sinh_u2) KEY_Sinh_uu2 = uint(C.GDK_KEY_Sinh_uu2) KEY_Sinh_ru2 = uint(C.GDK_KEY_Sinh_ru2) KEY_Sinh_e2 = uint(C.GDK_KEY_Sinh_e2) KEY_Sinh_ee2 = uint(C.GDK_KEY_Sinh_ee2) KEY_Sinh_ai2 = uint(C.GDK_KEY_Sinh_ai2) KEY_Sinh_o2 = uint(C.GDK_KEY_Sinh_o2) KEY_Sinh_oo2 = uint(C.GDK_KEY_Sinh_oo2) KEY_Sinh_au2 = uint(C.GDK_KEY_Sinh_au2) KEY_Sinh_lu2 = uint(C.GDK_KEY_Sinh_lu2) KEY_Sinh_ruu2 = uint(C.GDK_KEY_Sinh_ruu2) KEY_Sinh_luu2 = uint(C.GDK_KEY_Sinh_luu2) KEY_Sinh_kunddaliya = uint(C.GDK_KEY_Sinh_kunddaliya) KEY_ModeLock = uint(C.GDK_KEY_ModeLock) KEY_MonBrightnessUp = uint(C.GDK_KEY_MonBrightnessUp) KEY_MonBrightnessDown = uint(C.GDK_KEY_MonBrightnessDown) KEY_KbdLightOnOff = uint(C.GDK_KEY_KbdLightOnOff) KEY_KbdBrightnessUp = uint(C.GDK_KEY_KbdBrightnessUp) KEY_KbdBrightnessDown = uint(C.GDK_KEY_KbdBrightnessDown) KEY_Standby = uint(C.GDK_KEY_Standby) KEY_AudioLowerVolume = uint(C.GDK_KEY_AudioLowerVolume) KEY_AudioMute = uint(C.GDK_KEY_AudioMute) KEY_AudioRaiseVolume = uint(C.GDK_KEY_AudioRaiseVolume) KEY_AudioPlay = uint(C.GDK_KEY_AudioPlay) KEY_AudioStop = uint(C.GDK_KEY_AudioStop) KEY_AudioPrev = uint(C.GDK_KEY_AudioPrev) KEY_AudioNext = uint(C.GDK_KEY_AudioNext) KEY_HomePage = uint(C.GDK_KEY_HomePage) KEY_Mail = uint(C.GDK_KEY_Mail) KEY_Start = uint(C.GDK_KEY_Start) KEY_Search = uint(C.GDK_KEY_Search) KEY_AudioRecord = uint(C.GDK_KEY_AudioRecord) KEY_Calculator = uint(C.GDK_KEY_Calculator) KEY_Memo = uint(C.GDK_KEY_Memo) KEY_ToDoList = uint(C.GDK_KEY_ToDoList) KEY_Calendar = uint(C.GDK_KEY_Calendar) KEY_PowerDown = uint(C.GDK_KEY_PowerDown) KEY_ContrastAdjust = uint(C.GDK_KEY_ContrastAdjust) KEY_RockerUp = uint(C.GDK_KEY_RockerUp) KEY_RockerDown = uint(C.GDK_KEY_RockerDown) KEY_RockerEnter = uint(C.GDK_KEY_RockerEnter) KEY_Back = uint(C.GDK_KEY_Back) KEY_Forward = uint(C.GDK_KEY_Forward) KEY_Stop = uint(C.GDK_KEY_Stop) KEY_Refresh = uint(C.GDK_KEY_Refresh) KEY_PowerOff = uint(C.GDK_KEY_PowerOff) KEY_WakeUp = uint(C.GDK_KEY_WakeUp) KEY_Eject = uint(C.GDK_KEY_Eject) KEY_ScreenSaver = uint(C.GDK_KEY_ScreenSaver) KEY_WWW = uint(C.GDK_KEY_WWW) KEY_Sleep = uint(C.GDK_KEY_Sleep) KEY_Favorites = uint(C.GDK_KEY_Favorites) KEY_AudioPause = uint(C.GDK_KEY_AudioPause) KEY_AudioMedia = uint(C.GDK_KEY_AudioMedia) KEY_MyComputer = uint(C.GDK_KEY_MyComputer) KEY_VendorHome = uint(C.GDK_KEY_VendorHome) KEY_LightBulb = uint(C.GDK_KEY_LightBulb) KEY_Shop = uint(C.GDK_KEY_Shop) KEY_History = uint(C.GDK_KEY_History) KEY_OpenURL = uint(C.GDK_KEY_OpenURL) KEY_AddFavorite = uint(C.GDK_KEY_AddFavorite) KEY_HotLinks = uint(C.GDK_KEY_HotLinks) KEY_BrightnessAdjust = uint(C.GDK_KEY_BrightnessAdjust) KEY_Finance = uint(C.GDK_KEY_Finance) KEY_Community = uint(C.GDK_KEY_Community) KEY_AudioRewind = uint(C.GDK_KEY_AudioRewind) KEY_BackForward = uint(C.GDK_KEY_BackForward) KEY_Launch0 = uint(C.GDK_KEY_Launch0) KEY_Launch1 = uint(C.GDK_KEY_Launch1) KEY_Launch2 = uint(C.GDK_KEY_Launch2) KEY_Launch3 = uint(C.GDK_KEY_Launch3) KEY_Launch4 = uint(C.GDK_KEY_Launch4) KEY_Launch5 = uint(C.GDK_KEY_Launch5) KEY_Launch6 = uint(C.GDK_KEY_Launch6) KEY_Launch7 = uint(C.GDK_KEY_Launch7) KEY_Launch8 = uint(C.GDK_KEY_Launch8) KEY_Launch9 = uint(C.GDK_KEY_Launch9) KEY_LaunchA = uint(C.GDK_KEY_LaunchA) KEY_LaunchB = uint(C.GDK_KEY_LaunchB) KEY_LaunchC = uint(C.GDK_KEY_LaunchC) KEY_LaunchD = uint(C.GDK_KEY_LaunchD) KEY_LaunchE = uint(C.GDK_KEY_LaunchE) KEY_LaunchF = uint(C.GDK_KEY_LaunchF) KEY_ApplicationLeft = uint(C.GDK_KEY_ApplicationLeft) KEY_ApplicationRight = uint(C.GDK_KEY_ApplicationRight) KEY_Book = uint(C.GDK_KEY_Book) KEY_CD = uint(C.GDK_KEY_CD) KEY_WindowClear = uint(C.GDK_KEY_WindowClear) KEY_Close = uint(C.GDK_KEY_Close) KEY_Copy = uint(C.GDK_KEY_Copy) KEY_Cut = uint(C.GDK_KEY_Cut) KEY_Display = uint(C.GDK_KEY_Display) KEY_DOS = uint(C.GDK_KEY_DOS) KEY_Documents = uint(C.GDK_KEY_Documents) KEY_Excel = uint(C.GDK_KEY_Excel) KEY_Explorer = uint(C.GDK_KEY_Explorer) KEY_Game = uint(C.GDK_KEY_Game) KEY_Go = uint(C.GDK_KEY_Go) KEY_iTouch = uint(C.GDK_KEY_iTouch) KEY_LogOff = uint(C.GDK_KEY_LogOff) KEY_Market = uint(C.GDK_KEY_Market) KEY_Meeting = uint(C.GDK_KEY_Meeting) KEY_MenuKB = uint(C.GDK_KEY_MenuKB) KEY_MenuPB = uint(C.GDK_KEY_MenuPB) KEY_MySites = uint(C.GDK_KEY_MySites) KEY_New = uint(C.GDK_KEY_New) KEY_News = uint(C.GDK_KEY_News) KEY_OfficeHome = uint(C.GDK_KEY_OfficeHome) KEY_Open = uint(C.GDK_KEY_Open) KEY_Option = uint(C.GDK_KEY_Option) KEY_Paste = uint(C.GDK_KEY_Paste) KEY_Phone = uint(C.GDK_KEY_Phone) KEY_Reply = uint(C.GDK_KEY_Reply) KEY_Reload = uint(C.GDK_KEY_Reload) KEY_RotateWindows = uint(C.GDK_KEY_RotateWindows) KEY_RotationPB = uint(C.GDK_KEY_RotationPB) KEY_RotationKB = uint(C.GDK_KEY_RotationKB) KEY_Save = uint(C.GDK_KEY_Save) KEY_ScrollUp = uint(C.GDK_KEY_ScrollUp) KEY_ScrollDown = uint(C.GDK_KEY_ScrollDown) KEY_ScrollClick = uint(C.GDK_KEY_ScrollClick) KEY_Send = uint(C.GDK_KEY_Send) KEY_Spell = uint(C.GDK_KEY_Spell) KEY_SplitScreen = uint(C.GDK_KEY_SplitScreen) KEY_Support = uint(C.GDK_KEY_Support) KEY_TaskPane = uint(C.GDK_KEY_TaskPane) KEY_Terminal = uint(C.GDK_KEY_Terminal) KEY_Tools = uint(C.GDK_KEY_Tools) KEY_Travel = uint(C.GDK_KEY_Travel) KEY_UserPB = uint(C.GDK_KEY_UserPB) KEY_User1KB = uint(C.GDK_KEY_User1KB) KEY_User2KB = uint(C.GDK_KEY_User2KB) KEY_Video = uint(C.GDK_KEY_Video) KEY_WheelButton = uint(C.GDK_KEY_WheelButton) KEY_Word = uint(C.GDK_KEY_Word) KEY_Xfer = uint(C.GDK_KEY_Xfer) KEY_ZoomIn = uint(C.GDK_KEY_ZoomIn) KEY_ZoomOut = uint(C.GDK_KEY_ZoomOut) KEY_Away = uint(C.GDK_KEY_Away) KEY_Messenger = uint(C.GDK_KEY_Messenger) KEY_WebCam = uint(C.GDK_KEY_WebCam) KEY_MailForward = uint(C.GDK_KEY_MailForward) KEY_Pictures = uint(C.GDK_KEY_Pictures) KEY_Music = uint(C.GDK_KEY_Music) KEY_Battery = uint(C.GDK_KEY_Battery) KEY_Bluetooth = uint(C.GDK_KEY_Bluetooth) KEY_WLAN = uint(C.GDK_KEY_WLAN) KEY_UWB = uint(C.GDK_KEY_UWB) KEY_AudioForward = uint(C.GDK_KEY_AudioForward) KEY_AudioRepeat = uint(C.GDK_KEY_AudioRepeat) KEY_AudioRandomPlay = uint(C.GDK_KEY_AudioRandomPlay) KEY_Subtitle = uint(C.GDK_KEY_Subtitle) KEY_AudioCycleTrack = uint(C.GDK_KEY_AudioCycleTrack) KEY_CycleAngle = uint(C.GDK_KEY_CycleAngle) KEY_FrameBack = uint(C.GDK_KEY_FrameBack) KEY_FrameForward = uint(C.GDK_KEY_FrameForward) KEY_Time = uint(C.GDK_KEY_Time) KEY_SelectButton = uint(C.GDK_KEY_SelectButton) KEY_View = uint(C.GDK_KEY_View) KEY_TopMenu = uint(C.GDK_KEY_TopMenu) KEY_Red = uint(C.GDK_KEY_Red) KEY_Green = uint(C.GDK_KEY_Green) KEY_Yellow = uint(C.GDK_KEY_Yellow) KEY_Blue = uint(C.GDK_KEY_Blue) KEY_Suspend = uint(C.GDK_KEY_Suspend) KEY_Hibernate = uint(C.GDK_KEY_Hibernate) KEY_TouchpadToggle = uint(C.GDK_KEY_TouchpadToggle) KEY_TouchpadOn = uint(C.GDK_KEY_TouchpadOn) KEY_TouchpadOff = uint(C.GDK_KEY_TouchpadOff) KEY_AudioMicMute = uint(C.GDK_KEY_AudioMicMute) KEY_Switch_VT_1 = uint(C.GDK_KEY_Switch_VT_1) KEY_Switch_VT_2 = uint(C.GDK_KEY_Switch_VT_2) KEY_Switch_VT_3 = uint(C.GDK_KEY_Switch_VT_3) KEY_Switch_VT_4 = uint(C.GDK_KEY_Switch_VT_4) KEY_Switch_VT_5 = uint(C.GDK_KEY_Switch_VT_5) KEY_Switch_VT_6 = uint(C.GDK_KEY_Switch_VT_6) KEY_Switch_VT_7 = uint(C.GDK_KEY_Switch_VT_7) KEY_Switch_VT_8 = uint(C.GDK_KEY_Switch_VT_8) KEY_Switch_VT_9 = uint(C.GDK_KEY_Switch_VT_9) KEY_Switch_VT_10 = uint(C.GDK_KEY_Switch_VT_10) KEY_Switch_VT_11 = uint(C.GDK_KEY_Switch_VT_11) KEY_Switch_VT_12 = uint(C.GDK_KEY_Switch_VT_12) KEY_Ungrab = uint(C.GDK_KEY_Ungrab) KEY_ClearGrab = uint(C.GDK_KEY_ClearGrab) KEY_Next_VMode = uint(C.GDK_KEY_Next_VMode) KEY_Prev_VMode = uint(C.GDK_KEY_Prev_VMode) KEY_LogWindowTree = uint(C.GDK_KEY_LogWindowTree) KEY_LogGrabInfo = uint(C.GDK_KEY_LogGrabInfo) ) gotk3-0.6.2/gdk/pixbuf.go000066400000000000000000000432521431157473000151520ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" import ( "errors" "reflect" "runtime" "strconv" "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.gdk_pixbuf_alpha_mode_get_type()), marshalPixbufAlphaMode}, // Objects/Interfaces {glib.Type(C.gdk_pixbuf_get_type()), marshalPixbuf}, {glib.Type(C.gdk_pixbuf_animation_get_type()), marshalPixbufAnimation}, {glib.Type(C.gdk_pixbuf_loader_get_type()), marshalPixbufLoader}, } glib.RegisterGValueMarshalers(tm) } /* * Constants */ // TODO: // GdkPixbufError // PixbufRotation is a representation of GDK's GdkPixbufRotation. type PixbufRotation int const ( PIXBUF_ROTATE_NONE PixbufRotation = C.GDK_PIXBUF_ROTATE_NONE PIXBUF_ROTATE_COUNTERCLOCKWISE PixbufRotation = C.GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE PIXBUF_ROTATE_UPSIDEDOWN PixbufRotation = C.GDK_PIXBUF_ROTATE_UPSIDEDOWN PIXBUF_ROTATE_CLOCKWISE PixbufRotation = C.GDK_PIXBUF_ROTATE_CLOCKWISE ) // PixbufAlphaMode is a representation of GDK's GdkPixbufAlphaMode. type PixbufAlphaMode int const ( GDK_PIXBUF_ALPHA_BILEVEL PixbufAlphaMode = C.GDK_PIXBUF_ALPHA_BILEVEL GDK_PIXBUF_ALPHA_FULL PixbufAlphaMode = C.GDK_PIXBUF_ALPHA_FULL ) func marshalPixbufAlphaMode(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PixbufAlphaMode(c), nil } /* * GdkPixbuf */ // PixbufGetType is a wrapper around gdk_pixbuf_get_type(). func PixbufGetType() glib.Type { return glib.Type(C.gdk_pixbuf_get_type()) } // Pixbuf is a representation of GDK's GdkPixbuf. type Pixbuf struct { *glib.Object } // native returns a pointer to the underlying GdkPixbuf. func (v *Pixbuf) native() *C.GdkPixbuf { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkPixbuf(p) } // Native returns a pointer to the underlying GdkPixbuf. func (v *Pixbuf) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *Pixbuf) NativePrivate() *C.GdkPixbuf { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkPixbuf(p) } func marshalPixbuf(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Pixbuf{obj}, nil } // PixbufNew is a wrapper around gdk_pixbuf_new(). func PixbufNew(colorspace Colorspace, hasAlpha bool, bitsPerSample, width, height int) (*Pixbuf, error) { c := C.gdk_pixbuf_new(C.GdkColorspace(colorspace), gbool(hasAlpha), C.int(bitsPerSample), C.int(width), C.int(height)) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // File Loading // PixbufNewFromFile is a wrapper around gdk_pixbuf_new_from_file(). func PixbufNewFromFile(filename string) (*Pixbuf, error) { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) var err *C.GError c := C.gdk_pixbuf_new_from_file((*C.char)(cstr), &err) if c == nil { defer C.g_error_free(err) return nil, errors.New(C.GoString((*C.char)(err.message))) } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // Image Data in Memory // PixbufNewFromData is a wrapper around gdk_pixbuf_new_from_data(). func PixbufNewFromData(pixbufData []byte, cs Colorspace, hasAlpha bool, bitsPerSample, width, height, rowStride int) (*Pixbuf, error) { arrayPtr := (*C.guchar)(unsafe.Pointer(&pixbufData[0])) c := C.gdk_pixbuf_new_from_data( arrayPtr, C.GdkColorspace(cs), gbool(hasAlpha), C.int(bitsPerSample), C.int(width), C.int(height), C.int(rowStride), nil, // TODO: missing support for GdkPixbufDestroyNotify nil, ) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // PixbufNewFromDataOnly is a convenient alternative to PixbufNewFromData() and also a wrapper around gdk_pixbuf_new_from_data(). func PixbufNewFromDataOnly(pixbufData []byte) (*Pixbuf, error) { pixbufLoader, err := PixbufLoaderNew() if err != nil { return nil, err } return pixbufLoader.WriteAndReturnPixbuf(pixbufData) } // PixbufNewFromResource is a wrapper around gdk_pixbuf_new_from_resource() func PixbufNewFromResource(resourcePath string) (*Pixbuf, error) { var gerr *C.GError cstr := C.CString(resourcePath) defer C.free(unsafe.Pointer(cstr)) c := C.gdk_pixbuf_new_from_resource((*C.gchar)(cstr), &gerr) if gerr != nil { defer C.g_error_free(gerr) return nil, errors.New(C.GoString(gerr.message)) } obj := glib.Take(unsafe.Pointer(c)) return &Pixbuf{obj}, nil } // PixbufNewFromResourceAtScale is a wrapper around gdk_pixbuf_new_from_resource_at_scale() func PixbufNewFromResourceAtScale(resourcePath string, width, height int, preserveAspectRatio bool) (*Pixbuf, error) { var gerr *C.GError cstr := C.CString(resourcePath) defer C.free(unsafe.Pointer(cstr)) cPreserveAspectRatio := gbool(preserveAspectRatio) c := C.gdk_pixbuf_new_from_resource_at_scale( (*C.gchar)(cstr), C.gint(width), C.gint(height), C.gboolean(cPreserveAspectRatio), &gerr, ) if gerr != nil { defer C.g_error_free(gerr) return nil, errors.New(C.GoString(gerr.message)) } obj := glib.Take(unsafe.Pointer(c)) return &Pixbuf{obj}, nil } // TODO: // gdk_pixbuf_new_from_xpm_data(). // gdk_pixbuf_new_subpixbuf() // PixbufCopy is a wrapper around gdk_pixbuf_copy(). func PixbufCopy(v *Pixbuf) (*Pixbuf, error) { c := C.gdk_pixbuf_copy(v.native()) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // The GdkPixbuf Structure // GetColorspace is a wrapper around gdk_pixbuf_get_colorspace(). func (v *Pixbuf) GetColorspace() Colorspace { c := C.gdk_pixbuf_get_colorspace(v.native()) return Colorspace(c) } // GetNChannels is a wrapper around gdk_pixbuf_get_n_channels(). func (v *Pixbuf) GetNChannels() int { c := C.gdk_pixbuf_get_n_channels(v.native()) return int(c) } // GetHasAlpha is a wrapper around gdk_pixbuf_get_has_alpha(). func (v *Pixbuf) GetHasAlpha() bool { c := C.gdk_pixbuf_get_has_alpha(v.native()) return gobool(c) } // GetBitsPerSample is a wrapper around gdk_pixbuf_get_bits_per_sample(). func (v *Pixbuf) GetBitsPerSample() int { c := C.gdk_pixbuf_get_bits_per_sample(v.native()) return int(c) } // GetPixels is a wrapper around gdk_pixbuf_get_pixels_with_length(). // A Go slice is used to represent the underlying Pixbuf data array, one // byte per channel. func (v *Pixbuf) GetPixels() (channels []byte) { var length C.guint c := C.gdk_pixbuf_get_pixels_with_length(v.native(), &length) sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&channels)) sliceHeader.Data = uintptr(unsafe.Pointer(c)) sliceHeader.Len = int(length) sliceHeader.Cap = int(length) // To make sure the slice doesn't outlive the Pixbuf, add a reference v.Ref() runtime.SetFinalizer(&channels, func(_ *[]byte) { glib.FinalizerStrategy(v.Unref) }) return } // GetWidth is a wrapper around gdk_pixbuf_get_width(). func (v *Pixbuf) GetWidth() int { c := C.gdk_pixbuf_get_width(v.native()) return int(c) } // GetHeight is a wrapper around gdk_pixbuf_get_height(). func (v *Pixbuf) GetHeight() int { c := C.gdk_pixbuf_get_height(v.native()) return int(c) } // GetRowstride is a wrapper around gdk_pixbuf_get_rowstride(). func (v *Pixbuf) GetRowstride() int { c := C.gdk_pixbuf_get_rowstride(v.native()) return int(c) } // GetOption is a wrapper around gdk_pixbuf_get_option(). ok is true if // the key has an associated value. func (v *Pixbuf) GetOption(key string) (value string, ok bool) { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) c := C.gdk_pixbuf_get_option(v.native(), (*C.gchar)(cstr)) if c == nil { return "", false } return C.GoString((*C.char)(c)), true } // Scaling // ScaleSimple is a wrapper around gdk_pixbuf_scale_simple(). func (v *Pixbuf) ScaleSimple(destWidth, destHeight int, interpType InterpType) (*Pixbuf, error) { c := C.gdk_pixbuf_scale_simple(v.native(), C.int(destWidth), C.int(destHeight), C.GdkInterpType(interpType)) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // Scale is a wrapper around gdk_pixbuf_scale(). func (v *Pixbuf) Scale(dest *Pixbuf, destX, destY, destWidth, destHeight int, offsetX, offsetY, scaleX, scaleY float64, interpType InterpType) { C.gdk_pixbuf_scale( v.native(), dest.native(), C.int(destX), C.int(destY), C.int(destWidth), C.int(destHeight), C.double(offsetX), C.double(offsetY), C.double(scaleX), C.double(scaleY), C.GdkInterpType(interpType), ) } // Composite is a wrapper around gdk_pixbuf_composite(). func (v *Pixbuf) Composite(dest *Pixbuf, destX, destY, destWidth, destHeight int, offsetX, offsetY, scaleX, scaleY float64, interpType InterpType, overallAlpha int) { C.gdk_pixbuf_composite( v.native(), dest.native(), C.int(destX), C.int(destY), C.int(destWidth), C.int(destHeight), C.double(offsetX), C.double(offsetY), C.double(scaleX), C.double(scaleY), C.GdkInterpType(interpType), C.int(overallAlpha), ) } // TODO: // gdk_pixbuf_composite_color_simple(). // gdk_pixbuf_composite_color(). // Utilities // TODO: // gdk_pixbuf_copy_area(). // gdk_pixbuf_saturate_and_pixelate(). // Fill is a wrapper around gdk_pixbuf_fill(). The given pixel is an RGBA value. func (v *Pixbuf) Fill(pixel uint32) { C.gdk_pixbuf_fill(v.native(), C.guint32(pixel)) } // AddAlpha is a wrapper around gdk_pixbuf_add_alpha(). If substituteColor is // true, then the color specified by r, g and b will be assigned zero opacity. func (v *Pixbuf) AddAlpha(substituteColor bool, r, g, b uint8) *Pixbuf { c := C.gdk_pixbuf_add_alpha(v.native(), gbool(substituteColor), C.guchar(r), C.guchar(g), C.guchar(b)) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p } // File saving // TODO: // gdk_pixbuf_savev(). // gdk_pixbuf_save(). // SaveJPEG is a convenience wrapper around gdk_pixbuf_save() for saving image as jpeg file. // Quality is a number between 0...100 func (v *Pixbuf) SaveJPEG(path string, quality int) error { cpath := C.CString(path) cquality := C.CString(strconv.Itoa(quality)) defer C.free(unsafe.Pointer(cpath)) defer C.free(unsafe.Pointer(cquality)) var err *C.GError c := C._gdk_pixbuf_save_jpeg(v.native(), cpath, &err, cquality) if !gobool(c) { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // SavePNG is a convenience wrapper around gdk_pixbuf_save() for saving image as png file. // Compression is a number between 0...9 func (v *Pixbuf) SavePNG(path string, compression int) error { cpath := C.CString(path) ccompression := C.CString(strconv.Itoa(compression)) defer C.free(unsafe.Pointer(cpath)) defer C.free(unsafe.Pointer(ccompression)) var err *C.GError c := C._gdk_pixbuf_save_png(v.native(), cpath, &err, ccompression) if !gobool(c) { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } /* * PixbufFormat */ type PixbufFormat struct { format *C.GdkPixbufFormat } // native returns a pointer to the underlying GdkPixbuf. func (v *PixbufFormat) native() *C.GdkPixbufFormat { if v == nil { return nil } return v.format } func wrapPixbufFormat(obj *C.GdkPixbufFormat) *PixbufFormat { return &PixbufFormat{obj} } // Native returns a pointer to the underlying GdkPixbuf. func (v *PixbufFormat) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } /* * GdkPixbufAnimation */ // PixbufAnimation is a representation of GDK's GdkPixbufAnimation. type PixbufAnimation struct { *glib.Object } // native returns a pointer to the underlying GdkPixbufAnimation. func (v *PixbufAnimation) native() *C.GdkPixbufAnimation { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkPixbufAnimation(p) } func (v *PixbufAnimation) NativePrivate() *C.GdkPixbufAnimation { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkPixbufAnimation(p) } func (v *PixbufAnimation) GetStaticImage() *Pixbuf { c := C.gdk_pixbuf_animation_get_static_image(v.native()) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} // Add a reference so the pixbuf doesn't outlive the parent pixbuf // animation. v.Ref() runtime.SetFinalizer(p, func(*Pixbuf) { glib.FinalizerStrategy(v.Unref) }) return p } func marshalPixbufAnimation(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &PixbufAnimation{obj}, nil } // PixbufAnimationNewFromFile is a wrapper around gdk_pixbuf_animation_new_from_file(). func PixbufAnimationNewFromFile(filename string) (*PixbufAnimation, error) { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) var err *C.GError c := C.gdk_pixbuf_animation_new_from_file((*C.char)(cstr), &err) if c == nil { defer C.g_error_free(err) return nil, errors.New(C.GoString((*C.char)(err.message))) } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &PixbufAnimation{obj} runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // TODO: // gdk_pixbuf_animation_new_from_resource(). /* * GdkPixbufLoader */ // PixbufLoader is a representation of GDK's GdkPixbufLoader. // Users of PixbufLoader are expected to call Close() when they are finished. type PixbufLoader struct { *glib.Object } // native() returns a pointer to the underlying GdkPixbufLoader. func (v *PixbufLoader) native() *C.GdkPixbufLoader { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkPixbufLoader(p) } func marshalPixbufLoader(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &PixbufLoader{obj}, nil } // PixbufLoaderNew() is a wrapper around gdk_pixbuf_loader_new(). func PixbufLoaderNew() (*PixbufLoader, error) { c := C.gdk_pixbuf_loader_new() if c == nil { return nil, nilPtrErr } return &PixbufLoader{glib.AssumeOwnership(unsafe.Pointer(c))}, nil } // PixbufLoaderNewWithType() is a wrapper around gdk_pixbuf_loader_new_with_type(). func PixbufLoaderNewWithType(t string) (*PixbufLoader, error) { var err *C.GError cstr := C.CString(t) defer C.free(unsafe.Pointer(cstr)) c := C.gdk_pixbuf_loader_new_with_type((*C.char)(cstr), &err) if err != nil { defer C.g_error_free(err) return nil, errors.New(C.GoString((*C.char)(err.message))) } if c == nil { return nil, nilPtrErr } return &PixbufLoader{glib.AssumeOwnership(unsafe.Pointer(c))}, nil } // Write() is a wrapper around gdk_pixbuf_loader_write(). The // function signature differs from the C equivalent to satisify the // io.Writer interface. func (v *PixbufLoader) Write(data []byte) (int, error) { // n is set to 0 on error, and set to len(data) otherwise. // This is a tiny hacky to satisfy io.Writer and io.WriteCloser, // which would allow access to all io and ioutil goodies, // and play along nice with go environment. if len(data) == 0 { return 0, nil } var err *C.GError c := C.gdk_pixbuf_loader_write(v.native(), (*C.guchar)(unsafe.Pointer(&data[0])), C.gsize(len(data)), &err) if !gobool(c) { defer C.g_error_free(err) return 0, errors.New(C.GoString((*C.char)(err.message))) } return len(data), nil } // Convenient function like above for Pixbuf. Write data, close loader and return Pixbuf. func (v *PixbufLoader) WriteAndReturnPixbuf(data []byte) (*Pixbuf, error) { _, err := v.Write(data) if err != nil { return nil, err } if err := v.Close(); err != nil { return nil, err } return v.GetPixbuf() } // Close is a wrapper around gdk_pixbuf_loader_close(). An error is // returned instead of a bool like the native C function to support the // io.Closer interface. func (v *PixbufLoader) Close() error { var err *C.GError if ok := gobool(C.gdk_pixbuf_loader_close(v.native(), &err)); !ok { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // GetPixbuf is a wrapper around gdk_pixbuf_loader_get_pixbuf(). func (v *PixbufLoader) GetPixbuf() (*Pixbuf, error) { c := C.gdk_pixbuf_loader_get_pixbuf(v.native()) if c == nil { return nil, nilPtrErr } return &Pixbuf{glib.Take(unsafe.Pointer(c))}, nil } // GetAnimation is a wrapper around gdk_pixbuf_loader_get_animation(). func (v *PixbufLoader) GetAnimation() (*PixbufAnimation, error) { c := C.gdk_pixbuf_loader_get_animation(v.native()) if c == nil { return nil, nilPtrErr } return &PixbufAnimation{glib.Take(unsafe.Pointer(c))}, nil } // Convenient function like above for Pixbuf. Write data, close loader and return PixbufAnimation. func (v *PixbufLoader) WriteAndReturnPixbufAnimation(data []byte) (*PixbufAnimation, error) { _, err := v.Write(data) if err != nil { return nil, err } if err := v.Close(); err != nil { return nil, err } return v.GetAnimation() } gotk3-0.6.2/gdk/pixbuf.go.h000066400000000000000000000015461431157473000154000ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project #include static GdkPixbuf *toGdkPixbuf(void *p) { return (GDK_PIXBUF(p)); } static GdkPixbufAnimation *toGdkPixbufAnimation(void *p) { return (GDK_PIXBUF_ANIMATION(p)); } static gboolean _gdk_pixbuf_save_png(GdkPixbuf *pixbuf, const char *filename, GError **err, const char *compression) { return gdk_pixbuf_save(pixbuf, filename, "png", err, "compression", compression, NULL); } static gboolean _gdk_pixbuf_save_jpeg(GdkPixbuf *pixbuf, const char *filename, GError **err, const char *quality) { return gdk_pixbuf_save(pixbuf, filename, "jpeg", err, "quality", quality, NULL); } static GdkPixbufLoader *toGdkPixbufLoader(void *p) { return (GDK_PIXBUF_LOADER(p)); } gotk3-0.6.2/gdk/pixbuf_deprecated_since_2_32.go000066400000000000000000000007321431157473000212340ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project //+build gdk_pixbuf_2_2 gdk_pixbuf_2_4 gdk_pixbuf_2_6 gdk_pixbuf_2_8 gdk_pixbuf_2_12 gdk_pixbuf_2_14 gdk_pixbuf_2_24 gdk_pixbuf_2_26 gdk_pixbuf_2_28 gdk_pixbuf_2_30 gdk_pixbuf_deprecated package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" // Image Data in Memory // TODO: // gdk_pixbuf_new_from_inline(). gotk3-0.6.2/gdk/pixbuf_since_2_12.go000066400000000000000000000014561431157473000170560ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gdk_pixbuf_2_2,!gdk_pixbuf_2_4,!gdk_pixbuf_2_6,!gdk_pixbuf_2_8 package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) // Utilities // ApplyEmbeddedOrientation is a wrapper around gdk_pixbuf_apply_embedded_orientation(). func (v *Pixbuf) ApplyEmbeddedOrientation() (*Pixbuf, error) { c := C.gdk_pixbuf_apply_embedded_orientation(v.native()) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } gotk3-0.6.2/gdk/pixbuf_since_2_14.go000066400000000000000000000007751431157473000170630ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gdk_pixbuf_2_2,!gdk_pixbuf_2_4,!gdk_pixbuf_2_6,!gdk_pixbuf_2_8,!gdk_pixbuf_2_12 package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" // File Loading // TODO: // gdk_pixbuf_new_from_stream(). // gdk_pixbuf_new_from_stream_async(). // gdk_pixbuf_new_from_stream_at_scale(). // File saving // TODO: // gdk_pixbuf_save_to_stream(). gotk3-0.6.2/gdk/pixbuf_since_2_2.go000066400000000000000000000047331431157473000167760ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) // The GdkPixbuf Structure // TODO: // gdk_pixbuf_set_option(). /* * GdkPixbufLoader */ // SetSize is a wrapper around gdk_pixbuf_loader_set_size(). func (v *PixbufLoader) SetSize(width, height int) { C.gdk_pixbuf_loader_set_size(v.native(), C.int(width), C.int(height)) } /* * PixbufFormat */ // PixbufGetFormats is a wrapper around gdk_pixbuf_get_formats(). func PixbufGetFormats() []*PixbufFormat { l := (*C.struct__GSList)(C.gdk_pixbuf_get_formats()) formats := glib.WrapSList(uintptr(unsafe.Pointer(l))) if formats == nil { return nil // no error. A nil list is considered to be empty. } // "The structures themselves are owned by GdkPixbuf". Free the list only. defer formats.Free() ret := make([]*PixbufFormat, 0, formats.Length()) formats.Foreach(func(item interface{}) { ret = append( ret, &PixbufFormat{ (*C.GdkPixbufFormat)(item.(unsafe.Pointer))}) }) return ret } // GetName is a wrapper around gdk_pixbuf_format_get_name(). func (f *PixbufFormat) GetName() (string, error) { c := C.gdk_pixbuf_format_get_name(f.native()) return C.GoString((*C.char)(c)), nil } // GetDescription is a wrapper around gdk_pixbuf_format_get_description(). func (f *PixbufFormat) GetDescription() (string, error) { c := C.gdk_pixbuf_format_get_description(f.native()) return C.GoString((*C.char)(c)), nil } // GetMimeTypes is a wrapper around gdk_pixbuf_format_get_mime_types(). func (f *PixbufFormat) GetMimeTypes() []string { var types []string c := C.gdk_pixbuf_format_get_mime_types(f.native()) if c == nil { return nil } for *c != nil { types = append(types, C.GoString((*C.char)(*c))) c = C.next_gcharptr(c) } return types } // GetExtensions is a wrapper around gdk_pixbuf_format_get_extensions(). func (f *PixbufFormat) GetExtensions() []string { var extensions []string c := C.gdk_pixbuf_format_get_extensions(f.native()) if c == nil { return nil } for *c != nil { extensions = append(extensions, C.GoString((*C.char)(*c))) c = C.next_gcharptr(c) } return extensions } // GetLicense is a wrapper around gdk_pixbuf_format_get_license(). func (f *PixbufFormat) GetLicense() (string, error) { c := C.gdk_pixbuf_format_get_license(f.native()) return C.GoString((*C.char)(c)), nil } gotk3-0.6.2/gdk/pixbuf_since_2_22.go000066400000000000000000000006061431157473000170530ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gdk_pixbuf_2_2,!gdk_pixbuf_2_4,!gdk_pixbuf_2_6,!gdk_pixbuf_2_8,!gdk_pixbuf_2_12,!gdk_pixbuf_2_14 package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" /* * PixbufFormat */ // TODO: // gdk_pixbuf_format_copy(). gotk3-0.6.2/gdk/pixbuf_since_2_24.go000066400000000000000000000010621431157473000170520ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gdk_pixbuf_2_2,!gdk_pixbuf_2_4,!gdk_pixbuf_2_6,!gdk_pixbuf_2_8,!gdk_pixbuf_2_12,!gdk_pixbuf_2_14,!gdk_pixbuf_2_22 package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" // File Loading // TODO: // gdk_pixbuf_new_from_stream_finish(). // gdk_pixbuf_new_from_stream_at_scale_async(). // File saving // TODO: // gdk_pixbuf_save_to_stream_async(). // gdk_pixbuf_save_to_stream_finish(). gotk3-0.6.2/gdk/pixbuf_since_2_26.go000066400000000000000000000012321431157473000170530ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gdk_pixbuf_2_2,!gdk_pixbuf_2_4,!gdk_pixbuf_2_6,!gdk_pixbuf_2_8,!gdk_pixbuf_2_12,!gdk_pixbuf_2_14,!gdk_pixbuf_2_22,!gdk_pixbuf_2_24 package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" // File Loading // TODO: // gdk_pixbuf_new_from_resource(). // gdk_pixbuf_new_from_resource_at_scale(). // The GdkPixbuf Structure // GetByteLength is a wrapper around gdk_pixbuf_get_byte_length(). func (v *Pixbuf) GetByteLength() int { c := C.gdk_pixbuf_get_byte_length(v.native()) return int(c) } gotk3-0.6.2/gdk/pixbuf_since_2_32.go000066400000000000000000000033571431157473000170620ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gdk_pixbuf_2_2,!gdk_pixbuf_2_4,!gdk_pixbuf_2_6,!gdk_pixbuf_2_8,!gdk_pixbuf_2_12,!gdk_pixbuf_2_14,!gdk_pixbuf_2_22,!gdk_pixbuf_2_24,!gdk_pixbuf_2_26,!gdk_pixbuf_2_28,!gdk_pixbuf_2_30 package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) // Image Data in Memory // PixbufNewFromBytes is a wrapper around gdk_pixbuf_new_from_bytes(). // see go package "encoding/base64" func PixbufNewFromBytes(pixbufData []byte, cs Colorspace, hasAlpha bool, bitsPerSample, width, height, rowStride int) (*Pixbuf, error) { arrayPtr := (*C.GBytes)(unsafe.Pointer(&pixbufData[0])) c := C.gdk_pixbuf_new_from_bytes( arrayPtr, C.GdkColorspace(cs), gbool(hasAlpha), C.int(bitsPerSample), C.int(width), C.int(height), C.int(rowStride), ) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // PixbufNewFromBytesOnly is a convenient alternative to PixbufNewFromBytes() and also a wrapper around gdk_pixbuf_new_from_bytes(). // see go package "encoding/base64" func PixbufNewFromBytesOnly(pixbufData []byte) (*Pixbuf, error) { pixbufLoader, err := PixbufLoaderNew() if err != nil { return nil, err } return pixbufLoader.WriteAndReturnPixbuf(pixbufData) } // File loading // TODO: // gdk_pixbuf_get_file_info_async(). // gdk_pixbuf_get_file_info_finish(). // The GdkPixbuf Structure // TODO: // gdk_pixbuf_get_options(). // gdk_pixbuf_read_pixels(). gotk3-0.6.2/gdk/pixbuf_since_2_36.go000066400000000000000000000011621431157473000170560ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gdk_pixbuf_2_2,!gdk_pixbuf_2_4,!gdk_pixbuf_2_6,!gdk_pixbuf_2_8,!gdk_pixbuf_2_12,!gdk_pixbuf_2_14,!gdk_pixbuf_2_22,!gdk_pixbuf_2_24,!gdk_pixbuf_2_26,!gdk_pixbuf_2_28,!gdk_pixbuf_2_30,!gdk_pixbuf_2_32 package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" // File saving // TODO: // gdk_pixbuf_save_to_streamv(). // gdk_pixbuf_save_to_streamv_async(). // The GdkPixbuf Structure // TODO: // gdk_pixbuf_remove_option(). // gdk_pixbuf_copy_options(). gotk3-0.6.2/gdk/pixbuf_since_2_4.go000066400000000000000000000071121431157473000167720ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gdk_pixbuf_2_2 package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 gmodule-2.0 // #include // #include // #include // #include "gdk.go.h" // #include "pixbuf.go.h" // #include "pixbuf_since_2_4.go.h" import "C" import ( "errors" "io" "reflect" "runtime" "strconv" "unsafe" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/internal/callback" ) // File saving //export goPixbufSaveCallback func goPixbufSaveCallback(buf *C.gchar, count C.gsize, gerr **C.GError, id C.gpointer) C.gboolean { v := callback.Get(uintptr(id)) if v == nil { C._pixbuf_error_set_callback_not_found(gerr) return C.FALSE } var bytes []byte header := (*reflect.SliceHeader)((unsafe.Pointer(&bytes))) header.Cap = int(count) header.Len = int(count) header.Data = uintptr(unsafe.Pointer(buf)) _, err := v.(io.Writer).Write(bytes) if err != nil { cerr := C.CString(err.Error()) defer C.free(unsafe.Pointer(cerr)) C._pixbuf_error_set(gerr, cerr) return C.FALSE } return C.TRUE } // WritePNG is a convenience wrapper around gdk_pixbuf_save_to_callback() for // saving images using a streaming callback API. Compression is a number from 0 // to 9. func (v *Pixbuf) WritePNG(w io.Writer, compression int) error { ccompression := C.CString(strconv.Itoa(compression)) defer C.free(unsafe.Pointer(ccompression)) id := callback.Assign(w) var err *C.GError c := C._gdk_pixbuf_save_png_writer(v.native(), C.gpointer(id), &err, ccompression) callback.Delete(id) if !gobool(c) { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // WriteJPEG is a convenience wrapper around gdk_pixbuf_save_to_callback() for // saving images using a streaming callback API. Quality is a number from 0 to // 100. func (v *Pixbuf) WriteJPEG(w io.Writer, quality int) error { cquality := C.CString(strconv.Itoa(quality)) defer C.free(unsafe.Pointer(cquality)) id := callback.Assign(w) var err *C.GError c := C._gdk_pixbuf_save_jpeg_writer(v.native(), C.gpointer(id), &err, cquality) callback.Delete(id) if !gobool(c) { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // TODO: // GdkPixbufSaveFunc // gdk_pixbuf_save_to_callback(). // gdk_pixbuf_save_to_callbackv(). // gdk_pixbuf_save_to_buffer(). // gdk_pixbuf_save_to_bufferv(). // File Loading // PixbufNewFromFileAtSize is a wrapper around gdk_pixbuf_new_from_file_at_size(). func PixbufNewFromFileAtSize(filename string, width, height int) (*Pixbuf, error) { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil c := C.gdk_pixbuf_new_from_file_at_size(cstr, C.int(width), C.int(height), &err) if err != nil { defer C.g_error_free(err) return nil, errors.New(C.GoString((*C.char)(err.message))) } if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // PixbufGetFileInfo is a wrapper around gdk_pixbuf_get_file_info(). func PixbufGetFileInfo(filename string) (*PixbufFormat, int, int, error) { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) var cw, ch C.gint format := C.gdk_pixbuf_get_file_info((*C.gchar)(cstr), &cw, &ch) if format == nil { return nil, -1, -1, nilPtrErr } // The returned PixbufFormat value is owned by Pixbuf and should not be freed. return wrapPixbufFormat(format), int(cw), int(ch), nil } gotk3-0.6.2/gdk/pixbuf_since_2_4.go.h000066400000000000000000000027271431157473000172270ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project #include extern gboolean goPixbufSaveCallback(gchar *buf, gsize count, GError **error, gpointer data); static inline gboolean _gdk_pixbuf_save_png_writer(GdkPixbuf *pixbuf, gpointer callback_id, GError **err, const char *compression) { return gdk_pixbuf_save_to_callback( pixbuf, (GdkPixbufSaveFunc)(goPixbufSaveCallback), callback_id, "png", err, "compression", compression, NULL); } static inline gboolean _gdk_pixbuf_save_jpeg_writer(GdkPixbuf *pixbuf, gpointer callback_id, GError **err, const char *quality) { return gdk_pixbuf_save_to_callback( pixbuf, (GdkPixbufSaveFunc)(goPixbufSaveCallback), callback_id, "jpeg", err, "quality", quality, NULL); } static inline void _pixbuf_error_set_callback_not_found(GError **err) { GQuark domain = g_quark_from_static_string("go error"); g_set_error_literal(err, domain, 1, "pixbuf callback not found"); } static inline void _pixbuf_error_set(GError **err, char *message) { GQuark domain = g_quark_from_static_string("go error"); g_set_error_literal(err, domain, 1, message); } gotk3-0.6.2/gdk/pixbuf_since_2_6.go000066400000000000000000000036251431157473000170010ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gdk_pixbuf_2_2,!gdk_pixbuf_2_4 package gdk // #cgo pkg-config: gdk-3.0 glib-2.0 gobject-2.0 // #include // #include "gdk.go.h" // #include "pixbuf.go.h" import "C" import ( "errors" "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) // File Loading // PixbufNewFromFileAtScale is a wrapper around gdk_pixbuf_new_from_file_at_scale(). func PixbufNewFromFileAtScale(filename string, width, height int, preserveAspectRatio bool) (*Pixbuf, error) { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil c := C.gdk_pixbuf_new_from_file_at_scale(cstr, C.int(width), C.int(height), gbool(preserveAspectRatio), &err) if err != nil { defer C.g_error_free(err) return nil, errors.New(C.GoString((*C.char)(err.message))) } if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // Scaling // RotateSimple is a wrapper around gdk_pixbuf_rotate_simple(). func (v *Pixbuf) RotateSimple(angle PixbufRotation) (*Pixbuf, error) { c := C.gdk_pixbuf_rotate_simple(v.native(), C.GdkPixbufRotation(angle)) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } // Flip is a wrapper around gdk_pixbuf_flip(). func (v *Pixbuf) Flip(horizontal bool) (*Pixbuf, error) { c := C.gdk_pixbuf_flip(v.native(), gbool(horizontal)) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &Pixbuf{obj} //obj.Ref() runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p, nil } gotk3-0.6.2/gdk/screen.go000066400000000000000000000056561431157473000151420ustar00rootroot00000000000000package gdk // #include // #include "gdk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) /* * GdkScreen */ // Screen is a representation of GDK's GdkScreen. type Screen struct { *glib.Object } // native returns a pointer to the underlying GdkScreen. func (v *Screen) native() *C.GdkScreen { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkScreen(p) } // Native returns a pointer to the underlying GdkScreen. func (v *Screen) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalScreen(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &Screen{obj}, nil } func toScreen(s *C.GdkScreen) (*Screen, error) { if s == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(s))} return &Screen{obj}, nil } // GetRGBAVisual is a wrapper around gdk_screen_get_rgba_visual(). func (v *Screen) GetRGBAVisual() (*Visual, error) { c := C.gdk_screen_get_rgba_visual(v.native()) if c == nil { return nil, nilPtrErr } return &Visual{glib.Take(unsafe.Pointer(c))}, nil } // GetSystemVisual is a wrapper around gdk_screen_get_system_visual(). func (v *Screen) GetSystemVisual() (*Visual, error) { c := C.gdk_screen_get_system_visual(v.native()) if c == nil { return nil, nilPtrErr } return &Visual{glib.Take(unsafe.Pointer(c))}, nil } // ScreenGetDefault is a wrapper around gdk_screen_get_default(). func ScreenGetDefault() (*Screen, error) { return toScreen(C.gdk_screen_get_default()) } // IsComposited is a wrapper around gdk_screen_is_composited(). func (v *Screen) IsComposited() bool { return gobool(C.gdk_screen_is_composited(v.native())) } // GetRootWindow is a wrapper around gdk_screen_get_root_window(). func (v *Screen) GetRootWindow() (*Window, error) { return toWindow(C.gdk_screen_get_root_window(v.native())) } // GetDisplay is a wrapper around gdk_screen_get_display(). func (v *Screen) GetDisplay() (*Display, error) { return toDisplay(C.gdk_screen_get_display(v.native())) } func toString(c *C.gchar) (string, error) { if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // GetResolution is a wrapper around gdk_screen_get_resolution(). func (v *Screen) GetResolution() float64 { return float64(C.gdk_screen_get_resolution(v.native())) } // SetResolution is a wrapper around gdk_screen_set_resolution(). func (v *Screen) SetResolution(r float64) { C.gdk_screen_set_resolution(v.native(), C.gdouble(r)) } // TODO: // void gdk_screen_set_font_options () // gboolean gdk_screen_get_setting () // const cairo_font_options_t * gdk_screen_get_font_options () // GList * gdk_screen_get_window_stack () // GList * gdk_screen_list_visuals () // GList * gdk_screen_get_toplevel_windows () // void gdk_screen_get_monitor_geometry () // void gdk_screen_get_monitor_workarea () gotk3-0.6.2/gdk/screen_no_x11.go000066400000000000000000000016201431157473000163120ustar00rootroot00000000000000// +build !linux no_x11 package gdk func WorkspaceControlSupported() bool { return false } // GetScreenNumber is a wrapper around gdk_x11_screen_get_screen_number(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Screen) GetScreenNumber() int { return -1 } // GetNumberOfDesktops is a wrapper around gdk_x11_screen_get_number_of_desktops(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Screen) GetNumberOfDesktops() uint32 { return 0 } // GetCurrentDesktop is a wrapper around gdk_x11_screen_get_current_desktop(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Screen) GetCurrentDesktop() uint32 { return 0 } gotk3-0.6.2/gdk/screen_x11.go000066400000000000000000000021701431157473000156170ustar00rootroot00000000000000// +build linux // +build !no_x11 package gdk // #include // #include import "C" func WorkspaceControlSupported() bool { return true } // GetScreenNumber is a wrapper around gdk_x11_screen_get_screen_number(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Screen) GetScreenNumber() int { return int(C.gdk_x11_screen_get_screen_number(v.native())) } // GetNumberOfDesktops is a wrapper around gdk_x11_screen_get_number_of_desktops(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Screen) GetNumberOfDesktops() uint32 { return uint32(C.gdk_x11_screen_get_number_of_desktops(v.native())) } // GetCurrentDesktop is a wrapper around gdk_x11_screen_get_current_desktop(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Screen) GetCurrentDesktop() uint32 { return uint32(C.gdk_x11_screen_get_current_desktop(v.native())) } gotk3-0.6.2/gdk/testing.go000066400000000000000000000041701431157473000153260ustar00rootroot00000000000000package gdk // #include import "C" // TestRenderSync retrieves a pixel from window to force the windowing system to carry out any pending rendering commands. // This function is intended to be used to synchronize with rendering pipelines, to benchmark windowing system rendering operations. // This is a wrapper around gdk_test_render_sync(). func TestRenderSync(window *Window) { C.gdk_test_render_sync(window.native()) } // TestSimulateButton simulates a single mouse button event (press or release) at the given coordinates relative to the window. // Hint: a single click of a button requires this method to be called twice, once for pressed and once for released. // In most cases, gtk.TestWidgetClick() should be used. // // button: Mouse button number, starts with 0 // modifiers: Keyboard modifiers for the button event // buttonPressRelease: either GDK_BUTTON_PRESS or GDK_BUTTON_RELEASE // // This is a wrapper around gdk_test_simulate_button(). func TestSimulateButton(window *Window, x, y int, button Button, modifiers ModifierType, buttonPressRelease EventType) bool { return gobool(C.gdk_test_simulate_button(window.native(), C.gint(x), C.gint(y), C.guint(button), C.GdkModifierType(modifiers), C.GdkEventType(buttonPressRelease))) } // TestSimulateButton simulates a keyboard event (press or release) at the given coordinates relative to the window. // If the coordinates (-1, -1) are used, the window origin is used instead. // Hint: a single key press requires this method to be called twice, once for pressed and once for released. // In most cases, gtk.TestWidgetSendKey() should be used. // // keyval: A GDK keyboard value (See KeyvalFromName(), UnicodeToKeyval(), ...) // modifiers: Keyboard modifiers for the key event // buttonPressRelease: either GDK_BUTTON_PRESS or GDK_BUTTON_RELEASE // // This is a wrapper around gdk_test_simulate_key(). func TestSimulateKey(window *Window, x, y int, keyval uint, modifiers ModifierType, buttonPressRelease EventType) bool { return gobool(C.gdk_test_simulate_key(window.native(), C.gint(x), C.gint(y), C.guint(keyval), C.GdkModifierType(modifiers), C.GdkEventType(buttonPressRelease))) } gotk3-0.6.2/gdk/window_no_x11.go000066400000000000000000000011111431157473000163350ustar00rootroot00000000000000// +build !linux no_x11 package gdk func (v *Window) MoveToCurrentDesktop() { } // GetDesktop is a wrapper around gdk_x11_window_get_desktop(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Window) GetDesktop() uint32 { return 0 } // MoveToDesktop is a wrapper around gdk_x11_window_move_to_desktop(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Window) MoveToDesktop(d uint32) { } gotk3-0.6.2/gdk/window_x11.go000066400000000000000000000034501431157473000156510ustar00rootroot00000000000000// +build linux // +build !no_x11 package gdk // #include // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) // MoveToCurrentDesktop is a wrapper around gdk_x11_window_move_to_current_desktop(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Window) MoveToCurrentDesktop() { C.gdk_x11_window_move_to_current_desktop(v.native()) } // GetDesktop is a wrapper around gdk_x11_window_get_desktop(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Window) GetDesktop() uint32 { return uint32(C.gdk_x11_window_get_desktop(v.native())) } // MoveToDesktop is a wrapper around gdk_x11_window_move_to_desktop(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Window) MoveToDesktop(d uint32) { C.gdk_x11_window_move_to_desktop(v.native(), C.guint32(d)) } // GetXID is a wrapper around gdk_x11_window_get_xid(). // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Window) GetXID() uint32 { return uint32(C.gdk_x11_window_get_xid(v.native())) } //ForeignNewForDisplay is a wrapper around gdk_x11_window_foreign_new_for_display() // It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false func (v *Display) ForeignNewForDisplay(xid uint32) (*Window, error) { c := C.gdk_x11_window_foreign_new_for_display(v.native(), C.Window(xid)) if c == nil { return nil, nilPtrErr } return &Window{glib.Take(unsafe.Pointer(c))}, nil } gotk3-0.6.2/gio/000077500000000000000000000000001431157473000133315ustar00rootroot00000000000000gotk3-0.6.2/gio/gresource.go000066400000000000000000000054441431157473000156650ustar00rootroot00000000000000// package resource wraps operations over GResource package gio // #cgo pkg-config: gio-2.0 glib-2.0 gobject-2.0 // #include // #include // #include "gresource.go.h" import "C" import ( "errors" "unsafe" ) // ResourceLookupFlags is a representation of GTK's GResourceLookupFlags type ResourceLookupFlags int func (f ResourceLookupFlags) native() C.GResourceLookupFlags { return (C.GResourceLookupFlags)(f) } const ( G_RESOURCE_LOOKUP_FLAGS_NONE ResourceLookupFlags = C.G_RESOURCE_LOOKUP_FLAGS_NONE ) // GResource wraps native GResource object // // See: https://developer.gnome.org/gio/stable/GResource.html type GResource *C.GResource // LoadGResource is a wrapper around g_resource_load() // // See: https://developer.gnome.org/gio/stable/GResource.html#g-resource-load func LoadGResource(path string) (GResource, error) { cpath := C.CString(path) defer C.free(unsafe.Pointer(cpath)) var gerr *C.GError resPtr := C.g_resource_load((*C.gchar)(unsafe.Pointer(cpath)), &gerr) if gerr != nil { defer C.g_error_free(gerr) return nil, errors.New(goString(gerr.message)) } res := wrapGResource(resPtr) return res, nil } // NewGResourceFromData is a wrapper around g_resource_new_from_data() // // See: https://developer.gnome.org/gio/stable/GResource.html#g-resource-new-from-data func NewGResourceFromData(data []byte) (GResource, error) { arrayPtr := (*C.GBytes)(unsafe.Pointer(&data[0])) var gerr *C.GError resPtr := C.g_resource_new_from_data(arrayPtr, &gerr) if gerr != nil { defer C.g_error_free(gerr) return nil, errors.New(goString(gerr.message)) } res := wrapGResource(resPtr) return res, nil } // Register wraps g_resources_register() // // See: https://developer.gnome.org/gio/stable/GResource.html#g-resources-register func RegisterGResource(res GResource) { C.g_resources_register(res) } // Unregister wraps g_resources_unregister() // // See: https://developer.gnome.org/gio/stable/GResource.html#g-resources-unregister func UnregisterGResource(res GResource) { C.g_resources_unregister(res) } // GResourceEnumerateChildren wraps g_resources_enumerate_children() // // See: https://developer.gnome.org/gio/stable/GResource.html#g-resources-enumerate-children func GResourceEnumerateChildren(path string, flags ResourceLookupFlags) ([]string, error) { cpath := C.CString(path) defer C.free(unsafe.Pointer(cpath)) var gerr *C.GError arrChildren := C.g_resources_enumerate_children(cpath, flags.native(), &gerr) if gerr != nil { defer C.g_error_free(gerr) return nil, errors.New(goString(gerr.message)) } if arrChildren == nil { return nil, errors.New("unexpected nil pointer from g_resources_enumerate_children") } arr := toGoStringArray(arrChildren) return arr, nil } func wrapGResource(resPtr *C.GResource) GResource { res := GResource(resPtr) return res } gotk3-0.6.2/gio/gresource.go.h000066400000000000000000000003731431157473000161070ustar00rootroot00000000000000#pragma once #include #include #include #include #include static inline char **next_charptr(char **s) { return (s + 1); } static inline void char_g_strfreev(char **s) { g_strfreev((gchar **)s); } gotk3-0.6.2/gio/utils.go000066400000000000000000000010641431157473000150210ustar00rootroot00000000000000package gio // #include // #include "gresource.go.h" import "C" // same implementation as package glib func toGoStringArray(c **C.char) []string { var strs []string originalc := c defer C.char_g_strfreev(originalc) for *c != nil { strs = append(strs, C.GoString((*C.char)(*c))) c = C.next_charptr(c) } return strs } func goString(cstr *C.gchar) string { return C.GoString((*C.char)(cstr)) } func gbool(b bool) C.gboolean { if b { return C.gboolean(1) } return C.gboolean(0) } func gobool(b C.gboolean) bool { return b != C.FALSE } gotk3-0.6.2/glib/000077500000000000000000000000001431157473000134705ustar00rootroot00000000000000gotk3-0.6.2/glib/application.go000066400000000000000000000136441431157473000163320ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" // Application is a representation of GApplication. type Application struct { *Object // Interfaces IActionMap IActionGroup } // native() returns a pointer to the underlying GApplication. func (v *Application) native() *C.GApplication { if v == nil || v.GObject == nil { return nil } return C.toGApplication(unsafe.Pointer(v.GObject)) } func (v *Application) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalApplication(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapApplication(wrapObject(unsafe.Pointer(c))), nil } func wrapApplication(obj *Object) *Application { am := wrapActionMap(obj) ag := wrapActionGroup(obj) return &Application{obj, am, ag} } // ApplicationIDIsValid is a wrapper around g_application_id_is_valid(). func ApplicationIDIsValid(id string) bool { cstr1 := (*C.gchar)(C.CString(id)) defer C.free(unsafe.Pointer(cstr1)) return gobool(C.g_application_id_is_valid(cstr1)) } // ApplicationNew is a wrapper around g_application_new(). func ApplicationNew(appID string, flags ApplicationFlags) *Application { cstr1 := (*C.gchar)(C.CString(appID)) defer C.free(unsafe.Pointer(cstr1)) c := C.g_application_new(cstr1, C.GApplicationFlags(flags)) if c == nil { return nil } return wrapApplication(wrapObject(unsafe.Pointer(c))) } // GetApplicationID is a wrapper around g_application_get_application_id(). func (v *Application) GetApplicationID() string { c := C.g_application_get_application_id(v.native()) return C.GoString((*C.char)(c)) } // SetApplicationID is a wrapper around g_application_set_application_id(). func (v *Application) SetApplicationID(id string) { cstr1 := (*C.gchar)(C.CString(id)) defer C.free(unsafe.Pointer(cstr1)) C.g_application_set_application_id(v.native(), cstr1) } // GetInactivityTimeout is a wrapper around g_application_get_inactivity_timeout(). func (v *Application) GetInactivityTimeout() uint { return uint(C.g_application_get_inactivity_timeout(v.native())) } // SetInactivityTimeout is a wrapper around g_application_set_inactivity_timeout(). func (v *Application) SetInactivityTimeout(timeout uint) { C.g_application_set_inactivity_timeout(v.native(), C.guint(timeout)) } // GetFlags is a wrapper around g_application_get_flags(). func (v *Application) GetFlags() ApplicationFlags { return ApplicationFlags(C.g_application_get_flags(v.native())) } // SetFlags is a wrapper around g_application_set_flags(). func (v *Application) SetFlags(flags ApplicationFlags) { C.g_application_set_flags(v.native(), C.GApplicationFlags(flags)) } // GetDbusObjectPath is a wrapper around g_application_get_dbus_object_path(). func (v *Application) GetDbusObjectPath() string { c := C.g_application_get_dbus_object_path(v.native()) return C.GoString((*C.char)(c)) } // GetIsRegistered is a wrapper around g_application_get_is_registered(). func (v *Application) GetIsRegistered() bool { return gobool(C.g_application_get_is_registered(v.native())) } // GetIsRemote is a wrapper around g_application_get_is_remote(). func (v *Application) GetIsRemote() bool { return gobool(C.g_application_get_is_remote(v.native())) } // Hold is a wrapper around g_application_hold(). func (v *Application) Hold() { C.g_application_hold(v.native()) } // Release is a wrapper around g_application_release(). func (v *Application) Release() { C.g_application_release(v.native()) } // Quit is a wrapper around g_application_quit(). func (v *Application) Quit() { C.g_application_quit(v.native()) } // Activate is a wrapper around g_application_activate(). func (v *Application) Activate() { C.g_application_activate(v.native()) } // SendNotification is a wrapper around g_application_send_notification(). func (v *Application) SendNotification(id string, notification *Notification) { cstr1 := (*C.gchar)(C.CString(id)) defer C.free(unsafe.Pointer(cstr1)) C.g_application_send_notification(v.native(), cstr1, notification.native()) } // WithdrawNotification is a wrapper around g_application_withdraw_notification(). func (v *Application) WithdrawNotification(id string) { cstr1 := (*C.gchar)(C.CString(id)) defer C.free(unsafe.Pointer(cstr1)) C.g_application_withdraw_notification(v.native(), cstr1) } // SetDefault is a wrapper around g_application_set_default(). func (v *Application) SetDefault() { C.g_application_set_default(v.native()) } // ApplicationGetDefault is a wrapper around g_application_get_default(). func ApplicationGetDefault() *Application { c := C.g_application_get_default() if c == nil { return nil } return wrapApplication(wrapObject(unsafe.Pointer(c))) } // MarkBusy is a wrapper around g_application_mark_busy(). func (v *Application) MarkBusy() { C.g_application_mark_busy(v.native()) } // UnmarkBusy is a wrapper around g_application_unmark_busy(). func (v *Application) UnmarkBusy() { C.g_application_unmark_busy(v.native()) } // Run is a wrapper around g_application_run(). func (v *Application) Run(args []string) int { cargs := C.make_strings(C.int(len(args))) defer C.destroy_strings(cargs) for i, arg := range args { cstr := C.CString(arg) defer C.free(unsafe.Pointer(cstr)) C.set_string(cargs, C.int(i), (*C.char)(cstr)) } return int(C.g_application_run(v.native(), C.int(len(args)), cargs)) } // void g_application_bind_busy_property () // void g_application_unbind_busy_property () // gboolean g_application_register () // requires GCancellable // void g_application_set_action_group () // Deprecated since 2.32 // GDBusConnection * g_application_get_dbus_connection () // No support for GDBusConnection // void g_application_open () // Needs GFile // void g_application_add_main_option_entries () //Needs GOptionEntry // void g_application_add_main_option () //Needs GOptionFlags and GOptionArg // void g_application_add_option_group () // Needs GOptionGroup gotk3-0.6.2/glib/cast.go000066400000000000000000000001421431157473000147460ustar00rootroot00000000000000package glib type WrapFn interface{} var WrapMap = map[string]WrapFn{ "GMenu": wrapMenuModel, }gotk3-0.6.2/glib/connect.go000066400000000000000000000131451431157473000154540ustar00rootroot00000000000000package glib // #include // #include // #include "glib.go.h" import "C" import ( "reflect" "unsafe" "github.com/gotk3/gotk3/internal/closure" ) /* * Events */ // SignalHandle is the ID of a signal handler. type SignalHandle uint // Connect is a wrapper around g_signal_connect_closure(). f must be a function // with at least one parameter matching the type it is connected to. // // It is optional to list the rest of the required types from Gtk, as values // that don't fit into the function parameter will simply be ignored; however, // extraneous types will trigger a runtime panic. Arguments for f must be a // matching Go equivalent type for the C callback, or an interface type which // the value may be packed in. If the type is not suitable, a runtime panic will // occur when the signal is emitted. // // Circular References // // To prevent circular references, prefer declaring Connect functions like so: // // obj.Connect(func(obj *ObjType) { obj.Do() }) // // Instead of directly referencing the object from outside like so: // // obj.Connect(func() { obj.Do() }) // // When using Connect, beware of referencing variables outside the closure that // may cause a circular reference that prevents both Go from garbage collecting // the callback and GTK from successfully unreferencing its values. // // Below is an example piece of code that is considered "leaky": // // type ChatBox struct { // gtk.TextView // Loader *gdk.PixbufLoader // // State State // } // // func (box *ChatBox) Method() { // box.Loader.Connect("size-allocate", func(loader *gdk.PixbufLoader) { // // Here, we're dereferencing box to get the state, which might // // keep box alive along with the PixbufLoader, causing a circular // // reference. // loader.SetSize(box.State.Width, box.State.Height) // }) // } // // There are many solutions to fix the above piece of code. For example, // box.Loader could be discarded manually immediately after it's done by setting // it to nil, or the signal handle could be disconnected manually, or box could // be set to nil after its first call in the callback. func (v *Object) Connect(detailedSignal string, f interface{}) SignalHandle { return v.connectClosure(false, detailedSignal, f) } // ConnectAfter is a wrapper around g_signal_connect_closure(). The difference // between Connect and ConnectAfter is that the latter will be invoked after the // default handler, not before. For more information, refer to Connect. func (v *Object) ConnectAfter(detailedSignal string, f interface{}) SignalHandle { return v.connectClosure(true, detailedSignal, f) } // ClosureCheckReceiver, if true, will make GLib check for every single // closure's first argument to ensure that it is correct, otherwise it will // panic with a message warning about the possible circular references. The // receiver in this case is most often the first argument of the callback. // // This constant can be changed by using go.mod's replace directive for // debugging purposes. const ClosureCheckReceiver = false func (v *Object) connectClosure(after bool, detailedSignal string, f interface{}) SignalHandle { fs := closure.NewFuncStack(f, 2) if ClosureCheckReceiver { // This is a bit slow, but we could be careful. objValue, err := v.goValue() if err == nil { fsType := fs.Func.Type() if fsType.NumIn() < 1 { fs.Panicf("callback should have the object receiver to avoid circular references") } objType := reflect.TypeOf(objValue) if first := fsType.In(0); !objType.ConvertibleTo(first) { fs.Panicf("receiver not convertible to expected type %s, got %s", objType, first) } } // Allow the type check to fail if we can't get a value marshaler. This // rarely happens, but it might, and we want to at least allow working // around it. } cstr := C.CString(detailedSignal) defer C.free(unsafe.Pointer(cstr)) gclosure := ClosureNewFunc(fs) c := C.g_signal_connect_closure(C.gpointer(v.native()), (*C.gchar)(cstr), gclosure, gbool(after)) // TODO: There's a slight race condition here, where // g_signal_connect_closure may trigger signal callbacks before the signal // is registered. It is therefore ideal to have another intermediate ID to // pass into the connect function. This is not a big issue though, since // there isn't really any guarantee that signals should arrive until after // the Connect functions return successfully. closure.RegisterSignal(uint(c), unsafe.Pointer(gclosure)) return SignalHandle(c) } // ClosureNew creates a new GClosure and adds its callback function to the // internal registry. It's exported for visibility to other gotk3 packages and // should not be used in a regular application. func ClosureNew(f interface{}) *C.GClosure { return ClosureNewFunc(closure.NewFuncStack(f, 2)) } // ClosureNewFunc creates a new GClosure and adds its callback function to the // internal registry. It's exported for visibility to other gotk3 packages; it // cannot be used in application code, as package closure is part of the // internals. func ClosureNewFunc(funcStack closure.FuncStack) *C.GClosure { gclosure := C._g_closure_new() closure.Assign(unsafe.Pointer(gclosure), funcStack) return gclosure } // removeClosure removes a closure from the internal closures map. This is // needed to prevent a leak where Go code can access the closure context // (along with rf and userdata) even after an object has been destroyed and // the GClosure is invalidated and will never run. // //export removeClosure func removeClosure(_ C.gpointer, gclosure *C.GClosure) { closure.Delete(unsafe.Pointer(gclosure)) } gotk3-0.6.2/glib/finalizers.go000066400000000000000000000011021431157473000161570ustar00rootroot00000000000000package glib // Finalizer is a function that when called will finalize an object type Finalizer func() // FinalizerStrategy will be called by every runtime finalizer in gotk3 // The simple version will just call the finalizer given as an argument // but in larger programs this might cause problems with the UI thread. // The FinalizerStrategy function will always be called in the goroutine that // `runtime.SetFinalizer` uses. It is a `var` to explicitly allow clients to // change the strategy to something more advanced. var FinalizerStrategy = func(f Finalizer) { f() } gotk3-0.6.2/glib/gaction.go000066400000000000000000000145571431157473000154570ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import ( "unsafe" ) func init() { tm := []TypeMarshaler{ // Objects/Interfaces {Type(C.g_simple_action_get_type()), marshalSimpleAction}, {Type(C.g_action_get_type()), marshalAction}, {Type(C.g_property_action_get_type()), marshalPropertyAction}, } RegisterGValueMarshalers(tm) } // Action is a representation of glib's GAction GInterface. type Action struct { *Object } // IAction is an interface type implemented by all structs // embedding an Action. It is meant to be used as an argument type // for wrapper functions that wrap around a C function taking a // GAction. type IAction interface { toGAction() *C.GAction toAction() *Action } func (v *Action) toGAction() *C.GAction { if v == nil { return nil } return v.native() } func (v *Action) toAction() *Action { return v } // gboolean g_action_parse_detailed_name (const gchar *detailed_name, gchar **action_name, GVariant **target_value, GError **error); // ActionPrintDetailedName is a wrapper around g_action_print_detailed_name(). func ActionPrintDetailedName(action_name string, target_value *Variant) string { cstr := C.CString(action_name) defer C.free(unsafe.Pointer(cstr)) return C.GoString((*C.char)(C.g_action_print_detailed_name((*C.gchar)(cstr), target_value.native()))) } // native() returns a pointer to the underlying GAction. func (v *Action) native() *C.GAction { if v == nil || v.GObject == nil { return nil } return C.toGAction(unsafe.Pointer(v.GObject)) } func (v *Action) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalAction(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapAction(wrapObject(unsafe.Pointer(c))), nil } func wrapAction(obj *Object) *Action { return &Action{obj} } // ActionNameIsValid is a wrapper around g_action_name_is_valid func ActionNameIsValid(actionName string) bool { cstr := (*C.gchar)(C.CString(actionName)) return gobool(C.g_action_name_is_valid(cstr)) } // GetName is a wrapper around g_action_get_name func (v *Action) GetName() string { return C.GoString((*C.char)(C.g_action_get_name(v.native()))) } // GetEnabled is a wrapper around g_action_get_enabled func (v *Action) GetEnabled() bool { return gobool(C.g_action_get_enabled(v.native())) } // GetState is a wrapper around g_action_get_state func (v *Action) GetState() *Variant { c := C.g_action_get_state(v.native()) if c == nil { return nil } return newVariant((*C.GVariant)(c)) } // GetStateHint is a wrapper around g_action_get_state_hint func (v *Action) GetStateHint() *Variant { c := C.g_action_get_state_hint(v.native()) if c == nil { return nil } return newVariant((*C.GVariant)(c)) } // GetParameterType is a wrapper around g_action_get_parameter_type func (v *Action) GetParameterType() *VariantType { c := C.g_action_get_parameter_type(v.native()) if c == nil { return nil } return newVariantType((*C.GVariantType)(c)) } // GetStateType is a wrapper around g_action_get_state_type func (v *Action) GetStateType() *VariantType { c := C.g_action_get_state_type(v.native()) if c == nil { return nil } return newVariantType((*C.GVariantType)(c)) } // ChangeState is a wrapper around g_action_change_state func (v *Action) ChangeState(value *Variant) { C.g_action_change_state(v.native(), value.native()) } // Activate is a wrapper around g_action_activate func (v *Action) Activate(parameter *Variant) { C.g_action_activate(v.native(), parameter.native()) } // SimpleAction is a representation of GSimpleAction type SimpleAction struct { Action } func (v *SimpleAction) native() *C.GSimpleAction { if v == nil || v.GObject == nil { return nil } return C.toGSimpleAction(unsafe.Pointer(v.GObject)) } func (v *SimpleAction) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalSimpleAction(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapSimpleAction(wrapObject(unsafe.Pointer(c))), nil } func wrapSimpleAction(obj *Object) *SimpleAction { return &SimpleAction{Action{obj}} } // SimpleActionNew is a wrapper around g_simple_action_new func SimpleActionNew(name string, parameterType *VariantType) *SimpleAction { c := C.g_simple_action_new((*C.gchar)(C.CString(name)), parameterType.native()) if c == nil { return nil } return wrapSimpleAction(wrapObject(unsafe.Pointer(c))) } // SimpleActionNewStateful is a wrapper around g_simple_action_new_stateful func SimpleActionNewStateful(name string, parameterType *VariantType, state *Variant) *SimpleAction { c := C.g_simple_action_new_stateful((*C.gchar)(C.CString(name)), parameterType.native(), state.native()) if c == nil { return nil } return wrapSimpleAction(wrapObject(unsafe.Pointer(c))) } // SetEnabled is a wrapper around g_simple_action_set_enabled func (v *SimpleAction) SetEnabled(enabled bool) { C.g_simple_action_set_enabled(v.native(), gbool(enabled)) } // SetState is a wrapper around g_simple_action_set_state // This should only be called by the implementor of the action. // Users of the action should not attempt to directly modify the 'state' property. // Instead, they should call ChangeState [g_action_change_state()] to request the change. func (v *SimpleAction) SetState(value *Variant) { C.g_simple_action_set_state(v.native(), value.native()) } // PropertyAction is a representation of GPropertyAction type PropertyAction struct { Action } func (v *PropertyAction) native() *C.GPropertyAction { if v == nil || v.GObject == nil { return nil } return C.toGPropertyAction(unsafe.Pointer(v.GObject)) } func (v *PropertyAction) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalPropertyAction(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapPropertyAction(wrapObject(unsafe.Pointer(c))), nil } func wrapPropertyAction(obj *Object) *PropertyAction { return &PropertyAction{Action{obj}} } // PropertyActionNew is a wrapper around g_property_action_new func PropertyActionNew(name string, object *Object, propertyName string) *PropertyAction { c := C.g_property_action_new((*C.gchar)(C.CString(name)), C.gpointer(unsafe.Pointer(object.native())), (*C.gchar)(C.CString(propertyName))) if c == nil { return nil } return wrapPropertyAction(wrapObject(unsafe.Pointer(c))) } gotk3-0.6.2/glib/gactiongroup.go000066400000000000000000000074671431157473000165360ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" // IActionGroup is an interface representation of ActionGroup, // used to avoid duplication when embedding the type in a wrapper of another GObject-based type. type IActionGroup interface { Native() uintptr HasAction(actionName string) bool GetActionEnabled(actionName string) bool GetActionParameterType(actionName string) *VariantType GetActionStateType(actionName string) *VariantType GetActionState(actionName string) *Variant GetActionStateHint(actionName string) *Variant ChangeActionState(actionName string, value *Variant) Activate(actionName string, parameter *Variant) } // ActionGroup is a representation of glib's GActionGroup GInterface type ActionGroup struct { *Object } // g_action_group_list_actions() // g_action_group_query_action() // should only called from implementations: // g_action_group_action_added // g_action_group_action_removed // g_action_group_action_enabled_changed // g_action_group_action_state_changed // native() returns a pointer to the underlying GActionGroup. func (v *ActionGroup) native() *C.GActionGroup { if v == nil || v.GObject == nil { return nil } return C.toGActionGroup(unsafe.Pointer(v.GObject)) } func (v *ActionGroup) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalActionGroup(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapActionGroup(wrapObject(unsafe.Pointer(c))), nil } func wrapActionGroup(obj *Object) *ActionGroup { return &ActionGroup{obj} } // HasAction is a wrapper around g_action_group_has_action(). func (v *ActionGroup) HasAction(actionName string) bool { return gobool(C.g_action_group_has_action(v.native(), (*C.gchar)(C.CString(actionName)))) } // GetActionEnabled is a wrapper around g_action_group_get_action_enabled(). func (v *ActionGroup) GetActionEnabled(actionName string) bool { return gobool(C.g_action_group_get_action_enabled(v.native(), (*C.gchar)(C.CString(actionName)))) } // GetActionParameterType is a wrapper around g_action_group_get_action_parameter_type(). func (v *ActionGroup) GetActionParameterType(actionName string) *VariantType { c := C.g_action_group_get_action_parameter_type(v.native(), (*C.gchar)(C.CString(actionName))) if c == nil { return nil } return newVariantType((*C.GVariantType)(c)) } // GetActionStateType is a wrapper around g_action_group_get_action_state_type(). func (v *ActionGroup) GetActionStateType(actionName string) *VariantType { c := C.g_action_group_get_action_state_type(v.native(), (*C.gchar)(C.CString(actionName))) if c == nil { return nil } return newVariantType((*C.GVariantType)(c)) } // GetActionState is a wrapper around g_action_group_get_action_state(). func (v *ActionGroup) GetActionState(actionName string) *Variant { c := C.g_action_group_get_action_state(v.native(), (*C.gchar)(C.CString(actionName))) if c == nil { return nil } return newVariant((*C.GVariant)(c)) } // GetActionStateHint is a wrapper around g_action_group_get_action_state_hint(). func (v *ActionGroup) GetActionStateHint(actionName string) *Variant { c := C.g_action_group_get_action_state_hint(v.native(), (*C.gchar)(C.CString(actionName))) if c == nil { return nil } return newVariant((*C.GVariant)(c)) } // ChangeActionState is a wrapper around g_action_group_change_action_state func (v *ActionGroup) ChangeActionState(actionName string, value *Variant) { C.g_action_group_change_action_state(v.native(), (*C.gchar)(C.CString(actionName)), value.native()) } // Activate is a wrapper around g_action_group_activate_action func (v *ActionGroup) Activate(actionName string, parameter *Variant) { C.g_action_group_activate_action(v.native(), (*C.gchar)(C.CString(actionName)), parameter.native()) } gotk3-0.6.2/glib/gactionmap.go000066400000000000000000000035531431157473000161470ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" // IActionMap is an interface representation of ActionMap, // used to avoid duplication when embedding the type in a wrapper of another GObject-based type. type IActionMap interface { Native() uintptr LookupAction(actionName string) *Action AddAction(action IAction) RemoveAction(actionName string) } // ActionMap is a representation of glib's GActionMap GInterface type ActionMap struct { *Object } // void g_action_map_add_action_entries (GActionMap *action_map, const GActionEntry *entries, gint n_entries, gpointer user_data); // struct GActionEntry // native() returns a pointer to the underlying GActionMap. func (v *ActionMap) native() *C.GActionMap { if v == nil || v.GObject == nil { return nil } return C.toGActionMap(unsafe.Pointer(v.GObject)) } func (v *ActionMap) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalActionMap(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapActionMap(wrapObject(unsafe.Pointer(c))), nil } func wrapActionMap(obj *Object) *ActionMap { return &ActionMap{obj} } // LookupAction is a wrapper around g_action_map_lookup_action func (v *ActionMap) LookupAction(actionName string) *Action { c := C.g_action_map_lookup_action(v.native(), (*C.gchar)(C.CString(actionName))) if c == nil { return nil } return wrapAction(wrapObject(unsafe.Pointer(c))) } // AddAction is a wrapper around g_action_map_add_action func (v *ActionMap) AddAction(action IAction) { C.g_action_map_add_action(v.native(), action.toGAction()) } // RemoveAction is a wrapper around g_action_map_remove_action func (v *ActionMap) RemoveAction(actionName string) { C.g_action_map_remove_action(v.native(), (*C.gchar)(C.CString(actionName))) } gotk3-0.6.2/glib/gasyncresult.go000066400000000000000000000037371431157473000165540ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import ( "errors" "unsafe" ) // IAsyncResult is an interface representation of AsyncResult, // used to avoid duplication when embedding the type in a wrapper of another GObject-based type. type IAsyncResult interface { GetUserData() uintptr GetSourceObject() *Object IsTagged(sourceTag uintptr) bool LegacyPropagateError() error } // AsyncReadyCallback is a representation of GAsyncReadyCallback type AsyncReadyCallback func(object *Object, res *AsyncResult) // AsyncResult is a representation of GIO's GAsyncResult. type AsyncResult struct { *Object } // native() returns a pointer to the underlying GAsyncResult. func (v *AsyncResult) native() *C.GAsyncResult { if v == nil || v.GObject == nil { return nil } return C.toGAsyncResult(unsafe.Pointer(v.GObject)) } func wrapAsyncResult(obj *Object) *AsyncResult { return &AsyncResult{obj} } // GetUserData is a wrapper around g_async_result_get_user_data() func (v *AsyncResult) GetUserData() uintptr { c := C.g_async_result_get_user_data(v.native()) return uintptr(unsafe.Pointer(c)) } // GetSourceObject is a wrapper around g_async_result_get_source_object func (v *AsyncResult) GetSourceObject() *Object { obj := C.g_async_result_get_source_object(v.native()) if obj == nil { return nil } return wrapObject(unsafe.Pointer(obj)) } // IsTagged is a wrapper around g_async_result_is_tagged func (v *AsyncResult) IsTagged(sourceTag uintptr) bool { c := C.g_async_result_is_tagged(v.native(), C.gpointer(sourceTag)) return gobool(c) } // LegacyPropagateError is a wrapper around g_async_result_legacy_propagate_error func (v *AsyncResult) LegacyPropagateError() error { var err *C.GError c := C.g_async_result_legacy_propagate_error(v.native(), &err) isSimpleAsyncResult := gobool(c) if isSimpleAsyncResult { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } gotk3-0.6.2/glib/gbinding.go000066400000000000000000000040111431157473000155740ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" type BindingFlags int const ( BINDING_DEFAULT BindingFlags = C.G_BINDING_DEFAULT BINDING_BIDIRECTIONAL BindingFlags = C.G_BINDING_BIDIRECTIONAL BINDING_SYNC_CREATE = C.G_BINDING_SYNC_CREATE BINDING_INVERT_BOOLEAN = C.G_BINDING_INVERT_BOOLEAN ) type Binding struct { *Object } func (v *Binding) native() *C.GBinding { if v == nil || v.GObject == nil { return nil } return C.toGBinding(unsafe.Pointer(v.GObject)) } func marshalBinding(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return &Binding{wrapObject(unsafe.Pointer(c))}, nil } // Creates a binding between source property on source and target property on // target . Whenever the source property is changed the target_property is // updated using the same value. func BindProperty(source *Object, sourceProperty string, target *Object, targetProperty string, flags BindingFlags) *Binding { srcStr := (*C.gchar)(C.CString(sourceProperty)) defer C.free(unsafe.Pointer(srcStr)) tgtStr := (*C.gchar)(C.CString(targetProperty)) defer C.free(unsafe.Pointer(tgtStr)) obj := C.g_object_bind_property( C.gpointer(source.GObject), srcStr, C.gpointer(target.GObject), tgtStr, C.GBindingFlags(flags), ) if obj == nil { return nil } return &Binding{wrapObject(unsafe.Pointer(obj))} } // Explicitly releases the binding between the source and the target property // expressed by Binding func (v *Binding) Unbind() { C.g_binding_unbind(v.native()) } // Retrieves the name of the property of “target” used as the target of // the binding. func (v *Binding) GetTargetProperty() string { s := C.g_binding_get_target_property(v.native()) return C.GoString((*C.char)(s)) } // Retrieves the flags passed when constructing the GBinding. func (v *Binding) GetFlags() BindingFlags { flags := C.g_binding_get_flags(v.native()) return BindingFlags(flags) } gotk3-0.6.2/glib/gbinding_deprecated_since_2_68.go000066400000000000000000000011251431157473000216760ustar00rootroot00000000000000// +build glib_deprecated package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" // GetSource is a wrapper around g_binding_get_source(). func (v *Binding) GetSource() *Object { obj := C.g_binding_get_source(v.native()) if obj == nil { return nil } return wrapObject(unsafe.Pointer(obj)) } // GetTarget is a wrapper around g_binding_get_target(). func (v *Binding) GetTarget() *Object { obj := C.g_binding_get_target(v.native()) if obj == nil { return nil } return wrapObject(unsafe.Pointer(obj)) } gotk3-0.6.2/glib/gbinding_since_2_68.go000066400000000000000000000017201431157473000175170ustar00rootroot00000000000000//go:build !glib_deprecated && !glib_2_40 && !glib_2_42 && !glib_2_44 && !glib_2_46 && !glib_2_48 && !glib_2_50 && !glib_2_52 && !glib_2_54 && !glib_2_56 && !glib_2_58 && !glib_2_60 && !glib_2_62 && !glib_2_64 && !glib_2_66 // +build !glib_deprecated,!glib_2_40,!glib_2_42,!glib_2_44,!glib_2_46,!glib_2_48,!glib_2_50,!glib_2_52,!glib_2_54,!glib_2_56,!glib_2_58,!glib_2_60,!glib_2_62,!glib_2_64,!glib_2_66 package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" // DupSource is a wrapper around g_binding_dup_source(). func (v *Binding) DupSource() *Object { obj := C.g_binding_dup_source(v.native()) if obj == nil { return nil } return wrapObject(unsafe.Pointer(obj)) } // DupTarget is a wrapper around g_binding_dup_target(). func (v *Binding) DupTarget() *Object { obj := C.g_binding_dup_target(v.native()) if obj == nil { return nil } return wrapObject(unsafe.Pointer(obj)) } gotk3-0.6.2/glib/gcancellable.go000066400000000000000000000045451431157473000164230ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import ( "errors" "unsafe" ) // Cancellable is a representation of GIO's GCancellable. type Cancellable struct { *Object } // native returns a pointer to the underlying GCancellable. func (v *Cancellable) native() *C.GCancellable { if v == nil || v.GObject == nil { return nil } return C.toCancellable(unsafe.Pointer(v.GObject)) } func marshalCancellable(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapCancellable(wrapObject(unsafe.Pointer(c))), nil } func wrapCancellable(obj *Object) *Cancellable { return &Cancellable{obj} } // CancellableNew is a wrapper around g_cancellable_new(). func CancellableNew() (*Cancellable, error) { c := C.g_cancellable_new() if c == nil { return nil, nilPtrErr } return wrapCancellable(wrapObject(unsafe.Pointer(c))), nil } // IsCancelled is a wrapper around g_cancellable_is_cancelled(). func (v *Cancellable) IsCancelled() bool { c := C.g_cancellable_is_cancelled(v.native()) return gobool(c) } // SetErrorIfCancelled is a wrapper around g_cancellable_set_error_if_cancelled(). func (v *Cancellable) SetErrorIfCancelled() error { var err *C.GError c := C.g_cancellable_set_error_if_cancelled(v.native(), &err) cancelled := gobool(c) if cancelled { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // GetFD is a wrapper around g_cancellable_get_fd(). func (v *Cancellable) GetFD() int { c := C.g_cancellable_get_fd(v.native()) return int(c) } // MakePollFD is a wrapper around g_cancellable_make_pollfd(). // func (v *Cancellable) MakePollFD(pollFD *PollFD) bool { // c := C.g_cancellable_make_pollfd(v.native(), ) // return gobool(c) // } // ReleaseFD is a wrapper around g_cancellable_release_fd(). func (v *Cancellable) ReleaseFD() { C.g_cancellable_release_fd(v.native()) } // SourceNew is a wrapper around g_cancellable_source_new(). func (v *Cancellable) SourceNew() *Source { c := C.g_cancellable_source_new(v.native()) return wrapSource(c) } // Reset is a wrapper around g_cancellable_reset(). func (v *Cancellable) Reset() { C.g_cancellable_reset(v.native()) } // Cancel is a wrapper around g_cancellable_cancel(). func (v *Cancellable) Cancel() { C.g_cancellable_cancel(v.native()) } gotk3-0.6.2/glib/gfile.go000066400000000000000000000243011431157473000151050ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" // #include "gfile.go.h" import "C" import ( "errors" "unsafe" ) func init() { tm := []TypeMarshaler{ {Type(C.g_file_get_type()), marshalFile}, {Type(C.g_file_input_stream_get_type()), marshalFileInputStream}, {Type(C.g_file_output_stream_get_type()), marshalFileOutputStream}, } RegisterGValueMarshalers(tm) } func goString(cstr *C.gchar) string { return C.GoString((*C.char)(cstr)) } /* * GFile */ // File is a representation of GIO's GFile. type File struct { *Object } // native returns a pointer to the underlying GFile. func (v *File) native() *C.GFile { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGFile(p) } // NativePrivate: to be used inside Gotk3 only. func (v *File) NativePrivate() *C.GFile { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGFile(p) } // Native returns a pointer to the underlying GFile. func (v *File) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalFile(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := Take(unsafe.Pointer(c)) return wrapFile(obj), nil } func wrapFile(obj *Object) *File { return &File{obj} } // FileNew is a wrapper around g_file_new_for_path(). // To avoid breaking previous implementation of GFile ... func FileNew(path string) *File { f, e := FileNewForPath(path) if e != nil { return nil } return f } // FileNewForPath is a wrapper around g_file_new_for_path(). func FileNewForPath(path string) (*File, error) { cstr := (*C.char)(C.CString(path)) defer C.free(unsafe.Pointer(cstr)) c := C.g_file_new_for_path(cstr) if c == nil { return nil, nilPtrErr } return wrapFile(Take(unsafe.Pointer(c))), nil } // TODO g_file_*** and more /* void (*GFileProgressCallback) () gboolean (*GFileReadMoreCallback) () void (*GFileMeasureProgressCallback) () GFile * g_file_new_for_uri () GFile * g_file_new_for_commandline_arg () GFile * g_file_new_for_commandline_arg_and_cwd () GFile * g_file_new_tmp () GFile * g_file_parse_name () GFile * g_file_new_build_filename () GFile * g_file_dup () guint g_file_hash () gboolean g_file_equal () char * g_file_get_basename () */ /* char * g_file_get_path (GFile *file); */ // GetPath is a wrapper around g_file_get_path(). func (v *File) GetPath() string { var s string if c := C.g_file_get_path(v.native()); c != nil { s = C.GoString(c) defer C.g_free((C.gpointer)(c)) } return s } /* const char * g_file_peek_path () char * g_file_get_uri () char * g_file_get_parse_name () GFile * g_file_get_parent () gboolean g_file_has_parent () GFile * g_file_get_child () GFile * g_file_get_child_for_display_name () gboolean g_file_has_prefix () char * g_file_get_relative_path () GFile * g_file_resolve_relative_path () gboolean g_file_is_native () gboolean g_file_has_uri_scheme () char * g_file_get_uri_scheme () */ /* GFileInputStream * g_file_read (GFile *file, GCancellable *cancellable, GError **error); */ // Read is a wrapper around g_file_read(). // Object.Unref() must be used after use func (v *File) Read(cancellable *Cancellable) (*FileInputStream, error) { var gerr *C.GError c := C.g_file_read( v.native(), cancellable.native(), &gerr) if c == nil { defer C.g_error_free(gerr) return nil, errors.New(goString(gerr.message)) } return wrapFileInputStream(Take(unsafe.Pointer(c))), nil } /* void g_file_read_async () GFileInputStream * g_file_read_finish () GFileOutputStream * g_file_append_to () GFileOutputStream * g_file_create () GFileOutputStream * g_file_replace () void g_file_append_to_async () GFileOutputStream * g_file_append_to_finish () void g_file_create_async () GFileOutputStream * g_file_create_finish () void g_file_replace_async () GFileOutputStream * g_file_replace_finish () GFileInfo * g_file_query_info () void g_file_query_info_async () GFileInfo * g_file_query_info_finish () gboolean g_file_query_exists () GFileType g_file_query_file_type () GFileInfo * g_file_query_filesystem_info () void g_file_query_filesystem_info_async () GFileInfo * g_file_query_filesystem_info_finish () GAppInfo * g_file_query_default_handler () void g_file_query_default_handler_async () GAppInfo * g_file_query_default_handler_finish () gboolean g_file_measure_disk_usage () void g_file_measure_disk_usage_async () gboolean g_file_measure_disk_usage_finish () GMount * g_file_find_enclosing_mount () void g_file_find_enclosing_mount_async () GMount * g_file_find_enclosing_mount_finish () GFileEnumerator * g_file_enumerate_children () void g_file_enumerate_children_async () GFileEnumerator * g_file_enumerate_children_finish () GFile * g_file_set_display_name () void g_file_set_display_name_async () GFile * g_file_set_display_name_finish () gboolean g_file_delete () void g_file_delete_async () gboolean g_file_delete_finish () gboolean g_file_trash () void g_file_trash_async () gboolean g_file_trash_finish () gboolean g_file_copy () void g_file_copy_async () gboolean g_file_copy_finish () gboolean g_file_move () gboolean g_file_make_directory () void g_file_make_directory_async () gboolean g_file_make_directory_finish () gboolean g_file_make_directory_with_parents () gboolean g_file_make_symbolic_link () GFileAttributeInfoList * g_file_query_settable_attributes () GFileAttributeInfoList * g_file_query_writable_namespaces () gboolean g_file_set_attribute () gboolean g_file_set_attributes_from_info () void g_file_set_attributes_async () gboolean g_file_set_attributes_finish () gboolean g_file_set_attribute_string () gboolean g_file_set_attribute_byte_string () gboolean g_file_set_attribute_uint32 () gboolean g_file_set_attribute_int32 () gboolean g_file_set_attribute_uint64 () gboolean g_file_set_attribute_int64 () void g_file_mount_mountable () GFile * g_file_mount_mountable_finish () void g_file_unmount_mountable () gboolean g_file_unmount_mountable_finish () void g_file_unmount_mountable_with_operation () gboolean g_file_unmount_mountable_with_operation_finish () void g_file_eject_mountable () gboolean g_file_eject_mountable_finish () void g_file_eject_mountable_with_operation () gboolean g_file_eject_mountable_with_operation_finish () void g_file_start_mountable () gboolean g_file_start_mountable_finish () void g_file_stop_mountable () gboolean g_file_stop_mountable_finish () void g_file_poll_mountable () gboolean g_file_poll_mountable_finish () void g_file_mount_enclosing_volume () gboolean g_file_mount_enclosing_volume_finish () GFileMonitor * g_file_monitor_directory () GFileMonitor * g_file_monitor_file () GFileMonitor * g_file_monitor () GBytes * g_file_load_bytes () void g_file_load_bytes_async () GBytes * g_file_load_bytes_finish () gboolean g_file_load_contents () void g_file_load_contents_async () gboolean g_file_load_contents_finish () void g_file_load_partial_contents_async () gboolean g_file_load_partial_contents_finish () gboolean g_file_replace_contents () void g_file_replace_contents_async () void g_file_replace_contents_bytes_async () gboolean g_file_replace_contents_finish () gboolean g_file_copy_attributes () GFileIOStream * g_file_create_readwrite () void g_file_create_readwrite_async () GFileIOStream * g_file_create_readwrite_finish () GFileIOStream * g_file_open_readwrite () void g_file_open_readwrite_async () GFileIOStream * g_file_open_readwrite_finish () GFileIOStream * g_file_replace_readwrite () void g_file_replace_readwrite_async () GFileIOStream * g_file_replace_readwrite_finish () gboolean g_file_supports_thread_contexts () */ /* * GFileInputStream */ // FileInputStream is a representation of GIO's GFileInputStream. type FileInputStream struct { *InputStream } // native returns a pointer to the underlying GFileInputStream. func (v *FileInputStream) native() *C.GFileInputStream { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGFileInputStream(p) } // NativePrivate: to be used inside Gotk3 only. func (v *FileInputStream) NativePrivate() *C.GFileInputStream { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGFileInputStream(p) } // Native returns a pointer to the underlying GFileInputStream. func (v *FileInputStream) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalFileInputStream(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := Take(unsafe.Pointer(c)) return wrapFileInputStream(obj), nil } func wrapFileInputStream(obj *Object) *FileInputStream { return &FileInputStream{wrapInputStream(obj)} } // TODO g_file_input_stream_query_info and more /* GFileInfo * g_file_input_stream_query_info () void g_file_input_stream_query_info_async () GFileInfo * g_file_input_stream_query_info_finish () */ /* * GFileOutputStream */ // FileOutputStream is a representation of GIO's GFileOutputStream. type FileOutputStream struct { *OutputStream } // native returns a pointer to the underlying GFileOutputStream. func (v *FileOutputStream) native() *C.GFileOutputStream { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGFileOutputStream(p) } // NativePrivate: to be used inside Gotk3 only. func (v *FileOutputStream) NativePrivate() *C.GFileOutputStream { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGFileOutputStream(p) } // Native returns a pointer to the underlying GFileOutputStream. func (v *FileOutputStream) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalFileOutputStream(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := Take(unsafe.Pointer(c)) return wrapFileOutputStream(obj), nil } func wrapFileOutputStream(obj *Object) *FileOutputStream { return &FileOutputStream{wrapOutputStream(obj)} } // TODO g_file_output_stream_query_info and more /* GFileInfo * g_file_output_stream_query_info () void g_file_output_stream_query_info_async () GFileInfo * g_file_output_stream_query_info_finish () char * g_file_output_stream_get_etag () */ gotk3-0.6.2/glib/gfile.go.h000066400000000000000000000004161431157473000153340ustar00rootroot00000000000000#include #include #include #include static GFileInputStream *toGFileInputStream(void *p) { return (G_FILE_INPUT_STREAM(p)); } static GFileOutputStream *toGFileOutputStream(void *p) { return (G_FILE_OUTPUT_STREAM(p)); } gotk3-0.6.2/glib/gicon.go000066400000000000000000000072631431157473000151260ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import ( "errors" "runtime" "unsafe" ) func init() { tm := []TypeMarshaler{ {Type(C.g_file_get_type()), marshalFile}, {Type(C.g_file_icon_get_type()), marshalFileIcon}, } RegisterGValueMarshalers(tm) } /* * GIcon */ // Icon is a representation of GIO's GIcon. // Interface for icons type Icon struct { *Object } // native returns a pointer to the underlying GIcon. func (v *Icon) native() *C.GIcon { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGIcon(p) } // NativePrivate: to be used inside Gotk3 only. func (v *Icon) NativePrivate() *C.GIcon { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGIcon(p) } // Native returns a pointer to the underlying GIcon. func (v *Icon) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalIcon(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := Take(unsafe.Pointer(c)) return wrapIcon(obj), nil } func wrapIcon(obj *Object) *Icon { return &Icon{obj} } // TODO I dont know how to handle it ... /* guint g_icon_hash (gconstpointer icon); */ // Equal is a wrapper around g_icon_equal(). func (v *Icon) Equal(icon *Icon) bool { return gobool(C.g_icon_equal(v.native(), icon.native())) } // ToString is a wrapper around g_icon_to_string(). func (v *Icon) ToString() string { var s string if c := C.g_icon_to_string(v.native()); c != nil { s = goString(c) defer C.g_free((C.gpointer)(c)) } return s } // IconNewForString is a wrapper around g_icon_new_for_string(). func IconNewForString(str string) (*Icon, error) { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) var err *C.GError c := C.g_icon_new_for_string((*C.gchar)(cstr), &err) if c == nil { defer C.g_error_free(err) return nil, errors.New(C.GoString((*C.char)(err.message))) } obj := &Object{ToGObject(unsafe.Pointer(c))} i := &Icon{obj} runtime.SetFinalizer(i, func(_ interface{}) { FinalizerStrategy(obj.Unref) }) return i, nil } // TODO Requiere GVariant /* GVariant * g_icon_serialize () GIcon * g_icon_deserialize () */ /* * GFileIcon */ // FileIcon is a representation of GIO's GFileIcon. type FileIcon struct { *Object } // native returns a pointer to the underlying GFileIcon. func (v *FileIcon) native() *C.GFileIcon { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGFileIcon(p) } // NativePrivate: to be used inside Gotk3 only. func (v *FileIcon) NativePrivate() *C.GFileIcon { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGFileIcon(p) } // Native returns a pointer to the underlying GFileIcon. func (v *FileIcon) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalFileIcon(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := Take(unsafe.Pointer(c)) return wrapFileIcon(obj), nil } func wrapFileIcon(obj *Object) *FileIcon { return &FileIcon{obj} } // FileIconNewN is a wrapper around g_file_icon_new(). // This version respect Gtk3 documentation. func FileIconNewN(file *File) (*Icon, error) { c := C.g_file_icon_new(file.native()) if c == nil { return nil, nilPtrErr } return wrapIcon(Take(unsafe.Pointer(c))), nil } // FileIconNew is a wrapper around g_file_icon_new(). // To not break previous implementation of GFileIcon ... func FileIconNew(path string) *Icon { file := FileNew(path) c := C.g_file_icon_new(file.native()) if c == nil { return nil } return wrapIcon(Take(unsafe.Pointer(c))) } gotk3-0.6.2/glib/giostream.go000066400000000000000000000261351431157473000160200ustar00rootroot00000000000000package glib // #cgo pkg-config: gio-2.0 glib-2.0 gobject-2.0 // #include // #include // #include "giostream.go.h" import "C" import ( "bytes" "errors" "unsafe" ) func init() { tm := []TypeMarshaler{ {Type(C.g_io_stream_get_type()), marshalIOStream}, {Type(C.g_output_stream_get_type()), marshalOutputStream}, {Type(C.g_input_stream_get_type()), marshalInputStream}, } RegisterGValueMarshalers(tm) } // OutputStreamSpliceFlags is a representation of GTK's GOutputStreamSpliceFlags. type OutputStreamSpliceFlags int const ( OUTPUT_STREAM_SPLICE_NONE OutputStreamSpliceFlags = C.G_OUTPUT_STREAM_SPLICE_NONE OUTPUT_STREAM_SPLICE_CLOSE_SOURCE = C.G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE OUTPUT_STREAM_SPLICE_CLOSE_TARGET = C.G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET ) /* * GIOStream */ // IOStream is a representation of GIO's GIOStream. // Base class for implementing read/write streams type IOStream struct { *Object } // native returns a pointer to the underlying GIOStream. func (v *IOStream) native() *C.GIOStream { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGIOStream(p) } // NativePrivate: to be used inside Gotk3 only. func (v *IOStream) NativePrivate() *C.GIOStream { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGIOStream(p) } // Native returns a pointer to the underlying GIOStream. func (v *IOStream) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalIOStream(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := Take(unsafe.Pointer(c)) return wrapIOStream(obj), nil } func wrapIOStream(obj *Object) *IOStream { return &IOStream{obj} } /* GInputStream * g_io_stream_get_input_stream () GOutputStream * g_io_stream_get_output_stream () void g_io_stream_splice_async () gboolean g_io_stream_splice_finish () */ // Close is a wrapper around g_io_stream_close(). func (v *IOStream) Close(cancellable *Cancellable) (bool, error) { var gerr *C.GError ok := gobool(C.g_io_stream_close( v.native(), cancellable.native(), &gerr)) if !ok { defer C.g_error_free(gerr) return false, errors.New(goString(gerr.message)) } return ok, nil } /* void g_io_stream_close_async () gboolean g_io_stream_close_finish () gboolean g_io_stream_is_closed () gboolean g_io_stream_has_pending () gboolean g_io_stream_set_pending () void g_io_stream_clear_pending () */ /* * GInputStream */ // InputStream is a representation of GIO's GInputStream. // Base class for implementing streaming input type InputStream struct { *Object } // native returns a pointer to the underlying GInputStream. func (v *InputStream) native() *C.GInputStream { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGInputStream(p) } // NativePrivate: to be used inside Gotk3 only. func (v *InputStream) NativePrivate() *C.GInputStream { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGInputStream(p) } // Native returns a pointer to the underlying GInputStream. func (v *InputStream) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalInputStream(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := Take(unsafe.Pointer(c)) return wrapInputStream(obj), nil } func wrapInputStream(obj *Object) *InputStream { return &InputStream{obj} } // Read is a wrapper around g_input_stream_read(). func (v *InputStream) Read(length uint, cancellable *Cancellable) (*bytes.Buffer, int, error) { var gerr *C.GError var buffer = bytes.NewBuffer(make([]byte, length)) c := C.g_input_stream_read( v.native(), unsafe.Pointer(&buffer.Bytes()[0]), C.gsize(length), cancellable.native(), &gerr) if c == -1 { defer C.g_error_free(gerr) return nil, -1, errors.New(goString(gerr.message)) } return buffer, int(c), nil } // TODO find a way to get size to be read without asking for ... /* gboolean g_input_stream_read_all (GInputStream *stream, void *buffer, gsize count, gsize *bytes_read, GCancellable *cancellable, GError **error); */ /* void g_input_stream_read_all_async () gboolean g_input_stream_read_all_finish () gssize g_input_stream_skip () */ // Close is a wrapper around g_input_stream_close(). func (v *InputStream) Close(cancellable *Cancellable) (bool, error) { var gerr *C.GError ok := gobool(C.g_input_stream_close( v.native(), cancellable.native(), &gerr)) if !ok { defer C.g_error_free(gerr) return false, errors.New(goString(gerr.message)) } return ok, nil } // TODO g_input_stream*** /* void g_input_stream_read_async () gssize g_input_stream_read_finish () void g_input_stream_skip_async () gssize g_input_stream_skip_finish () void g_input_stream_close_async () gboolean g_input_stream_close_finish () */ // IsClosed is a wrapper around g_input_stream_is_closed(). func (v *InputStream) IsClosed() bool { return gobool(C.g_input_stream_is_closed(v.native())) } // HasPending is a wrapper around g_input_stream_has_pending(). func (v *InputStream) HasPending() bool { return gobool(C.g_input_stream_has_pending(v.native())) } // SetPending is a wrapper around g_input_stream_set_pending(). func (v *InputStream) SetPending() (bool, error) { var gerr *C.GError ok := gobool(C.g_input_stream_set_pending( v.native(), &gerr)) if !ok { defer C.g_error_free(gerr) return false, errors.New(goString(gerr.message)) } return ok, nil } // ClearPending is a wrapper around g_input_stream_clear_pending(). func (v *InputStream) ClearPending() { C.g_input_stream_clear_pending(v.native()) } /* Useless functions due to Go language specification and actual implementation of (*InputStream).Read that do same thing. GBytes * g_input_stream_read_bytes () void g_input_stream_read_bytes_async () GBytes * g_input_stream_read_bytes_finish () */ /* * GOutputStream */ // OutputStream is a representation of GIO's GOutputStream. // Base class for implementing streaming output type OutputStream struct { *Object } // native returns a pointer to the underlying GOutputStream. func (v *OutputStream) native() *C.GOutputStream { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGOutputStream(p) } // NativePrivate: to be used inside Gotk3 only. func (v *OutputStream) NativePrivate() *C.GOutputStream { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGOutputStream(p) } // Native returns a pointer to the underlying GOutputStream. func (v *OutputStream) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalOutputStream(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := Take(unsafe.Pointer(c)) return wrapOutputStream(obj), nil } func wrapOutputStream(obj *Object) *OutputStream { return &OutputStream{obj} } /* gssize g_output_stream_write (GOutputStream *stream, const void *buffer, gsize count, GCancellable *cancellable, GError **error); */ // Write is a wrapper around g_output_stream_write(). // buffer := bytes.NewBuffer(make([]byte, length)) func (v *OutputStream) Write(buffer *bytes.Buffer, cancellable *Cancellable) (int, error) { var gerr *C.GError length := buffer.Len() c := C.g_output_stream_write( v.native(), unsafe.Pointer(&buffer.Bytes()[0]), C.gsize(length), cancellable.native(), &gerr) if c == -1 { defer C.g_error_free(gerr) return -1, errors.New(goString(gerr.message)) } return int(c), nil } // Write is a wrapper around g_output_stream_write(). // func (v *OutputStream) Write(buffer *[]byte, cancellable *Cancellable) (int, error) { // // cdata := C.CString(data) // // defer C.free(unsafe.Pointer(cdata)) // var gerr *C.GError // c := C.g_output_stream_write( // v.native(), // unsafe.Pointer(buffer), // C.gsize(len(*buffer)), // cancellable.native(), // &gerr) // if c == -1 { // defer C.g_error_free(gerr) // return 0, errors.New(goString(gerr.message)) // } // return int(c), nil // } /* gboolean g_output_stream_write_all () */ // TODO outputStream asynch functions /* void g_output_stream_write_all_async () gboolean g_output_stream_write_all_finish () gboolean g_output_stream_writev () gboolean g_output_stream_writev_all () void g_output_stream_writev_async () gboolean g_output_stream_writev_finish () void g_output_stream_writev_all_async () gboolean g_output_stream_writev_all_finish () */ /* gssize g_output_stream_splice (GOutputStream *stream, GInputStream *source, GOutputStreamSpliceFlags flags, GCancellable *cancellable, GError **error); */ // Flush is a wrapper around g_output_stream_flush(). func (v *OutputStream) Flush(cancellable *Cancellable) (bool, error) { var gerr *C.GError ok := gobool(C.g_output_stream_flush( v.native(), cancellable.native(), &gerr)) if !ok { defer C.g_error_free(gerr) return false, errors.New(goString(gerr.message)) } return ok, nil } // Close is a wrapper around g_output_stream_close(). func (v *OutputStream) Close(cancellable *Cancellable) (bool, error) { var gerr *C.GError ok := gobool(C.g_output_stream_close( v.native(), cancellable.native(), &gerr)) if !ok { defer C.g_error_free(gerr) return false, errors.New(goString(gerr.message)) } return ok, nil } // TODO outputStream asynch functions /* void g_output_stream_write_async () gssize g_output_stream_write_finish () void g_output_stream_splice_async () gssize g_output_stream_splice_finish () void g_output_stream_flush_async () gboolean g_output_stream_flush_finish () void g_output_stream_close_async () gboolean g_output_stream_close_finish () */ // IsClosing is a wrapper around g_output_stream_is_closing(). func (v *OutputStream) IsClosing() bool { return gobool(C.g_output_stream_is_closing(v.native())) } // IsClosed is a wrapper around g_output_stream_is_closed(). func (v *OutputStream) IsClosed() bool { return gobool(C.g_output_stream_is_closed(v.native())) } // HasPending is a wrapper around g_output_stream_has_pending(). func (v *OutputStream) HasPending() bool { return gobool(C.g_output_stream_has_pending(v.native())) } // SetPending is a wrapper around g_output_stream_set_pending(). func (v *OutputStream) SetPending() (bool, error) { var gerr *C.GError ok := gobool(C.g_output_stream_set_pending( v.native(), &gerr)) if !ok { defer C.g_error_free(gerr) return false, errors.New(goString(gerr.message)) } return ok, nil } // ClearPending is a wrapper around g_output_stream_clear_pending(). func (v *OutputStream) ClearPending() { C.g_output_stream_clear_pending(v.native()) } /* gssize g_output_stream_write_bytes () void g_output_stream_write_bytes_async () gssize g_output_stream_write_bytes_finish () gboolean g_output_stream_printf () gboolean g_output_stream_vprintf () */ gotk3-0.6.2/glib/giostream.go.h000066400000000000000000000005501431157473000162370ustar00rootroot00000000000000#pragma once #include #include #include #include #include #include static GIOStream *toGIOStream(void *p) { return (G_IO_STREAM(p)); } static GInputStream *toGInputStream(void *p) { return (G_INPUT_STREAM(p)); } static GOutputStream *toGOutputStream(void *p) { return (G_OUTPUT_STREAM(p)); } gotk3-0.6.2/glib/glib.go000066400000000000000000001216211431157473000147370ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // Package glib provides Go bindings for GLib 2. It supports version 2.36 and // later. package glib // #cgo pkg-config: gio-2.0 glib-2.0 gobject-2.0 // #include // #include // #include // #include // #include "glib.go.h" import "C" import ( "errors" "fmt" "reflect" "runtime" "unsafe" "github.com/gotk3/gotk3/internal/callback" "github.com/gotk3/gotk3/internal/closure" ) /* * Type conversions */ func gbool(b bool) C.gboolean { if b { return C.gboolean(1) } return C.gboolean(0) } func gobool(b C.gboolean) bool { if b != 0 { return true } return false } /* * Unexported vars */ var nilPtrErr = errors.New("cgo returned unexpected nil pointer") /* * Constants */ // Type is a representation of GLib's GType. type Type uint const ( TYPE_INVALID Type = C.G_TYPE_INVALID TYPE_NONE Type = C.G_TYPE_NONE TYPE_INTERFACE Type = C.G_TYPE_INTERFACE TYPE_CHAR Type = C.G_TYPE_CHAR TYPE_UCHAR Type = C.G_TYPE_UCHAR TYPE_BOOLEAN Type = C.G_TYPE_BOOLEAN TYPE_INT Type = C.G_TYPE_INT TYPE_UINT Type = C.G_TYPE_UINT TYPE_LONG Type = C.G_TYPE_LONG TYPE_ULONG Type = C.G_TYPE_ULONG TYPE_INT64 Type = C.G_TYPE_INT64 TYPE_UINT64 Type = C.G_TYPE_UINT64 TYPE_ENUM Type = C.G_TYPE_ENUM TYPE_FLAGS Type = C.G_TYPE_FLAGS TYPE_FLOAT Type = C.G_TYPE_FLOAT TYPE_DOUBLE Type = C.G_TYPE_DOUBLE TYPE_STRING Type = C.G_TYPE_STRING TYPE_POINTER Type = C.G_TYPE_POINTER TYPE_BOXED Type = C.G_TYPE_BOXED TYPE_PARAM Type = C.G_TYPE_PARAM TYPE_OBJECT Type = C.G_TYPE_OBJECT TYPE_VARIANT Type = C.G_TYPE_VARIANT ) // IsValue checks whether the passed in type can be used for g_value_init(). func (t Type) IsValue() bool { return gobool(C._g_type_is_value(C.GType(t))) } // Name is a wrapper around g_type_name(). func (t Type) Name() string { return C.GoString((*C.char)(C.g_type_name(C.GType(t)))) } // Depth is a wrapper around g_type_depth(). func (t Type) Depth() uint { return uint(C.g_type_depth(C.GType(t))) } // Parent is a wrapper around g_type_parent(). func (t Type) Parent() Type { return Type(C.g_type_parent(C.GType(t))) } // IsA is a wrapper around g_type_is_a(). func (t Type) IsA(isAType Type) bool { return gobool(C.g_type_is_a(C.GType(t), C.GType(isAType))) } // TypeFromName is a wrapper around g_type_from_name func TypeFromName(typeName string) Type { cstr := (*C.gchar)(C.CString(typeName)) defer C.free(unsafe.Pointer(cstr)) return Type(C.g_type_from_name(cstr)) } //TypeNextBase is a wrapper around g_type_next_base func TypeNextBase(leafType, rootType Type) Type { return Type(C.g_type_next_base(C.GType(leafType), C.GType(rootType))) } // SettingsBindFlags is a representation of GLib's GSettingsBindFlags. type SettingsBindFlags int const ( SETTINGS_BIND_DEFAULT SettingsBindFlags = C.G_SETTINGS_BIND_DEFAULT SETTINGS_BIND_GET SettingsBindFlags = C.G_SETTINGS_BIND_GET SETTINGS_BIND_SET SettingsBindFlags = C.G_SETTINGS_BIND_SET SETTINGS_BIND_NO_SENSITIVITY SettingsBindFlags = C.G_SETTINGS_BIND_NO_SENSITIVITY SETTINGS_BIND_GET_NO_CHANGES SettingsBindFlags = C.G_SETTINGS_BIND_GET_NO_CHANGES SETTINGS_BIND_INVERT_BOOLEAN SettingsBindFlags = C.G_SETTINGS_BIND_INVERT_BOOLEAN ) // UserDirectory is a representation of GLib's GUserDirectory. type UserDirectory int const ( USER_DIRECTORY_DESKTOP UserDirectory = C.G_USER_DIRECTORY_DESKTOP USER_DIRECTORY_DOCUMENTS UserDirectory = C.G_USER_DIRECTORY_DOCUMENTS USER_DIRECTORY_DOWNLOAD UserDirectory = C.G_USER_DIRECTORY_DOWNLOAD USER_DIRECTORY_MUSIC UserDirectory = C.G_USER_DIRECTORY_MUSIC USER_DIRECTORY_PICTURES UserDirectory = C.G_USER_DIRECTORY_PICTURES USER_DIRECTORY_PUBLIC_SHARE UserDirectory = C.G_USER_DIRECTORY_PUBLIC_SHARE USER_DIRECTORY_TEMPLATES UserDirectory = C.G_USER_DIRECTORY_TEMPLATES USER_DIRECTORY_VIDEOS UserDirectory = C.G_USER_DIRECTORY_VIDEOS ) const USER_N_DIRECTORIES int = C.G_USER_N_DIRECTORIES /* * GApplicationFlags */ type ApplicationFlags int const ( APPLICATION_FLAGS_NONE ApplicationFlags = C.G_APPLICATION_FLAGS_NONE APPLICATION_IS_SERVICE ApplicationFlags = C.G_APPLICATION_IS_SERVICE APPLICATION_HANDLES_OPEN ApplicationFlags = C.G_APPLICATION_HANDLES_OPEN APPLICATION_HANDLES_COMMAND_LINE ApplicationFlags = C.G_APPLICATION_HANDLES_COMMAND_LINE APPLICATION_SEND_ENVIRONMENT ApplicationFlags = C.G_APPLICATION_SEND_ENVIRONMENT APPLICATION_NON_UNIQUE ApplicationFlags = C.G_APPLICATION_NON_UNIQUE ) // goMarshal is called by the GLib runtime when a closure needs to be invoked. // The closure will be invoked with as many arguments as it can take, from 0 to // the full amount provided by the call. If the closure asks for more parameters // than there are to give, then a runtime panic will occur. // //export goMarshal func goMarshal( gclosure *C.GClosure, retValue *C.GValue, nParams C.guint, params *C.GValue, invocationHint C.gpointer, marshalData *C.GValue) { // Get the function value associated with this callback closure. fs := closure.Get(unsafe.Pointer(gclosure)) if !fs.IsValid() { // Possible data race, bail. return } fsType := fs.Func.Type() // Get number of parameters passed in. nGLibParams := int(nParams) nTotalParams := nGLibParams // Reflect may panic, so we defer recover here to re-panic with our trace. defer fs.TryRepanic() // Get number of parameters from the callback closure. If this exceeds // the total number of marshaled parameters, trigger a runtime panic. nCbParams := fsType.NumIn() if nCbParams > nTotalParams { fs.Panicf("too many closure args: have %d, max %d", nCbParams, nTotalParams) } // Create a slice of reflect.Values as arguments to call the function. gValues := gValueSlice(params, nCbParams) args := make([]reflect.Value, 0, nCbParams) // Fill beginning of args, up to the minimum of the total number of callback // parameters and parameters from the glib runtime. for i := 0; i < nCbParams && i < nGLibParams; i++ { v := Value{&gValues[i]} val, err := v.GoValue() if err != nil { fs.Panicf("no suitable Go value for arg %d: %v", i, err) } // Parameters that are descendants of GObject come wrapped in another // GObject. For C applications, the default marshaller // (g_cclosure_marshal_VOID__VOID in gmarshal.c in the GTK glib library) // 'peeks' into the enclosing object and passes the wrapped object to // the handler. Use the *Object.goValue function to emulate that for Go // signal handlers. switch objVal := val.(type) { case *Object: if innerVal, err := objVal.goValue(); err == nil { val = innerVal } case *Variant: switch ts := objVal.TypeString(); ts { case "s": val = objVal.GetString() case "b": val = gobool(C.g_variant_get_boolean(objVal.native())) case "d": val = float64(C.g_variant_get_double(objVal.native())) case "n": val = int16(C.g_variant_get_int16(objVal.native())) case "i": val = int32(C.g_variant_get_int32(objVal.native())) case "x": val = int64(C.g_variant_get_int64(objVal.native())) case "y": val = uint8(C.g_variant_get_byte(objVal.native())) case "q": val = uint16(C.g_variant_get_uint16(objVal.native())) case "u": val = uint32(C.g_variant_get_uint32(objVal.native())) case "t": val = uint64(C.g_variant_get_uint64(objVal.native())) default: fs.Panicf("variant conversion not yet implemented for type %s", ts) } } args = append(args, reflect.ValueOf(val).Convert(fsType.In(i))) } // Call closure with args. If the callback returns one or more values, save // the GValue equivalent of the first. rv := fs.Func.Call(args) if retValue != nil && len(rv) > 0 { g, err := GValue(rv[0].Interface()) if err != nil { fs.Panicf("cannot save callback return value: %v", err) } t, _, err := g.Type() if err != nil { fs.Panicf("cannot determine callback return value: %v", err) } // Explicitly copy the return value as it may point to go-owned memory. C.g_value_unset(retValue) C.g_value_init(retValue, C.GType(t)) C.g_value_copy(g.native(), retValue) } } // gValueSlice converts a C array of GValues to a Go slice. func gValueSlice(values *C.GValue, nValues int) (slice []C.GValue) { header := (*reflect.SliceHeader)((unsafe.Pointer(&slice))) header.Cap = nValues header.Len = nValues header.Data = uintptr(unsafe.Pointer(values)) return } /* * Main event loop */ // Priority is the enumerated type for GLib priority event sources. type Priority int const ( PRIORITY_HIGH Priority = C.G_PRIORITY_HIGH PRIORITY_DEFAULT Priority = C.G_PRIORITY_DEFAULT // TimeoutAdd PRIORITY_HIGH_IDLE Priority = C.G_PRIORITY_HIGH_IDLE PRIORITY_DEFAULT_IDLE Priority = C.G_PRIORITY_DEFAULT_IDLE // IdleAdd PRIORITY_LOW Priority = C.G_PRIORITY_LOW ) type SourceHandle uint // sourceFunc is the callback for g_idle_add_full and g_timeout_add_full that // replaces the GClosure API. // //export sourceFunc func sourceFunc(data C.gpointer) C.gboolean { v := callback.Get(uintptr(data)) fs := v.(closure.FuncStack) rv := fs.Func.Call(nil) if len(rv) == 1 && rv[0].Bool() { return C.TRUE } return C.FALSE } //export removeSourceFunc func removeSourceFunc(data C.gpointer) { callback.Delete(uintptr(data)) } var ( _sourceFunc = (*[0]byte)(C.sourceFunc) _removeSourceFunc = (*[0]byte)(C.removeSourceFunc) ) // IdleAdd adds an idle source to the default main event loop context with the // DefaultIdle priority. If f is not a function with no parameter, then IdleAdd // will panic. // // After running once, the source func will be removed from the main event loop, // unless f returns a single bool true. func IdleAdd(f interface{}) SourceHandle { return idleAdd(PRIORITY_DEFAULT_IDLE, f) } // IdleAddPriority adds an idle source to the default main event loop context // with the given priority. Its behavior is the same as IdleAdd. func IdleAddPriority(priority Priority, f interface{}) SourceHandle { return idleAdd(priority, f) } func idleAdd(priority Priority, f interface{}) SourceHandle { fs := closure.NewIdleFuncStack(f, 2) id := C.gpointer(callback.Assign(fs)) h := C.g_idle_add_full(C.gint(priority), _sourceFunc, id, _removeSourceFunc) return SourceHandle(h) } // TimeoutAdd adds an timeout source to the default main event loop context. // Timeout is in milliseconds. If f is not a function with no parameter, then it // will panic. // // After running once, the source func will be removed from the main event loop, // unless f returns a single bool true. func TimeoutAdd(milliseconds uint, f interface{}) SourceHandle { return timeoutAdd(milliseconds, false, PRIORITY_DEFAULT, f) } // TimeoutAddPriority is similar to TimeoutAdd with the given priority. Refer to // TimeoutAdd for more information. func TimeoutAddPriority(milliseconds uint, priority Priority, f interface{}) SourceHandle { return timeoutAdd(milliseconds, false, priority, f) } // TimeoutSecondsAdd is similar to TimeoutAdd, except with seconds granularity. func TimeoutSecondsAdd(seconds uint, f interface{}) SourceHandle { return timeoutAdd(seconds, true, PRIORITY_DEFAULT, f) } // TimeoutSecondsAddPriority adds a timeout source with the given priority. // Refer to TimeoutSecondsAdd for more information. func TimeoutSecondsAddPriority(seconds uint, priority Priority, f interface{}) SourceHandle { return timeoutAdd(seconds, true, priority, f) } func timeoutAdd(time uint, sec bool, priority Priority, f interface{}) SourceHandle { fs := closure.NewIdleFuncStack(f, 2) id := C.gpointer(callback.Assign(fs)) var h C.guint if sec { h = C.g_timeout_add_seconds_full(C.gint(priority), C.guint(time), _sourceFunc, id, _removeSourceFunc) } else { h = C.g_timeout_add_full(C.gint(priority), C.guint(time), _sourceFunc, id, _removeSourceFunc) } return SourceHandle(h) } // Destroy is a wrapper around g_source_destroy() func (v *Source) Destroy() { C.g_source_destroy(v.native()) } // IsDestroyed is a wrapper around g_source_is_destroyed() func (v *Source) IsDestroyed() bool { return gobool(C.g_source_is_destroyed(v.native())) } // Unref is a wrapper around g_source_unref() func (v *Source) Unref() { C.g_source_unref(v.native()) } // Ref is a wrapper around g_source_ref() func (v *Source) Ref() *Source { c := C.g_source_ref(v.native()) if c == nil { return nil } return (*Source)(c) } // SourceRemove is a wrapper around g_source_remove() func SourceRemove(src SourceHandle) bool { return gobool(C.g_source_remove(C.guint(src))) } /* * Miscellaneous Utility Functions */ // GetHomeDir is a wrapper around g_get_home_dir(). func GetHomeDir() string { c := C.g_get_home_dir() return C.GoString((*C.char)(c)) } // GetUserCacheDir is a wrapper around g_get_user_cache_dir(). func GetUserCacheDir() string { c := C.g_get_user_cache_dir() return C.GoString((*C.char)(c)) } // GetUserDataDir is a wrapper around g_get_user_data_dir(). func GetUserDataDir() string { c := C.g_get_user_data_dir() return C.GoString((*C.char)(c)) } // GetUserConfigDir is a wrapper around g_get_user_config_dir(). func GetUserConfigDir() string { c := C.g_get_user_config_dir() return C.GoString((*C.char)(c)) } // GetUserRuntimeDir is a wrapper around g_get_user_runtime_dir(). func GetUserRuntimeDir() string { c := C.g_get_user_runtime_dir() return C.GoString((*C.char)(c)) } // GetUserSpecialDir is a wrapper around g_get_user_special_dir(). A // non-nil error is returned in the case that g_get_user_special_dir() // returns NULL to differentiate between NULL and an empty string. func GetUserSpecialDir(directory UserDirectory) (string, error) { c := C.g_get_user_special_dir(C.GUserDirectory(directory)) if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // FormatSize is a wrapper around g_format_size(). func FormatSize(size uint64) string { char := C.g_format_size(C.guint64(size)) defer C.free(unsafe.Pointer(char)) return C.GoString(char) } // FormatSizeFlags are flags to modify the format of the string returned by // FormatSizeFull. type FormatSizeFlags int const ( FORMAT_SIZE_DEFAULT FormatSizeFlags = C.G_FORMAT_SIZE_DEFAULT FORMAT_SIZE_LONG_FORMAT FormatSizeFlags = C.G_FORMAT_SIZE_LONG_FORMAT FORMAT_SIZE_IEC_UNITS FormatSizeFlags = C.G_FORMAT_SIZE_IEC_UNITS ) // FormatSizeFull is a wrapper around g_format_size_full(). func FormatSizeFull(size uint64, flags FormatSizeFlags) string { char := C.g_format_size_full(C.guint64(size), C.GFormatSizeFlags(flags)) defer C.free(unsafe.Pointer(char)) return C.GoString(char) } // SpacedPrimesClosest is a wrapper around g_spaced_primes_closest(). func SpacedPrimesClosest(num uint) uint { return uint(C.g_spaced_primes_closest(C.guint(num))) } /* * GObject */ // IObject is an interface type implemented by Object and all types which embed // an Object. It is meant to be used as a type for function arguments which // require GObjects or any subclasses thereof. type IObject interface { toGObject() *C.GObject toObject() *Object } // Object is a representation of GLib's GObject. type Object struct { GObject *C.GObject } func (v *Object) toGObject() *C.GObject { if v == nil { return nil } return v.native() } func (v *Object) toObject() *Object { return v } // newObject creates a new Object from a GObject pointer. func newObject(p *C.GObject) *Object { if p == nil { return nil } return &Object{GObject: p} } // native returns a pointer to the underlying GObject. func (v *Object) native() *C.GObject { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGObject(p) } // goValue converts a *Object to a Go type (e.g. *Object => *gtk.Entry). // It is used in goMarshal to convert generic GObject parameters to // signal handlers to the actual types expected by the signal handler. func (v *Object) goValue() (interface{}, error) { objType := Type(C._g_type_from_instance(C.gpointer(v.native()))) f, err := gValueMarshalers.lookupType(objType) if err != nil { return nil, err } // The marshalers expect Values, not Objects val, err := ValueInit(objType) if err != nil { return nil, err } val.SetInstance(uintptr(unsafe.Pointer(v.GObject))) rv, err := f(uintptr(unsafe.Pointer(val.native()))) return rv, err } // Take wraps a unsafe.Pointer as a glib.Object, taking ownership of it. // This function is exported for visibility in other gotk3 packages and // is not meant to be used by applications. // // To be clear, this should mostly be used when Gtk says "transfer none". Refer // to AssumeOwnership for more details. func Take(ptr unsafe.Pointer) *Object { obj := newObject(ToGObject(ptr)) if obj == nil { return nil } obj.RefSink() runtime.SetFinalizer(obj, func(v *Object) { FinalizerStrategy(v.Unref) }) return obj } // AssumeOwnership is similar to Take, except the function does not take a // reference. This is usually used for newly constructed objects that for some // reason does not have an initial floating reference. // // To be clear, this should often be used when Gtk says "transfer full", as it // means the ownership is transferred to the caller, so we can assume that much. // This is in contrary to Take, which is used when Gtk says "transfer none", as // we're now referencing an object that might possibly be kept, so we should // mark as such. func AssumeOwnership(ptr unsafe.Pointer) *Object { obj := newObject(ToGObject(ptr)) runtime.SetFinalizer(obj, func(v *Object) { FinalizerStrategy(v.Unref) }) return obj } // Native returns a pointer to the underlying GObject. func (v *Object) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } // IsA is a wrapper around g_type_is_a(). func (v *Object) IsA(typ Type) bool { return gobool(C.g_type_is_a(C.GType(v.TypeFromInstance()), C.GType(typ))) } // TypeFromInstance is a wrapper around g_type_from_instance(). func (v *Object) TypeFromInstance() Type { c := C._g_type_from_instance(C.gpointer(unsafe.Pointer(v.native()))) return Type(c) } // ToGObject type converts an unsafe.Pointer as a native C GObject. // This function is exported for visibility in other gotk3 packages and // is not meant to be used by applications. func ToGObject(p unsafe.Pointer) *C.GObject { return (*C.GObject)(p) // return C.toGObject(p) } // Ref is a wrapper around g_object_ref(). func (v *Object) Ref() { C.g_object_ref(C.gpointer(v.GObject)) } // Unref is a wrapper around g_object_unref(). func (v *Object) Unref() { C.g_object_unref(C.gpointer(v.GObject)) } // RefSink is a wrapper around g_object_ref_sink(). func (v *Object) RefSink() { C.g_object_ref_sink(C.gpointer(v.GObject)) } // IsFloating is a wrapper around g_object_is_floating(). func (v *Object) IsFloating() bool { c := C.g_object_is_floating(C.gpointer(v.GObject)) return gobool(c) } // ForceFloating is a wrapper around g_object_force_floating(). func (v *Object) ForceFloating() { C.g_object_force_floating(v.GObject) } // StopEmission is a wrapper around g_signal_stop_emission_by_name(). func (v *Object) StopEmission(s string) { cstr := C.CString(s) defer C.free(unsafe.Pointer(cstr)) C.g_signal_stop_emission_by_name((C.gpointer)(v.GObject), (*C.gchar)(cstr)) } // Set calls SetProperty. func (v *Object) Set(name string, value interface{}) error { return v.SetProperty(name, value) } // GetPropertyType returns the Type of a property of the underlying GObject. // If the property is missing it will return TYPE_INVALID and an error. func (v *Object) GetPropertyType(name string) (Type, error) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) paramSpec := C.g_object_class_find_property(C._g_object_get_class(v.native()), (*C.gchar)(cstr)) if paramSpec == nil { return TYPE_INVALID, errors.New("couldn't find Property") } return Type(paramSpec.value_type), nil } // GetProperty is a wrapper around g_object_get_property(). func (v *Object) GetProperty(name string) (interface{}, error) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) t, err := v.GetPropertyType(name) if err != nil { return nil, err } p, err := ValueInit(t) if err != nil { return nil, errors.New("unable to allocate value") } C.g_object_get_property(v.GObject, (*C.gchar)(cstr), p.native()) return p.GoValue() } // SetProperty is a wrapper around g_object_set_property(). func (v *Object) SetProperty(name string, value interface{}) error { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) if _, ok := value.(Object); ok { value = value.(Object).GObject } p, err := GValue(value) if err != nil { return errors.New("Unable to perform type conversion") } C.g_object_set_property(v.GObject, (*C.gchar)(cstr), p.native()) return nil } /* * GObject Signals */ // Emit is a wrapper around g_signal_emitv() and emits the signal // specified by the string s to an Object. Arguments to callback // functions connected to this signal must be specified in args. Emit() // returns an interface{} which must be type asserted as the Go // equivalent type to the return value for native C callback. // // Note that this code is unsafe in that the types of values in args are // not checked against whether they are suitable for the callback. func (v *Object) Emit(s string, args ...interface{}) (interface{}, error) { cstr := C.CString(s) defer C.free(unsafe.Pointer(cstr)) // Create array of this instance and arguments valv := C.alloc_gvalue_list(C.int(len(args)) + 1) defer C.free(unsafe.Pointer(valv)) // Add args and valv val, err := GValue(v) if err != nil { return nil, errors.New("Error converting Object to GValue: " + err.Error()) } C.val_list_insert(valv, C.int(0), val.native()) for i := range args { val, err := GValue(args[i]) if err != nil { return nil, fmt.Errorf("Error converting arg %d to GValue: %s", i, err.Error()) } C.val_list_insert(valv, C.int(i+1), val.native()) } t := v.TypeFromInstance() // TODO: use just the signal name id := C.g_signal_lookup((*C.gchar)(cstr), C.GType(t)) ret, err := ValueAlloc() if err != nil { return nil, errors.New("Error creating Value for return value") } C.g_signal_emitv(valv, id, C.GQuark(0), ret.native()) return ret.GoValue() } // HandlerBlock is a wrapper around g_signal_handler_block(). func (v *Object) HandlerBlock(handle SignalHandle) { C.g_signal_handler_block(C.gpointer(v.GObject), C.gulong(handle)) } // HandlerUnblock is a wrapper around g_signal_handler_unblock(). func (v *Object) HandlerUnblock(handle SignalHandle) { C.g_signal_handler_unblock(C.gpointer(v.GObject), C.gulong(handle)) } // HandlerDisconnect is a wrapper around g_signal_handler_disconnect(). func (v *Object) HandlerDisconnect(handle SignalHandle) { // Ensure that Gtk will not use the closure beforehand. C.g_signal_handler_disconnect(C.gpointer(v.GObject), C.gulong(handle)) closure.DisconnectSignal(uint(handle)) } // Wrapper function for new objects with reference management. func wrapObject(ptr unsafe.Pointer) *Object { return Take(ptr) } /* * GInitiallyUnowned */ // InitiallyUnowned is a representation of GLib's GInitiallyUnowned. type InitiallyUnowned struct { // This must be a pointer so copies of the ref-sinked object // do not outlive the original object, causing an unref // finalizer to prematurely run. *Object } // Native returns a pointer to the underlying GObject. This is implemented // here rather than calling Native on the embedded Object to prevent a nil // pointer dereference. func (v *InitiallyUnowned) Native() uintptr { if v == nil || v.Object == nil { return uintptr(unsafe.Pointer(nil)) } return v.Object.Native() } /* * GValue */ // Value is a representation of GLib's GValue. // // Don't allocate Values on the stack or heap manually as they may not // be properly unset when going out of scope. Instead, use ValueAlloc(), // which will set the runtime finalizer to unset the Value after it has // left scope. type Value struct { GValue *C.GValue } // native returns a pointer to the underlying GValue. func (v *Value) native() *C.GValue { return v.GValue } // Native returns a pointer to the underlying GValue. func (v *Value) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } // IsValue checks if value is a valid and initialized GValue structure. func (v *Value) IsValue() bool { return gobool(C._g_is_value(v.native())) } // TypeName gets the type name of value. func (v *Value) TypeName() string { return C.GoString((*C.char)(C._g_value_type_name(v.native()))) } // ValueAlloc allocates a Value and sets a runtime finalizer to call // g_value_unset() on the underlying GValue after leaving scope. // ValueAlloc() returns a non-nil error if the allocation failed. func ValueAlloc() (*Value, error) { c := C._g_value_alloc() if c == nil { return nil, nilPtrErr } v := &Value{c} //An allocated GValue is not guaranteed to hold a value that can be unset //We need to double check before unsetting, to prevent: //`g_value_unset: assertion 'G_IS_VALUE (value)' failed` runtime.SetFinalizer(v, func(f *Value) { FinalizerStrategy(func() { if !f.IsValue() { C.g_free(C.gpointer(f.native())) return } f.unset() }) }) return v, nil } // ValueInit is a wrapper around g_value_init() and allocates and // initializes a new Value with the Type t. A runtime finalizer is set // to call g_value_unset() on the underlying GValue after leaving scope. // ValueInit() returns a non-nil error if the allocation failed. func ValueInit(t Type) (*Value, error) { c := C._g_value_init(C.GType(t)) if c == nil { return nil, nilPtrErr } v := &Value{c} runtime.SetFinalizer(v, func(vv *Value) { FinalizerStrategy(vv.unset) }) return v, nil } // ValueFromNative returns a type-asserted pointer to the Value. func ValueFromNative(l unsafe.Pointer) *Value { //TODO why it does not add finalizer to the value? return &Value{(*C.GValue)(l)} } func (v *Value) unset() { C.g_value_unset(v.native()) } // Unset is wrapper for g_value_unset func (v *Value) Unset() { v.unset() } // Type is a wrapper around the G_VALUE_HOLDS_GTYPE() macro and // the g_value_get_gtype() function. GetType() returns TYPE_INVALID if v // does not hold a Type, or otherwise returns the Type of v. func (v *Value) Type() (actual Type, fundamental Type, err error) { if !v.IsValue() { return actual, fundamental, errors.New("invalid GValue") } cActual := C._g_value_type(v.native()) cFundamental := C._g_value_fundamental(cActual) return Type(cActual), Type(cFundamental), nil } // GValue converts a Go type to a comparable GValue. GValue() // returns a non-nil error if the conversion was unsuccessful. func GValue(v interface{}) (gvalue *Value, err error) { if v == nil { val, err := ValueInit(TYPE_POINTER) if err != nil { return nil, err } val.SetPointer(uintptr(unsafe.Pointer(nil))) return val, nil } switch e := v.(type) { case bool: val, err := ValueInit(TYPE_BOOLEAN) if err != nil { return nil, err } val.SetBool(e) return val, nil case int8: val, err := ValueInit(TYPE_CHAR) if err != nil { return nil, err } val.SetSChar(e) return val, nil case int64: val, err := ValueInit(TYPE_INT64) if err != nil { return nil, err } val.SetInt64(e) return val, nil case int: val, err := ValueInit(TYPE_INT) if err != nil { return nil, err } val.SetInt(e) return val, nil case uint8: val, err := ValueInit(TYPE_UCHAR) if err != nil { return nil, err } val.SetUChar(e) return val, nil case uint64: val, err := ValueInit(TYPE_UINT64) if err != nil { return nil, err } val.SetUInt64(e) return val, nil case uint: val, err := ValueInit(TYPE_UINT) if err != nil { return nil, err } val.SetUInt(e) return val, nil case float32: val, err := ValueInit(TYPE_FLOAT) if err != nil { return nil, err } val.SetFloat(e) return val, nil case float64: val, err := ValueInit(TYPE_DOUBLE) if err != nil { return nil, err } val.SetDouble(e) return val, nil case string: val, err := ValueInit(TYPE_STRING) if err != nil { return nil, err } val.SetString(e) return val, nil case *Object: val, err := ValueInit(TYPE_OBJECT) if err != nil { return nil, err } val.SetInstance(uintptr(unsafe.Pointer(e.GObject))) return val, nil default: /* Try this since above doesn't catch constants under other types */ rval := reflect.ValueOf(v) switch rval.Kind() { case reflect.Int8: val, err := ValueInit(TYPE_CHAR) if err != nil { return nil, err } val.SetSChar(int8(rval.Int())) return val, nil case reflect.Int16: return nil, errors.New("Type not implemented") case reflect.Int32: return nil, errors.New("Type not implemented") case reflect.Int64: val, err := ValueInit(TYPE_INT64) if err != nil { return nil, err } val.SetInt64(rval.Int()) return val, nil case reflect.Int: val, err := ValueInit(TYPE_INT) if err != nil { return nil, err } val.SetInt(int(rval.Int())) return val, nil case reflect.Uintptr, reflect.Ptr: val, err := ValueInit(TYPE_POINTER) if err != nil { return nil, err } val.SetPointer(rval.Pointer()) return val, nil } } return nil, errors.New("Type not implemented") } // GValueMarshaler is a marshal function to convert a GValue into an // appropriate Go type. The uintptr parameter is a *C.GValue. type GValueMarshaler func(uintptr) (interface{}, error) // TypeMarshaler represents an actual type and it's associated marshaler. type TypeMarshaler struct { T Type F GValueMarshaler } // RegisterGValueMarshalers adds marshalers for several types to the // internal marshalers map. Once registered, calling GoValue on any // Value with a registered type will return the data returned by the // marshaler. func RegisterGValueMarshalers(tm []TypeMarshaler) { gValueMarshalers.register(tm) } type marshalMap map[Type]GValueMarshaler // gValueMarshalers is a map of Glib types to functions to marshal a // GValue to a native Go type. var gValueMarshalers = marshalMap{ TYPE_INVALID: marshalInvalid, TYPE_NONE: marshalNone, TYPE_INTERFACE: marshalInterface, TYPE_CHAR: marshalChar, TYPE_UCHAR: marshalUchar, TYPE_BOOLEAN: marshalBoolean, TYPE_INT: marshalInt, TYPE_LONG: marshalLong, TYPE_ENUM: marshalEnum, TYPE_INT64: marshalInt64, TYPE_UINT: marshalUint, TYPE_ULONG: marshalUlong, TYPE_FLAGS: marshalFlags, TYPE_UINT64: marshalUint64, TYPE_FLOAT: marshalFloat, TYPE_DOUBLE: marshalDouble, TYPE_STRING: marshalString, TYPE_POINTER: marshalPointer, TYPE_BOXED: marshalBoxed, TYPE_OBJECT: marshalObject, TYPE_VARIANT: marshalVariant, } func (m marshalMap) register(tm []TypeMarshaler) { for i := range tm { m[tm[i].T] = tm[i].F } } func (m marshalMap) lookup(v *Value) (GValueMarshaler, error) { actual, fundamental, err := v.Type() if err != nil { return nil, err } if f, ok := m[actual]; ok { return f, nil } if f, ok := m[fundamental]; ok { return f, nil } return nil, errors.New("missing marshaler for type") } func (m marshalMap) lookupType(t Type) (GValueMarshaler, error) { if f, ok := m[Type(t)]; ok { return f, nil } return nil, errors.New("missing marshaler for type") } func marshalInvalid(uintptr) (interface{}, error) { return nil, errors.New("invalid type") } func marshalNone(uintptr) (interface{}, error) { return nil, nil } func marshalInterface(uintptr) (interface{}, error) { return nil, errors.New("interface conversion not yet implemented") } func marshalChar(p uintptr) (interface{}, error) { c := C.g_value_get_schar((*C.GValue)(unsafe.Pointer(p))) return int8(c), nil } func marshalUchar(p uintptr) (interface{}, error) { c := C.g_value_get_uchar((*C.GValue)(unsafe.Pointer(p))) return uint8(c), nil } func marshalBoolean(p uintptr) (interface{}, error) { c := C.g_value_get_boolean((*C.GValue)(unsafe.Pointer(p))) return gobool(c), nil } func marshalInt(p uintptr) (interface{}, error) { c := C.g_value_get_int((*C.GValue)(unsafe.Pointer(p))) return int(c), nil } func marshalLong(p uintptr) (interface{}, error) { c := C.g_value_get_long((*C.GValue)(unsafe.Pointer(p))) return int(c), nil } func marshalEnum(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return int(c), nil } func marshalInt64(p uintptr) (interface{}, error) { c := C.g_value_get_int64((*C.GValue)(unsafe.Pointer(p))) return int64(c), nil } func marshalUint(p uintptr) (interface{}, error) { c := C.g_value_get_uint((*C.GValue)(unsafe.Pointer(p))) return uint(c), nil } func marshalUlong(p uintptr) (interface{}, error) { c := C.g_value_get_ulong((*C.GValue)(unsafe.Pointer(p))) return uint(c), nil } func marshalFlags(p uintptr) (interface{}, error) { c := C.g_value_get_flags((*C.GValue)(unsafe.Pointer(p))) return uint(c), nil } func marshalUint64(p uintptr) (interface{}, error) { c := C.g_value_get_uint64((*C.GValue)(unsafe.Pointer(p))) return uint64(c), nil } func marshalFloat(p uintptr) (interface{}, error) { c := C.g_value_get_float((*C.GValue)(unsafe.Pointer(p))) return float32(c), nil } func marshalDouble(p uintptr) (interface{}, error) { c := C.g_value_get_double((*C.GValue)(unsafe.Pointer(p))) return float64(c), nil } func marshalString(p uintptr) (interface{}, error) { c := C.g_value_get_string((*C.GValue)(unsafe.Pointer(p))) return C.GoString((*C.char)(c)), nil } func marshalBoxed(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return uintptr(unsafe.Pointer(c)), nil } func marshalPointer(p uintptr) (interface{}, error) { c := C.g_value_get_pointer((*C.GValue)(unsafe.Pointer(p))) return unsafe.Pointer(c), nil } func marshalObject(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return newObject((*C.GObject)(c)), nil } func marshalVariant(p uintptr) (interface{}, error) { c := C.g_value_get_variant((*C.GValue)(unsafe.Pointer(p))) return newVariant((*C.GVariant)(c)), nil } // GoValue converts a Value to comparable Go type. GoValue() // returns a non-nil error if the conversion was unsuccessful. The // returned interface{} must be type asserted as the actual Go // representation of the Value. // // This function is a wrapper around the many g_value_get_*() // functions, depending on the type of the Value. func (v *Value) GoValue() (interface{}, error) { f, err := gValueMarshalers.lookup(v) if err != nil { return nil, err } //No need to add finalizer because it is already done by ValueAlloc and ValueInit rv, err := f(uintptr(unsafe.Pointer(v.native()))) return rv, err } // SetBool is a wrapper around g_value_set_boolean(). func (v *Value) SetBool(val bool) { C.g_value_set_boolean(v.native(), gbool(val)) } // SetSChar is a wrapper around g_value_set_schar(). func (v *Value) SetSChar(val int8) { C.g_value_set_schar(v.native(), C.gint8(val)) } // SetInt64 is a wrapper around g_value_set_int64(). func (v *Value) SetInt64(val int64) { C.g_value_set_int64(v.native(), C.gint64(val)) } // SetInt is a wrapper around g_value_set_int(). func (v *Value) SetInt(val int) { C.g_value_set_int(v.native(), C.gint(val)) } // SetUChar is a wrapper around g_value_set_uchar(). func (v *Value) SetUChar(val uint8) { C.g_value_set_uchar(v.native(), C.guchar(val)) } // SetUInt64 is a wrapper around g_value_set_uint64(). func (v *Value) SetUInt64(val uint64) { C.g_value_set_uint64(v.native(), C.guint64(val)) } // SetUInt is a wrapper around g_value_set_uint(). func (v *Value) SetUInt(val uint) { C.g_value_set_uint(v.native(), C.guint(val)) } // SetFloat is a wrapper around g_value_set_float(). func (v *Value) SetFloat(val float32) { C.g_value_set_float(v.native(), C.gfloat(val)) } // SetDouble is a wrapper around g_value_set_double(). func (v *Value) SetDouble(val float64) { C.g_value_set_double(v.native(), C.gdouble(val)) } // SetString is a wrapper around g_value_set_string(). func (v *Value) SetString(val string) { cstr := C.CString(val) defer C.free(unsafe.Pointer(cstr)) C.g_value_set_string(v.native(), (*C.gchar)(cstr)) } // SetInstance is a wrapper around g_value_set_instance(). func (v *Value) SetInstance(instance uintptr) { C.g_value_set_instance(v.native(), C.gpointer(instance)) } // SetPointer is a wrapper around g_value_set_pointer(). func (v *Value) SetPointer(p uintptr) { C.g_value_set_pointer(v.native(), C.gpointer(p)) } // GetPointer is a wrapper around g_value_get_pointer(). func (v *Value) GetPointer() unsafe.Pointer { return unsafe.Pointer(C.g_value_get_pointer(v.native())) } // GetString is a wrapper around g_value_get_string(). GetString() // returns a non-nil error if g_value_get_string() returned a NULL // pointer to distinguish between returning a NULL pointer and returning // an empty string. func (v *Value) GetString() (string, error) { c := C.g_value_get_string(v.native()) if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } type Signal struct { name string signalId C.guint } func SignalNew(signalName string) (*Signal, error) { cstr := C.CString(signalName) defer C.free(unsafe.Pointer(cstr)) signalId := C._g_signal_new((*C.gchar)(cstr)) if signalId == 0 { return nil, fmt.Errorf("invalid signal name: %s", signalName) } return &Signal{ name: signalName, signalId: signalId, }, nil } // SignalNewV is a wrapper around g_signal_newv(). // // Parameters: // - signalName : The name for the signal. // - returnType : The type of return value, or TYPE_NONE for a signal without a return value. // - nParams : Amount of extra parameters the signal is going to recieve (the object who emits the signal does not count). // - paramsTypes... : Datatypes of the parameters (amount of elements must match nParams, except when nParams is 0). // If nParams is 0 then paramsTypes has to be TYPE_NONE. // If nParams is 1 then paramsTypes has to be different from TYPE_NONE. func SignalNewV( signalName string, returnType Type, nParams uint, paramsTypes ...Type, ) (*Signal, error) { if nParams == 0 { if paramsTypes[0] != TYPE_NONE || len(paramsTypes) != 1 { return nil, fmt.Errorf("invalid Types: the amount of parameters is %d, paramsTypes must be TYPE_NONE", nParams) } } else if nParams == 1 { if paramsTypes[0] == TYPE_NONE || len(paramsTypes) != 1 { return nil, fmt.Errorf("invalid Types: the amount of parameters is %d, paramsTypes must be different from TYPE_NONE", nParams) } } else { if len(paramsTypes) != int(nParams) { return nil, fmt.Errorf("invalid Types: The amount of elements of paramsTypes has to be equal to %d", nParams) } } cstr := C.CString(signalName) defer C.free(unsafe.Pointer(cstr)) var sliceOfGTypes []C.GType for _, paramType := range paramsTypes { sliceOfGTypes = append(sliceOfGTypes, C.gsize(paramType)) } signalId := C._g_signal_newv((*C.gchar)(cstr), C.gsize(returnType), C.guint(nParams), (*C.GType)(&sliceOfGTypes[0])) if signalId == 0 { return nil, fmt.Errorf("invalid signal name: %s", signalName) } return &Signal{ name: signalName, signalId: signalId, }, nil } func (s *Signal) String() string { return s.name } type Quark uint32 // GetPrgname is a wrapper around g_get_prgname(). func GetPrgname() string { c := C.g_get_prgname() return C.GoString((*C.char)(c)) } // SetPrgname is a wrapper around g_set_prgname(). func SetPrgname(name string) { cstr := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr)) C.g_set_prgname(cstr) } // GetApplicationName is a wrapper around g_get_application_name(). func GetApplicationName() string { c := C.g_get_application_name() return C.GoString((*C.char)(c)) } // SetApplicationName is a wrapper around g_set_application_name(). func SetApplicationName(name string) { cstr := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr)) C.g_set_application_name(cstr) } // InitI18n initializes the i18n subsystem. func InitI18n(domain string, dir string) { domainStr := C.CString(domain) defer C.free(unsafe.Pointer(domainStr)) dirStr := C.CString(dir) defer C.free(unsafe.Pointer(dirStr)) C.init_i18n(domainStr, dirStr) } // Local localizes a string using gettext func Local(input string) string { cstr := C.CString(input) defer C.free(unsafe.Pointer(cstr)) return C.GoString(C.localize(cstr)) } // MarkupEscapeText will escape the given text func MarkupEscapeText(input string) string { cstr := C.CString(input) defer C.free(unsafe.Pointer(cstr)) return C.GoString(C.g_markup_escape_text(cstr, -1)) } gotk3-0.6.2/glib/glib.go.h000066400000000000000000000135311431157473000151650ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef __GLIB_GO_H__ #define __GLIB_GO_H__ #include #include #include #include #define G_SETTINGS_ENABLE_BACKEND #include #include #include #include #include /* GObject Type Casting */ static GObject *toGObject(void *p) { return (G_OBJECT(p)); } static GAction *toGAction(void *p) { return (G_ACTION(p)); } static GActionGroup *toGActionGroup(void *p) { return (G_ACTION_GROUP(p)); } static GActionMap *toGActionMap(void *p) { return (G_ACTION_MAP(p)); } static GAsyncResult *toGAsyncResult(void *p) { return (G_ASYNC_RESULT(p)); } static GSimpleAction *toGSimpleAction(void *p) { return (G_SIMPLE_ACTION(p)); } static GSimpleActionGroup *toGSimpleActionGroup(void *p) { return (G_SIMPLE_ACTION_GROUP(p)); } static GPropertyAction *toGPropertyAction(void *p) { return (G_PROPERTY_ACTION(p)); } static GMenuModel *toGMenuModel(void *p) { return (G_MENU_MODEL(p)); } static GMenu *toGMenu(void *p) { return (G_MENU(p)); } static GMenuItem *toGMenuItem(void *p) { return (G_MENU_ITEM(p)); } static GNotification *toGNotification(void *p) { return (G_NOTIFICATION(p)); } static GPermission *toGPermission(void *p) { return (G_PERMISSION(p)); } static GCancellable *toCancellable(void *p) { return (G_CANCELLABLE(p)); } static GIcon *toGIcon(void *p) { return (G_ICON(p)); } static GFileIcon *toGFileIcon(void *p) { return (G_FILE_ICON(p)); } static GFile *toGFile(void *p) { return (G_FILE(p)); } static GApplication *toGApplication(void *p) { return (G_APPLICATION(p)); } static GSettings *toGSettings(void *p) { return (G_SETTINGS(p)); } static GSettingsBackend *toGSettingsBackend(void *p) { return (G_SETTINGS_BACKEND(p)); } static GBinding *toGBinding(void *p) { return (G_BINDING(p)); } static GType _g_type_from_instance(gpointer instance) { return (G_TYPE_FROM_INSTANCE(instance)); } /* Wrapper to avoid variable arg list */ static void _g_object_set_one(gpointer object, const gchar *property_name, void *val) { g_object_set(object, property_name, *(gpointer **)val, NULL); } static GValue *alloc_gvalue_list(int n) { GValue *valv; valv = g_new0(GValue, n); return (valv); } static void val_list_insert(GValue *valv, int i, GValue *val) { valv[i] = *val; } /* * GValue */ static GValue *_g_value_alloc() { return (g_new0(GValue, 1)); } static GValue *_g_value_init(GType g_type) { GValue *value; value = g_new0(GValue, 1); return (g_value_init(value, g_type)); } static gboolean _g_type_is_value(GType g_type) { return (G_TYPE_IS_VALUE(g_type)); } static gboolean _g_is_value(GValue *val) { return (G_IS_VALUE(val)); } static GType _g_value_type(GValue *val) { return (G_VALUE_TYPE(val)); } static const gchar *_g_value_type_name(GValue *val) { return (G_VALUE_TYPE_NAME(val)); } static GType _g_value_fundamental(GType type) { return (G_TYPE_FUNDAMENTAL(type)); } static GObjectClass *_g_object_get_class(GObject *object) { return (G_OBJECT_GET_CLASS(object)); } /* * Closure support */ extern void removeSourceFunc(gpointer data); extern gboolean sourceFunc(gpointer data); extern void goMarshal(GClosure *, GValue *, guint, GValue *, gpointer, GValue *); extern void removeClosure(gpointer, GClosure *); static inline GClosure *_g_closure_new() { GClosure *closure; closure = g_closure_new_simple(sizeof(GClosure), NULL); g_closure_set_marshal(closure, (GClosureMarshal)(goMarshal)); g_closure_add_finalize_notifier(closure, NULL, (GClosureNotify)(removeClosure)); return closure; } static inline guint _g_signal_new(const gchar *name) { return g_signal_new(name, G_TYPE_OBJECT, G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, 0, NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 0); } static inline guint _g_signal_newv(const gchar *name, const GType return_type, const guint n_params, GType *const param_types) { return g_signal_newv(name, G_TYPE_OBJECT, G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, NULL, NULL, NULL, g_cclosure_marshal_VOID__POINTER, return_type, n_params, param_types); } static void init_i18n(const char *domain, const char *dir) { setlocale(LC_ALL, ""); bindtextdomain(domain, dir); bind_textdomain_codeset(domain, "UTF-8"); textdomain(domain); } static const char *localize(const char *string) { return _(string); } static inline char **make_strings(int count) { return (char **)malloc(sizeof(char *) * count); } static inline void destroy_strings(char **strings) { free(strings); } static inline char *get_string(char **strings, int n) { return strings[n]; } static inline void set_string(char **strings, int n, char *str) { strings[n] = str; } static inline gchar **next_gcharptr(gchar **s) { return (s + 1); } extern gint goCompareDataFuncs(gconstpointer a, gconstpointer b, gpointer user_data); #endif gotk3-0.6.2/glib/glib_export.go000066400000000000000000000013001431157473000163270ustar00rootroot00000000000000package glib // #cgo pkg-config: gio-2.0 // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/internal/callback" ) //export goAsyncReadyCallbacks func goAsyncReadyCallbacks(sourceObject *C.GObject, res *C.GAsyncResult, userData C.gpointer) { var source *Object if sourceObject != nil { source = wrapObject(unsafe.Pointer(sourceObject)) } fn := callback.Get(uintptr(userData)).(AsyncReadyCallback) fn(source, wrapAsyncResult(wrapObject(unsafe.Pointer(res)))) } //export goCompareDataFuncs func goCompareDataFuncs(a, b C.gconstpointer, userData C.gpointer) C.gint { fn := callback.Get(uintptr(userData)).(CompareDataFunc) return C.gint(fn(uintptr(a), uintptr(b))) } gotk3-0.6.2/glib/glib_extension.go000066400000000000000000000007221431157473000170310ustar00rootroot00000000000000//glib_extension contains definitions and functions to interface between glib/gtk/gio and go universe package glib import ( "reflect" ) // Should be implemented by any class which need special conversion like // gtk.Application -> gio.Application type IGlibConvert interface { // If conversion can't be done, the function has to panic with a message that it can't convert to type Convert(reflect.Type) reflect.Value } var ( IGlibConvertType reflect.Type ) gotk3-0.6.2/glib/glib_since_2_42.go000066400000000000000000000026501431157473000166460ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !glib_2_40 package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" /* * Notification */ // NotificationPriority is a representation of GLib's GNotificationPriority. type NotificationPriority int const ( NOTIFICATION_PRIORITY_NORMAL NotificationPriority = C.G_NOTIFICATION_PRIORITY_NORMAL NOTIFICATION_PRIORITY_LOW NotificationPriority = C.G_NOTIFICATION_PRIORITY_LOW NOTIFICATION_PRIORITY_HIGH NotificationPriority = C.G_NOTIFICATION_PRIORITY_HIGH NOTIFICATION_PRIORITY_URGENT NotificationPriority = C.G_NOTIFICATION_PRIORITY_URGENT ) // SetPriority is a wrapper around g_notification_set_priority(). func (v *Notification) SetPriority(prio NotificationPriority) { C.g_notification_set_priority(v.native(), C.GNotificationPriority(prio)) } /* * Application */ // GetResourceBasePath is a wrapper around g_application_get_resource_base_path(). func (v *Application) GetResourceBasePath() string { c := C.g_application_get_resource_base_path(v.native()) return C.GoString((*C.char)(c)) } // SetResourceBasePath is a wrapper around g_application_set_resource_base_path(). func (v *Application) SetResourceBasePath(bp string) { cstr1 := (*C.gchar)(C.CString(bp)) defer C.free(unsafe.Pointer(cstr1)) C.g_application_set_resource_base_path(v.native(), cstr1) } gotk3-0.6.2/glib/glib_since_2_44.go000066400000000000000000000012311431157473000166420ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !glib_2_40,!glib_2_42 package glib // #include // #include // #include // #include "glib.go.h" // #include "glib_since_2_44.go.h" import "C" /* * Application */ // GetIsBusy is a wrapper around g_application_get_is_busy(). func (v *Application) GetIsBusy() bool { return gobool(C.g_application_get_is_busy(v.native())) } /* * SimpleAction */ // SetStateHint is a wrapper around g_simple_action_set_state_hint func (v *SimpleAction) SetStateHint(stateHint *Variant) { C.g_simple_action_set_state_hint(v.native(), stateHint.native()) } gotk3-0.6.2/glib/glib_since_2_44.go.h000066400000000000000000000010541431157473000170730ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project #include #include #include static GListModel *toGListModel(void *p) { return (G_LIST_MODEL(p)); } static GListStore *toGListStore(void *p) { return (G_LIST_STORE(p)); } static inline void _g_list_store_insert_sorted(GListStore *model, gpointer item, gpointer user_data) { g_list_store_insert_sorted(model, item, (GCompareDataFunc)(goCompareDataFuncs), user_data); } gotk3-0.6.2/glib/glib_since_2_46.go000066400000000000000000000010641431157473000166500ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !glib_2_40,!glib_2_42,!glib_2_44 package glib // #include // #include // #include // #include "glib.go.h" // #include "glib_since_2_44.go.h" // #include "glib_since_2_46.go.h" import "C" import "github.com/gotk3/gotk3/internal/callback" /* * GListStore */ // Sort is a wrapper around g_list_store_sort(). func (v *ListStore) Sort(compareFunc CompareDataFunc) { C._g_list_store_sort(v.native(), C.gpointer(callback.Assign(compareFunc))) } gotk3-0.6.2/glib/glib_since_2_46.go.h000066400000000000000000000004511431157473000170750ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project #include #include #include static inline void _g_list_store_sort(GListStore *model, gpointer user_data) { g_list_store_sort(model, (GCompareDataFunc)(goCompareDataFuncs), user_data); } gotk3-0.6.2/glib/glib_since_2_58.go000066400000000000000000000005641431157473000166570ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !glib_2_40,!glib_2_42,!glib_2_44,!glib_2_46,!glib_2_48,!glib_2_50,!glib_2_52,!glib_2_54,!glib_2_56 package glib // #include // #include // #include // #include "glib.go.h" import "C" const ( FORMAT_SIZE_BITS FormatSizeFlags = C.G_FORMAT_SIZE_BITS ) gotk3-0.6.2/glib/glib_since_2_64.go000066400000000000000000000007371431157473000166560ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !glib_2_40,!glib_2_42,!glib_2_44,!glib_2_46,!glib_2_48,!glib_2_50,!glib_2_52,!glib_2_54,!glib_2_56,!glib_2_58,!glib_2_60,!glib_2_62 package glib // // #include // // #include // // #include // // #include "glib.go.h" // // #include "glib_since_2_44.go.h" // import "C" /* * GListStore */ // TODO // g_list_store_find // g_list_store_find_with_equal_func gotk3-0.6.2/glib/glib_test.go000066400000000000000000000040321431157473000157720ustar00rootroot00000000000000package glib_test import ( "testing" "github.com/gotk3/gotk3/glib" ) // TestConnectSignal tests that specific callback connected to the signal. func TestConnectSignal(t *testing.T) { ctx := glib.MainContextDefault() mainLoop := glib.MainLoopNew(ctx, true) // Create any GObject that has defined properties. obj, _ := glib.CancellableNew() // Connect to a "notify::" signal to listen on property changes. obj.Connect("cancelled", func() { mainLoop.Quit() }) glib.IdleAdd(func() bool { obj.Cancel() return false }) mainLoop.Run() } // TestTypeNames tests both glib.TypeFromName and glib.Type.Name func TestTypeNames(t *testing.T) { tp := glib.TypeFromName("GObject") name := tp.Name() if name != "GObject" { t.Error("Expected GObject, got", name) } } func TestTypeIsA(t *testing.T) { tp := glib.TypeFromName("GCancellable") tpParent := glib.TypeFromName("GObject") isA := tp.IsA(tpParent) if !isA { t.Error("Expected true, GCancellable is a GObject") } } func TestTypeNextBase(t *testing.T) { // http://manual.freeshell.org/glibmm-2.4/reference/html/classGlib_1_1ObjectBase.html tpLeaf := glib.TypeFromName("GFileInputStream") tpParent := glib.TypeFromName("GObject") tpNextBase := glib.TypeNextBase(tpLeaf, tpParent) name := tpNextBase.Name() if name != "GInputStream" { t.Error("Expected GInputStream, got", name) } } func TestValueString_NonEmpty(t *testing.T) { expected := "test" value, err := glib.GValue(expected) if err != nil { t.Error("acquiring gvalue failed:", err.Error()) return } actual, err := value.GetString() if err != nil { t.Error(err.Error()) return } if actual != expected { t.Errorf("Expected %q, got %q", expected, actual) } } func TestValueString_Empty(t *testing.T) { expected := "" value, err := glib.GValue(expected) if err != nil { t.Error("acquiring gvalue failed:", err.Error()) return } actual, err := value.GetString() if err != nil { t.Error(err.Error()) return } if actual != expected { t.Errorf("Expected %q, got %q", expected, actual) } } gotk3-0.6.2/glib/glistmodel.go000066400000000000000000000107411431157473000161650ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !glib_2_40,!glib_2_42 package glib // #include // #include // #include // #include "glib.go.h" // #include "glib_since_2_44.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/internal/callback" ) /* * GListModel */ // IListModel is an interface representation of ListModel, // used to avoid duplication when embedding the type in a wrapper of another GObject-based type. type IListModel interface { toGListModel() *C.GListModel } // ListModel is a representation of GIO's GListModel. type ListModel struct { *Object } func (v *ListModel) toGListModel() *C.GListModel { if v == nil { return nil } return v.native() } // native returns a pointer to the underlying GListModel. func (v *ListModel) native() *C.GListModel { if v == nil || v.GObject == nil { return nil } return C.toGListModel(unsafe.Pointer(v.GObject)) } // Native returns a pointer to the underlying GListModel. func (v *ListModel) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalListModel(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapListModel(wrapObject(unsafe.Pointer(c))), nil } func wrapListModel(obj *Object) *ListModel { return &ListModel{obj} } // GetItemType is a wrapper around g_list_model_get_item_type(). func (v *ListModel) GetItemType() Type { return Type(C.g_list_model_get_item_type(v.native())) } // GetNItems is a wrapper around g_list_model_get_n_items(). func (v *ListModel) GetNItems() uint { return uint(C.g_list_model_get_n_items(v.native())) } // GetItem is a wrapper around g_list_model_get_item(). func (v *ListModel) GetItem(position uint) uintptr { c := C.g_list_model_get_item(v.native(), C.guint(position)) return uintptr(unsafe.Pointer(c)) } // GetObject is a wrapper around g_list_model_get_object(). func (v *ListModel) GetObject(position uint) *Object { c := C.g_list_model_get_object(v.native(), C.guint(position)) return wrapObject(unsafe.Pointer(c)) } // ItemsChanged is a wrapper around g_list_model_items_changed(). func (v *ListModel) ItemsChanged(position, removed, added uint) { C.g_list_model_items_changed(v.native(), C.guint(position), C.guint(removed), C.guint(added)) } /* * GListStore */ // ListStore is a representation of GListStore type ListStore struct { ListModel } func (v *ListStore) native() *C.GListStore { if v == nil || v.GObject == nil { return nil } return C.toGListStore(unsafe.Pointer(v.GObject)) } func (v *ListStore) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalListStore(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapListStore(wrapObject(unsafe.Pointer(c))), nil } func wrapListStore(obj *Object) *ListStore { return &ListStore{ListModel{obj}} } // ListStoreNew is a wrapper around g_list_store_new(). func ListStoreNew(itemType Type) *ListStore { c := C.g_list_store_new(C.GType(itemType)) if c == nil { return nil } return wrapListStore(wrapObject(unsafe.Pointer(c))) } // Insert is a wrapper around g_list_store_insert(). func (v *ListStore) Insert(position uint, item interface{}) { gItem := ToGObject(unsafe.Pointer(&item)) C.g_list_store_insert(v.native(), C.guint(position), C.gpointer(gItem)) } // InsertSorted is a wrapper around g_list_store_insert_sorted(). func (v *ListStore) InsertSorted(item interface{}, compareFunc CompareDataFunc) { gItem := ToGObject(unsafe.Pointer(&item)) C._g_list_store_insert_sorted(v.native(), C.gpointer(gItem), C.gpointer(callback.Assign(compareFunc))) } // Append is a wrapper around g_list_store_append(). func (v *ListStore) Append(item interface{}) { gItem := ToGObject(unsafe.Pointer(&item)) C.g_list_store_append(v.native(), C.gpointer(gItem)) } // Remove is a wrapper around g_list_store_remove(). func (v *ListStore) Remove(position uint) { C.g_list_store_remove(v.native(), C.guint(position)) } // Splice is a wrapper around g_list_store_splice(). func (v *ListStore) Splice(position uint, removalLength uint, additions []interface{}) { additionsLength := len(additions) gAdditions := make([]*C.GObject, additionsLength) for i, add := range additions { gAdditions[i] = ToGObject(unsafe.Pointer(&add)) } gAdditions = append(gAdditions, nil) additionsPtr := C.gpointer(gAdditions[0]) C.g_list_store_splice(v.native(), C.guint(position), C.guint(removalLength), &additionsPtr, C.guint(additionsLength)) } gotk3-0.6.2/glib/gmain_context.go000066400000000000000000000032161431157473000166600ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" type MainContext C.GMainContext // native returns a pointer to the underlying GMainContext. func (v *MainContext) native() *C.GMainContext { if v == nil { return nil } return (*C.GMainContext)(v) } // MainContextDefault is a wrapper around g_main_context_default(). func MainContextDefault() *MainContext { c := C.g_main_context_default() if c == nil { return nil } return (*MainContext)(c) } // Iteration is a wrapper around g_main_context_iteration() func (v *MainContext) Iteration(mayBlock bool) bool { return gobool(C.g_main_context_iteration(v.native(), gbool(mayBlock))) } // Pending is a wrapper around g_main_context_pending() func (v *MainContext) Pending() bool { return gobool(C.g_main_context_pending(v.native())) } // MainDepth is a wrapper around g_main_depth(). func MainDepth() int { return int(C.g_main_depth()) } // FindSourceById is a wrapper around g_main_context_find_source_by_id() func (v *MainContext) FindSourceById(hdlSrc SourceHandle) *Source { c := C.g_main_context_find_source_by_id(v.native(), C.guint(hdlSrc)) if c == nil { return nil } return (*Source)(c) } // Acquire is a wrapper around g_main_context_acquire(). func (v *MainContext) Acquire() bool { return gobool(C.g_main_context_acquire(v.native())) } // Release is a wrapper around g_main_context_release(). func (v *MainContext) Release() { C.g_main_context_release(v.native()) } // IsOwner is a wrapper around g_main_context_is_owner(). func (v *MainContext) IsOwner() bool { return gobool(C.g_main_context_is_owner(v.native())) } gotk3-0.6.2/glib/gmain_loop.go000066400000000000000000000016161431157473000161470ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" type MainLoop C.GMainLoop // native returns a pointer to the underlying GMainContext. func (v *MainLoop) native() *C.GMainLoop { if v == nil { return nil } return (*C.GMainLoop)(v) } // MainLoopNew is a wrapper around g_main_loop_new(). func MainLoopNew(ctx *MainContext, isRunning bool) *MainLoop { c := C.g_main_loop_new(ctx.native(), gbool(isRunning)) if c == nil { return nil } return (*MainLoop)(c) } // IsRunning is a wrapper around g_main_loop_is_running() func (v *MainLoop) IsRunning() bool { return gobool(C.g_main_loop_is_running(v.native())) } // Run is a wrapper around g_main_loop_run() func (v *MainLoop) Run() { C.g_main_loop_run(v.native()) } // Quit is a wrapper around g_main_loop_quit() func (v *MainLoop) Quit() { C.g_main_loop_quit(v.native()) } gotk3-0.6.2/glib/gpermission.go000066400000000000000000000072141431157473000163620ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" // #include "gpermission.go.h" import "C" import ( "errors" "unsafe" "github.com/gotk3/gotk3/internal/callback" ) // Permission is a representation of GIO's GPermission. type Permission struct { *Object } func (v *Permission) native() *C.GPermission { if v == nil || v.GObject == nil { return nil } return C.toGPermission(unsafe.Pointer(v.GObject)) } // Native returns a uintptr to the underlying C.GPermission. func (v *Permission) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalPermission(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapPermission(wrapObject(unsafe.Pointer(c))), nil } func wrapPermission(obj *Object) *Permission { return &Permission{obj} } // WrapPermission wraps given unsafe pointer into Permission. func WrapPermission(ptr unsafe.Pointer) *Permission { return wrapPermission(wrapObject(ptr)) } // GetAllowed is a wrapper around g_permission_get_allowed(). func (v *Permission) GetAllowed() bool { c := C.g_permission_get_allowed(v.native()) return gobool(c) } // GetCanAcquire is a wrapper around g_permission_get_can_acquire(). func (v *Permission) GetCanAcquire() bool { c := C.g_permission_get_can_acquire(v.native()) return gobool(c) } // GetCanRelease is a wrapper around g_permission_get_can_release(). func (v *Permission) GetCanRelease() bool { c := C.g_permission_get_can_release(v.native()) return gobool(c) } // Acquire is a wrapper around g_permission_acquire(). func (v *Permission) Acquire(cancellable *Cancellable) error { var err *C.GError c := C.g_permission_acquire(v.native(), cancellable.native(), &err) acquired := gobool(c) if !acquired { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // AcquireAsync is a wrapper around g_permission_acquire_async(). func (v *Permission) AcquireAsync(cancellable *Cancellable, fn AsyncReadyCallback) { C._g_permission_acquire_async(v.native(), cancellable.native(), C.gpointer(callback.Assign(fn))) } // AcquireFinish is a wrapper around g_permission_acquire_finish(). func (v *Permission) AcquireFinish(result *AsyncResult) error { var err *C.GError c := C.g_permission_acquire_finish(v.native(), result.native(), &err) acquired := gobool(c) if !acquired { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // Release is a wrapper around g_permission_release(). func (v *Permission) Release(cancellable *Cancellable) error { var err *C.GError c := C.g_permission_release(v.native(), cancellable.native(), &err) released := gobool(c) if !released { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // ReleaseAsync is a wrapper around g_permission_release_async(). func (v *Permission) ReleaseAsync(cancellable *Cancellable, fn AsyncReadyCallback) { C._g_permission_release_async(v.native(), cancellable.native(), C.gpointer(callback.Assign(fn))) } // ReleaseFinish is a wrapper around g_permission_release_finish(). func (v *Permission) ReleaseFinish(result *AsyncResult) error { var err *C.GError c := C.g_permission_release_finish(v.native(), result.native(), &err) released := gobool(c) if !released { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // ImplUpdate is a wrapper around g_permission_impl_update(). func (v *Permission) ImplUpdate(allowed, canAcquire, canRelease bool) { C.g_permission_impl_update(v.native(), gbool(allowed), gbool(canAcquire), gbool(canRelease)) } gotk3-0.6.2/glib/gpermission.go.h000066400000000000000000000017631431157473000166130ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project /* * GAsyncReadyCallback */ extern void goAsyncReadyCallbacks(GObject *source_object, GAsyncResult *res, gpointer user_data); static inline void _g_permission_acquire_async(GPermission *permission, GCancellable *cancellable, gpointer user_data) { g_permission_acquire_async(permission, cancellable, (GAsyncReadyCallback)(goAsyncReadyCallbacks), user_data); } static inline void _g_permission_release_async(GPermission *permission, GCancellable *cancellable, gpointer user_data) { g_permission_release_async(permission, cancellable, (GAsyncReadyCallback)(goAsyncReadyCallbacks), user_data); } gotk3-0.6.2/glib/gsimpleactiongroup.go000066400000000000000000000026411431157473000177350ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import ( "unsafe" ) // SimpleActionGroup is a representation of glib's GSimpleActionGroup type SimpleActionGroup struct { *Object // Interfaces IActionMap IActionGroup } // deprecated since 2.38: // g_simple_action_group_lookup() // g_simple_action_group_insert() // g_simple_action_group_remove() // g_simple_action_group_add_entries() // -> See implementations in ActionMap // native() returns a pointer to the underlying GSimpleActionGroup. func (v *SimpleActionGroup) native() *C.GSimpleActionGroup { if v == nil || v.GObject == nil { return nil } return C.toGSimpleActionGroup(unsafe.Pointer(v.GObject)) } func (v *SimpleActionGroup) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalSimpleActionGroup(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapSimpleActionGroup(wrapObject(unsafe.Pointer(c))), nil } func wrapSimpleActionGroup(obj *Object) *SimpleActionGroup { am := wrapActionMap(obj) ag := wrapActionGroup(obj) return &SimpleActionGroup{obj, am, ag} } // SimpleActionGroupNew is a wrapper around g_simple_action_group_new func SimpleActionGroupNew() *SimpleActionGroup { c := C.g_simple_action_group_new() if c == nil { return nil } return wrapSimpleActionGroup(wrapObject(unsafe.Pointer(c))) } gotk3-0.6.2/glib/gsimpleactiongroup_test.go000066400000000000000000000030651431157473000207750ustar00rootroot00000000000000package glib import ( "testing" ) func TestSimpleActionGroupNew(t *testing.T) { sag := SimpleActionGroupNew() if sag == nil { t.Error("SimpleActionGroupNew returned nil") } if sag.IActionGroup == nil { t.Error("Embedded IActionGroup is nil") } if sag.IActionMap == nil { t.Error("Embedded IActionGroup is nil") } } func TestSimpleActionGroup_AddAction_RemoveAction_HasAction(t *testing.T) { sag := SimpleActionGroupNew() if sag == nil { t.Error("SimpleActionGroup returned nil") } // Check before: empty hasAction := sag.HasAction("nope") if hasAction { t.Error("Action group contained unexpected action 'nope'") } hasAction = sag.HasAction("yepp") if hasAction { t.Error("Action group contained unexpected action 'yepp'") } // Add a new action act := SimpleActionNew("yepp", nil) if act == nil { t.Error("SimpleActionNew returned nil") } sag.AddAction(act) // Check that it exists hasAction = sag.HasAction("nope") if hasAction { t.Error("Action group contained unexpected action 'nope'") } hasAction = sag.HasAction("yepp") if !hasAction { t.Error("Action group did not contain action 'yepp' after adding it") } // Remove the action again sag.RemoveAction("yepp") // Check that it was removed hasAction = sag.HasAction("nope") if hasAction { t.Error("Action group contained unexpected action 'nope'") } hasAction = sag.HasAction("yepp") if hasAction { t.Error("Action group contained unexpected action 'yepp'") } // NoFail check: removing a non-existing action sag.RemoveAction("yepp") sag.RemoveAction("nope") } gotk3-0.6.2/glib/gsource.go000066400000000000000000000011061431157473000154640ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" type Source C.GSource // native returns a pointer to the underlying GSource. func (v *Source) native() *C.GSource { if v == nil { return nil } return (*C.GSource)(v) } func wrapSource(sourcePtr *C.GSource) *Source { source := Source(*sourcePtr) return &source } // MainCurrentSource is a wrapper around g_main_current_source(). func MainCurrentSource() *Source { c := C.g_main_current_source() if c == nil { return nil } return (*Source)(c) } gotk3-0.6.2/glib/gvariant.go000066400000000000000000000342671431157473000156460ustar00rootroot00000000000000//GVariant : GVariant — strongly typed value datatype // https://developer.gnome.org/glib/2.26/glib-GVariant.html package glib // #include "gvariant.go.h" // #include "glib.go.h" import "C" import ( "errors" "fmt" "runtime" "unsafe" ) /* * GVariant */ // IVariant is an interface type implemented by Variant and all types which embed // an Variant. It is meant to be used as a type for function arguments which // require GVariants or any subclasses thereof. type IVariant interface { ToGVariant() *C.GVariant ToVariant() *Variant } // A Variant is a representation of GLib's GVariant. type Variant struct { GVariant *C.GVariant } // ToGVariant exposes the underlying *C.GVariant type for this Variant, // necessary to implement IVariant. func (v *Variant) ToGVariant() *C.GVariant { if v == nil { return nil } return v.native() } // ToVariant returns this Variant, necessary to implement IVariant. func (v *Variant) ToVariant() *Variant { return v } // native returns a pointer to the underlying GVariant. func (v *Variant) native() *C.GVariant { if v == nil || v.GVariant == nil { return nil } return v.GVariant } // Native returns a pointer to the underlying GVariant. func (v *Variant) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } // newVariant wraps a native GVariant. // Does NOT handle reference counting! Use takeVariant() to take ownership of values. func newVariant(p *C.GVariant) *Variant { if p == nil { return nil } return &Variant{GVariant: p} } // TakeVariant wraps a unsafe.Pointer as a glib.Variant, taking ownership of it. // This function is exported for visibility in other gotk3 packages and // is not meant to be used by applications. func TakeVariant(ptr unsafe.Pointer) *Variant { return takeVariant(C.toGVariant(ptr)) } // takeVariant wraps a native GVariant, // takes ownership and sets up a finalizer to free the instance during GC. func takeVariant(p *C.GVariant) *Variant { if p == nil { return nil } obj := &Variant{GVariant: p} if obj.IsFloating() { obj.RefSink() } else { obj.Ref() } runtime.SetFinalizer(obj, func(v *Variant) { FinalizerStrategy(v.Unref) }) return obj } // IsFloating returns true if the variant has a floating reference count. // Reference counting is usually handled in the gotk layer, // most applications should not call this. func (v *Variant) IsFloating() bool { return gobool(C.g_variant_is_floating(v.native())) } // Ref is a wrapper around g_variant_ref. // Reference counting is usually handled in the gotk layer, // most applications should not need to call this. func (v *Variant) Ref() { C.g_variant_ref(v.native()) } // RefSink is a wrapper around g_variant_ref_sink. // Reference counting is usually handled in the gotk layer, // most applications should not need to call this. func (v *Variant) RefSink() { C.g_variant_ref_sink(v.native()) } // TakeRef is a wrapper around g_variant_take_ref. // Reference counting is usually handled in the gotk layer, // most applications should not need to call this. func (v *Variant) TakeRef() { C.g_variant_take_ref(v.native()) } // Unref is a wrapper around g_variant_unref. // Reference counting is usually handled in the gotk layer, // most applications should not need to call this. func (v *Variant) Unref() { C.g_variant_unref(v.native()) } // VariantFromInt16 is a wrapper around g_variant_new_int16 func VariantFromInt16(value int16) *Variant { return takeVariant(C.g_variant_new_int16(C.gint16(value))) } // VariantFromInt32 is a wrapper around g_variant_new_int32 func VariantFromInt32(value int32) *Variant { return takeVariant(C.g_variant_new_int32(C.gint32(value))) } // VariantFromInt64 is a wrapper around g_variant_new_int64 func VariantFromInt64(value int64) *Variant { return takeVariant(C.g_variant_new_int64(C.gint64(value))) } // VariantFromByte is a wrapper around g_variant_new_byte func VariantFromByte(value uint8) *Variant { return takeVariant(C.g_variant_new_byte(C.guint8(value))) } // VariantFromUint16 is a wrapper around g_variant_new_uint16 func VariantFromUint16(value uint16) *Variant { return takeVariant(C.g_variant_new_uint16(C.guint16(value))) } // VariantFromUint32 is a wrapper around g_variant_new_uint32 func VariantFromUint32(value uint32) *Variant { return takeVariant(C.g_variant_new_uint32(C.guint32(value))) } // VariantFromUint64 is a wrapper around g_variant_new_uint64 func VariantFromUint64(value uint64) *Variant { return takeVariant(C.g_variant_new_uint64(C.guint64(value))) } // VariantFromBoolean is a wrapper around g_variant_new_boolean func VariantFromBoolean(value bool) *Variant { return takeVariant(C.g_variant_new_boolean(gbool(value))) } // VariantFromFloat64 is a wrapper around g_variant_new_double(). // I chose to respect the Golang float64 nomenclature instead // of 'double' 'C'. Corresponding VariantType is: 'VARIANT_TYPE_DOUBLE' func VariantFromFloat64(value float64) *Variant { return takeVariant(C.g_variant_new_double(C.gdouble(value))) } // VariantFromString is a wrapper around g_variant_new_string/g_variant_new_take_string. // Uses g_variant_new_take_string to reduce memory allocations if possible. func VariantFromString(value string) *Variant { cstr := (*C.gchar)(C.CString(value)) // g_variant_new_take_string takes owhership of the cstring and will call free() on it when done. // Do NOT free this string in this function! return takeVariant(C.g_variant_new_take_string(cstr)) } // VariantFromVariant is a wrapper around g_variant_new_variant. func VariantFromVariant(value *Variant) *Variant { return takeVariant(C.g_variant_new_variant(value.native())) } // TypeString returns the g variant type string for this variant. func (v *Variant) TypeString() string { // the string returned from this belongs to GVariant and must not be freed. return C.GoString((*C.char)(C.g_variant_get_type_string(v.native()))) } // IsContainer returns true if the variant is a container and false otherwise. func (v *Variant) IsContainer() bool { return gobool(C.g_variant_is_container(v.native())) } // GetBoolean returns the bool value of this variant. func (v *Variant) GetBoolean() bool { return gobool(C.g_variant_get_boolean(v.native())) } // GetDouble is a wrapper around g_variant_get_double() func (v *Variant) GetDouble() float64 { return float64(C.g_variant_get_double(v.native())) } // GetString is a wrapper around g_variant_get_string. // It returns the string value of the variant. func (v *Variant) GetString() string { // The string value remains valid as long as the GVariant exists, do NOT free the cstring in this function. var len C.gsize gc := C.g_variant_get_string(v.native(), &len) // This is opposed to g_variant_dup_string, which copies the string. // g_variant_dup_string is not implemented, // as we copy the string value anyways when converting to a go string. return C.GoStringN((*C.char)(gc), (C.int)(len)) } // GetVariant is a wrapper around g_variant_get_variant. // It unboxes a nested GVariant. func (v *Variant) GetVariant() *Variant { c := C.g_variant_get_variant(v.native()) if c == nil { return nil } // The returned value is returned with full ownership transfer, // only Unref(), don't Ref(). obj := newVariant(c) runtime.SetFinalizer(obj, func(v *Variant) { FinalizerStrategy(v.Unref) }) return obj } // GetStrv returns a slice of strings from this variant. It wraps // g_variant_get_strv, but returns copies of the strings instead. func (v *Variant) GetStrv() []string { gstrv := C.g_variant_get_strv(v.native(), nil) // we do not own the memory for these strings, so we must not use strfreev // but we must free the actual pointer we receive (transfer container). // We don't implement g_variant_dup_strv which copies the strings, // as we need to copy anyways when converting to go strings. c := gstrv defer C.g_free(C.gpointer(gstrv)) var strs []string for *c != nil { strs = append(strs, C.GoString((*C.char)(*c))) c = C.next_gcharptr(c) } return strs } // GetObjv returns a slice of object paths from this variant. It wraps // g_variant_get_objv, but returns copies of the strings instead. func (v *Variant) GetObjv() []string { gstrv := C.g_variant_get_objv(v.native(), nil) // we do not own the memory for these strings, so we must not use strfreev // but we must free the actual pointer we receive (transfer container). // We don't implement g_variant_dup_objv which copies the strings, // as we need to copy anyways when converting to go strings. c := gstrv defer C.g_free(C.gpointer(gstrv)) var strs []string for *c != nil { strs = append(strs, C.GoString((*C.char)(*c))) c = C.next_gcharptr(c) } return strs } // GetInt returns the int64 value of the variant if it is an integer type, and // an error otherwise. It wraps variouns `g_variant_get_*` functions dealing // with integers of different sizes. func (v *Variant) GetInt() (int64, error) { t := v.TypeString() var i int64 switch t { case "n": i = int64(C.g_variant_get_int16(v.native())) case "i": i = int64(C.g_variant_get_int32(v.native())) case "x": i = int64(C.g_variant_get_int64(v.native())) default: return 0, fmt.Errorf("variant type %s not a signed integer type", t) } return i, nil } // GetUint returns the uint64 value of the variant if it is an integer type, and // an error otherwise. It wraps variouns `g_variant_get_*` functions dealing // with integers of different sizes. func (v *Variant) GetUint() (uint64, error) { t := v.TypeString() var i uint64 switch t { case "y": i = uint64(C.g_variant_get_byte(v.native())) case "q": i = uint64(C.g_variant_get_uint16(v.native())) case "u": i = uint64(C.g_variant_get_uint32(v.native())) case "t": i = uint64(C.g_variant_get_uint64(v.native())) default: return 0, fmt.Errorf("variant type %s not an unsigned integer type", t) } return i, nil } // Type returns the VariantType for this variant. func (v *Variant) Type() *VariantType { // The return value is valid for the lifetime of value and must not be freed. return newVariantType(C.g_variant_get_type(v.native())) } // IsType returns true if the variant's type matches t. func (v *Variant) IsType(t *VariantType) bool { return gobool(C.g_variant_is_of_type(v.native(), t.native())) } // String wraps g_variant_print(). It returns a string understood // by g_variant_parse(). func (v *Variant) String() string { gc := C.g_variant_print(v.native(), gbool(false)) defer C.g_free(C.gpointer(gc)) return C.GoString((*C.char)(gc)) } // AnnotatedString wraps g_variant_print(), but returns a type-annotated // string. func (v *Variant) AnnotatedString() string { gc := C.g_variant_print(v.native(), gbool(true)) defer C.g_free(C.gpointer(gc)) return C.GoString((*C.char)(gc)) } // TODO: //gint g_variant_compare () //GVariantClass g_variant_classify () //gboolean g_variant_check_format_string () //void g_variant_get () //void g_variant_get_va () //GVariant * g_variant_new () //GVariant * g_variant_new_va () //GVariant * g_variant_new_handle () //GVariant * g_variant_new_printf () //GVariant * g_variant_new_object_path () //gboolean g_variant_is_object_path () //GVariant * g_variant_new_signature () //gboolean g_variant_is_signature () //GVariant * g_variant_new_strv () //GVariant * g_variant_new_objv () //GVariant * g_variant_new_bytestring () //GVariant * g_variant_new_bytestring_array () //guchar g_variant_get_byte () //gint16 g_variant_get_int16 () //guint16 g_variant_get_uint16 () //gint32 g_variant_get_int32 () //guint32 g_variant_get_uint32 () //gint64 g_variant_get_int64 () //guint64 g_variant_get_uint64 () //gint32 g_variant_get_handle () //gdouble g_variant_get_double () //const gchar * g_variant_get_bytestring () //gchar * g_variant_dup_bytestring () //const gchar ** g_variant_get_bytestring_array () //gchar ** g_variant_dup_bytestring_array () //GVariant * g_variant_new_maybe () //GVariant * g_variant_new_array () //GVariant * g_variant_new_tuple () //GVariant * g_variant_new_dict_entry () //GVariant * g_variant_new_fixed_array () //GVariant * g_variant_get_maybe () //gsize g_variant_n_children () //GVariant * g_variant_get_child_value () //void g_variant_get_child () //GVariant * g_variant_lookup_value () //gboolean g_variant_lookup () //gconstpointer g_variant_get_fixed_array () //gsize g_variant_get_size () //gconstpointer g_variant_get_data () //GBytes * g_variant_get_data_as_bytes () //void g_variant_store () //GVariant * g_variant_new_from_data () //GVariant * g_variant_new_from_bytes () //GVariant * g_variant_byteswap () //GVariant * g_variant_get_normal_form () //gboolean g_variant_is_normal_form () //guint g_variant_hash () //gboolean g_variant_equal () //gchar * g_variant_print () //GString * g_variant_print_string () //GVariantIter * g_variant_iter_copy () //void g_variant_iter_free () //gsize g_variant_iter_init () //gsize g_variant_iter_n_children () //GVariantIter * g_variant_iter_new () //GVariant * g_variant_iter_next_value () //gboolean g_variant_iter_next () //gboolean g_variant_iter_loop () //void g_variant_builder_unref () //GVariantBuilder * g_variant_builder_ref () //GVariantBuilder * g_variant_builder_new () //void g_variant_builder_init () //void g_variant_builder_clear () //void g_variant_builder_add_value () //void g_variant_builder_add () //void g_variant_builder_add_parsed () //GVariant * g_variant_builder_end () //void g_variant_builder_open () //void g_variant_builder_close () //void g_variant_dict_unref () //GVariantDict * g_variant_dict_ref () //GVariantDict * g_variant_dict_new () //void g_variant_dict_init () //void g_variant_dict_clear () //gboolean g_variant_dict_contains () //gboolean g_variant_dict_lookup () //GVariant * g_variant_dict_lookup_value () //void g_variant_dict_insert () //void g_variant_dict_insert_value () //gboolean g_variant_dict_remove () //GVariant * g_variant_dict_end () //#define G_VARIANT_PARSE_ERROR // VariantParse is a wrapper around g_variant_parse() func VariantParse(vType *VariantType, text string) (*Variant, error) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) var gerr *C.GError c := C.g_variant_parse(vType.native(), (*C.gchar)(cstr), nil, nil, &gerr) if c == nil { defer C.g_error_free(gerr) return nil, errors.New(goString(gerr.message)) } // will be freed during GC return takeVariant(c), nil } //GVariant * g_variant_new_parsed_va () //GVariant * g_variant_new_parsed () //gchar * g_variant_parse_error_print_context () gotk3-0.6.2/glib/gvariant.go.h000066400000000000000000000012101431157473000160520ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // GVariant : GVariant — strongly typed value datatype // https://developer.gnome.org/glib/2.26/glib-GVariant.html #ifndef __GVARIANT_GO_H__ #define __GVARIANT_GO_H__ #include #include #include #include // Type Casting static GVariant *toGVariant(void *p) { return (GVariant *)p; } static GVariantBuilder *toGVariantBuilder(void *p) { return (GVariantBuilder *)p; } static GVariantDict *toGVariantDict(void *p) { return (GVariantDict *)p; } static GVariantIter *toGVariantIter(void *p) { return (GVariantIter *)p; } #endif gotk3-0.6.2/glib/gvariant_test.go000066400000000000000000000102311431157473000166660ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package glib_test import ( "math" "testing" "github.com/gotk3/gotk3/glib" ) func TestVariantGetInt(t *testing.T) { t.Run("int16", func(t *testing.T) { expected := int16(math.MinInt16) variant := glib.VariantFromInt16(expected) actual, err := variant.GetInt() if err != nil { t.Error("Unexpected error:", err.Error()) } if int64(expected) != actual { t.Error("Expected", expected, "got", actual) } }) t.Run("int32", func(t *testing.T) { expected := int32(math.MinInt32) variant := glib.VariantFromInt32(expected) actual, err := variant.GetInt() if err != nil { t.Error("Unexpected error:", err.Error()) } if int64(expected) != actual { t.Error("Expected", expected, "got", actual) } }) t.Run("int64", func(t *testing.T) { expected := int64(math.MinInt64) variant := glib.VariantFromInt64(expected) actual, err := variant.GetInt() if err != nil { t.Error("Unexpected error:", err.Error()) } if expected != actual { t.Error("Expected", expected, "got", actual) } }) t.Run("other type", func(t *testing.T) { variant := glib.VariantFromUint64(987) _, err := variant.GetInt() if err == nil { t.Error("expected error, did not get one") } }) } func TestVariantGetUint(t *testing.T) { t.Run("byte", func(t *testing.T) { expected := uint8(math.MaxUint8) variant := glib.VariantFromByte(expected) actual, err := variant.GetUint() if err != nil { t.Error("Unexpected error:", err.Error()) } if uint64(expected) != actual { t.Error("Expected", expected, "got", actual) } }) t.Run("int16", func(t *testing.T) { expected := uint16(math.MaxUint16) variant := glib.VariantFromUint16(expected) actual, err := variant.GetUint() if err != nil { t.Error("Unexpected error:", err.Error()) } if uint64(expected) != actual { t.Error("Expected", expected, "got", actual) } }) t.Run("int32", func(t *testing.T) { expected := uint32(math.MaxUint32) variant := glib.VariantFromUint32(expected) actual, err := variant.GetUint() if err != nil { t.Error("Unexpected error:", err.Error()) } if uint64(expected) != actual { t.Error("Expected", expected, "got", actual) } }) t.Run("int64", func(t *testing.T) { expected := uint64(math.MaxUint64) variant := glib.VariantFromUint64(expected) actual, err := variant.GetUint() if err != nil { t.Error("Unexpected error:", err.Error()) } if expected != actual { t.Error("Expected", expected, "got", actual) } }) t.Run("other type", func(t *testing.T) { variant := glib.VariantFromInt64(987) _, err := variant.GetUint() if err == nil { t.Error("expected error, did not get one") } }) } func TestVariantType(t *testing.T) { variant := glib.VariantFromBoolean(true) variantType := variant.Type() if !glib.VariantTypeEqual(glib.VARIANT_TYPE_BOOLEAN, variantType) { t.Error("Expected", glib.VARIANT_TYPE_BOOLEAN, "got", variantType) } } func TestVariantBool(t *testing.T) { testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "false", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { variant := glib.VariantFromBoolean(tC.value) actual := variant.GetBoolean() if tC.value != actual { t.Error("Expected", tC.value, "got", actual) } }) } } func TestVariantString(t *testing.T) { testCases := []struct { desc string value string }{ { desc: "Plain string", value: "Simple Data", }, { desc: "String with special characters", value: "Üö@/Data", }, { desc: "Empty String", value: "", }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { variant := glib.VariantFromString(tC.value) actual := variant.GetString() if tC.value != actual { t.Error("Expected", tC.value, "got", actual) } }) } } func TestVariantVariant(t *testing.T) { boxed := glib.VariantFromString("I'm in a box") variant := glib.VariantFromVariant(boxed) actual := variant.GetVariant() if boxed.Native() != actual.Native() { t.Error("Expected", boxed.Native(), "got", actual.Native()) } } gotk3-0.6.2/glib/gvariantbuilder.go000066400000000000000000000024021431157473000171770ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // GVariant : GVariant — strongly typed value datatype // https://developer.gnome.org/glib/2.26/glib-GVariant.html package glib // #include // #include // #include "glib.go.h" // #include "gvariant.go.h" import "C" import "unsafe" /* * GVariantBuilder */ // VariantBuilder is a representation of GLib's VariantBuilder. type VariantBuilder struct { GVariantBuilder *C.GVariantBuilder } func (v *VariantBuilder) toGVariantBuilder() *C.GVariantBuilder { if v == nil { return nil } return v.native() } func (v *VariantBuilder) toVariantBuilder() *VariantBuilder { return v } // newVariantBuilder creates a new VariantBuilder from a GVariantBuilder pointer. func newVariantBuilder(p *C.GVariantBuilder) *VariantBuilder { return &VariantBuilder{GVariantBuilder: p} } // native returns a pointer to the underlying GVariantBuilder. func (v *VariantBuilder) native() *C.GVariantBuilder { if v == nil || v.GVariantBuilder == nil { return nil } p := unsafe.Pointer(v.GVariantBuilder) return C.toGVariantBuilder(p) } // Native returns a pointer to the underlying GVariantBuilder. func (v *VariantBuilder) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } gotk3-0.6.2/glib/gvariantclass.go000066400000000000000000000045101431157473000166600ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project //GVariant : GVariant — strongly typed value datatype // https://developer.gnome.org/glib/2.26/glib-GVariant.html package glib // #include // #include // #include "glib.go.h" // #include "gvariant.go.h" import "C" /* * GVariantClass */ type VariantClass int const ( VARIANT_CLASS_BOOLEAN VariantClass = C.G_VARIANT_CLASS_BOOLEAN //The GVariant is a boolean. VARIANT_CLASS_BYTE VariantClass = C.G_VARIANT_CLASS_BYTE //The GVariant is a byte. VARIANT_CLASS_INT16 VariantClass = C.G_VARIANT_CLASS_INT16 //The GVariant is a signed 16 bit integer. VARIANT_CLASS_UINT16 VariantClass = C.G_VARIANT_CLASS_UINT16 //The GVariant is an unsigned 16 bit integer. VARIANT_CLASS_INT32 VariantClass = C.G_VARIANT_CLASS_INT32 //The GVariant is a signed 32 bit integer. VARIANT_CLASS_UINT32 VariantClass = C.G_VARIANT_CLASS_UINT32 //The GVariant is an unsigned 32 bit integer. VARIANT_CLASS_INT64 VariantClass = C.G_VARIANT_CLASS_INT64 //The GVariant is a signed 64 bit integer. VARIANT_CLASS_UINT64 VariantClass = C.G_VARIANT_CLASS_UINT64 //The GVariant is an unsigned 64 bit integer. VARIANT_CLASS_HANDLE VariantClass = C.G_VARIANT_CLASS_HANDLE //The GVariant is a file handle index. VARIANT_CLASS_DOUBLE VariantClass = C.G_VARIANT_CLASS_DOUBLE //The GVariant is a double precision floating point value. VARIANT_CLASS_STRING VariantClass = C.G_VARIANT_CLASS_STRING //The GVariant is a normal string. VARIANT_CLASS_OBJECT_PATH VariantClass = C.G_VARIANT_CLASS_OBJECT_PATH //The GVariant is a D-Bus object path string. VARIANT_CLASS_SIGNATURE VariantClass = C.G_VARIANT_CLASS_SIGNATURE //The GVariant is a D-Bus signature string. VARIANT_CLASS_VARIANT VariantClass = C.G_VARIANT_CLASS_VARIANT //The GVariant is a variant. VARIANT_CLASS_MAYBE VariantClass = C.G_VARIANT_CLASS_MAYBE //The GVariant is a maybe-typed value. VARIANT_CLASS_ARRAY VariantClass = C.G_VARIANT_CLASS_ARRAY //The GVariant is an array. VARIANT_CLASS_TUPLE VariantClass = C.G_VARIANT_CLASS_TUPLE //The GVariant is a tuple. VARIANT_CLASS_DICT_ENTRY VariantClass = C.G_VARIANT_CLASS_DICT_ENTRY //The GVariant is a dictionary entry. ) gotk3-0.6.2/glib/gvariantdict.go000066400000000000000000000022551431157473000165020ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project //GVariant : GVariant — strongly typed value datatype // https://developer.gnome.org/glib/2.26/glib-GVariant.html package glib // #include // #include // #include "glib.go.h" // #include "gvariant.go.h" import "C" import "unsafe" /* * GVariantDict */ // VariantDict is a representation of GLib's VariantDict. type VariantDict struct { GVariantDict *C.GVariantDict } func (v *VariantDict) toGVariantDict() *C.GVariantDict { if v == nil { return nil } return v.native() } func (v *VariantDict) toVariantDict() *VariantDict { return v } // newVariantDict creates a new VariantDict from a GVariantDict pointer. func newVariantDict(p *C.GVariantDict) *VariantDict { return &VariantDict{GVariantDict: p} } // native returns a pointer to the underlying GVariantDict. func (v *VariantDict) native() *C.GVariantDict { if v == nil || v.GVariantDict == nil { return nil } p := unsafe.Pointer(v.GVariantDict) return C.toGVariantDict(p) } // Native returns a pointer to the underlying GVariantDict. func (v *VariantDict) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } gotk3-0.6.2/glib/gvariantiter.go000066400000000000000000000022561431157473000165230ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project //GVariant : GVariant — strongly typed value datatype // https://developer.gnome.org/glib/2.26/glib-GVariant.html package glib // #include // #include // #include "glib.go.h" // #include "gvariant.go.h" import "C" import "unsafe" /* * GVariantIter */ // VariantIter is a representation of GLib's GVariantIter. type VariantIter struct { GVariantIter *C.GVariantIter } func (v *VariantIter) toGVariantIter() *C.GVariantIter { if v == nil { return nil } return v.native() } func (v *VariantIter) toVariantIter() *VariantIter { return v } // newVariantIter creates a new VariantIter from a GVariantIter pointer. func newVariantIter(p *C.GVariantIter) *VariantIter { return &VariantIter{GVariantIter: p} } // native returns a pointer to the underlying GVariantIter. func (v *VariantIter) native() *C.GVariantIter { if v == nil || v.GVariantIter == nil { return nil } p := unsafe.Pointer(v.GVariantIter) return C.toGVariantIter(p) } // Native returns a pointer to the underlying GVariantIter. func (v *VariantIter) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } gotk3-0.6.2/glib/gvarianttype.go000066400000000000000000000124171431157473000165410ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project //GVariant : GVariant — strongly typed value datatype // https://developer.gnome.org/glib/2.26/glib-GVariant.html package glib // #include // #include // #include "gvarianttype.go.h" import "C" import ( "runtime" "unsafe" ) // A VariantType is a wrapper for the GVariantType, which encodes type // information for GVariants. type VariantType struct { GVariantType *C.GVariantType } func (v *VariantType) native() *C.GVariantType { if v == nil { return nil } return v.GVariantType } // String returns a copy of this VariantType's type string. func (v *VariantType) String() string { ch := C.g_variant_type_dup_string(v.native()) defer C.g_free(C.gpointer(ch)) return C.GoString((*C.char)(ch)) } // newVariantType wraps a native GVariantType. // Does not create a finalizer. // Use takeVariantType for instances which need to be freed after use. func newVariantType(v *C.GVariantType) *VariantType { if v == nil { return nil } return &VariantType{v} } // takeVariantType wraps a native GVariantType // and sets up a finalizer to free the instance during GC. func takeVariantType(v *C.GVariantType) *VariantType { if v == nil { return nil } obj := &VariantType{v} runtime.SetFinalizer(obj, func(v *VariantType) { FinalizerStrategy(v.Free) }) return obj } // Variant types for comparing between them. Cannot be const because // they are pointers. // Note that variant types cannot be compared by value, use VariantTypeEqual() instead. var ( VARIANT_TYPE_BOOLEAN = newVariantType(C._G_VARIANT_TYPE_BOOLEAN) VARIANT_TYPE_BYTE = newVariantType(C._G_VARIANT_TYPE_BYTE) VARIANT_TYPE_INT16 = newVariantType(C._G_VARIANT_TYPE_INT16) VARIANT_TYPE_UINT16 = newVariantType(C._G_VARIANT_TYPE_UINT16) VARIANT_TYPE_INT32 = newVariantType(C._G_VARIANT_TYPE_INT32) VARIANT_TYPE_UINT32 = newVariantType(C._G_VARIANT_TYPE_UINT32) VARIANT_TYPE_INT64 = newVariantType(C._G_VARIANT_TYPE_INT64) VARIANT_TYPE_UINT64 = newVariantType(C._G_VARIANT_TYPE_UINT64) VARIANT_TYPE_HANDLE = newVariantType(C._G_VARIANT_TYPE_HANDLE) VARIANT_TYPE_DOUBLE = newVariantType(C._G_VARIANT_TYPE_DOUBLE) VARIANT_TYPE_STRING = newVariantType(C._G_VARIANT_TYPE_STRING) VARIANT_TYPE_OBJECT_PATH = newVariantType(C._G_VARIANT_TYPE_OBJECT_PATH) VARIANT_TYPE_SIGNATURE = newVariantType(C._G_VARIANT_TYPE_SIGNATURE) VARIANT_TYPE_VARIANT = newVariantType(C._G_VARIANT_TYPE_VARIANT) VARIANT_TYPE_ANY = newVariantType(C._G_VARIANT_TYPE_ANY) VARIANT_TYPE_BASIC = newVariantType(C._G_VARIANT_TYPE_BASIC) VARIANT_TYPE_MAYBE = newVariantType(C._G_VARIANT_TYPE_MAYBE) VARIANT_TYPE_ARRAY = newVariantType(C._G_VARIANT_TYPE_ARRAY) VARIANT_TYPE_TUPLE = newVariantType(C._G_VARIANT_TYPE_TUPLE) VARIANT_TYPE_UNIT = newVariantType(C._G_VARIANT_TYPE_UNIT) VARIANT_TYPE_DICT_ENTRY = newVariantType(C._G_VARIANT_TYPE_DICT_ENTRY) VARIANT_TYPE_DICTIONARY = newVariantType(C._G_VARIANT_TYPE_DICTIONARY) VARIANT_TYPE_STRING_ARRAY = newVariantType(C._G_VARIANT_TYPE_STRING_ARRAY) VARIANT_TYPE_OBJECT_PATH_ARRAY = newVariantType(C._G_VARIANT_TYPE_OBJECT_PATH_ARRAY) VARIANT_TYPE_BYTESTRING = newVariantType(C._G_VARIANT_TYPE_BYTESTRING) VARIANT_TYPE_BYTESTRING_ARRAY = newVariantType(C._G_VARIANT_TYPE_BYTESTRING_ARRAY) VARIANT_TYPE_VARDICT = newVariantType(C._G_VARIANT_TYPE_VARDICT) ) // Free is a wrapper around g_variant_type_free. // Reference counting is usually handled in the gotk layer, // most applications should not call this. func (v *VariantType) Free() { C.g_variant_type_free(v.native()) } // VariantTypeNew is a wrapper around g_variant_type_new. func VariantTypeNew(typeString string) *VariantType { cstr := (*C.gchar)(C.CString(typeString)) defer C.free(unsafe.Pointer(cstr)) c := C.g_variant_type_new(cstr) return takeVariantType(c) } // VariantTypeStringIsValid is a wrapper around g_variant_type_string_is_valid. func VariantTypeStringIsValid(typeString string) bool { cstr := (*C.gchar)(C.CString(typeString)) defer C.free(unsafe.Pointer(cstr)) return gobool(C.g_variant_type_string_is_valid(cstr)) } // VariantTypeEqual is a wrapper around g_variant_type_equal func VariantTypeEqual(type1, type2 *VariantType) bool { return gobool(C.g_variant_type_equal(C.gconstpointer(type1.native()), C.gconstpointer(type2.native()))) } // IsSubtypeOf is a wrapper around g_variant_type_is_subtype_of func (v *VariantType) IsSubtypeOf(supertype *VariantType) bool { return gobool(C.g_variant_type_is_subtype_of(v.native(), supertype.native())) } // TODO: // g_variant_type_copy // g_variant_type_string_scan // g_variant_type_is_definite // g_variant_type_is_container // g_variant_type_is_basic // g_variant_type_is_maybe // g_variant_type_is_array // g_variant_type_is_tuple // g_variant_type_is_dict_entry // g_variant_type_is_variant // g_variant_type_hash // g_variant_type_new_maybe // g_variant_type_new_array // g_variant_type_new_tuple // g_variant_type_new_dict_entry // g_variant_type_element // g_variant_type_n_items // g_variant_type_first // g_variant_type_next // g_variant_type_key // g_variant_type_value gotk3-0.6.2/glib/gvarianttype.go.h000066400000000000000000000041771431157473000167730ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // GVariant : GVariant — strongly typed value datatype // https://developer.gnome.org/glib/2.26/glib-GVariant.html #ifndef __GVARIANTTYPE_GO_H__ #define __GVARIANTTYPE_GO_H__ const GVariantType *_G_VARIANT_TYPE_BOOLEAN = G_VARIANT_TYPE_BOOLEAN; const GVariantType *_G_VARIANT_TYPE_BYTE = G_VARIANT_TYPE_BYTE; const GVariantType *_G_VARIANT_TYPE_INT16 = G_VARIANT_TYPE_INT16; const GVariantType *_G_VARIANT_TYPE_UINT16 = G_VARIANT_TYPE_UINT16; const GVariantType *_G_VARIANT_TYPE_INT32 = G_VARIANT_TYPE_INT32; const GVariantType *_G_VARIANT_TYPE_UINT32 = G_VARIANT_TYPE_UINT32; const GVariantType *_G_VARIANT_TYPE_INT64 = G_VARIANT_TYPE_INT64; const GVariantType *_G_VARIANT_TYPE_UINT64 = G_VARIANT_TYPE_UINT64; const GVariantType *_G_VARIANT_TYPE_HANDLE = G_VARIANT_TYPE_HANDLE; const GVariantType *_G_VARIANT_TYPE_DOUBLE = G_VARIANT_TYPE_DOUBLE; const GVariantType *_G_VARIANT_TYPE_STRING = G_VARIANT_TYPE_STRING; const GVariantType *_G_VARIANT_TYPE_OBJECT_PATH = G_VARIANT_TYPE_OBJECT_PATH; const GVariantType *_G_VARIANT_TYPE_SIGNATURE = G_VARIANT_TYPE_SIGNATURE; const GVariantType *_G_VARIANT_TYPE_VARIANT = G_VARIANT_TYPE_VARIANT; const GVariantType *_G_VARIANT_TYPE_ANY = G_VARIANT_TYPE_ANY; const GVariantType *_G_VARIANT_TYPE_BASIC = G_VARIANT_TYPE_BASIC; const GVariantType *_G_VARIANT_TYPE_MAYBE = G_VARIANT_TYPE_MAYBE; const GVariantType *_G_VARIANT_TYPE_ARRAY = G_VARIANT_TYPE_ARRAY; const GVariantType *_G_VARIANT_TYPE_TUPLE = G_VARIANT_TYPE_TUPLE; const GVariantType *_G_VARIANT_TYPE_UNIT = G_VARIANT_TYPE_UNIT; const GVariantType *_G_VARIANT_TYPE_DICT_ENTRY = G_VARIANT_TYPE_DICT_ENTRY; const GVariantType *_G_VARIANT_TYPE_DICTIONARY = G_VARIANT_TYPE_DICTIONARY; const GVariantType *_G_VARIANT_TYPE_STRING_ARRAY = G_VARIANT_TYPE_STRING_ARRAY; const GVariantType *_G_VARIANT_TYPE_OBJECT_PATH_ARRAY = G_VARIANT_TYPE_OBJECT_PATH_ARRAY; const GVariantType *_G_VARIANT_TYPE_BYTESTRING = G_VARIANT_TYPE_BYTESTRING; const GVariantType *_G_VARIANT_TYPE_BYTESTRING_ARRAY = G_VARIANT_TYPE_BYTESTRING_ARRAY; const GVariantType *_G_VARIANT_TYPE_VARDICT = G_VARIANT_TYPE_VARDICT; #endif gotk3-0.6.2/glib/gvarianttype_test.go000066400000000000000000000046461431157473000176050ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package glib_test import ( "testing" "github.com/gotk3/gotk3/glib" ) func TestVariantTypeEqual(t *testing.T) { testCases := []struct { desc string type1 *glib.VariantType type2 *glib.VariantType expected bool }{ { desc: "bool == bool constants", type1: glib.VARIANT_TYPE_BOOLEAN, type2: glib.VARIANT_TYPE_BOOLEAN, expected: true, }, { desc: "bool != string constants", type1: glib.VARIANT_TYPE_BOOLEAN, type2: glib.VARIANT_TYPE_STRING, expected: false, }, { desc: "bool == bool dynamic", type1: glib.VARIANT_TYPE_BOOLEAN, type2: glib.VariantTypeNew("b"), expected: true, }, { desc: "bool != string dynamic", type1: glib.VariantTypeNew("b"), type2: glib.VariantTypeNew("s"), expected: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { actual := glib.VariantTypeEqual(tC.type1, tC.type2) if tC.expected != actual { t.Error("Expected", tC.expected, "got", actual) } }) } } func TestVariantTypeStringIsValid(t *testing.T) { testCases := []struct { desc string input string expected bool }{ { desc: "String", input: "s", expected: true, }, { desc: "Boolean", input: "b", expected: true, }, { desc: "Tuple of String and Boolean", input: "(sb)", expected: true, }, { desc: "Junk", input: "r{{sb}", expected: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { actual := glib.VariantTypeStringIsValid(tC.input) if tC.expected != actual { t.Error("Expected", tC.expected, "got", actual) } }) } } func TestVariantIsSubtypeOf(t *testing.T) { testCases := []struct { desc string type1 *glib.VariantType superType *glib.VariantType expected bool }{ { desc: "bool is not a supertype", type1: glib.VARIANT_TYPE_STRING, superType: glib.VARIANT_TYPE_BOOLEAN, expected: false, }, { desc: "a* is supertype of as", type1: glib.VariantTypeNew("as"), superType: glib.VariantTypeNew("a*"), expected: true, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { actual := tC.type1.IsSubtypeOf(tC.superType) if tC.expected != actual { t.Error("Expected", tC.expected, "got", actual) } }) } } gotk3-0.6.2/glib/list.go000066400000000000000000000104671431157473000150020ustar00rootroot00000000000000package glib // #include // #include // #include "glib.go.h" import "C" import ( "unsafe" ) /* * Linked Lists */ // List is a representation of Glib's GList. type List struct { list *C.struct__GList // If set, dataWrap is called every time NthData() // or Data() is called to wrap raw underlying // value into appropriate type. dataWrap func(unsafe.Pointer) interface{} } func WrapList(obj uintptr) *List { return wrapList((*C.struct__GList)(unsafe.Pointer(obj))) } func wrapList(obj *C.struct__GList) *List { if obj == nil { return nil } return &List{list: obj} } func (v *List) wrapNewHead(obj *C.struct__GList) *List { if obj == nil { return nil } return &List{ list: obj, dataWrap: v.dataWrap, } } func (v *List) Native() uintptr { return uintptr(unsafe.Pointer(v.list)) } func (v *List) native() *C.struct__GList { if v == nil || v.list == nil { return nil } return v.list } // DataWapper sets wrap functions, which is called during NthData() // and Data(). It's used to cast raw C data into appropriate // Go structures and types every time that data is retreived. func (v *List) DataWrapper(fn func(unsafe.Pointer) interface{}) { if v == nil { return } v.dataWrap = fn } // Append is a wrapper around g_list_append(). func (v *List) Append(data uintptr) *List { glist := C.g_list_append(v.native(), C.gpointer(data)) return v.wrapNewHead(glist) } // Prepend is a wrapper around g_list_prepend(). func (v *List) Prepend(data uintptr) *List { glist := C.g_list_prepend(v.native(), C.gpointer(data)) return v.wrapNewHead(glist) } // Insert is a wrapper around g_list_insert(). func (v *List) Insert(data uintptr, position int) *List { glist := C.g_list_insert(v.native(), C.gpointer(data), C.gint(position)) return v.wrapNewHead(glist) } // Length is a wrapper around g_list_length(). func (v *List) Length() uint { return uint(C.g_list_length(v.native())) } // nthDataRaw is a wrapper around g_list_nth_data(). func (v *List) nthDataRaw(n uint) unsafe.Pointer { return unsafe.Pointer(C.g_list_nth_data(v.native(), C.guint(n))) } // Nth() is a wrapper around g_list_nth(). func (v *List) Nth(n uint) *List { list := wrapList(C.g_list_nth(v.native(), C.guint(n))) list.DataWrapper(v.dataWrap) return list } // NthData acts the same as g_list_nth_data(), but passes // retrieved value before returning through wrap function, set by DataWrapper(). // If no wrap function is set, it returns raw unsafe.Pointer. func (v *List) NthData(n uint) interface{} { ptr := v.nthDataRaw(n) if v.dataWrap != nil { return v.dataWrap(ptr) } return ptr } // Free is a wrapper around g_list_free(). func (v *List) Free() { C.g_list_free(v.native()) } // Next is a wrapper around the next struct field func (v *List) Next() *List { return v.wrapNewHead(v.native().next) } // Previous is a wrapper around the prev struct field func (v *List) Previous() *List { return v.wrapNewHead(v.native().prev) } // First is a wrapper around g_list_first(). func (v *List) First() *List { return v.wrapNewHead(C.g_list_first(v.native())) } // Last is a wrapper around g_list_last(). func (v *List) Last() *List { return v.wrapNewHead(C.g_list_last(v.native())) } // Reverse is a wrapper around g_list_reverse(). func (v *List) Reverse() *List { return v.wrapNewHead(C.g_list_reverse(v.native())) } // dataRaw is a wrapper around the data struct field func (v *List) dataRaw() unsafe.Pointer { return unsafe.Pointer(v.native().data) } // Data acts the same as data struct field, but passes // retrieved value before returning through wrap function, set by DataWrapper(). // If no wrap function is set, it returns raw unsafe.Pointer. func (v *List) Data() interface{} { ptr := v.dataRaw() if v.dataWrap != nil { return v.dataWrap(ptr) } return ptr } // Foreach acts the same as g_list_foreach(). // No user_data argument is implemented because of Go clojure capabilities. func (v *List) Foreach(fn func(item interface{})) { for l := v; l != nil; l = l.Next() { fn(l.Data()) } } // FreeFull acts the same as g_list_free_full(). // Calling list.FreeFull(fn) is equivalent to calling list.Foreach(fn) and // list.Free() sequentially. func (v *List) FreeFull(fn func(item interface{})) { v.Foreach(fn) v.Free() } // CompareDataFunc is a representation of GCompareDataFunc type CompareDataFunc func(a, b uintptr) int gotk3-0.6.2/glib/list_test.go000066400000000000000000000035531431157473000160370ustar00rootroot00000000000000package glib import ( "fmt" "testing" "unsafe" ) func TestList_Basics(t *testing.T) { list := (&List{}).Append(0).Append(1).Append(2) if list.Length() != 3 { t.Errorf("Length of list with 3 appended elements must be 3. (Got %v).", list.Length()) } list = (&List{}).Prepend(0).Prepend(1).Prepend(2) if list.Length() != 3 { t.Errorf("Length of list with 3 prepended elements must be 3. (Got %v).", list.Length()) } list = (&List{}).Insert(0, 0).Insert(1, 0).Insert(2, 0) if list.Length() != 3 { t.Errorf("Length of list with 3 inserted elements must be 3. (Got %v).", list.Length()) } } func TestList_DataWrapper(t *testing.T) { list := (&List{}).Append(0).Append(1).Append(2) list.DataWrapper(func(ptr unsafe.Pointer) interface{} { return fmt.Sprintf("Value %v", uintptr(ptr)) }) i := 0 for l := list; l != nil; l = l.Next() { expect := fmt.Sprintf("Value %v", i) i++ actual, ok := l.Data().(string) if !ok { t.Error("DataWrapper must have returned a string!") } if actual != expect { t.Errorf("DataWrapper returned unexpected result. Expected '%v', got '%v'.", expect, actual) } } } func TestList_Foreach(t *testing.T) { list := (&List{}).Append(0).Append(1).Append(2) list.DataWrapper(func(ptr unsafe.Pointer) interface{} { return int(uintptr(ptr) + 1) }) sum := 0 list.Foreach(func(item interface{}) { sum += item.(int) }) if sum != 6 { t.Errorf("Foreach resulted into wrong sum. Got %v, expected %v.", sum, 6) } } func TestList_Nth(t *testing.T) { list := (&List{}).Append(0).Append(1).Append(2) list.DataWrapper(func(ptr unsafe.Pointer) interface{} { return int(uintptr(ptr) + 1) }) for i := uint(0); i < 3; i++ { nth := list.Nth(i).Data().(int) nthData := list.NthData(i).(int) if nth != nthData { t.Errorf("%v's element didn't match. Nth->Data returned %v; NthData returned %v.", i, nth, nthData) } } } gotk3-0.6.2/glib/menu.go000066400000000000000000000323201431157473000147630ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" // Predefined attribute names for GMenu var ( MENU_ATTRIBUTE_ACTION string = C.G_MENU_ATTRIBUTE_ACTION MENU_ATTRIBUTE_ACTION_NAMESPACE string = C.G_MENU_ATTRIBUTE_ACTION_NAMESPACE MENU_ATTRIBUTE_TARGET string = C.G_MENU_ATTRIBUTE_TARGET MENU_ATTRIBUTE_LABEL string = C.G_MENU_ATTRIBUTE_LABEL MENU_ATTRIBUTE_ICON string = C.G_MENU_ATTRIBUTE_ICON ) // Predefined link names for GMenu var ( MENU_LINK_SECTION string = C.G_MENU_LINK_SECTION MENU_LINK_SUBMENU string = C.G_MENU_LINK_SUBMENU ) // MenuModel is a representation of GMenuModel. type MenuModel struct { *Object } // native returns a pointer to the underlying GMenuModel. func (v *MenuModel) native() *C.GMenuModel { if v == nil || v.GObject == nil { return nil } return C.toGMenuModel(unsafe.Pointer(v.GObject)) } // Native returns a pointer to the underlying GMenuModel. func (v *MenuModel) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalMenuModel(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapMenuModel(wrapObject(unsafe.Pointer(c))), nil } func wrapMenuModel(obj *Object) *MenuModel { return &MenuModel{obj} } // IsMutable is a wrapper around g_menu_model_is_mutable(). func (v *MenuModel) IsMutable() bool { return gobool(C.g_menu_model_is_mutable(v.native())) } // GetNItems is a wrapper around g_menu_model_get_n_items(). func (v *MenuModel) GetNItems() int { return int(C.g_menu_model_get_n_items(v.native())) } // GetItemLink is a wrapper around g_menu_model_get_item_link(). func (v *MenuModel) GetItemLink(index int, link string) *MenuModel { cstr := (*C.gchar)(C.CString(link)) defer C.free(unsafe.Pointer(cstr)) c := C.g_menu_model_get_item_link(v.native(), C.gint(index), cstr) if c == nil { return nil } return wrapMenuModel(wrapObject(unsafe.Pointer(c))) } // ItemsChanged is a wrapper around g_menu_model_items_changed(). func (v *MenuModel) ItemsChanged(position, removed, added int) { C.g_menu_model_items_changed(v.native(), C.gint(position), C.gint(removed), C.gint(added)) } // GVariant * g_menu_model_get_item_attribute_value () // gboolean g_menu_model_get_item_attribute () // GMenuAttributeIter * g_menu_model_iterate_item_attributes () // GMenuLinkIter * g_menu_model_iterate_item_links () // Menu is a representation of GMenu. type Menu struct { MenuModel } // native() returns a pointer to the underlying GMenu. func (v *Menu) native() *C.GMenu { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGMenu(p) } func marshalMenu(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapMenu(wrapObject(unsafe.Pointer(c))), nil } func wrapMenu(obj *Object) *Menu { return &Menu{MenuModel{obj}} } // MenuNew is a wrapper around g_menu_new(). func MenuNew() *Menu { c := C.g_menu_new() if c == nil { return nil } return wrapMenu(wrapObject(unsafe.Pointer(c))) } // Freeze is a wrapper around g_menu_freeze(). func (v *Menu) Freeze() { C.g_menu_freeze(v.native()) } // Insert is a wrapper around g_menu_insert(). func (v *Menu) Insert(position int, label, detailedAction string) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) cstr2 := (*C.gchar)(C.CString(detailedAction)) defer C.free(unsafe.Pointer(cstr2)) C.g_menu_insert(v.native(), C.gint(position), cstr1, cstr2) } // Prepend is a wrapper around g_menu_prepend(). func (v *Menu) Prepend(label, detailedAction string) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) cstr2 := (*C.gchar)(C.CString(detailedAction)) defer C.free(unsafe.Pointer(cstr2)) C.g_menu_prepend(v.native(), cstr1, cstr2) } // Append is a wrapper around g_menu_append(). func (v *Menu) Append(label, detailedAction string) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) cstr2 := (*C.gchar)(C.CString(detailedAction)) defer C.free(unsafe.Pointer(cstr2)) C.g_menu_append(v.native(), cstr1, cstr2) } // InsertItem is a wrapper around g_menu_insert_item(). func (v *Menu) InsertItem(position int, item *MenuItem) { C.g_menu_insert_item(v.native(), C.gint(position), item.native()) } // AppendItem is a wrapper around g_menu_append_item(). func (v *Menu) AppendItem(item *MenuItem) { C.g_menu_append_item(v.native(), item.native()) } // PrependItem is a wrapper around g_menu_prepend_item(). func (v *Menu) PrependItem(item *MenuItem) { C.g_menu_prepend_item(v.native(), item.native()) } // InsertSection is a wrapper around g_menu_insert_section(). func (v *Menu) InsertSection(position int, label string, section *MenuModel) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) C.g_menu_insert_section(v.native(), C.gint(position), cstr1, section.native()) } // PrependSection is a wrapper around g_menu_prepend_section(). func (v *Menu) PrependSection(label string, section *MenuModel) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) C.g_menu_prepend_section(v.native(), cstr1, section.native()) } // AppendSection is a wrapper around g_menu_append_section(). func (v *Menu) AppendSection(label string, section *MenuModel) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) C.g_menu_append_section(v.native(), cstr1, section.native()) } // InsertSectionWithoutLabel is a wrapper around g_menu_insert_section() // with label set to null. func (v *Menu) InsertSectionWithoutLabel(position int, section *MenuModel) { C.g_menu_insert_section(v.native(), C.gint(position), nil, section.native()) } // PrependSectionWithoutLabel is a wrapper around // g_menu_prepend_section() with label set to null. func (v *Menu) PrependSectionWithoutLabel(section *MenuModel) { C.g_menu_prepend_section(v.native(), nil, section.native()) } // AppendSectionWithoutLabel is a wrapper around g_menu_append_section() // with label set to null. func (v *Menu) AppendSectionWithoutLabel(section *MenuModel) { C.g_menu_append_section(v.native(), nil, section.native()) } // InsertSubmenu is a wrapper around g_menu_insert_submenu(). func (v *Menu) InsertSubmenu(position int, label string, submenu *MenuModel) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) C.g_menu_insert_submenu(v.native(), C.gint(position), cstr1, submenu.native()) } // PrependSubmenu is a wrapper around g_menu_prepend_submenu(). func (v *Menu) PrependSubmenu(label string, submenu *MenuModel) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) C.g_menu_prepend_submenu(v.native(), cstr1, submenu.native()) } // AppendSubmenu is a wrapper around g_menu_append_submenu(). func (v *Menu) AppendSubmenu(label string, submenu *MenuModel) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) C.g_menu_append_submenu(v.native(), cstr1, submenu.native()) } // Remove is a wrapper around g_menu_remove(). func (v *Menu) Remove(position int) { C.g_menu_remove(v.native(), C.gint(position)) } // RemoveAll is a wrapper around g_menu_remove_all(). func (v *Menu) RemoveAll() { C.g_menu_remove_all(v.native()) } // MenuItem is a representation of GMenuItem. type MenuItem struct { *Object } // native() returns a pointer to the underlying GMenuItem. func (v *MenuItem) native() *C.GMenuItem { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGMenuItem(p) } func marshalMenuItem(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapMenuItem(wrapObject(unsafe.Pointer(c))), nil } func wrapMenuItem(obj *Object) *MenuItem { return &MenuItem{obj} } // MenuItemNew is a wrapper around g_menu_item_new(NULL, NULL). func MenuItemNew() *MenuItem { c := C.g_menu_item_new(nil, nil) if c == nil { return nil } return wrapMenuItem(wrapObject(unsafe.Pointer(c))) } // MenuItemNewWithLabel is a wrapper around g_menu_item_new(label, NULL). func MenuItemNewWithLabel(label string) *MenuItem { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) c := C.g_menu_item_new(cstr1, nil) if c == nil { return nil } return wrapMenuItem(wrapObject(unsafe.Pointer(c))) } // MenuItemNewWithAction is a wrapper around g_menu_item_new(NULL, detailedAction). func MenuItemNewWithAction(detailedAction string) *MenuItem { cstr1 := (*C.gchar)(C.CString(detailedAction)) defer C.free(unsafe.Pointer(cstr1)) c := C.g_menu_item_new(nil, cstr1) if c == nil { return nil } return wrapMenuItem(wrapObject(unsafe.Pointer(c))) } // MenuItemNewWithLabelAndAction is a wrapper around g_menu_item_new(label, detailedAction). func MenuItemNewWithLabelAndAction(label, detailedAction string) *MenuItem { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) cstr2 := (*C.gchar)(C.CString(detailedAction)) defer C.free(unsafe.Pointer(cstr2)) c := C.g_menu_item_new(cstr1, cstr2) if c == nil { return nil } return wrapMenuItem(wrapObject(unsafe.Pointer(c))) } // MenuItemNewSection is a wrapper around g_menu_item_new_section(). func MenuItemNewSection(label string, section *MenuModel) *MenuItem { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) c := C.g_menu_item_new_section(cstr1, section.native()) if c == nil { return nil } return wrapMenuItem(wrapObject(unsafe.Pointer(c))) } // MenuItemNewSubmenu is a wrapper around g_menu_item_new_submenu(). func MenuItemNewSubmenu(label string, submenu *MenuModel) *MenuItem { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) c := C.g_menu_item_new_submenu(cstr1, submenu.native()) if c == nil { return nil } return wrapMenuItem(wrapObject(unsafe.Pointer(c))) } // MenuItemNewFromModel is a wrapper around g_menu_item_new_from_model(). func MenuItemNewFromModel(model *MenuModel, index int) *MenuItem { c := C.g_menu_item_new_from_model(model.native(), C.gint(index)) if c == nil { return nil } return wrapMenuItem(wrapObject(unsafe.Pointer(c))) } // SetLabel is a wrapper around g_menu_item_set_label(). func (v *MenuItem) SetLabel(label string) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) C.g_menu_item_set_label(v.native(), cstr1) } // UnsetLabel is a wrapper around g_menu_item_set_label(NULL). func (v *MenuItem) UnsetLabel() { C.g_menu_item_set_label(v.native(), nil) } // SetDetailedAction is a wrapper around g_menu_item_set_detailed_action(). func (v *MenuItem) SetDetailedAction(act string) { cstr1 := (*C.gchar)(C.CString(act)) defer C.free(unsafe.Pointer(cstr1)) C.g_menu_item_set_detailed_action(v.native(), cstr1) } // SetSection is a wrapper around g_menu_item_set_section(). func (v *MenuItem) SetSection(section *MenuModel) { C.g_menu_item_set_section(v.native(), section.native()) } // SetSubmenu is a wrapper around g_menu_item_set_submenu(). func (v *MenuItem) SetSubmenu(submenu *MenuModel) { C.g_menu_item_set_submenu(v.native(), submenu.native()) } // GetLink is a wrapper around g_menu_item_get_link(). func (v *MenuItem) GetLink(link string) *MenuModel { cstr1 := (*C.gchar)(C.CString(link)) defer C.free(unsafe.Pointer(cstr1)) c := C.g_menu_item_get_link(v.native(), cstr1) if c == nil { return nil } return wrapMenuModel(wrapObject(unsafe.Pointer(c))) } // SetLink is a wrapper around g_menu_item_Set_link(). func (v *MenuItem) SetLink(link string, model *MenuModel) { cstr1 := (*C.gchar)(C.CString(link)) defer C.free(unsafe.Pointer(cstr1)) C.g_menu_item_set_link(v.native(), cstr1, model.native()) } // SetActionAndTargetValue is a wrapper around g_menu_item_set_action_and_target_value() func (v *MenuItem) SetActionAndTargetValue(action string, targetValue IVariant) { cstr1 := (*C.gchar)(C.CString(action)) defer C.free(unsafe.Pointer(cstr1)) var c *C.GVariant if targetValue != nil { c = targetValue.ToGVariant() } C.g_menu_item_set_action_and_target_value(v.native(), cstr1, c) } // UnsetAction is a wrapper around g_menu_item_set_action_and_target_value(NULL, NULL) // Unsets both action and target value. Unsetting the action also clears the target value. func (v *MenuItem) UnsetAction() { C.g_menu_item_set_action_and_target_value(v.native(), nil, nil) } // SetAttributeValue is a wrapper around g_menu_item_set_attribute_value() func (v *MenuItem) SetAttributeValue(attribute string, value IVariant) { var c *C.GVariant if value != nil { c = value.ToGVariant() } cstr1 := (*C.gchar)(C.CString(attribute)) defer C.free(unsafe.Pointer(cstr1)) C.g_menu_item_set_attribute_value(v.native(), cstr1, c) } // GetAttributeValue is a wrapper around g_menu_item_get_attribute_value() func (v *MenuItem) GetAttributeValue(attribute string, expectedType *VariantType) *Variant { cstr1 := (*C.gchar)(C.CString(attribute)) defer C.free(unsafe.Pointer(cstr1)) c := C.g_menu_item_get_attribute_value(v.native(), cstr1, expectedType.native()) if c == nil { return nil } return newVariant(c) } // TODO: These require positional parameters with *any* type, according to the format string passed. // This is likely not possible to represent 1:1 in go. // gboolean g_menu_item_get_attribute () // void g_menu_item_set_attribute () // void g_menu_item_set_action_and_target () gotk3-0.6.2/glib/menu_test.go000066400000000000000000000073311431157473000160260ustar00rootroot00000000000000package glib_test import ( "testing" "github.com/gotk3/gotk3/glib" ) func TestGetSetAttributeValueCustomBool(t *testing.T) { testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "false", value: false, }, } menuItem := glib.MenuItemNew() for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { variant := glib.VariantFromBoolean(tC.value) menuItem.SetAttributeValue("custom-bool-attribute", variant) actual := menuItem.GetAttributeValue("custom-bool-attribute", glib.VARIANT_TYPE_BOOLEAN) if !actual.IsType(glib.VARIANT_TYPE_BOOLEAN) { t.Error("Expected value of type", glib.VARIANT_TYPE_BOOLEAN, "got", actual.Type()) } if tC.value != actual.GetBoolean() { t.Error("Expected", tC.value, "got", actual) } }) } } func TestUnsetLabel(t *testing.T) { menuItem := glib.MenuItemNewWithLabel("unit_label") menuItem.UnsetLabel() value := menuItem.GetAttributeValue(glib.MENU_ATTRIBUTE_LABEL, glib.VARIANT_TYPE_STRING) actual := value.GetString() if "" != actual { t.Error("Expected empty string, got", actual) } } func TestSetLabel(t *testing.T) { menuItem := glib.MenuItemNewWithLabel("unit_label") expected := "New Label" menuItem.SetLabel(expected) value := menuItem.GetAttributeValue(glib.MENU_ATTRIBUTE_LABEL, glib.VARIANT_TYPE_STRING) actual := value.GetString() if expected != actual { t.Error("Expected", expected, "got", actual) } } func TestSetDetailedAction(t *testing.T) { menuItem := glib.MenuItemNewWithAction("unit_action") expected := "new-action" menuItem.SetDetailedAction(expected) value := menuItem.GetAttributeValue(glib.MENU_ATTRIBUTE_ACTION, glib.VARIANT_TYPE_STRING) actual := value.GetString() if expected != actual { t.Error("Expected", expected, "got", actual) } } func TestSetActionAndTargetValue(t *testing.T) { menuItem := glib.MenuItemNew() t.Run("Action, Value", func(t *testing.T) { expectedValue := glib.VariantFromString("Hello!") expected := "act1" menuItem.SetActionAndTargetValue(expected, expectedValue) // Check target value actualValue := menuItem.GetAttributeValue(glib.MENU_ATTRIBUTE_TARGET, glib.VARIANT_TYPE_STRING) if expectedValue.Native() != actualValue.Native() { t.Error("Expected", expectedValue.Native(), "got", actualValue.Native()) } // Check action value actualAction := menuItem.GetAttributeValue(glib.MENU_ATTRIBUTE_ACTION, glib.VARIANT_TYPE_STRING).GetString() if expected != actualAction { t.Error("Expected", expected, "got", actualAction) } }) t.Run("Action, Null Value", func(t *testing.T) { expected := "act2" menuItem.SetActionAndTargetValue(expected, nil) // Check target value actualValue := menuItem.GetAttributeValue(glib.MENU_ATTRIBUTE_TARGET, glib.VARIANT_TYPE_STRING) if actualValue != nil { t.Error("Expected nil value got", actualValue.Native()) } // Check action value actualAction := menuItem.GetAttributeValue(glib.MENU_ATTRIBUTE_ACTION, glib.VARIANT_TYPE_STRING).GetString() if expected != actualAction { t.Error("Expected", expected, "got", actualAction) } }) } func TestUnsetAction(t *testing.T) { menuItem := glib.MenuItemNew() initialValue := glib.VariantFromString("Hello!") initial := "act1" menuItem.SetActionAndTargetValue(initial, initialValue) menuItem.UnsetAction() // Check target value actualValue := menuItem.GetAttributeValue(glib.MENU_ATTRIBUTE_TARGET, glib.VARIANT_TYPE_STRING) if actualValue != nil { t.Error("Expected nil value got", actualValue.Native()) } // Check action value actualAction := menuItem.GetAttributeValue(glib.MENU_ATTRIBUTE_ACTION, glib.VARIANT_TYPE_STRING) if actualAction != nil { t.Error("Expected nil action got", actualAction.Native()) } } gotk3-0.6.2/glib/notifications.go000066400000000000000000000053731431157473000167000ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" // Notification is a representation of GNotification. type Notification struct { *Object } // native() returns a pointer to the underlying GNotification. func (v *Notification) native() *C.GNotification { if v == nil || v.GObject == nil { return nil } return C.toGNotification(unsafe.Pointer(v.GObject)) } func (v *Notification) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalNotification(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapNotification(wrapObject(unsafe.Pointer(c))), nil } func wrapNotification(obj *Object) *Notification { return &Notification{obj} } // NotificationNew is a wrapper around g_notification_new(). func NotificationNew(title string) *Notification { cstr1 := (*C.gchar)(C.CString(title)) defer C.free(unsafe.Pointer(cstr1)) c := C.g_notification_new(cstr1) if c == nil { return nil } return wrapNotification(wrapObject(unsafe.Pointer(c))) } // SetTitle is a wrapper around g_notification_set_title(). func (v *Notification) SetTitle(title string) { cstr1 := (*C.gchar)(C.CString(title)) defer C.free(unsafe.Pointer(cstr1)) C.g_notification_set_title(v.native(), cstr1) } // SetBody is a wrapper around g_notification_set_body(). func (v *Notification) SetBody(body string) { cstr1 := (*C.gchar)(C.CString(body)) defer C.free(unsafe.Pointer(cstr1)) C.g_notification_set_body(v.native(), cstr1) } // SetDefaultAction is a wrapper around g_notification_set_default_action(). func (v *Notification) SetDefaultAction(detailedAction string) { cstr1 := (*C.gchar)(C.CString(detailedAction)) defer C.free(unsafe.Pointer(cstr1)) C.g_notification_set_default_action(v.native(), cstr1) } // AddButton is a wrapper around g_notification_add_button(). func (v *Notification) AddButton(label, detailedAction string) { cstr1 := (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr1)) cstr2 := (*C.gchar)(C.CString(detailedAction)) defer C.free(unsafe.Pointer(cstr2)) C.g_notification_add_button(v.native(), cstr1, cstr2) } // SetIcon is a wrapper around g_notification_set_icon(). func (v *Notification) SetIcon(iconPath string) { fileIcon := FileIconNew(iconPath) C.g_notification_set_icon(v.native(), (*C.GIcon)(fileIcon.native())) } // void g_notification_set_default_action_and_target () // requires varargs // void g_notification_set_default_action_and_target_value () // requires variant // void g_notification_add_button_with_target () // requires varargs // void g_notification_add_button_with_target_value () //requires variant // void g_notification_set_urgent () // Deprecated, so not implemented gotk3-0.6.2/glib/quark.go000066400000000000000000000004711431157473000151440ustar00rootroot00000000000000package glib import ( "unsafe" ) // #include // #include import "C" // QuarkFromString is a wrapper around g_quark_from_string(). func QuarkFromString(str string) Quark { cstr := (*C.gchar)(C.CString(str)) defer C.free(unsafe.Pointer(cstr)) return Quark(C.g_quark_from_string(cstr)) } gotk3-0.6.2/glib/settings.go000066400000000000000000000222551431157473000156650ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" // Settings is a representation of GSettings. type Settings struct { *Object } // native() returns a pointer to the underlying GSettings. func (v *Settings) native() *C.GSettings { if v == nil || v.GObject == nil { return nil } return C.toGSettings(unsafe.Pointer(v.GObject)) } func (v *Settings) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalSettings(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapSettings(wrapObject(unsafe.Pointer(c))), nil } func wrapSettings(obj *Object) *Settings { return &Settings{obj} } func wrapFullSettings(obj *C.GSettings) *Settings { if obj == nil { return nil } return wrapSettings(wrapObject(unsafe.Pointer(obj))) } // SettingsNew is a wrapper around g_settings_new(). func SettingsNew(schemaID string) *Settings { cstr := (*C.gchar)(C.CString(schemaID)) defer C.free(unsafe.Pointer(cstr)) return wrapFullSettings(C.g_settings_new(cstr)) } // SettingsNewWithPath is a wrapper around g_settings_new_with_path(). func SettingsNewWithPath(schemaID, path string) *Settings { cstr1 := (*C.gchar)(C.CString(schemaID)) defer C.free(unsafe.Pointer(cstr1)) cstr2 := (*C.gchar)(C.CString(path)) defer C.free(unsafe.Pointer(cstr2)) return wrapFullSettings(C.g_settings_new_with_path(cstr1, cstr2)) } // SettingsNewWithBackend is a wrapper around g_settings_new_with_backend(). func SettingsNewWithBackend(schemaID string, backend *SettingsBackend) *Settings { cstr1 := (*C.gchar)(C.CString(schemaID)) defer C.free(unsafe.Pointer(cstr1)) return wrapFullSettings(C.g_settings_new_with_backend(cstr1, backend.native())) } // SettingsNewWithBackendAndPath is a wrapper around g_settings_new_with_backend_and_path(). func SettingsNewWithBackendAndPath(schemaID string, backend *SettingsBackend, path string) *Settings { cstr1 := (*C.gchar)(C.CString(schemaID)) defer C.free(unsafe.Pointer(cstr1)) cstr2 := (*C.gchar)(C.CString(path)) defer C.free(unsafe.Pointer(cstr2)) return wrapFullSettings(C.g_settings_new_with_backend_and_path(cstr1, backend.native(), cstr2)) } // SettingsNewFull is a wrapper around g_settings_new_full(). func SettingsNewFull(schema *SettingsSchema, backend *SettingsBackend, path string) *Settings { cstr1 := (*C.gchar)(C.CString(path)) defer C.free(unsafe.Pointer(cstr1)) return wrapFullSettings(C.g_settings_new_full(schema.native(), backend.native(), cstr1)) } // SettingsSync is a wrapper around g_settings_sync(). func SettingsSync() { C.g_settings_sync() } // IsWritable is a wrapper around g_settings_is_writable(). func (v *Settings) IsWritable(name string) bool { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return gobool(C.g_settings_is_writable(v.native(), cstr1)) } // Delay is a wrapper around g_settings_delay(). func (v *Settings) Delay() { C.g_settings_delay(v.native()) } // Apply is a wrapper around g_settings_apply(). func (v *Settings) Apply() { C.g_settings_apply(v.native()) } // Revert is a wrapper around g_settings_revert(). func (v *Settings) Revert() { C.g_settings_revert(v.native()) } // GetHasUnapplied is a wrapper around g_settings_get_has_unapplied(). func (v *Settings) GetHasUnapplied() bool { return gobool(C.g_settings_get_has_unapplied(v.native())) } // GetChild is a wrapper around g_settings_get_child(). func (v *Settings) GetChild(name string) *Settings { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return wrapFullSettings(C.g_settings_get_child(v.native(), cstr1)) } // Reset is a wrapper around g_settings_reset(). func (v *Settings) Reset(name string) { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) C.g_settings_reset(v.native(), cstr1) } // ListChildren is a wrapper around g_settings_list_children(). func (v *Settings) ListChildren() []string { return toGoStringArray(C.g_settings_list_children(v.native())) } // GetBoolean is a wrapper around g_settings_get_boolean(). func (v *Settings) GetBoolean(name string) bool { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return gobool(C.g_settings_get_boolean(v.native(), cstr1)) } // SetBoolean is a wrapper around g_settings_set_boolean(). func (v *Settings) SetBoolean(name string, value bool) bool { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return gobool(C.g_settings_set_boolean(v.native(), cstr1, gbool(value))) } // GetInt is a wrapper around g_settings_get_int(). func (v *Settings) GetInt(name string) int { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return int(C.g_settings_get_int(v.native(), cstr1)) } // SetInt is a wrapper around g_settings_set_int(). func (v *Settings) SetInt(name string, value int) bool { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return gobool(C.g_settings_set_int(v.native(), cstr1, C.gint(value))) } // GetUInt is a wrapper around g_settings_get_uint(). func (v *Settings) GetUInt(name string) uint { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return uint(C.g_settings_get_uint(v.native(), cstr1)) } // SetUInt is a wrapper around g_settings_set_uint(). func (v *Settings) SetUInt(name string, value uint) bool { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return gobool(C.g_settings_set_uint(v.native(), cstr1, C.guint(value))) } // GetDouble is a wrapper around g_settings_get_double(). func (v *Settings) GetDouble(name string) float64 { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return float64(C.g_settings_get_double(v.native(), cstr1)) } // SetDouble is a wrapper around g_settings_set_double(). func (v *Settings) SetDouble(name string, value float64) bool { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return gobool(C.g_settings_set_double(v.native(), cstr1, C.gdouble(value))) } // GetString is a wrapper around g_settings_get_string(). func (v *Settings) GetString(name string) string { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return C.GoString((*C.char)(C.g_settings_get_string(v.native(), cstr1))) } // SetString is a wrapper around g_settings_set_string(). func (v *Settings) SetString(name string, value string) bool { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) cstr2 := (*C.gchar)(C.CString(value)) defer C.free(unsafe.Pointer(cstr2)) return gobool(C.g_settings_set_string(v.native(), cstr1, cstr2)) } // GetEnum is a wrapper around g_settings_get_enum(). func (v *Settings) GetEnum(name string) int { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return int(C.g_settings_get_enum(v.native(), cstr1)) } // GetStrv is a wrapper around g_settings_get_strv(). func (v *Settings) GetStrv(name string) []string { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return toGoStringArray(C.g_settings_get_strv(v.native(), cstr1)) } // SetStrv is a wrapper around g_settings_set_strv(). func (v *Settings) SetStrv(name string, values []string) bool { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) cvalues := make([]*C.gchar, len(values)) for i, accel := range values { cvalues[i] = (*C.gchar)(C.CString(accel)) defer C.free(unsafe.Pointer(cvalues[i])) } cvalues = append(cvalues, nil) return gobool(C.g_settings_set_strv(v.native(), cstr1, &cvalues[0])) } // SetEnum is a wrapper around g_settings_set_enum(). func (v *Settings) SetEnum(name string, value int) bool { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return gobool(C.g_settings_set_enum(v.native(), cstr1, C.gint(value))) } // GetFlags is a wrapper around g_settings_get_flags(). func (v *Settings) GetFlags(name string) uint { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return uint(C.g_settings_get_flags(v.native(), cstr1)) } // SetFlags is a wrapper around g_settings_set_flags(). func (v *Settings) SetFlags(name string, value uint) bool { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) return gobool(C.g_settings_set_flags(v.native(), cstr1, C.guint(value))) } func (v *Settings) GetValue(name string) *Variant { cstr := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr)) return newVariant(C.g_settings_get_value(v.native(), cstr)) } // GVariant * g_settings_get_value () // gboolean g_settings_set_value () // GVariant * g_settings_get_user_value () // GVariant * g_settings_get_default_value () // const gchar * const * g_settings_list_schemas () // const gchar * const * g_settings_list_relocatable_schemas () // gchar ** g_settings_list_keys () // GVariant * g_settings_get_range () // gboolean g_settings_range_check () // void g_settings_get () // gboolean g_settings_set () // gpointer g_settings_get_mapped () // void g_settings_bind () // void g_settings_bind_with_mapping () // void g_settings_bind_writable () // void g_settings_unbind () // gaction * g_settings_create_action () // gchar ** g_settings_get_strv () // gboolean g_settings_set_strv () gotk3-0.6.2/glib/settings_backend.go000066400000000000000000000044401431157473000173300ustar00rootroot00000000000000package glib // #include // #include // #include "glib.go.h" import "C" import "unsafe" // SettingsBackend is a representation of GSettingsBackend. type SettingsBackend struct { *Object } // native() returns a pointer to the underlying GSettingsBackend. func (v *SettingsBackend) native() *C.GSettingsBackend { if v == nil || v.GObject == nil { return nil } return C.toGSettingsBackend(unsafe.Pointer(v.GObject)) } func (v *SettingsBackend) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalSettingsBackend(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapSettingsBackend(wrapObject(unsafe.Pointer(c))), nil } func wrapSettingsBackend(obj *Object) *SettingsBackend { return &SettingsBackend{obj} } // SettingsBackendGetDefault is a wrapper around g_settings_backend_get_default(). func SettingsBackendGetDefault() *SettingsBackend { return wrapSettingsBackend(wrapObject(unsafe.Pointer(C.g_settings_backend_get_default()))) } // KeyfileSettingsBackendNew is a wrapper around g_keyfile_settings_backend_new(). func KeyfileSettingsBackendNew(filename, rootPath, rootGroup string) *SettingsBackend { cstr1 := (*C.gchar)(C.CString(filename)) defer C.free(unsafe.Pointer(cstr1)) cstr2 := (*C.gchar)(C.CString(rootPath)) defer C.free(unsafe.Pointer(cstr2)) cstr3 := (*C.gchar)(C.CString(rootGroup)) defer C.free(unsafe.Pointer(cstr3)) return wrapSettingsBackend(wrapObject(unsafe.Pointer(C.g_keyfile_settings_backend_new(cstr1, cstr2, cstr3)))) } // MemorySettingsBackendNew is a wrapper around g_memory_settings_backend_new(). func MemorySettingsBackendNew() *SettingsBackend { return wrapSettingsBackend(wrapObject(unsafe.Pointer(C.g_memory_settings_backend_new()))) } // NullSettingsBackendNew is a wrapper around g_null_settings_backend_new(). func NullSettingsBackendNew() *SettingsBackend { return wrapSettingsBackend(wrapObject(unsafe.Pointer(C.g_null_settings_backend_new()))) } // void g_settings_backend_changed () // void g_settings_backend_path_changed () // void g_settings_backend_keys_changed () // void g_settings_backend_path_writable_changed () // void g_settings_backend_writable_changed () // void g_settings_backend_changed_tree () // void g_settings_backend_flatten_tree () gotk3-0.6.2/glib/settings_schema.go000066400000000000000000000051641431157473000172050ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" // SettingsSchema is a representation of GSettingsSchema. type SettingsSchema struct { schema *C.GSettingsSchema } func wrapSettingsSchema(obj *C.GSettingsSchema) *SettingsSchema { if obj == nil { return nil } return &SettingsSchema{obj} } func (v *SettingsSchema) Native() uintptr { return uintptr(unsafe.Pointer(v.schema)) } func (v *SettingsSchema) native() *C.GSettingsSchema { if v == nil || v.schema == nil { return nil } return v.schema } // Ref() is a wrapper around g_settings_schema_ref(). func (v *SettingsSchema) Ref() *SettingsSchema { return wrapSettingsSchema(C.g_settings_schema_ref(v.native())) } // Unref() is a wrapper around g_settings_schema_unref(). func (v *SettingsSchema) Unref() { C.g_settings_schema_unref(v.native()) } // GetID() is a wrapper around g_settings_schema_get_id(). func (v *SettingsSchema) GetID() string { return C.GoString((*C.char)(C.g_settings_schema_get_id(v.native()))) } // GetPath() is a wrapper around g_settings_schema_get_path(). func (v *SettingsSchema) GetPath() string { return C.GoString((*C.char)(C.g_settings_schema_get_path(v.native()))) } // HasKey() is a wrapper around g_settings_schema_has_key(). func (v *SettingsSchema) HasKey(v1 string) bool { cstr := (*C.gchar)(C.CString(v1)) defer C.free(unsafe.Pointer(cstr)) return gobool(C.g_settings_schema_has_key(v.native(), cstr)) } func toGoStringArray(c **C.gchar) []string { var strs []string originalc := c defer C.g_strfreev(originalc) for *c != nil { strs = append(strs, C.GoString((*C.char)(*c))) c = C.next_gcharptr(c) } return strs } // // ListChildren() is a wrapper around g_settings_schema_list_children(). // func (v *SettingsSchema) ListChildren() []string { // return toGoStringArray(C.g_settings_schema_list_children(v.native())) // } // // ListKeys() is a wrapper around g_settings_schema_list_keys(). // func (v *SettingsSchema) ListKeys() []string { // return toGoStringArray(C.g_settings_schema_list_keys(v.native())) // } // const GVariantType * g_settings_schema_key_get_value_type () // GVariant * g_settings_schema_key_get_default_value () // GVariant * g_settings_schema_key_get_range () // gboolean g_settings_schema_key_range_check () // const gchar * g_settings_schema_key_get_name () // const gchar * g_settings_schema_key_get_summary () // const gchar * g_settings_schema_key_get_description () // GSettingsSchemaKey * g_settings_schema_get_key () // GSettingsSchemaKey * g_settings_schema_key_ref () // void g_settings_schema_key_unref () gotk3-0.6.2/glib/settings_schema_source.go000066400000000000000000000044761431157473000205720ustar00rootroot00000000000000package glib // #include // #include // #include // #include "glib.go.h" import "C" import "unsafe" // SettingsSchemaSource is a representation of GSettingsSchemaSource. type SettingsSchemaSource struct { source *C.GSettingsSchemaSource } func wrapSettingsSchemaSource(obj *C.GSettingsSchemaSource) *SettingsSchemaSource { if obj == nil { return nil } return &SettingsSchemaSource{obj} } func (v *SettingsSchemaSource) Native() uintptr { return uintptr(unsafe.Pointer(v.source)) } func (v *SettingsSchemaSource) native() *C.GSettingsSchemaSource { if v == nil || v.source == nil { return nil } return v.source } // SettingsSchemaSourceGetDefault is a wrapper around g_settings_schema_source_get_default(). func SettingsSchemaSourceGetDefault() *SettingsSchemaSource { return wrapSettingsSchemaSource(C.g_settings_schema_source_get_default()) } // Ref() is a wrapper around g_settings_schema_source_ref(). func (v *SettingsSchemaSource) Ref() *SettingsSchemaSource { return wrapSettingsSchemaSource(C.g_settings_schema_source_ref(v.native())) } // Unref() is a wrapper around g_settings_schema_source_unref(). func (v *SettingsSchemaSource) Unref() { C.g_settings_schema_source_unref(v.native()) } // SettingsSchemaSourceNewFromDirectory() is a wrapper around g_settings_schema_source_new_from_directory(). func SettingsSchemaSourceNewFromDirectory(dir string, parent *SettingsSchemaSource, trusted bool) *SettingsSchemaSource { cstr := (*C.gchar)(C.CString(dir)) defer C.free(unsafe.Pointer(cstr)) return wrapSettingsSchemaSource(C.g_settings_schema_source_new_from_directory(cstr, parent.native(), gbool(trusted), nil)) } // Lookup() is a wrapper around g_settings_schema_source_lookup(). func (v *SettingsSchemaSource) Lookup(schema string, recursive bool) *SettingsSchema { cstr := (*C.gchar)(C.CString(schema)) defer C.free(unsafe.Pointer(cstr)) return wrapSettingsSchema(C.g_settings_schema_source_lookup(v.native(), cstr, gbool(recursive))) } // ListSchemas is a wrapper around g_settings_schema_source_list_schemas(). func (v *SettingsSchemaSource) ListSchemas(recursive bool) (nonReolcatable, relocatable []string) { var nonRel, rel **C.gchar C.g_settings_schema_source_list_schemas(v.native(), gbool(recursive), &nonRel, &rel) return toGoStringArray(nonRel), toGoStringArray(rel) } gotk3-0.6.2/glib/slist.go000066400000000000000000000074341431157473000151650ustar00rootroot00000000000000package glib // #include // #include // #include "glib.go.h" import "C" import "unsafe" // SList is a representation of Glib's GSList. A SList must be manually freed // by either calling Free() or FreeFull() type SList struct { list *C.struct__GSList // If set, dataWrap is called every time Data() // is called to wrap raw underlying // value into appropriate type. dataWrap func(unsafe.Pointer) interface{} } func WrapSList(obj uintptr) *SList { return wrapSList((*C.struct__GSList)(unsafe.Pointer(obj))) } func wrapSList(obj *C.struct__GSList) *SList { if obj == nil { return nil } //NOTE a list should be freed by calling either //g_slist_free() or g_slist_free_full(). However, it's not possible to use a //finalizer for this. return &SList{list: obj} } func (v *SList) wrapNewHead(obj *C.struct__GSList) *SList { if obj == nil { return nil } return &SList{ list: obj, dataWrap: v.dataWrap, } } func (v *SList) Native() uintptr { return uintptr(unsafe.Pointer(v.list)) } func (v *SList) native() *C.struct__GSList { if v == nil || v.list == nil { return nil } return v.list } // DataWapper sets wrap functions, which is called during NthData() // and Data(). It's used to cast raw C data into appropriate // Go structures and types every time that data is retreived. func (v *SList) DataWrapper(fn func(unsafe.Pointer) interface{}) { if v == nil { return } v.dataWrap = fn } func (v *SList) Append(data uintptr) *SList { ret := C.g_slist_append(v.native(), C.gpointer(data)) if ret == v.native() { return v } return wrapSList(ret) } // Length is a wrapper around g_slist_length(). func (v *SList) Length() uint { return uint(C.g_slist_length(v.native())) } // Next is a wrapper around the next struct field func (v *SList) Next() *SList { n := v.native() if n == nil { return nil } return wrapSList(n.next) } // dataRaw is a wrapper around the data struct field func (v *SList) dataRaw() unsafe.Pointer { n := v.native() if n == nil { return nil } return unsafe.Pointer(n.data) } // DataRaw is a wrapper around the data struct field func (v *SList) DataRaw() unsafe.Pointer { n := v.native() if n == nil { return nil } return unsafe.Pointer(n.data) } // Data acts the same as data struct field, but it returns raw unsafe.Pointer as interface. // TODO: Align with List struct and add member + logic for `dataWrap func(unsafe.Pointer) interface{}`? func (v *SList) Data() interface{} { ptr := v.dataRaw() if v.dataWrap != nil { return v.dataWrap(ptr) } return ptr } // Foreach acts the same as g_slist_foreach(). // No user_data argument is implemented because of Go clojure capabilities. func (v *SList) Foreach(fn func(item interface{})) { for l := v; l != nil; l = l.Next() { fn(l.Data()) } } // Free is a wrapper around g_slist_free(). func (v *SList) Free() { C.g_slist_free(v.native()) } // FreeFull is a wrapper around g_slist_free_full(). func (v *SList) FreeFull() { //TODO implement GDestroyNotify callback C.g_slist_free_full(v.native(), nil) } // GSList * g_slist_alloc () // GSList * g_slist_prepend () // GSList * g_slist_insert () // GSList * g_slist_insert_before () // GSList * g_slist_insert_sorted () // GSList * g_slist_remove () // GSList * g_slist_remove_link () // GSList * g_slist_delete_link () // GSList * g_slist_remove_all () // void g_slist_free_1 () // GSList * g_slist_copy () // GSList * g_slist_copy_deep () // GSList * g_slist_reverse () // GSList * g_slist_insert_sorted_with_data () // GSList * g_slist_sort () // GSList * g_slist_sort_with_data () // GSList * g_slist_concat () // GSList * g_slist_last () // GSList * g_slist_nth () // gpointer g_slist_nth_data () // GSList * g_slist_find () // GSList * g_slist_find_custom () // gint g_slist_position () // gint g_slist_index () gotk3-0.6.2/go.mod000066400000000000000000000000471431157473000136620ustar00rootroot00000000000000module github.com/gotk3/gotk3 go 1.14 gotk3-0.6.2/gtk/000077500000000000000000000000001431157473000133405ustar00rootroot00000000000000gotk3-0.6.2/gtk/aboutdialog.go000066400000000000000000000235621431157473000161710ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_about_dialog_get_type()), marshalAboutDialog}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkAboutDialog"] = wrapAboutDialog } /* * GtkAboutDialog */ // AboutDialog is a representation of GTK's GtkAboutDialog. type AboutDialog struct { Dialog } // native returns a pointer to the underlying GtkAboutDialog. func (v *AboutDialog) native() *C.GtkAboutDialog { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAboutDialog(p) } func marshalAboutDialog(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapAboutDialog(obj), nil } func wrapAboutDialog(obj *glib.Object) *AboutDialog { if obj == nil { return nil } return &AboutDialog{Dialog{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}}} } // AboutDialogNew is a wrapper around gtk_about_dialog_new(). func AboutDialogNew() (*AboutDialog, error) { c := C.gtk_about_dialog_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapAboutDialog(obj), nil } // GetComments is a wrapper around gtk_about_dialog_get_comments(). func (v *AboutDialog) GetComments() string { c := C.gtk_about_dialog_get_comments(v.native()) return C.GoString((*C.char)(c)) } // SetComments is a wrapper around gtk_about_dialog_set_comments(). func (v *AboutDialog) SetComments(comments string) { cstr := C.CString(comments) defer C.free(unsafe.Pointer(cstr)) C.gtk_about_dialog_set_comments(v.native(), (*C.gchar)(cstr)) } // GetCopyright is a wrapper around gtk_about_dialog_get_copyright(). func (v *AboutDialog) GetCopyright() string { c := C.gtk_about_dialog_get_copyright(v.native()) return C.GoString((*C.char)(c)) } // SetCopyright is a wrapper around gtk_about_dialog_set_copyright(). func (v *AboutDialog) SetCopyright(copyright string) { cstr := C.CString(copyright) defer C.free(unsafe.Pointer(cstr)) C.gtk_about_dialog_set_copyright(v.native(), (*C.gchar)(cstr)) } // GetLicense is a wrapper around gtk_about_dialog_get_license(). func (v *AboutDialog) GetLicense() string { c := C.gtk_about_dialog_get_license(v.native()) return C.GoString((*C.char)(c)) } // SetLicense is a wrapper around gtk_about_dialog_set_license(). func (v *AboutDialog) SetLicense(license string) { cstr := C.CString(license) defer C.free(unsafe.Pointer(cstr)) C.gtk_about_dialog_set_license(v.native(), (*C.gchar)(cstr)) } // GetLicenseType is a wrapper around gtk_about_dialog_get_license_type(). func (v *AboutDialog) GetLicenseType() License { c := C.gtk_about_dialog_get_license_type(v.native()) return License(c) } // SetLicenseType is a wrapper around gtk_about_dialog_set_license_type(). func (v *AboutDialog) SetLicenseType(license License) { C.gtk_about_dialog_set_license_type(v.native(), C.GtkLicense(license)) } // GetLogo is a wrapper around gtk_about_dialog_get_logo(). func (v *AboutDialog) GetLogo() (*gdk.Pixbuf, error) { c := C.gtk_about_dialog_get_logo(v.native()) if c == nil { return nil, nilPtrErr } p := &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))} return p, nil } // SetLogo is a wrapper around gtk_about_dialog_set_logo(). func (v *AboutDialog) SetLogo(logo *gdk.Pixbuf) { logoPtr := (*C.GdkPixbuf)(unsafe.Pointer(logo.Native())) C.gtk_about_dialog_set_logo(v.native(), logoPtr) } // GetLogoIconName is a wrapper around gtk_about_dialog_get_logo_icon_name(). func (v *AboutDialog) GetLogoIconName() string { c := C.gtk_about_dialog_get_logo_icon_name(v.native()) return C.GoString((*C.char)(c)) } // SetLogoIconName is a wrapper around gtk_about_dialog_set_logo_icon_name(). func (v *AboutDialog) SetLogoIconName(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_about_dialog_set_logo_icon_name(v.native(), (*C.gchar)(cstr)) } // GetProgramName is a wrapper around gtk_about_dialog_get_program_name(). func (v *AboutDialog) GetProgramName() string { c := C.gtk_about_dialog_get_program_name(v.native()) return C.GoString((*C.char)(c)) } // SetProgramName is a wrapper around gtk_about_dialog_set_program_name(). func (v *AboutDialog) SetProgramName(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_about_dialog_set_program_name(v.native(), (*C.gchar)(cstr)) } // GetAuthors is a wrapper around gtk_about_dialog_get_authors(). func (v *AboutDialog) GetAuthors() []string { var authors []string cauthors := C.gtk_about_dialog_get_authors(v.native()) if cauthors == nil { return nil } for { if *cauthors == nil { break } authors = append(authors, C.GoString((*C.char)(*cauthors))) cauthors = nextgcharptr(cauthors) } return authors } // SetAuthors is a wrapper around gtk_about_dialog_set_authors(). func (v *AboutDialog) SetAuthors(authors []string) { cauthors := C.make_strings(C.int(len(authors) + 1)) for i, author := range authors { cstr := C.CString(author) defer C.free(unsafe.Pointer(cstr)) C.set_string(cauthors, C.int(i), (*C.gchar)(cstr)) } C.set_string(cauthors, C.int(len(authors)), nil) C.gtk_about_dialog_set_authors(v.native(), cauthors) C.destroy_strings(cauthors) } // GetArtists is a wrapper around gtk_about_dialog_get_artists(). func (v *AboutDialog) GetArtists() []string { var artists []string cartists := C.gtk_about_dialog_get_artists(v.native()) if cartists == nil { return nil } for { if *cartists == nil { break } artists = append(artists, C.GoString((*C.char)(*cartists))) cartists = nextgcharptr(cartists) } return artists } // SetArtists is a wrapper around gtk_about_dialog_set_artists(). func (v *AboutDialog) SetArtists(artists []string) { cartists := C.make_strings(C.int(len(artists) + 1)) for i, artist := range artists { cstr := C.CString(artist) defer C.free(unsafe.Pointer(cstr)) C.set_string(cartists, C.int(i), (*C.gchar)(cstr)) } C.set_string(cartists, C.int(len(artists)), nil) C.gtk_about_dialog_set_artists(v.native(), cartists) C.destroy_strings(cartists) } // GetDocumenters is a wrapper around gtk_about_dialog_get_documenters(). func (v *AboutDialog) GetDocumenters() []string { var documenters []string cdocumenters := C.gtk_about_dialog_get_documenters(v.native()) if cdocumenters == nil { return nil } for { if *cdocumenters == nil { break } documenters = append(documenters, C.GoString((*C.char)(*cdocumenters))) cdocumenters = nextgcharptr(cdocumenters) } return documenters } // SetDocumenters is a wrapper around gtk_about_dialog_set_documenters(). func (v *AboutDialog) SetDocumenters(documenters []string) { cdocumenters := C.make_strings(C.int(len(documenters) + 1)) for i, doc := range documenters { cstr := C.CString(doc) defer C.free(unsafe.Pointer(cstr)) C.set_string(cdocumenters, C.int(i), (*C.gchar)(cstr)) } C.set_string(cdocumenters, C.int(len(documenters)), nil) C.gtk_about_dialog_set_documenters(v.native(), cdocumenters) C.destroy_strings(cdocumenters) } // GetTranslatorCredits is a wrapper around gtk_about_dialog_get_translator_credits(). func (v *AboutDialog) GetTranslatorCredits() string { c := C.gtk_about_dialog_get_translator_credits(v.native()) return C.GoString((*C.char)(c)) } // SetTranslatorCredits is a wrapper around gtk_about_dialog_set_translator_credits(). func (v *AboutDialog) SetTranslatorCredits(translatorCredits string) { cstr := C.CString(translatorCredits) defer C.free(unsafe.Pointer(cstr)) C.gtk_about_dialog_set_translator_credits(v.native(), (*C.gchar)(cstr)) } // GetVersion is a wrapper around gtk_about_dialog_get_version(). func (v *AboutDialog) GetVersion() string { c := C.gtk_about_dialog_get_version(v.native()) return C.GoString((*C.char)(c)) } // SetVersion is a wrapper around gtk_about_dialog_set_version(). func (v *AboutDialog) SetVersion(version string) { cstr := C.CString(version) defer C.free(unsafe.Pointer(cstr)) C.gtk_about_dialog_set_version(v.native(), (*C.gchar)(cstr)) } // GetWebsite is a wrapper around gtk_about_dialog_get_website(). func (v *AboutDialog) GetWebsite() string { c := C.gtk_about_dialog_get_website(v.native()) return C.GoString((*C.char)(c)) } // SetWebsite is a wrapper around gtk_about_dialog_set_website(). func (v *AboutDialog) SetWebsite(website string) { cstr := C.CString(website) defer C.free(unsafe.Pointer(cstr)) C.gtk_about_dialog_set_website(v.native(), (*C.gchar)(cstr)) } // GetWebsiteLabel is a wrapper around gtk_about_dialog_get_website_label(). func (v *AboutDialog) GetWebsiteLabel() string { c := C.gtk_about_dialog_get_website_label(v.native()) return C.GoString((*C.char)(c)) } // SetWebsiteLabel is a wrapper around gtk_about_dialog_set_website_label(). func (v *AboutDialog) SetWebsiteLabel(websiteLabel string) { cstr := C.CString(websiteLabel) defer C.free(unsafe.Pointer(cstr)) C.gtk_about_dialog_set_website_label(v.native(), (*C.gchar)(cstr)) } // GetWrapLicense is a wrapper around gtk_about_dialog_get_wrap_license(). func (v *AboutDialog) GetWrapLicense() bool { return gobool(C.gtk_about_dialog_get_wrap_license(v.native())) } // SetWrapLicense is a wrapper around gtk_about_dialog_set_wrap_license(). func (v *AboutDialog) SetWrapLicense(wrapLicense bool) { C.gtk_about_dialog_set_wrap_license(v.native(), gbool(wrapLicense)) } // AddCreditSection is a wrapper around gtk_about_dialog_add_credit_section(). func (v *AboutDialog) AddCreditSection(sectionName string, people []string) { cname := (*C.gchar)(C.CString(sectionName)) defer C.free(unsafe.Pointer(cname)) cpeople := C.make_strings(C.int(len(people)) + 1) defer C.destroy_strings(cpeople) for i, p := range people { cp := (*C.gchar)(C.CString(p)) defer C.free(unsafe.Pointer(cp)) C.set_string(cpeople, C.int(i), cp) } C.set_string(cpeople, C.int(len(people)), nil) C.gtk_about_dialog_add_credit_section(v.native(), cname, cpeople) } gotk3-0.6.2/gtk/accel.go000066400000000000000000000320141431157473000147360ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains accelerator related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) // AccelFlags is a representation of GTK's GtkAccelFlags type AccelFlags int const ( ACCEL_VISIBLE AccelFlags = C.GTK_ACCEL_VISIBLE ACCEL_LOCKED AccelFlags = C.GTK_ACCEL_LOCKED ACCEL_MASK AccelFlags = C.GTK_ACCEL_MASK ) func marshalAccelFlags(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return AccelFlags(c), nil } // AcceleratorName is a wrapper around gtk_accelerator_name(). func AcceleratorName(key uint, mods gdk.ModifierType) string { c := C.gtk_accelerator_name(C.guint(key), C.GdkModifierType(mods)) defer C.free(unsafe.Pointer(c)) return C.GoString((*C.char)(c)) } // AcceleratorValid is a wrapper around gtk_accelerator_valid(). func AcceleratorValid(key uint, mods gdk.ModifierType) bool { return gobool(C.gtk_accelerator_valid(C.guint(key), C.GdkModifierType(mods))) } // AcceleratorGetDefaultModMask is a wrapper around gtk_accelerator_get_default_mod_mask(). func AcceleratorGetDefaultModMask() gdk.ModifierType { return gdk.ModifierType(C.gtk_accelerator_get_default_mod_mask()) } // AcceleratorParse is a wrapper around gtk_accelerator_parse(). func AcceleratorParse(acc string) (key uint, mods gdk.ModifierType) { cstr := C.CString(acc) defer C.free(unsafe.Pointer(cstr)) k := C.guint(0) m := C.GdkModifierType(0) C.gtk_accelerator_parse((*C.gchar)(cstr), &k, &m) return uint(k), gdk.ModifierType(m) } // AcceleratorGetLabel is a wrapper around gtk_accelerator_get_label(). func AcceleratorGetLabel(key uint, mods gdk.ModifierType) string { c := C.gtk_accelerator_get_label(C.guint(key), C.GdkModifierType(mods)) defer C.free(unsafe.Pointer(c)) return C.GoString((*C.char)(c)) } // AcceleratorSetDefaultModMask is a wrapper around gtk_accelerator_set_default_mod_mask(). func AcceleratorSetDefaultModMask(mods gdk.ModifierType) { C.gtk_accelerator_set_default_mod_mask(C.GdkModifierType(mods)) } /* * GtkAccelLabel */ // TODO: // gtk_accel_label_new(). // gtk_accel_label_set_accel_closure(). // gtk_accel_label_get_accel_widget(). // gtk_accel_label_set_accel_widget(). // gtk_accel_label_get_accel_width(). // gtk_accel_label_set_accel(). since GTK 3.6 // gtk_accel_label_get_accel(). since GTK 3.12 // gtk_accel_label_refetch(). /* * GtkAccelGroup */ // AccelGroup is a representation of GTK's GtkAccelGroup. type AccelGroup struct { *glib.Object } // native returns a pointer to the underlying GtkAccelGroup. func (v *AccelGroup) native() *C.GtkAccelGroup { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAccelGroup(p) } func marshalAccelGroup(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapAccelGroup(obj), nil } func wrapAccelGroup(obj *glib.Object) *AccelGroup { if obj == nil { return nil } return &AccelGroup{obj} } // AccelGroup is a wrapper around gtk_accel_group_new(). func AccelGroupNew() (*AccelGroup, error) { c := C.gtk_accel_group_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapAccelGroup(obj), nil } // Connect is a wrapper around gtk_accel_group_connect(). func (v *AccelGroup) Connect(key uint, mods gdk.ModifierType, flags AccelFlags, f interface{}) { closure := glib.ClosureNew(f) cl := (*C.struct__GClosure)(unsafe.Pointer(closure)) C.gtk_accel_group_connect( v.native(), C.guint(key), C.GdkModifierType(mods), C.GtkAccelFlags(flags), cl) } // ConnectByPath is a wrapper around gtk_accel_group_connect_by_path(). func (v *AccelGroup) ConnectByPath(path string, f interface{}) { closure := glib.ClosureNew(f) cl := (*C.struct__GClosure)(unsafe.Pointer(closure)) cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) C.gtk_accel_group_connect_by_path( v.native(), (*C.gchar)(cstr), cl) } // Disconnect is a wrapper around gtk_accel_group_disconnect(). func (v *AccelGroup) Disconnect(f interface{}) { closure := glib.ClosureNew(f) cl := (*C.struct__GClosure)(unsafe.Pointer(closure)) C.gtk_accel_group_disconnect(v.native(), cl) } // DisconnectKey is a wrapper around gtk_accel_group_disconnect_key(). func (v *AccelGroup) DisconnectKey(key uint, mods gdk.ModifierType) { C.gtk_accel_group_disconnect_key(v.native(), C.guint(key), C.GdkModifierType(mods)) } // Lock is a wrapper around gtk_accel_group_lock(). func (v *AccelGroup) Lock() { C.gtk_accel_group_lock(v.native()) } // Unlock is a wrapper around gtk_accel_group_unlock(). func (v *AccelGroup) Unlock() { C.gtk_accel_group_unlock(v.native()) } // IsLocked is a wrapper around gtk_accel_group_get_is_locked(). func (v *AccelGroup) IsLocked() bool { return gobool(C.gtk_accel_group_get_is_locked(v.native())) } // AccelGroupFromClosure is a wrapper around gtk_accel_group_from_accel_closure(). func AccelGroupFromClosure(f interface{}) *AccelGroup { closure := glib.ClosureNew(f) cl := (*C.struct__GClosure)(unsafe.Pointer(closure)) c := C.gtk_accel_group_from_accel_closure(cl) if c == nil { return nil } return wrapAccelGroup(glib.Take(unsafe.Pointer(c))) } // GetModifierMask is a wrapper around gtk_accel_group_get_modifier_mask(). func (v *AccelGroup) GetModifierMask() gdk.ModifierType { return gdk.ModifierType(C.gtk_accel_group_get_modifier_mask(v.native())) } // AccelGroupsActivate is a wrapper around gtk_accel_groups_activate(). func AccelGroupsActivate(obj *glib.Object, key uint, mods gdk.ModifierType) bool { return gobool(C.gtk_accel_groups_activate((*C.GObject)(unsafe.Pointer(obj.Native())), C.guint(key), C.GdkModifierType(mods))) } // Activate is a wrapper around gtk_accel_group_activate(). func (v *AccelGroup) Activate(quark glib.Quark, acceleratable *glib.Object, key uint, mods gdk.ModifierType) bool { return gobool(C.gtk_accel_group_activate(v.native(), C.GQuark(quark), (*C.GObject)(unsafe.Pointer(acceleratable.Native())), C.guint(key), C.GdkModifierType(mods))) } // AccelGroupsFromObject is a wrapper around gtk_accel_groups_from_object(). func AccelGroupsFromObject(obj *glib.Object) *glib.SList { res := C.gtk_accel_groups_from_object((*C.GObject)(unsafe.Pointer(obj.Native()))) if res == nil { return nil } // TODO: call DataWrapper on SList and wrap them to gtk.AccelGroup return (*glib.SList)(unsafe.Pointer(res)) } /* * GtkAccelMap */ // AccelMap is a representation of GTK's GtkAccelMap. type AccelMap struct { *glib.Object } // native returns a pointer to the underlying GtkAccelMap. func (v *AccelMap) native() *C.GtkAccelMap { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAccelMap(p) } func marshalAccelMap(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapAccelMap(obj), nil } func wrapAccelMap(obj *glib.Object) *AccelMap { if obj == nil { return nil } return &AccelMap{obj} } // AccelMapAddEntry is a wrapper around gtk_accel_map_add_entry(). func AccelMapAddEntry(path string, key uint, mods gdk.ModifierType) { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) C.gtk_accel_map_add_entry((*C.gchar)(cstr), C.guint(key), C.GdkModifierType(mods)) } type AccelKey C.GtkAccelKey func (v *AccelKey) native() *C.GtkAccelKey { if v == nil { return nil } return (*C.GtkAccelKey)(v) } // AccelMapLookupEntry is a wrapper around gtk_accel_map_lookup_entry(). func AccelMapLookupEntry(path string) *AccelKey { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) var v = new(AccelKey) C.gtk_accel_map_lookup_entry((*C.gchar)(cstr), v.native()) return v } // AccelMapChangeEntry is a wrapper around gtk_accel_map_change_entry(). func AccelMapChangeEntry(path string, key uint, mods gdk.ModifierType, replace bool) bool { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) return gobool(C.gtk_accel_map_change_entry((*C.gchar)(cstr), C.guint(key), C.GdkModifierType(mods), gbool(replace))) } // AccelMapLoad is a wrapper around gtk_accel_map_load(). func AccelMapLoad(fileName string) { cstr := C.CString(fileName) defer C.free(unsafe.Pointer(cstr)) C.gtk_accel_map_load((*C.gchar)(cstr)) } // AccelMapSave is a wrapper around gtk_accel_map_save(). func AccelMapSave(fileName string) { cstr := C.CString(fileName) defer C.free(unsafe.Pointer(cstr)) C.gtk_accel_map_save((*C.gchar)(cstr)) } // AccelMapLoadFD is a wrapper around gtk_accel_map_load_fd(). func AccelMapLoadFD(fd int) { C.gtk_accel_map_load_fd(C.gint(fd)) } // AccelMapSaveFD is a wrapper around gtk_accel_map_save_fd(). func AccelMapSaveFD(fd int) { C.gtk_accel_map_save_fd(C.gint(fd)) } // AccelMapAddFilter is a wrapper around gtk_accel_map_add_filter(). func AccelMapAddFilter(filter string) { cstr := C.CString(filter) defer C.free(unsafe.Pointer(cstr)) C.gtk_accel_map_add_filter((*C.gchar)(cstr)) } // AccelMapGet is a wrapper around gtk_accel_map_get(). func AccelMapGet() *AccelMap { c := C.gtk_accel_map_get() if c == nil { return nil } return wrapAccelMap(glib.Take(unsafe.Pointer(c))) } // AccelMapLockPath is a wrapper around gtk_accel_map_lock_path(). func AccelMapLockPath(path string) { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) C.gtk_accel_map_lock_path((*C.gchar)(cstr)) } // AccelMapUnlockPath is a wrapper around gtk_accel_map_unlock_path(). func AccelMapUnlockPath(path string) { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) C.gtk_accel_map_unlock_path((*C.gchar)(cstr)) } // SetAccelGroup is a wrapper around gtk_menu_set_accel_group(). func (v *Menu) SetAccelGroup(accelGroup *AccelGroup) { C.gtk_menu_set_accel_group(v.native(), accelGroup.native()) } // GetAccelGroup is a wrapper around gtk_menu_get_accel_group(). func (v *Menu) GetAccelGroup() *AccelGroup { c := C.gtk_menu_get_accel_group(v.native()) if c == nil { return nil } return wrapAccelGroup(glib.Take(unsafe.Pointer(c))) } // SetAccelPath is a wrapper around gtk_menu_set_accel_path(). func (v *Menu) SetAccelPath(path string) { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) C.gtk_menu_set_accel_path(v.native(), (*C.gchar)(cstr)) } // GetAccelPath is a wrapper around gtk_menu_get_accel_path(). func (v *Menu) GetAccelPath() string { c := C.gtk_menu_get_accel_path(v.native()) return C.GoString((*C.char)(c)) } // SetAccelPath is a wrapper around gtk_menu_item_set_accel_path(). func (v *MenuItem) SetAccelPath(path string) { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) C.gtk_menu_item_set_accel_path(v.native(), (*C.gchar)(cstr)) } // GetAccelPath is a wrapper around gtk_menu_item_get_accel_path(). func (v *MenuItem) GetAccelPath() string { c := C.gtk_menu_item_get_accel_path(v.native()) return C.GoString((*C.char)(c)) } // AddAccelerator is a wrapper around gtk_widget_add_accelerator(). func (v *Widget) AddAccelerator(signal string, group *AccelGroup, key uint, mods gdk.ModifierType, flags AccelFlags) { csignal := (*C.gchar)(C.CString(signal)) defer C.free(unsafe.Pointer(csignal)) C.gtk_widget_add_accelerator(v.native(), csignal, group.native(), C.guint(key), C.GdkModifierType(mods), C.GtkAccelFlags(flags)) } // RemoveAccelerator is a wrapper around gtk_widget_remove_accelerator(). func (v *Widget) RemoveAccelerator(group *AccelGroup, key uint, mods gdk.ModifierType) bool { return gobool(C.gtk_widget_remove_accelerator(v.native(), group.native(), C.guint(key), C.GdkModifierType(mods))) } // SetAccelPath is a wrapper around gtk_widget_set_accel_path(). func (v *Widget) SetAccelPath(path string, group *AccelGroup) { cstr := (*C.gchar)(C.CString(path)) defer C.free(unsafe.Pointer(cstr)) C.gtk_widget_set_accel_path(v.native(), cstr, group.native()) } // CanActivateAccel is a wrapper around gtk_widget_can_activate_accel(). func (v *Widget) CanActivateAccel(signalId uint) bool { return gobool(C.gtk_widget_can_activate_accel(v.native(), C.guint(signalId))) } // AddAccelGroup() is a wrapper around gtk_window_add_accel_group(). func (v *Window) AddAccelGroup(accelGroup *AccelGroup) { C.gtk_window_add_accel_group(v.native(), accelGroup.native()) } // RemoveAccelGroup() is a wrapper around gtk_window_remove_accel_group(). func (v *Window) RemoveAccelGroup(accelGroup *AccelGroup) { C.gtk_window_remove_accel_group(v.native(), accelGroup.native()) } // These three functions are for system level access - thus not as high priority to implement // TODO: void gtk_accelerator_parse_with_keycode () // TODO: gchar * gtk_accelerator_name_with_keycode () // TODO: gchar * gtk_accelerator_get_label_with_keycode () // TODO: GtkAccelKey * gtk_accel_group_find () - this function uses a function type - I don't know how to represent it in cgo // TODO: gtk_accel_map_foreach_unfiltered - can't be done without a function type // TODO: gtk_accel_map_foreach - can't be done without a function type // TODO: gtk_accel_map_load_scanner /* * GtkWidget */ // TODO: // gtk_widget_list_accel_closures gotk3-0.6.2/gtk/accel_test.go000066400000000000000000000013151431157473000157750ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package gtk import "testing" func Test_AccelGroup_Locking(t *testing.T) { ag, _ := AccelGroupNew() if ag.IsLocked() { t.Error("A newly created AccelGroup should not be locked") } ag.Lock() if !ag.IsLocked() { t.Error("A locked AccelGroup should report being locked") } ag.Unlock() if ag.IsLocked() { t.Error("An unlocked AccelGroup should report being unlocked") } } func Test_AcceleratorParse(t *testing.T) { l, r := AcceleratorParse("F1") if l != 65470 { t.Errorf("Expected parsed key to equal %d but was %d", 65470, l) } if r != 9 { t.Errorf("Expected parsed mods to equal %d but was %d", 9, r) } } gotk3-0.6.2/gtk/actionable.go000066400000000000000000000065461431157473000160030ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" // #include "actionable.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_actionable_get_type()), marshalActionable}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkActionable"] = marshalActionable } // IActionable is a representation of the GtkActionable GInterface, // used to avoid duplication when embedding the type in a wrapper of another GObject-based type. // The non-Interface version should only be used Actionable is used if the concrete type is not known. type IActionable interface { Native() uintptr toActionable() *C.GtkActionable SetActionName(name string) GetActionName() (string, error) // SetActionTargetValue(value *glib.Variant) // GetActionTargetValue() (*glib.Variant, error) // SetActionTarget(string, params...) SetDetailedActionName(name string) } // Actionable is a representation of the GtkActionable GInterface. // Do not embed this concrete type in implementing structs but rather use IActionable // (see Button wrapper for an example) type Actionable struct { *glib.Object } // native returns a pointer to the underlying GtkActionable. func (v *Actionable) native() *C.GtkActionable { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkActionable(p) } func marshalActionable(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapActionable(obj), nil } func wrapActionable(obj *glib.Object) *Actionable { if obj == nil { return nil } return &Actionable{obj} } func (v *Actionable) toActionable() *C.GtkActionable { if v == nil { return nil } return v.native() } // SetActionName is a wrapper around gtk_actionable_set_action_name(). // Since 3.4 func (v *Actionable) SetActionName(action_name string) { cstr := C.CString(action_name) defer C.free(unsafe.Pointer(cstr)) C.gtk_actionable_set_action_name(v.native(), (*C.gchar)(cstr)) } // GetActionName is a wrapper around gtk_actionable_set_action_name(). // Since 3.4 func (v *Actionable) GetActionName() (string, error) { c := C.gtk_actionable_get_action_name(v.native()) if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // SetDetailedActionName is a wrapper around gtk_actionable_set_detailed_action_name(). // Since 3.4 func (v *Actionable) SetDetailedActionName(detailed_action_name string) { cstr := C.CString(detailed_action_name) defer C.free(unsafe.Pointer(cstr)) C.gtk_actionable_set_detailed_action_name(v.native(), (*C.gchar)(cstr)) } // SetActionTargetValue is a wrapper around gtk_actionable_set_action_target_value(). // Since 3.4 /*func (v *Actionable) SetActionTargetValue(value *glib.Variant) { // FIXME ToGVariant does not work here C.gtk_actionable_set_action_target_value(v.native(), value.ToGVariant()) }*/ // GetActionTargetValue is a wrapper around gtk_actionable_get_action_target_value(). // Since 3.4 /*func (v *Actionable) GetActionTargetValue() (*glib.Variant, error) { // FIXME: newVariant is not exported from glib return newVariant(C.gtk_actionable_get_action_target_value(v.native(), cstr)) }*/ /* // Since 3.4 void gtk_actionable_set_action_target (GtkActionable *actionable, const gchar *format_string, ...); */ gotk3-0.6.2/gtk/actionable.go.h000066400000000000000000000001171431157473000162150ustar00rootroot00000000000000static GtkActionable *toGtkActionable(void *p) { return (GTK_ACTIONABLE(p)); } gotk3-0.6.2/gtk/actionable_test.go000066400000000000000000000013721431157473000170320ustar00rootroot00000000000000package gtk import "testing" func TestActionableImplementsIActionable(t *testing.T) { var cut interface{} cut = &Actionable{} _, ok := cut.(IActionable) if !ok { t.Error("Actionable does not implement IActionable") return } } // TestGetSetActionName tests the getter and setter for action name // using a button, as we need an actual instance implementing Actionable. func TestGetSetActionName(t *testing.T) { cut, err := ButtonNew() if err != nil { t.Fatal("Error creating button", err.Error()) } expected := "app.stuff" cut.SetActionName(expected) actual, err := cut.GetActionName() if err != nil { t.Fatal("Error getting action name", err.Error()) } if expected != actual { t.Fatalf("Expected %s got %s", expected, actual) } } gotk3-0.6.2/gtk/actionbar_since_3_12.go000066400000000000000000000062731431157473000175460ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10 // Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // This file includes wrapers for symbols included since GTK 3.12, and // and should not be included in a build intended to target any older GTK // versions. To target an older build, such as 3.10, use // 'go build -tags gtk_3_10'. Otherwise, if no build tags are used, GTK 3.12 // is assumed and this file is built. // +build !gtk_3_6,!gtk_3_8,!gtk_3_10 package gtk // #include // #include "actionbar_since_3_12.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_action_bar_get_type()), marshalActionBar}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkActionBar"] = wrapActionBar } // ActionBar is a representation of GtkActionBar type ActionBar struct { Bin } func (v *ActionBar) native() *C.GtkActionBar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkActionBar(p) } func marshalActionBar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapActionBar(glib.Take(unsafe.Pointer(c))), nil } func wrapActionBar(obj *glib.Object) *ActionBar { if obj == nil { return nil } return &ActionBar{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // ActionBarNew is a wrapper around gtk_action_bar_new() func ActionBarNew() (*ActionBar, error) { c := C.gtk_action_bar_new() if c == nil { return nil, nilPtrErr } return wrapActionBar(glib.Take(unsafe.Pointer(c))), nil } // PackStart is a wrapper around gtk_action_bar_pack_start(). func (a *ActionBar) PackStart(child IWidget) { C.gtk_action_bar_pack_start(a.native(), child.toWidget()) } // PackEnd is a wrapper around gtk_action_bar_pack_end(). func (a *ActionBar) PackEnd(child IWidget) { C.gtk_action_bar_pack_end(a.native(), child.toWidget()) } // SetCenterWidget is a wrapper around gtk_action_bar_set_center_widget(). func (a *ActionBar) SetCenterWidget(child IWidget) { if child == nil { C.gtk_action_bar_set_center_widget(a.native(), nil) } else { C.gtk_action_bar_set_center_widget(a.native(), child.toWidget()) } } // GetCenterWidget is a wrapper around gtk_action_bar_get_center_widget(). func (a *ActionBar) GetCenterWidget() (IWidget, error) { w := C.gtk_action_bar_get_center_widget(a.native()) if w == nil { return nil, nil } return castWidget(w) } gotk3-0.6.2/gtk/actionbar_since_3_12.go.h000066400000000000000000000017701431157473000177710ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12 /* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ static GtkActionBar *toGtkActionBar(void *p) { return (GTK_ACTION_BAR(p)); } gotk3-0.6.2/gtk/app_chooser.go000066400000000000000000000304371431157473000162000ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_app_chooser_get_type()), marshalAppChooser}, {glib.Type(C.gtk_app_chooser_button_get_type()), marshalAppChooserButton}, {glib.Type(C.gtk_app_chooser_widget_get_type()), marshalAppChooserWidget}, {glib.Type(C.gtk_app_chooser_dialog_get_type()), marshalAppChooserDialog}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkAppChooser"] = wrapAppChooser WrapMap["GtkAppChooserButton"] = wrapAppChooserButton WrapMap["GtkAppChooserWidget"] = wrapAppChooserWidget WrapMap["GtkAppChooserDialog"] = wrapAppChooserDialog } /* * GtkAppChooser */ // AppChooser is a representation of GTK's GtkAppChooser GInterface. type AppChooser struct { *glib.Object } // IAppChooser is an interface type implemented by all structs // embedding an AppChooser. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkAppChooser. type IAppChooser interface { toAppChooser() *C.GtkAppChooser } // native returns a pointer to the underlying GtkAppChooser. func (v *AppChooser) native() *C.GtkAppChooser { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAppChooser(p) } func marshalAppChooser(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapAppChooser(obj), nil } func wrapAppChooser(obj *glib.Object) *AppChooser { if obj == nil { return nil } return &AppChooser{obj} } func (v *AppChooser) toAppChooser() *C.GtkAppChooser { if v == nil { return nil } return v.native() } // TODO: Needs gio/GAppInfo implementation first // gtk_app_chooser_get_app_info () // GetContentType is a wrapper around gtk_app_chooser_get_content_type(). func (v *AppChooser) GetContentType() string { cstr := C.gtk_app_chooser_get_content_type(v.native()) defer C.free(unsafe.Pointer(cstr)) return C.GoString((*C.char)(cstr)) } // Refresh is a wrapper around gtk_app_chooser_refresh(). func (v *AppChooser) Refresh() { C.gtk_app_chooser_refresh(v.native()) } /* * GtkAppChooserButton */ // AppChooserButton is a representation of GTK's GtkAppChooserButton. type AppChooserButton struct { ComboBox // Interfaces AppChooser } // native returns a pointer to the underlying GtkAppChooserButton. func (v *AppChooserButton) native() *C.GtkAppChooserButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAppChooserButton(p) } func marshalAppChooserButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapAppChooserButton(glib.Take(unsafe.Pointer(c))), nil } func wrapAppChooserButton(obj *glib.Object) *AppChooserButton { if obj == nil { return nil } cl := wrapCellLayout(obj) ce := wrapCellEditable(obj) ac := wrapAppChooser(obj) return &AppChooserButton{ComboBox{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}, *cl, *ce}, *ac} } // AppChooserButtonNew() is a wrapper around gtk_app_chooser_button_new(). func AppChooserButtonNew(content_type string) (*AppChooserButton, error) { cstr := C.CString(content_type) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_app_chooser_button_new((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapAppChooserButton(glib.Take(unsafe.Pointer(c))), nil } // TODO: Needs gio/GIcon implemented first // gtk_app_chooser_button_append_custom_item () // AppendSeparator() is a wrapper around gtk_app_chooser_button_append_separator(). func (v *AppChooserButton) AppendSeparator() { C.gtk_app_chooser_button_append_separator(v.native()) } // SetActiveCustomItem() is a wrapper around gtk_app_chooser_button_set_active_custom_item(). func (v *AppChooserButton) SetActiveCustomItem(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_app_chooser_button_set_active_custom_item(v.native(), (*C.gchar)(cstr)) } // GetShowDefaultItem() is a wrapper around gtk_app_chooser_button_get_show_default_item(). func (v *AppChooserButton) GetShowDefaultItem() bool { return gobool(C.gtk_app_chooser_button_get_show_default_item(v.native())) } // SetShowDefaultItem() is a wrapper around gtk_app_chooser_button_set_show_default_item(). func (v *AppChooserButton) SetShowDefaultItem(setting bool) { C.gtk_app_chooser_button_set_show_default_item(v.native(), gbool(setting)) } // GetShowDialogItem() is a wrapper around gtk_app_chooser_button_get_show_dialog_item(). func (v *AppChooserButton) GetShowDialogItem() bool { return gobool(C.gtk_app_chooser_button_get_show_dialog_item(v.native())) } // SetShowDialogItem() is a wrapper around gtk_app_chooser_button_set_show_dialog_item(). func (v *AppChooserButton) SetShowDialogItem(setting bool) { C.gtk_app_chooser_button_set_show_dialog_item(v.native(), gbool(setting)) } // GetHeading() is a wrapper around gtk_app_chooser_button_get_heading(). // In case when gtk_app_chooser_button_get_heading() returns a nil string, // GetHeading() returns a non-nil error. func (v *AppChooserButton) GetHeading() (string, error) { cstr := C.gtk_app_chooser_button_get_heading(v.native()) if cstr == nil { return "", nilPtrErr } defer C.free(unsafe.Pointer(cstr)) return C.GoString((*C.char)(cstr)), nil } // SetHeading() is a wrapper around gtk_app_chooser_button_set_heading(). func (v *AppChooserButton) SetHeading(heading string) { cstr := C.CString(heading) defer C.free(unsafe.Pointer(cstr)) C.gtk_app_chooser_button_set_heading(v.native(), (*C.gchar)(cstr)) } /* * GtkAppChooserWidget */ // AppChooserWidget is a representation of GTK's GtkAppChooserWidget. type AppChooserWidget struct { Box // Interfaces AppChooser } // native returns a pointer to the underlying GtkAppChooserWidget. func (v *AppChooserWidget) native() *C.GtkAppChooserWidget { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAppChooserWidget(p) } func marshalAppChooserWidget(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapAppChooserWidget(glib.Take(unsafe.Pointer(c))), nil } func wrapAppChooserWidget(obj *glib.Object) *AppChooserWidget { if obj == nil { return nil } box := wrapBox(obj) ac := wrapAppChooser(obj) return &AppChooserWidget{*box, *ac} } // AppChooserWidgetNew() is a wrapper around gtk_app_chooser_widget_new(). func AppChooserWidgetNew(content_type string) (*AppChooserWidget, error) { cstr := C.CString(content_type) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_app_chooser_widget_new((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapAppChooserWidget(glib.Take(unsafe.Pointer(c))), nil } // GetShowDefault() is a wrapper around gtk_app_chooser_widget_get_show_default(). func (v *AppChooserWidget) GetShowDefault() bool { return gobool(C.gtk_app_chooser_widget_get_show_default(v.native())) } // SetShowDefault() is a wrapper around gtk_app_chooser_widget_set_show_default(). func (v *AppChooserWidget) SetShowDefault(setting bool) { C.gtk_app_chooser_widget_set_show_default(v.native(), gbool(setting)) } // GetShowRecommended() is a wrapper around gtk_app_chooser_widget_get_show_recommended(). func (v *AppChooserWidget) GetShowRecommended() bool { return gobool(C.gtk_app_chooser_widget_get_show_recommended(v.native())) } // SetShowRecommended() is a wrapper around gtk_app_chooser_widget_set_show_recommended(). func (v *AppChooserWidget) SetShowRecommended(setting bool) { C.gtk_app_chooser_widget_set_show_recommended(v.native(), gbool(setting)) } // GetShowFallback() is a wrapper around gtk_app_chooser_widget_get_show_fallback(). func (v *AppChooserWidget) GetShowFallback() bool { return gobool(C.gtk_app_chooser_widget_get_show_fallback(v.native())) } // SetShowFallback() is a wrapper around gtk_app_chooser_widget_set_show_fallback(). func (v *AppChooserWidget) SetShowFallback(setting bool) { C.gtk_app_chooser_widget_set_show_fallback(v.native(), gbool(setting)) } // GetShowOther() is a wrapper around gtk_app_chooser_widget_get_show_other(). func (v *AppChooserWidget) GetShowOther() bool { return gobool(C.gtk_app_chooser_widget_get_show_other(v.native())) } // SetShowOther() is a wrapper around gtk_app_chooser_widget_set_show_other(). func (v *AppChooserWidget) SetShowOther(setting bool) { C.gtk_app_chooser_widget_set_show_other(v.native(), gbool(setting)) } // GetShowAll() is a wrapper around gtk_app_chooser_widget_get_show_all(). func (v *AppChooserWidget) GetShowAll() bool { return gobool(C.gtk_app_chooser_widget_get_show_all(v.native())) } // SetShowAll() is a wrapper around gtk_app_chooser_widget_set_show_all(). func (v *AppChooserWidget) SetShowAll(setting bool) { C.gtk_app_chooser_widget_set_show_all(v.native(), gbool(setting)) } // GetDefaultText() is a wrapper around gtk_app_chooser_widget_get_default_text(). // In case when gtk_app_chooser_widget_get_default_text() returns a nil string, // GetDefaultText() returns a non-nil error. func (v *AppChooserWidget) GetDefaultText() (string, error) { cstr := C.gtk_app_chooser_widget_get_default_text(v.native()) if cstr == nil { return "", nilPtrErr } defer C.free(unsafe.Pointer(cstr)) return C.GoString((*C.char)(cstr)), nil } // SetDefaultText() is a wrapper around gtk_app_chooser_widget_set_default_text(). func (v *AppChooserWidget) SetDefaultText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_app_chooser_widget_set_default_text(v.native(), (*C.gchar)(cstr)) } /* * GtkAppChooserDialog */ // AppChooserDialog is a representation of GTK's GtkAppChooserDialog. type AppChooserDialog struct { Dialog // Interfaces AppChooser } // native returns a pointer to the underlying GtkAppChooserButton. func (v *AppChooserDialog) native() *C.GtkAppChooserDialog { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAppChooserDialog(p) } func marshalAppChooserDialog(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapAppChooserDialog(glib.Take(unsafe.Pointer(c))), nil } func wrapAppChooserDialog(obj *glib.Object) *AppChooserDialog { if obj == nil { return nil } dialog := wrapDialog(obj) ac := wrapAppChooser(obj) return &AppChooserDialog{*dialog, *ac} } // AppChooserDialogNew is a wrapper around gtk_app_chooser_dialog_new(). func AppChooserDialogNew(parent IWindow, flags DialogFlags, file *glib.File) (*AppChooserDialog, error) { var gfile *C.GFile if file != nil { gfile = (*C.GFile)(unsafe.Pointer(file.Native())) } var pw *C.GtkWindow = nil if parent != nil { pw = parent.toWindow() } c := C.gtk_app_chooser_dialog_new(pw, C.GtkDialogFlags(flags), gfile) if c == nil { return nil, nilPtrErr } return wrapAppChooserDialog(glib.Take(unsafe.Pointer(c))), nil } // AppChooserDialogNewForContentType() is a wrapper around gtk_app_chooser_dialog_new_for_content_type(). func AppChooserDialogNewForContentType(parent IWindow, flags DialogFlags, content_type string) (*AppChooserDialog, error) { cstr := C.CString(content_type) defer C.free(unsafe.Pointer(cstr)) var pw *C.GtkWindow = nil if parent != nil { pw = parent.toWindow() } c := C.gtk_app_chooser_dialog_new_for_content_type(pw, C.GtkDialogFlags(flags), (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapAppChooserDialog(glib.Take(unsafe.Pointer(c))), nil } // GetWidget() is a wrapper around gtk_app_chooser_dialog_get_widget(). func (v *AppChooserDialog) GetWidget() *AppChooserWidget { c := C.gtk_app_chooser_dialog_get_widget(v.native()) return wrapAppChooserWidget(glib.Take(unsafe.Pointer(c))) } // GetHeading() is a wrapper around gtk_app_chooser_dialog_get_heading(). // In case when gtk_app_chooser_dialog_get_heading() returns a nil string, // GetHeading() returns a non-nil error. func (v *AppChooserDialog) GetHeading() (string, error) { cstr := C.gtk_app_chooser_dialog_get_heading(v.native()) if cstr == nil { return "", nilPtrErr } defer C.free(unsafe.Pointer(cstr)) return C.GoString((*C.char)(cstr)), nil } // SetHeading() is a wrapper around gtk_app_chooser_dialog_set_heading(). func (v *AppChooserDialog) SetHeading(heading string) { cstr := C.CString(heading) defer C.free(unsafe.Pointer(cstr)) C.gtk_app_chooser_dialog_set_heading(v.native(), (*C.gchar)(cstr)) } gotk3-0.6.2/gtk/application.go000066400000000000000000000122011431157473000161660ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains style related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) // ApplicationInhibitFlags is a representation of GTK's GtkApplicationInhibitFlags. type ApplicationInhibitFlags int const ( APPLICATION_INHIBIT_LOGOUT ApplicationInhibitFlags = C.GTK_APPLICATION_INHIBIT_LOGOUT APPLICATION_INHIBIT_SWITCH ApplicationInhibitFlags = C.GTK_APPLICATION_INHIBIT_SWITCH APPLICATION_INHIBIT_SUSPEND ApplicationInhibitFlags = C.GTK_APPLICATION_INHIBIT_SUSPEND APPLICATION_INHIBIT_IDLE ApplicationInhibitFlags = C.GTK_APPLICATION_INHIBIT_IDLE ) /* * GtkApplication */ // Application is a representation of GTK's GtkApplication. type Application struct { glib.Application } // native returns a pointer to the underlying GtkApplication. func (v *Application) native() *C.GtkApplication { if v == nil || v.GObject == nil { return nil } return C.toGtkApplication(unsafe.Pointer(v.GObject)) } func marshalApplication(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapApplication(obj), nil } func wrapApplication(obj *glib.Object) *Application { if obj == nil { return nil } am := &glib.ActionMap{obj} ag := &glib.ActionGroup{obj} return &Application{glib.Application{obj, am, ag}} } // ApplicationNew is a wrapper around gtk_application_new(). func ApplicationNew(appId string, flags glib.ApplicationFlags) (*Application, error) { cstr := (*C.gchar)(C.CString(appId)) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_application_new(cstr, C.GApplicationFlags(flags)) if c == nil { return nil, nilPtrErr } return wrapApplication(glib.Take(unsafe.Pointer(c))), nil } // AddWindow is a wrapper around gtk_application_add_window(). func (v *Application) AddWindow(w IWindow) { C.gtk_application_add_window(v.native(), w.toWindow()) } // RemoveWindow is a wrapper around gtk_application_remove_window(). func (v *Application) RemoveWindow(w IWindow) { C.gtk_application_remove_window(v.native(), w.toWindow()) } // GetWindowByID is a wrapper around gtk_application_get_window_by_id(). func (v *Application) GetWindowByID(id uint) *Window { c := C.gtk_application_get_window_by_id(v.native(), C.guint(id)) if c == nil { return nil } return wrapWindow(glib.Take(unsafe.Pointer(c))) } // GetActiveWindow is a wrapper around gtk_application_get_active_window(). func (v *Application) GetActiveWindow() *Window { c := C.gtk_application_get_active_window(v.native()) if c == nil { return nil } return wrapWindow(glib.Take(unsafe.Pointer(c))) } // Uninhibit is a wrapper around gtk_application_uninhibit(). func (v *Application) Uninhibit(cookie uint) { C.gtk_application_uninhibit(v.native(), C.guint(cookie)) } // GetAppMenu is a wrapper around gtk_application_get_app_menu(). func (v *Application) GetAppMenu() *glib.MenuModel { c := C.gtk_application_get_app_menu(v.native()) if c == nil { return nil } return &glib.MenuModel{glib.Take(unsafe.Pointer(c))} } // SetAppMenu is a wrapper around gtk_application_set_app_menu(). func (v *Application) SetAppMenu(m *glib.MenuModel) { mptr := (*C.GMenuModel)(unsafe.Pointer(m.Native())) C.gtk_application_set_app_menu(v.native(), mptr) } // GetMenubar is a wrapper around gtk_application_get_menubar(). func (v *Application) GetMenubar() *glib.MenuModel { c := C.gtk_application_get_menubar(v.native()) if c == nil { return nil } return &glib.MenuModel{glib.Take(unsafe.Pointer(c))} } // SetMenubar is a wrapper around gtk_application_set_menubar(). func (v *Application) SetMenubar(m *glib.MenuModel) { mptr := (*C.GMenuModel)(unsafe.Pointer(m.Native())) C.gtk_application_set_menubar(v.native(), mptr) } // IsInhibited is a wrapper around gtk_application_is_inhibited(). func (v *Application) IsInhibited(flags ApplicationInhibitFlags) bool { return gobool(C.gtk_application_is_inhibited(v.native(), C.GtkApplicationInhibitFlags(flags))) } // Inhibited is a wrapper around gtk_application_inhibit(). func (v *Application) Inhibited(window IWindow, flags ApplicationInhibitFlags, reason string) uint { cstr1 := (*C.gchar)(C.CString(reason)) defer C.free(unsafe.Pointer(cstr1)) var w *C.GtkWindow = nil if window != nil { w = window.toWindow() } return uint(C.gtk_application_inhibit(v.native(), w, C.GtkApplicationInhibitFlags(flags), cstr1)) } // void gtk_application_add_accelerator () // deprecated and uses a gvariant paramater // void gtk_application_remove_accelerator () // deprecated and uses a gvariant paramater // GetWindows is a wrapper around gtk_application_get_windows(). // Returned list is wrapped to return *gtk.Window elements. func (v *Application) GetWindows() *glib.List { clist := C.gtk_application_get_windows(v.native()) if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return wrapWindow(glib.Take(ptr)) }) runtime.SetFinalizer(glist, func(v *glib.List) { glib.FinalizerStrategy(v.Free) }) return glist } gotk3-0.6.2/gtk/application_since_3_12.go000066400000000000000000000031441431157473000201010ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10 // See: https://developer.gnome.org/gtk3/3.12/api-index-3-12.html package gtk // #include // #include "gtk.go.h" import "C" import "unsafe" // GetAccelsForAction is a wrapper around gtk_application_get_accels_for_action(). func (v *Application) GetAccelsForAction(act string) []string { cstr1 := (*C.gchar)(C.CString(act)) defer C.free(unsafe.Pointer(cstr1)) var descs []string c := C.gtk_application_get_accels_for_action(v.native(), cstr1) originalc := c defer C.g_strfreev(originalc) for *c != nil { descs = append(descs, C.GoString((*C.char)(*c))) c = nextgcharptr(c) } return descs } // SetAccelsForAction is a wrapper around gtk_application_set_accels_for_action(). func (v *Application) SetAccelsForAction(act string, accels []string) { cstr1 := (*C.gchar)(C.CString(act)) defer C.free(unsafe.Pointer(cstr1)) caccels := C.make_strings(C.int(len(accels) + 1)) defer C.destroy_strings(caccels) for i, accel := range accels { cstr := C.CString(accel) defer C.free(unsafe.Pointer(cstr)) C.set_string(caccels, C.int(i), (*C.gchar)(cstr)) } C.set_string(caccels, C.int(len(accels)), nil) C.gtk_application_set_accels_for_action(v.native(), cstr1, caccels) } // ListActionDescriptions is a wrapper around gtk_application_list_action_descriptions(). func (v *Application) ListActionDescriptions() []string { var descs []string c := C.gtk_application_list_action_descriptions(v.native()) originalc := c defer C.g_strfreev(originalc) for *c != nil { descs = append(descs, C.GoString((*C.char)(*c))) c = nextgcharptr(c) } return descs } gotk3-0.6.2/gtk/application_since_3_14.go000066400000000000000000000023361431157473000201050ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12 // See: https://developer.gnome.org/gtk3/3.14/api-index-3-14.html package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) // PrefersAppMenu is a wrapper around gtk_application_prefers_app_menu(). func (v *Application) PrefersAppMenu() bool { return gobool(C.gtk_application_prefers_app_menu(v.native())) } // GetActionsForAccel is a wrapper around gtk_application_get_actions_for_accel(). func (v *Application) GetActionsForAccel(acc string) []string { cstr1 := (*C.gchar)(C.CString(acc)) defer C.free(unsafe.Pointer(cstr1)) var acts []string c := C.gtk_application_get_actions_for_accel(v.native(), cstr1) originalc := c defer C.g_strfreev(originalc) for *c != nil { acts = append(acts, C.GoString((*C.char)(*c))) c = nextgcharptr(c) } return acts } // GetMenuByID is a wrapper around gtk_application_get_menu_by_id(). func (v *Application) GetMenuByID(id string) *glib.Menu { cstr1 := (*C.gchar)(C.CString(id)) defer C.free(unsafe.Pointer(cstr1)) c := C.gtk_application_get_menu_by_id(v.native(), cstr1) if c == nil { return nil } return &glib.Menu{glib.MenuModel{glib.Take(unsafe.Pointer(c))}} } gotk3-0.6.2/gtk/application_window.go000066400000000000000000000041151431157473000175620ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains style related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) /* * GtkApplicationWindow */ // ApplicationWindow is a representation of GTK's GtkApplicationWindow. type ApplicationWindow struct { Window // Interfaces glib.IActionMap glib.IActionGroup } // native returns a pointer to the underlying GtkApplicationWindow. func (v *ApplicationWindow) native() *C.GtkApplicationWindow { if v == nil || v.Window.GObject == nil { // v.Window is necessary because v.GObject would be ambiguous return nil } p := unsafe.Pointer(v.Window.GObject) return C.toGtkApplicationWindow(p) } func marshalApplicationWindow(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapApplicationWindow(obj), nil } func wrapApplicationWindow(obj *glib.Object) *ApplicationWindow { if obj == nil { return nil } am := &glib.ActionMap{obj} ag := &glib.ActionGroup{obj} return &ApplicationWindow{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}, am, ag} } // ApplicationWindowNew is a wrapper around gtk_application_window_new(). func ApplicationWindowNew(app *Application) (*ApplicationWindow, error) { c := C.gtk_application_window_new(app.native()) if c == nil { return nil, nilPtrErr } return wrapApplicationWindow(glib.Take(unsafe.Pointer(c))), nil } // SetShowMenubar is a wrapper around gtk_application_window_set_show_menubar(). func (v *ApplicationWindow) SetShowMenubar(b bool) { C.gtk_application_window_set_show_menubar(v.native(), gbool(b)) } // GetShowMenubar is a wrapper around gtk_application_window_get_show_menubar(). func (v *ApplicationWindow) GetShowMenubar() bool { return gobool(C.gtk_application_window_get_show_menubar(v.native())) } // GetID is a wrapper around gtk_application_window_get_id(). func (v *ApplicationWindow) GetID() uint { return uint(C.gtk_application_window_get_id(v.native())) } gotk3-0.6.2/gtk/application_window_since_3_20.go000066400000000000000000000014501431157473000214650ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18 package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) // SetHelpOverlay is a wrapper around gtk_application_window_set_help_overlay(). func (v *ApplicationWindow) SetHelpOverlay(helpOverlay *ShortcutsWindow) { C.gtk_application_window_set_help_overlay(v.native(), helpOverlay.native()) } // GetHelpOverlay is a wrapper around gtk_application_window_get_help_overlay(). func (v *ApplicationWindow) GetHelpOverlay() *ShortcutsWindow { c := C.gtk_application_window_get_help_overlay(v.native()) if c == nil { return nil } return wrapShortcutsWindow(glib.Take(unsafe.Pointer(c))) } gotk3-0.6.2/gtk/box_since_3_12.go000066400000000000000000000034251431157473000163700ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10 // Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // This file includes wrapers for symbols included since GTK 3.12, and // and should not be included in a build intended to target any older GTK // versions. To target an older build, such as 3.10, use // 'go build -tags gtk_3_10'. Otherwise, if no build tags are used, GTK 3.12 // is assumed and this file is built. // +build !gtk_3_6,!gtk_3_8,!gtk_3_10 package gtk // #include // #include "gtk.go.h" import "C" // SetCenterWidget is a wrapper around gtk_box_set_center_widget(). func (a *Box) SetCenterWidget(child IWidget) { if child == nil { C.gtk_box_set_center_widget(a.native(), nil) } else { C.gtk_box_set_center_widget(a.native(), child.toWidget()) } } // GetCenterWidget is a wrapper around gtk_box_get_center_widget(). func (a *Box) GetCenterWidget() (IWidget, error) { w := C.gtk_box_get_center_widget(a.native()) if w == nil { return nil, nil } return castWidget(w) } gotk3-0.6.2/gtk/button_box.go000066400000000000000000000055541431157473000160630ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains accelerator related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) type ButtonBoxStyle int const ( BUTTONBOX_SPREAD ButtonBoxStyle = C.GTK_BUTTONBOX_SPREAD BUTTONBOX_EDGE ButtonBoxStyle = C.GTK_BUTTONBOX_EDGE BUTTONBOX_START ButtonBoxStyle = C.GTK_BUTTONBOX_START BUTTONBOX_END ButtonBoxStyle = C.GTK_BUTTONBOX_END BUTTONBOX_CENTER ButtonBoxStyle = C.GTK_BUTTONBOX_CENTER ) /* * GtkButtonBox */ // ButtonBox is a representation of GTK's GtkButtonBox. type ButtonBox struct { Box } // native returns a pointer to the underlying GtkButtonBox. func (v *ButtonBox) native() *C.GtkButtonBox { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkButtonBox(p) } func marshalButtonBox(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapButtonBox(obj), nil } func wrapButtonBox(obj *glib.Object) *ButtonBox { if obj == nil { return nil } return &ButtonBox{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // ButtonBoxNew is a wrapper around gtk_button_box_new(). func ButtonBoxNew(o Orientation) (*ButtonBox, error) { c := C.gtk_button_box_new(C.GtkOrientation(o)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapButtonBox(obj), nil } // GetLayout() is a wrapper around gtk_button_box_get_layout(). func (v *ButtonBox) GetLayout() ButtonBoxStyle { c := C.gtk_button_box_get_layout(v.native()) return ButtonBoxStyle(c) } // GetChildSecondary() is a wrapper around gtk_button_box_get_child_secondary(). func (v *ButtonBox) GetChildSecondary(child IWidget) bool { c := C.gtk_button_box_get_child_secondary(v.native(), child.toWidget()) return gobool(c) } // GetChildNonHomogeneous() is a wrapper around gtk_button_box_get_child_non_homogeneous(). func (v *ButtonBox) GetChildNonHomogeneous(child IWidget) bool { c := C.gtk_button_box_get_child_non_homogeneous(v.native(), child.toWidget()) return gobool(c) } // SetLayout() is a wrapper around gtk_button_box_set_layout(). func (v *ButtonBox) SetLayout(style ButtonBoxStyle) { C.gtk_button_box_set_layout(v.native(), C.GtkButtonBoxStyle(style)) } // SetChildSecondary() is a wrapper around gtk_button_box_set_child_secondary(). func (v *ButtonBox) SetChildSecondary(child IWidget, isSecondary bool) { C.gtk_button_box_set_child_secondary(v.native(), child.toWidget(), gbool(isSecondary)) } // SetChildNonHomogeneous() is a wrapper around gtk_button_box_set_child_non_homogeneous(). func (v *ButtonBox) SetChildNonHomogeneous(child IWidget, nonHomogeneous bool) { C.gtk_button_box_set_child_non_homogeneous(v.native(), child.toWidget(), gbool(nonHomogeneous)) } gotk3-0.6.2/gtk/cell_area.go000066400000000000000000000471771431157473000156160ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package gtk // #include // #include "gtk.go.h" import "C" import ( "fmt" "unsafe" "github.com/gotk3/gotk3/cairo" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) /* * GtkCellArea */ // TODO: macro // GTK_CELL_AREA_WARN_INVALID_CELL_PROPERTY_ID(object, property_id, pspec) // object - the GObject on which set_cell_property() or get_cell_property() was called // property_id - the numeric id of the property // pspec - the GParamSpec of the property // C.GTK_CELL_AREA_WARN_INVALID_CELL_PROPERTY_ID // CellArea is a representation of GTK's GtkCellArea. type CellArea struct { glib.InitiallyUnowned } type ICellArea interface { toCellArea() *C.GtkCellArea ToCellArea() *CellArea } // native returns a pointer to the underlying GtkCellArea. func (v *CellArea) native() *C.GtkCellArea { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellArea(p) } func (v *CellArea) toCellArea() *C.GtkCellArea { if v == nil { return nil } return v.native() } // ToCellArea is a helper getter, in case you use the interface gtk.ICellArea in your program. // It returns e.g. *gtk.CellAreaBox as a *gtk.CellArea. func (v *CellArea) ToCellArea() *CellArea { return v } func marshalCellArea(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellArea(obj), nil } func wrapCellArea(obj *glib.Object) *CellArea { if obj == nil { return nil } return &CellArea{glib.InitiallyUnowned{obj}} } // Add is a wrapper around gtk_cell_area_add(). func (v *CellArea) Add(renderer ICellRenderer) { C.gtk_cell_area_add(v.native(), renderer.toCellRenderer()) } // Remove is a wrapper around gtk_cell_area_remove(). func (v *CellArea) Remove(renderer ICellRenderer) { C.gtk_cell_area_remove(v.native(), renderer.toCellRenderer()) } // HasRenderer is a wrapper around gtk_cell_area_has_renderer(). func (v *CellArea) HasRenderer(renderer ICellRenderer) bool { return gobool(C.gtk_cell_area_has_renderer(v.native(), renderer.toCellRenderer())) } // TODO: // depends on GtkCellCallback // Foreach is a wrapper around gtk_cell_area_foreach(). // func (v *CellArea) Foreach(cb CellCallback, callbackData interface{}) { // } // TODO: // depends on GtkCellAllocCallback // ForeachAlloc is a wrapper around gtk_cell_area_foreach_alloc(). // func (v *CellArea) ForeachAlloc(context *CellAreaContext, widget IWidget, cellArea, backgroundArea *gdk.Rectangle, cb CellAllocCallback, callbackData interface{}) { // } // AreaEvent is a wrapper around gtk_cell_area_event(). func (v *CellArea) AreaEvent(context *CellAreaContext, widget IWidget, event *gdk.Event, cellArea *gdk.Rectangle, flags CellRendererState) int { e := (*C.GdkEvent)(unsafe.Pointer(event.Native())) c := C.gtk_cell_area_event(v.native(), context.native(), widget.toWidget(), e, nativeGdkRectangle(*cellArea), C.GtkCellRendererState(flags)) return int(c) } // Render is a wrapper around gtk_cell_area_render(). func (v *CellArea) Render(context *CellAreaContext, widget IWidget, cr *cairo.Context, backgroundArea, cellArea *gdk.Rectangle, flags CellRendererState, paintFocus bool) { cairoContext := (*C.cairo_t)(unsafe.Pointer(cr.Native())) C.gtk_cell_area_render(v.native(), context.native(), widget.toWidget(), cairoContext, nativeGdkRectangle(*backgroundArea), nativeGdkRectangle(*cellArea), C.GtkCellRendererState(flags), gbool(paintFocus)) } // GetCellAllocation is a wrapper around gtk_cell_area_get_cell_allocation(). func (v *CellArea) GetCellAllocation(context *CellAreaContext, widget IWidget, renderer ICellRenderer, cellArea *gdk.Rectangle) *gdk.Rectangle { var cRect *C.GdkRectangle C.gtk_cell_area_get_cell_allocation(v.native(), context.native(), widget.toWidget(), renderer.toCellRenderer(), nativeGdkRectangle(*cellArea), cRect) allocation := gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) return allocation } // GetCellAtPosition is a wrapper around gtk_cell_area_get_cell_at_position(). func (v *CellArea) GetCellAtPosition(context *CellAreaContext, widget IWidget, cellArea *gdk.Rectangle, x, y int) (ICellRenderer, *gdk.Rectangle, error) { var cRect *C.GdkRectangle renderer := C.gtk_cell_area_get_cell_at_position(v.native(), context.native(), widget.toWidget(), nativeGdkRectangle(*cellArea), C.gint(x), C.gint(y), cRect) var allocation *gdk.Rectangle if cRect != nil { allocation = gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) } r, err := castCellRenderer(renderer) return r, allocation, err } // CreateContext is a wrapper around gtk_cell_area_create_context(). func (v *CellArea) CreateContext() (*CellAreaContext, error) { c := C.gtk_cell_area_create_context(v.native()) if c == nil { return nil, nilPtrErr } return wrapCellAreaContext(glib.Take(unsafe.Pointer(c))), nil } // CopyContext is a wrapper around gtk_cell_area_copy_context(). func (v *CellArea) CopyContext(context *CellAreaContext) (*CellAreaContext, error) { c := C.gtk_cell_area_copy_context(v.native(), context.native()) if c == nil { return nil, nilPtrErr } return wrapCellAreaContext(glib.Take(unsafe.Pointer(c))), nil } // TODO: // depends on GtkSizeRequestMode // gtk_cell_area_get_request_mode // GetPreferredWidth is a wrapper around gtk_cell_area_get_preferred_width(). func (v *CellArea) GetPreferredWidth(context *CellAreaContext, widget IWidget) (int, int) { var minWidth C.gint var naturalWidth C.gint C.gtk_cell_area_get_preferred_width(v.native(), context.native(), widget.toWidget(), &minWidth, &naturalWidth) return int(minWidth), int(naturalWidth) } // GetPreferredHeightForWidth is a wrapper around gtk_cell_area_get_preferred_height_for_width(). func (v *CellArea) GetPreferredHeightForWidth(context *CellAreaContext, widget IWidget, width int) (int, int) { var minHeight C.gint var naturalHeight C.gint C.gtk_cell_area_get_preferred_height_for_width(v.native(), context.native(), widget.toWidget(), C.gint(width), &minHeight, &naturalHeight) return int(minHeight), int(naturalHeight) } // GetPreferredHeight is a wrapper around gtk_cell_area_get_preferred_height(). func (v *CellArea) GetPreferredHeight(context *CellAreaContext, widget IWidget) (int, int) { var minHeight C.gint var naturalHeight C.gint C.gtk_cell_area_get_preferred_height(v.native(), context.native(), widget.toWidget(), &minHeight, &naturalHeight) return int(minHeight), int(naturalHeight) } // GetPreferredWidthForHeight is a wrapper around gtk_cell_area_get_preferred_width_for_height(). func (v *CellArea) GetPreferredWidthForHeight(context *CellAreaContext, widget IWidget, height int) (int, int) { var minWidth C.gint var naturalWidth C.gint C.gtk_cell_area_get_preferred_width_for_height(v.native(), context.native(), widget.toWidget(), C.gint(height), &minWidth, &naturalWidth) return int(minWidth), int(naturalWidth) } // GetCurrentPathString is a wrapper around gtk_cell_area_get_current_path_string(). func (v *CellArea) GetCurrentPathString() string { c := C.gtk_cell_area_get_current_path_string(v.native()) // This string belongs to the area and should not be freed. return goString(c) } // ApplyAttributes is a wrapper around gtk_cell_area_apply_attributes(). func (v *CellArea) ApplyAttributes(model ITreeModel, iter *TreeIter, isExpander, isExpanded bool) { C.gtk_cell_area_apply_attributes(v.native(), model.toTreeModel(), iter.native(), gbool(isExpander), gbool(isExpanded)) } // AttributeConnect is a wrapper around gtk_cell_area_attribute_connect(). func (v *CellArea) AttributeConnect(renderer ICellRenderer, attribute string, column int) { cstr := C.CString(attribute) defer C.free(unsafe.Pointer(cstr)) C.gtk_cell_area_attribute_connect(v.native(), renderer.toCellRenderer(), (*C.gchar)(cstr), C.gint(column)) } // AttributeDisconnect is a wrapper around gtk_cell_area_attribute_disconnect(). func (v *CellArea) AttributeDisconnect(renderer ICellRenderer, attribute string) { cstr := C.CString(attribute) defer C.free(unsafe.Pointer(cstr)) C.gtk_cell_area_attribute_disconnect(v.native(), renderer.toCellRenderer(), (*C.gchar)(cstr)) } // TODO: // gtk_cell_area_class_install_cell_property // depends on GParamSpec // gtk_cell_area_class_find_cell_property // depends on GParamSpec // gtk_cell_area_class_list_cell_properties // depends on GParamSpec // gtk_cell_area_add_with_properties // gtk_cell_area_cell_set // gtk_cell_area_cell_get // gtk_cell_area_cell_set_valist // gtk_cell_area_cell_get_valist // CellSetProperty is a wrapper around gtk_cell_area_cell_set_property(). func (v *CellArea) CellSetProperty(renderer ICellRenderer, propertyName string, value interface{}) error { gval, err := glib.GValue(value) if err != nil { return err } cstr := C.CString(propertyName) defer C.free(unsafe.Pointer(cstr)) C.gtk_cell_area_cell_set_property(v.native(), renderer.toCellRenderer(), (*C.gchar)(cstr), (*C.GValue)(unsafe.Pointer(gval.Native()))) return nil } // CellGetProperty is a wrapper around gtk_cell_area_cell_get_property(). func (v *CellArea) CellGetProperty(renderer ICellRenderer, propertyName string) (interface{}, error) { cstr := C.CString(propertyName) defer C.free(unsafe.Pointer(cstr)) var gval C.GValue C.gtk_cell_area_cell_get_property(v.native(), renderer.toCellRenderer(), (*C.gchar)(cstr), &gval) value := glib.ValueFromNative(unsafe.Pointer(&gval)) return value.GoValue() } // IsActivatable is a wrapper around gtk_cell_area_is_activatable(). func (v *CellArea) IsActivatable() bool { return gobool(C.gtk_cell_area_is_activatable(v.native())) } // Activate is a wrapper around gtk_cell_area_activate(). func (v *CellArea) Activate(context *CellAreaContext, widget IWidget, cellArea *gdk.Rectangle, flags CellRendererState, editOnly bool) { C.gtk_cell_area_activate(v.native(), context.native(), widget.toWidget(), nativeGdkRectangle(*cellArea), C.GtkCellRendererState(flags), gbool(editOnly)) } // Focus is a wrapper around gtk_cell_area_focus(). func (v *CellArea) Focus(direction DirectionType) bool { return gobool(C.gtk_cell_area_focus(v.native(), C.GtkDirectionType(direction))) } // SetFocusCell is a wrapper around gtk_cell_area_set_focus_cell(). func (v *CellArea) SetFocusCell(renderer ICellRenderer) { C.gtk_cell_area_set_focus_cell(v.native(), renderer.toCellRenderer()) } // GetFocusCell is a wrapper around gtk_cell_area_get_focus_cell(). func (v *CellArea) GetFocusCell() (ICellRenderer, error) { c := C.gtk_cell_area_get_focus_cell(v.native()) return castCellRenderer(c) } // AddFocusSibling is a wrapper around gtk_cell_area_add_focus_sibling(). func (v *CellArea) AddFocusSibling(renderer, sibling ICellRenderer) { C.gtk_cell_area_add_focus_sibling(v.native(), renderer.toCellRenderer(), sibling.toCellRenderer()) } // RemoveFocusSibling is a wrapper around gtk_cell_area_remove_focus_sibling(). func (v *CellArea) RemoveFocusSibling(renderer, sibling ICellRenderer) { C.gtk_cell_area_remove_focus_sibling(v.native(), renderer.toCellRenderer(), sibling.toCellRenderer()) } // IsFocusSibling is a wrapper around gtk_cell_area_is_focus_sibling(). func (v *CellArea) IsFocusSibling(renderer, sibling ICellRenderer) bool { return gobool(C.gtk_cell_area_is_focus_sibling(v.native(), renderer.toCellRenderer(), sibling.toCellRenderer())) } // GetFocusSiblings is a wrapper around gtk_cell_area_get_focus_siblings(). func (v *CellArea) GetFocusSiblings(renderer ICellRenderer) ([]ICellRenderer, error) { clist := C.gtk_cell_area_get_focus_siblings(v.native(), renderer.toCellRenderer()) if clist == nil { return nil, nilPtrErr } // The returned list is internal and should not be freed. var cellRendererList []ICellRenderer wlist := glib.WrapList(uintptr(unsafe.Pointer(clist))) for ; wlist.Data() != nil; wlist = wlist.Next() { w, ok := wlist.Data().(*CellRenderer) if !ok { return nil, fmt.Errorf("element is not of type *CellRenderer, got %T", w) } cRenderer, err := castCellRenderer(w.toCellRenderer()) if err != nil { return nil, err } cellRendererList = append(cellRendererList, cRenderer) } return cellRendererList, nil } // GetFocusFromSibling is a wrapper around gtk_cell_area_get_focus_from_sibling(). func (v *CellArea) GetFocusFromSibling(renderer ICellRenderer) (ICellRenderer, error) { c := C.gtk_cell_area_get_focus_from_sibling(v.native(), renderer.toCellRenderer()) return castCellRenderer(c) } // GetEditedCell is a wrapper around gtk_cell_area_get_edited_cell(). func (v *CellArea) GetEditedCell() (ICellRenderer, error) { c := C.gtk_cell_area_get_edited_cell(v.native()) return castCellRenderer(c) } // GetEditWidget is a wrapper around gtk_cell_area_get_edit_widget(). func (v *CellArea) GetEditWidget() (ICellEditable, error) { c := C.gtk_cell_area_get_edit_widget(v.native()) return castCellEditable(c) } // ActivateCell is a wrapper around gtk_cell_area_activate_cell(). func (v *CellArea) ActivateCell(widget IWidget, renderer ICellRenderer, event *gdk.Event, cellArea *gdk.Rectangle, flags CellRendererState) bool { e := (*C.GdkEvent)(unsafe.Pointer(event.Native())) c := C.gtk_cell_area_activate_cell(v.native(), widget.toWidget(), renderer.toCellRenderer(), e, nativeGdkRectangle(*cellArea), C.GtkCellRendererState(flags)) return gobool(c) } // StopEditing is a wrapper around gtk_cell_area_stop_editing(). func (v *CellArea) StopEditing(cancelled bool) { C.gtk_cell_area_stop_editing(v.native(), gbool(cancelled)) } // InnerCellArea is a wrapper around gtk_cell_area_inner_cell_area(). func (v *CellArea) InnerCellArea(widget IWidget, cellArea *gdk.Rectangle) *gdk.Rectangle { var cRect *C.GdkRectangle C.gtk_cell_area_inner_cell_area(v.native(), widget.toWidget(), nativeGdkRectangle(*cellArea), cRect) innerArea := gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) return innerArea } // RequestRenderer is a wrapper around gtk_cell_area_request_renderer(). func (v *CellArea) RequestRenderer(renderer ICellRenderer, orientation Orientation, widget IWidget, forSize int) (int, int) { var minSize C.gint var naturalSize C.gint C.gtk_cell_area_request_renderer(v.native(), renderer.toCellRenderer(), C.GtkOrientation(orientation), widget.toWidget(), C.gint(forSize), &minSize, &naturalSize) return int(minSize), int(naturalSize) } /* * GtkCellAreaContext */ type CellAreaContext struct { *glib.Object } // native returns a pointer to the underlying GtkCellAreaContext. func (v *CellAreaContext) native() *C.GtkCellAreaContext { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellAreaContext(p) } func (v *CellAreaContext) toCellAreaContext() *C.GtkCellAreaContext { if v == nil { return nil } return v.native() } func marshalCellAreaContext(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellAreaContext(obj), nil } func wrapCellAreaContext(obj *glib.Object) *CellAreaContext { if obj == nil { return nil } return &CellAreaContext{obj} } // GetArea is a wrapper around gtk_cell_area_context_get_area(). func (v *CellAreaContext) GetArea() (*CellArea, error) { c := C.gtk_cell_area_context_get_area(v.native()) if c == nil { return nil, nilPtrErr } return wrapCellArea(glib.Take(unsafe.Pointer(c))), nil } // Allocate is a wrapper around gtk_cell_area_context_allocate(). func (v *CellAreaContext) Allocate(width, height int) { C.gtk_cell_area_context_allocate(v.native(), C.gint(width), C.gint(height)) } // Reset is a wrapper around gtk_cell_area_context_reset(). func (v *CellAreaContext) Reset(width, height int) { C.gtk_cell_area_context_reset(v.native()) } // GetPreferredWidth is a wrapper around gtk_cell_area_context_get_preferred_width(). func (v *CellAreaContext) GetPreferredWidth() (int, int) { var minWidth C.gint var naturalWidth C.gint C.gtk_cell_area_context_get_preferred_width(v.native(), &minWidth, &naturalWidth) return int(minWidth), int(naturalWidth) } // GetPreferredHeight is a wrapper around gtk_cell_area_context_get_preferred_height(). func (v *CellAreaContext) GetPreferredHeight() (int, int) { var minHeight C.gint var naturalHeight C.gint C.gtk_cell_area_context_get_preferred_height(v.native(), &minHeight, &naturalHeight) return int(minHeight), int(naturalHeight) } // GetPreferredHeightForWidth is a wrapper around gtk_cell_area_context_get_preferred_height_for_width(). func (v *CellAreaContext) GetPreferredHeightForWidth(width int) (int, int) { var minHeight C.gint var naturalHeight C.gint C.gtk_cell_area_context_get_preferred_height_for_width(v.native(), C.gint(width), &minHeight, &naturalHeight) return int(minHeight), int(naturalHeight) } // GetPreferredWidthForHeight is a wrapper around gtk_cell_area_context_get_preferred_width_for_height(). func (v *CellAreaContext) GetPreferredWidthForHeight(height int) (int, int) { var minWidth C.gint var naturalWidth C.gint C.gtk_cell_area_context_get_preferred_width_for_height(v.native(), C.gint(height), &minWidth, &naturalWidth) return int(minWidth), int(naturalWidth) } // GetAllocation is a wrapper around gtk_cell_area_context_get_allocation(). func (v *CellAreaContext) GetAllocation() (int, int) { var height C.gint var width C.gint C.gtk_cell_area_context_get_allocation(v.native(), &height, &width) return int(height), int(width) } // PushPreferredWidth is a wrapper around gtk_cell_area_context_push_preferred_width(). func (v *CellAreaContext) PushPreferredWidth(minWidth, naturalWidth int) { C.gtk_cell_area_context_push_preferred_width(v.native(), C.gint(minWidth), C.gint(naturalWidth)) } // PushPreferredHeight is a wrapper around gtk_cell_area_context_push_preferred_height(). func (v *CellAreaContext) PushPreferredHeight(minHeight, naturalHeight int) { C.gtk_cell_area_context_push_preferred_height(v.native(), C.gint(minHeight), C.gint(naturalHeight)) } /* * GtkCellAreaBox */ // CellAreaBox is a representation of GTK's GtkCellAreaBox. type CellAreaBox struct { CellArea // Interfaces Orientable } // native returns a pointer to the underlying GtkCellAreaBox. func (v *CellAreaBox) native() *C.GtkCellAreaBox { if v == nil || v.CellArea.GObject == nil { return nil } p := unsafe.Pointer(v.CellArea.GObject) return C.toGtkCellAreaBox(p) } func (v *CellArea) toOrientable() *C.GtkOrientable { if v == nil { return nil } return C.toGtkOrientable(unsafe.Pointer(v.GObject)) } func marshalCellAreaBox(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellAreaBox(obj), nil } func wrapCellAreaBox(obj *glib.Object) *CellAreaBox { if obj == nil { return nil } cellArea := wrapCellArea(obj) o := wrapOrientable(obj) return &CellAreaBox{*cellArea, *o} } // CellAreaBoxNew is a wrapper around gtk_cell_area_box_new(). func CellAreaBoxNew() (*CellAreaBox, error) { c := C.gtk_cell_area_box_new() if c == nil { return nil, nilPtrErr } return wrapCellAreaBox(glib.Take(unsafe.Pointer(c))), nil } // PackStart is a wrapper around gtk_cell_area_box_pack_start(). func (v *CellAreaBox) PackStart(renderer ICellRenderer, expand, align, fixed bool) { C.gtk_cell_area_box_pack_start(v.native(), renderer.toCellRenderer(), gbool(expand), gbool(align), gbool(fixed)) } // PackEnd is a wrapper around gtk_cell_area_box_pack_end(). func (v *CellAreaBox) PackEnd(renderer ICellRenderer, expand, align, fixed bool) { C.gtk_cell_area_box_pack_end(v.native(), renderer.toCellRenderer(), gbool(expand), gbool(align), gbool(fixed)) } // GetSpacing is a wrapper around gtk_cell_area_box_get_spacing(). func (v *CellAreaBox) GetSpacing() int { return int(C.gtk_cell_area_box_get_spacing(v.native())) } // SetSpacing is a wrapper around gtk_cell_area_box_set_spacing(). func (v *CellAreaBox) SetSpacing(spacing int) { C.gtk_cell_area_box_set_spacing(v.native(), C.gint(spacing)) } gotk3-0.6.2/gtk/cell_area_since_3_14.go000066400000000000000000000012211431157473000175010ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // See: https://developer.gnome.org/gtk3/3.14/api-index-3-14.html // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12 package gtk // #include // #include "gtk.go.h" import "C" import "unsafe" /* * GtkCellArea */ // AttributeGetColumn is a wrapper around gtk_cell_area_attribute_get_column(). func (v *CellArea) AttributeGetColumn(renderer ICellRenderer, attribute string) int { cstr := C.CString(attribute) defer C.free(unsafe.Pointer(cstr)) column := C.gtk_cell_area_attribute_get_column(v.native(), renderer.toCellRenderer(), (*C.gchar)(cstr)) return int(column) } gotk3-0.6.2/gtk/color_chooser.go000066400000000000000000000103011431157473000165220ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_color_chooser_get_type()), marshalColorChooser}, {glib.Type(C.gtk_color_chooser_dialog_get_type()), marshalColorChooserDialog}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkColorChooser"] = wrapColorChooser WrapMap["GtkColorChooserDialog"] = wrapColorChooserDialog } /* * GtkColorChooser */ // ColorChooser is a representation of GTK's GtkColorChooser GInterface. type ColorChooser struct { *glib.Object } // IColorChooser is an interface type implemented by all structs // embedding an ColorChooser. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkColorChooser. type IColorChooser interface { toColorChooser() *C.GtkColorChooser } // native returns a pointer to the underlying GtkColorChooser. func (v *ColorChooser) native() *C.GtkColorChooser { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkColorChooser(p) } func marshalColorChooser(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapColorChooser(obj), nil } func wrapColorChooser(obj *glib.Object) *ColorChooser { if obj == nil { return nil } return &ColorChooser{obj} } func (v *ColorChooser) toColorChooser() *C.GtkColorChooser { if v == nil { return nil } return v.native() } // GetRGBA() is a wrapper around gtk_color_chooser_get_rgba(). func (v *ColorChooser) GetRGBA() *gdk.RGBA { gdkColor := gdk.NewRGBA() C.gtk_color_chooser_get_rgba(v.native(), (*C.GdkRGBA)(unsafe.Pointer(gdkColor.Native()))) return gdkColor } // SetRGBA() is a wrapper around gtk_color_chooser_set_rgba(). func (v *ColorChooser) SetRGBA(gdkColor *gdk.RGBA) { C.gtk_color_chooser_set_rgba(v.native(), (*C.GdkRGBA)(unsafe.Pointer(gdkColor.Native()))) } // GetUseAlpha() is a wrapper around gtk_color_chooser_get_use_alpha(). func (v *ColorChooser) GetUseAlpha() bool { return gobool(C.gtk_color_chooser_get_use_alpha(v.native())) } // SetUseAlpha() is a wrapper around gtk_color_chooser_set_use_alpha(). func (v *ColorChooser) SetUseAlpha(use_alpha bool) { C.gtk_color_chooser_set_use_alpha(v.native(), gbool(use_alpha)) } // AddPalette() is a wrapper around gtk_color_chooser_add_palette(). func (v *ColorChooser) AddPalette(orientation Orientation, colors_per_line int, colors []*gdk.RGBA) { n_colors := len(colors) var c_colors []C.GdkRGBA for _, c := range colors { c_colors = append(c_colors, *(*C.GdkRGBA)(unsafe.Pointer(c.Native()))) } C.gtk_color_chooser_add_palette( v.native(), C.GtkOrientation(orientation), C.gint(colors_per_line), C.gint(n_colors), &c_colors[0], ) } /* * GtkColorChooserDialog */ // ColorChooserDialog is a representation of GTK's GtkColorChooserDialog. type ColorChooserDialog struct { Dialog // Interfaces ColorChooser } // native returns a pointer to the underlying GtkColorChooserDialog. func (v *ColorChooserDialog) native() *C.GtkColorChooserDialog { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkColorChooserDialog(p) } func marshalColorChooserDialog(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapColorChooserDialog(glib.Take(unsafe.Pointer(c))), nil } func wrapColorChooserDialog(obj *glib.Object) *ColorChooserDialog { if obj == nil { return nil } dialog := wrapDialog(obj) cc := wrapColorChooser(obj) return &ColorChooserDialog{*dialog, *cc} } // ColorChooserDialogNew() is a wrapper around gtk_color_chooser_dialog_new(). func ColorChooserDialogNew(title string, parent IWindow) (*ColorChooserDialog, error) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } c := C.gtk_color_chooser_dialog_new((*C.gchar)(cstr), w) if c == nil { return nil, nilPtrErr } return wrapColorChooserDialog(glib.Take(unsafe.Pointer(c))), nil } /* * GtkColorChooserWidget */ // TODO: // gtk_color_chooser_widget_new(). gotk3-0.6.2/gtk/combo_box.go000066400000000000000000000300011431157473000156300ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import ( "errors" "fmt" "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_combo_box_get_type()), marshalComboBox}, {glib.Type(C.gtk_combo_box_text_get_type()), marshalComboBoxText}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkComboBox"] = wrapComboBox WrapMap["GtkComboBoxText"] = wrapComboBoxText } /* * GtkComboBox */ // ComboBox is a representation of GTK's GtkComboBox. type ComboBox struct { Bin // Interfaces CellLayout CellEditable } // native returns a pointer to the underlying GtkComboBox. func (v *ComboBox) native() *C.GtkComboBox { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkComboBox(p) } func (v *ComboBox) toCellLayout() *C.GtkCellLayout { if v == nil { return nil } return C.toGtkCellLayout(unsafe.Pointer(v.GObject)) } func marshalComboBox(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapComboBox(obj), nil } func wrapComboBox(obj *glib.Object) *ComboBox { if obj == nil { return nil } cl := wrapCellLayout(obj) ce := wrapCellEditable(obj) return &ComboBox{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}, *cl, *ce} } // ComboBoxNew is a wrapper around gtk_combo_box_new(). func ComboBoxNew() (*ComboBox, error) { c := C.gtk_combo_box_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapComboBox(obj), nil } // ComboBoxNewWithEntry is a wrapper around gtk_combo_box_new_with_entry(). func ComboBoxNewWithEntry() (*ComboBox, error) { c := C.gtk_combo_box_new_with_entry() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapComboBox(obj), nil } // ComboBoxNewWithModel is a wrapper around gtk_combo_box_new_with_model(). func ComboBoxNewWithModel(model ITreeModel) (*ComboBox, error) { c := C.gtk_combo_box_new_with_model(model.toTreeModel()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapComboBox(obj), nil } // is a wrapper around gtk_combo_box_new_with_model_and_entry(). func ComboBoxNewWithModelAndEntry(model ITreeModel) (*ComboBox, error) { c := C.gtk_combo_box_new_with_model_and_entry(model.toTreeModel()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapComboBox(obj), nil } // GetWrapWidth is a wrapper around gtk_combo_box_get_wrap_width(). func (v *ComboBox) GetWrapWidth() int { c := C.gtk_combo_box_get_wrap_width(v.native()) return int(c) } // SetWrapWidth is a wrapper around gtk_combo_box_set_wrap_width(). func (v *ComboBox) SetWrapWidth(wrapWidth int) { C.gtk_combo_box_set_wrap_width(v.native(), C.gint(wrapWidth)) } // GetRowSpanColumn is a wrapper around gtk_combo_box_get_row_span_column(). func (v *ComboBox) GetRowSpanColumn() int { c := C.gtk_combo_box_get_row_span_column(v.native()) return int(c) } // SetRowSpanColumn is a wrapper around gtk_combo_box_set_row_span_column(). func (v *ComboBox) SetRowSpanColumn(rowSpan int) { C.gtk_combo_box_set_row_span_column(v.native(), C.gint(rowSpan)) } // GetColumnSpanColumn is a wrapper around gtk_combo_box_get_column_span_column(). func (v *ComboBox) GetColumnSpanColumn() int { c := C.gtk_combo_box_get_column_span_column(v.native()) return int(c) } // SetColumnSpanColumn is a wrapper around gtk_combo_box_set_column_span_column(). func (v *ComboBox) SetColumnSpanColumn(wrapWidth int) { C.gtk_combo_box_set_column_span_column(v.native(), C.gint(wrapWidth)) } // GetActive is a wrapper around gtk_combo_box_get_active(). func (v *ComboBox) GetActive() int { c := C.gtk_combo_box_get_active(v.native()) return int(c) } // SetActive is a wrapper around gtk_combo_box_set_active(). func (v *ComboBox) SetActive(index int) { C.gtk_combo_box_set_active(v.native(), C.gint(index)) } // GetActiveIter is a wrapper around gtk_combo_box_get_active_iter(). func (v *ComboBox) GetActiveIter() (*TreeIter, error) { var cIter C.GtkTreeIter c := C.gtk_combo_box_get_active_iter(v.native(), &cIter) if !gobool(c) { return nil, errors.New("unable to get active iter") } return &TreeIter{cIter}, nil } // SetActiveIter is a wrapper around gtk_combo_box_set_active_iter(). func (v *ComboBox) SetActiveIter(iter *TreeIter) { var cIter *C.GtkTreeIter if iter != nil { cIter = &iter.GtkTreeIter } C.gtk_combo_box_set_active_iter(v.native(), cIter) } // GetIDColumn is a wrapper around gtk_combo_box_get_id_column() func (v *ComboBox) GetIDColumn() int { c := C.gtk_combo_box_get_id_column(v.native()) return int(c) } // SetIDColumn is a wrapper around gtk_combo_box_set_id_column() func (v *ComboBox) SetIDColumn(idColumn int) { C.gtk_combo_box_set_id_column(v.native(), C.gint(idColumn)) } // GetActiveID is a wrapper around gtk_combo_box_get_active_id(). func (v *ComboBox) GetActiveID() string { c := C.gtk_combo_box_get_active_id(v.native()) return C.GoString((*C.char)(c)) } // SetActiveID is a wrapper around gtk_combo_box_set_active_id(). func (v *ComboBox) SetActiveID(id string) bool { cid := C.CString(id) defer C.free(unsafe.Pointer(cid)) c := C.gtk_combo_box_set_active_id(v.native(), (*C.gchar)(cid)) return gobool(c) } // GetModel is a wrapper around gtk_combo_box_get_model(). func (v *ComboBox) GetModel() (ITreeModel, error) { c := C.gtk_combo_box_get_model(v.native()) if c == nil { return nil, nilPtrErr } return castTreeModel(c) } // SetModel is a wrapper around gtk_combo_box_set_model(). func (v *ComboBox) SetModel(model ITreeModel) { var mptr *C.GtkTreeModel if model != nil { mptr = model.toTreeModel() } C.gtk_combo_box_set_model(v.native(), mptr) } // PopupForDevice is a wrapper around gtk_combo_box_popup_for_device() func (v *ComboBox) PopupForDevice(device *gdk.Device) { var devicePtr *C.GdkDevice if device != nil { devicePtr = (*C.GdkDevice)(unsafe.Pointer(device.Native())) } C.gtk_combo_box_popup_for_device(v.native(), devicePtr) } // Popup is a wrapper around gtk_combo_box_popup(). func (v *ComboBox) Popup() { C.gtk_combo_box_popup(v.native()) } // Popdown is a wrapper around gtk_combo_box_popdown(). func (v *ComboBox) Popdown() { C.gtk_combo_box_popdown(v.native()) } // GetHasEntry is a wrapper around gtk_combo_box_get_has_entry(). func (v *ComboBox) GetHasEntry() bool { c := C.gtk_combo_box_get_has_entry(v.native()) return gobool(c) } // SetEntryTextColumn is a wrapper around gtk_combo_box_set_entry_text_column(). func (v *ComboBox) SetEntryTextColumn(textColumn int) { C.gtk_combo_box_set_entry_text_column(v.native(), C.gint(textColumn)) } // GetEntryTextColumn is a wrapper around gtk_combo_box_get_entry_text_column(). func (v *ComboBox) GetEntryTextColumn() int { c := C.gtk_combo_box_get_entry_text_column(v.native()) return int(c) } // SetPopupFixedWidth is a wrapper around gtk_combo_box_set_popup_fixed_width func (v *ComboBox) SetPopupFixedWidth(fixedWidth bool) { C.gtk_combo_box_set_popup_fixed_width(v.native(), gbool(fixedWidth)) } // GetPopupFixedWidth is a wrapper around gtk_combo_box_get_popup_fixed_width func (v *ComboBox) GetPopupFixedWidth() bool { c := C.gtk_combo_box_get_popup_fixed_width(v.native()) return gobool(c) } // GetEntry is a convenience func to get the Entry within the ComboBox. // If the Combobox does not contain an Entry, an error is returned. func (v *ComboBox) GetEntry() (*Entry, error) { hasEntry := C.gtk_combo_box_get_has_entry(v.native()) if hasEntry == C.FALSE { return nil, errors.New("combobox has no entry") } bin := &v.Bin widget, err := bin.GetChild() if err != nil { return nil, err } entry, ok := widget.(*Entry) if !ok { return nil, fmt.Errorf("expected child to be of type *gtk.Entry, got %T", widget) } return entry, nil } /* * GtkComboBoxText */ // ComboBoxText is a representation of GTK's GtkComboBoxText. type ComboBoxText struct { ComboBox } // native returns a pointer to the underlying GtkComboBoxText. func (v *ComboBoxText) native() *C.GtkComboBoxText { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkComboBoxText(p) } func marshalComboBoxText(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapComboBoxText(obj), nil } func wrapComboBoxText(obj *glib.Object) *ComboBoxText { if obj == nil { return nil } return &ComboBoxText{*wrapComboBox(obj)} } // ComboBoxTextNew is a wrapper around gtk_combo_box_text_new(). func ComboBoxTextNew() (*ComboBoxText, error) { c := C.gtk_combo_box_text_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapComboBoxText(obj), nil } // ComboBoxTextNewWithEntry is a wrapper around gtk_combo_box_text_new_with_entry(). func ComboBoxTextNewWithEntry() (*ComboBoxText, error) { c := C.gtk_combo_box_text_new_with_entry() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapComboBoxText(obj), nil } // Append is a wrapper around gtk_combo_box_text_append(). func (v *ComboBoxText) Append(id, text string) { cid := C.CString(id) ctext := C.CString(text) defer C.free(unsafe.Pointer(cid)) defer C.free(unsafe.Pointer(ctext)) C.gtk_combo_box_text_append(v.native(), (*C.gchar)(cid), (*C.gchar)(ctext)) } // Prepend is a wrapper around gtk_combo_box_text_prepend(). func (v *ComboBoxText) Prepend(id, text string) { cid := C.CString(id) ctext := C.CString(text) defer C.free(unsafe.Pointer(cid)) defer C.free(unsafe.Pointer(ctext)) C.gtk_combo_box_text_prepend(v.native(), (*C.gchar)(cid), (*C.gchar)(ctext)) } // Insert is a wrapper around gtk_combo_box_text_insert(). func (v *ComboBoxText) Insert(position int, id, text string) { cid := C.CString(id) ctext := C.CString(text) defer C.free(unsafe.Pointer(cid)) defer C.free(unsafe.Pointer(ctext)) C.gtk_combo_box_text_insert(v.native(), C.gint(position), (*C.gchar)(cid), (*C.gchar)(ctext)) } // AppendText is a wrapper around gtk_combo_box_text_append_text(). func (v *ComboBoxText) AppendText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_combo_box_text_append_text(v.native(), (*C.gchar)(cstr)) } // PrependText is a wrapper around gtk_combo_box_text_prepend_text(). func (v *ComboBoxText) PrependText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_combo_box_text_prepend_text(v.native(), (*C.gchar)(cstr)) } // InsertText is a wrapper around gtk_combo_box_text_insert_text(). func (v *ComboBoxText) InsertText(position int, text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_combo_box_text_insert_text(v.native(), C.gint(position), (*C.gchar)(cstr)) } // Remove is a wrapper around gtk_combo_box_text_remove(). func (v *ComboBoxText) Remove(position int) { C.gtk_combo_box_text_remove(v.native(), C.gint(position)) } // RemoveAll is a wrapper around gtk_combo_box_text_remove_all(). func (v *ComboBoxText) RemoveAll() { C.gtk_combo_box_text_remove_all(v.native()) } // GetActiveText is a wrapper around gtk_combo_box_text_get_active_text(). func (v *ComboBoxText) GetActiveText() string { c := (*C.char)(C.gtk_combo_box_text_get_active_text(v.native())) defer C.free(unsafe.Pointer(c)) return C.GoString(c) } // gtk_combo_box_new_with_area, requires GtkCellArea // gtk_combo_box_new_with_area_and_entry, requires GtkCellArea // gtk_combo_box_get_row_separator_func, requires GtkTreeViewRowSeparatorFunc // gtk_combo_box_set_row_separator_func, requires GtkTreeViewRowSeparatorFunc // gtk_combo_box_get_popup_accessible, requires AtkObject // gtk_combo_box_set_add_tearoffs, deprecated since 3.10 // gtk_combo_box_get_add_tearoffs, deprecated since 3.10 // gtk_combo_box_set_title, deprecated since 3.10 // gtk_combo_box_get_title, deprecated since 3.10 // gtk_combo_box_set_focus_on_click, deprecated since 3.20 // gtk_combo_box_get_focus_on_click, deprecated since 3.20 // gtk_combo_box_set_button_sensitivity, requires GtkSensitivityType // gtk_combo_box_get_button_sensitivity, requires GtkSensitivityType gotk3-0.6.2/gtk/fixed.go000066400000000000000000000026171431157473000147740ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" // #include "fixed.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_fixed_get_type()), marshalFixed}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkFixed"] = wrapFixed } /* * GtkFixed */ // Fixed is a representation of GTK's GtkFixed. type Fixed struct { Container } func (v *Fixed) native() *C.GtkFixed { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFixed(p) } func marshalFixed(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFixed(obj), nil } func wrapFixed(obj *glib.Object) *Fixed { if obj == nil { return nil } return &Fixed{Container{Widget{glib.InitiallyUnowned{obj}}}} } // FixedNew is a wrapper around gtk_fixed_new(). func FixedNew() (*Fixed, error) { c := C.gtk_fixed_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapFixed(obj), nil } // Put is a wrapper around gtk_fixed_put(). func (v *Fixed) Put(w IWidget, x, y int) { C.gtk_fixed_put(v.native(), w.toWidget(), C.gint(x), C.gint(y)) } // Move is a wrapper around gtk_fixed_move(). func (v *Fixed) Move(w IWidget, x, y int) { C.gtk_fixed_move(v.native(), w.toWidget(), C.gint(x), C.gint(y)) } gotk3-0.6.2/gtk/fixed.go.h000066400000000000000000000000771431157473000152200ustar00rootroot00000000000000static GtkFixed *toGtkFixed(void *p) { return (GTK_FIXED(p)); }gotk3-0.6.2/gtk/font_chooser.go000066400000000000000000000157361431157473000163730ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_font_chooser_get_type()), marshalFontChooser}, {glib.Type(C.gtk_font_button_get_type()), marshalFontButton}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkFontChooser"] = wrapFontChooser WrapMap["GtkFontButton"] = wrapFontButton } /* * GtkFontChooser */ // FontChooser is a representation of GTK's GtkFontChooser GInterface. type FontChooser struct { *glib.Object } // IFontChooser is an interface type implemented by all structs // embedding an FontChooser. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkFontChooser. type IFontChooser interface { toFontChooser() *C.GtkFontChooser } // native returns a pointer to the underlying GtkFontChooser. func (v *FontChooser) native() *C.GtkFontChooser { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFontChooser(p) } func marshalFontChooser(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFontChooser(obj), nil } func wrapFontChooser(obj *glib.Object) *FontChooser { if obj == nil { return nil } return &FontChooser{obj} } func (v *FontChooser) toFontChooser() *C.GtkFontChooser { if v == nil { return nil } return v.native() } // GetFont is a wrapper around gtk_font_chooser_get_font(). func (v *FontChooser) GetFont() string { c := C.gtk_font_chooser_get_font(v.native()) return goString(c) } // SetFont is a wrapper around gtk_font_chooser_set_font(). func (v *FontChooser) SetFont(font string) { cstr := C.CString(font) defer C.free(unsafe.Pointer(cstr)) C.gtk_font_chooser_set_font(v.native(), (*C.gchar)(cstr)) } //PangoFontFamily * gtk_font_chooser_get_font_family () //PangoFontFace * gtk_font_chooser_get_font_face () //gint gtk_font_chooser_get_font_size () //PangoFontDescription * gtk_font_chooser_get_font_desc () //void gtk_font_chooser_set_font_desc () //gchar * gtk_font_chooser_get_preview_text () //void gtk_font_chooser_set_preview_text () //gboolean gtk_font_chooser_get_show_preview_entry () //void gtk_font_chooser_set_show_preview_entry () //gboolean (*GtkFontFilterFunc) () //void gtk_font_chooser_set_filter_func () //void gtk_font_chooser_set_font_map () //PangoFontMap * gtk_font_chooser_get_font_map () /* * GtkFontButton */ // FontButton is a representation of GTK's GtkFontButton. type FontButton struct { Button // Interfaces FontChooser } // native returns a pointer to the underlying GtkFontButton. func (v *FontButton) native() *C.GtkFontButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFontButton(p) } func marshalFontButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFontButton(obj), nil } func wrapFontButton(obj *glib.Object) *FontButton { if obj == nil { return nil } button := wrapButton(obj) fc := wrapFontChooser(obj) return &FontButton{*button, *fc} } // FontButtonNew is a wrapper around gtk_font_button_new(). func FontButtonNew() (*FontButton, error) { c := C.gtk_font_button_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapFontButton(obj), nil } // FontButtonNewWithFont is a wrapper around gtk_font_button_new_with_font(). func FontButtonNewWithFont(fontname string) (*FontButton, error) { cstr := C.CString(fontname) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_font_button_new_with_font((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapFontButton(obj), nil } // SetShowStyle is a wrapper around gtk_font_button_set_show_style(). func (v *FontButton) SetShowStyle(showStyle bool) { C.gtk_font_button_set_show_style(v.native(), gbool(showStyle)) } // GetShowStyle is a wrapper around gtk_font_button_get_show_style(). func (v *FontButton) GetShowStyle() bool { c := C.gtk_font_button_get_show_style(v.native()) return gobool(c) } // SetShowSize is a wrapper around gtk_font_button_set_show_size(). func (v *FontButton) SetShowSize(showSize bool) { C.gtk_font_button_set_show_size(v.native(), gbool(showSize)) } // GetShowSize is a wrapper around gtk_font_button_get_show_size(). func (v *FontButton) GetShowSize() bool { c := C.gtk_font_button_get_show_size(v.native()) return gobool(c) } // SetUseFont is a wrapper around gtk_font_button_set_use_font(). func (v *FontButton) SetUseFont(useFont bool) { C.gtk_font_button_set_use_font(v.native(), gbool(useFont)) } // GetUseFont is a wrapper around gtk_font_button_get_use_font(). func (v *FontButton) GetUseFont() bool { c := C.gtk_font_button_get_use_font(v.native()) return gobool(c) } // SetUseSize is a wrapper around gtk_font_button_set_use_size(). func (v *FontButton) SetUseSize(useSize bool) { C.gtk_font_button_set_use_size(v.native(), gbool(useSize)) } // GetUseSize is a wrapper around gtk_font_button_get_use_size(). func (v *FontButton) GetUseSize() bool { c := C.gtk_font_button_get_use_size(v.native()) return gobool(c) } // SetTitle is a wrapper around gtk_font_button_set_title(). func (v *FontButton) SetTitle(title string) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) C.gtk_font_button_set_title(v.native(), (*C.gchar)(cstr)) } // GetTitle is a wrapper around gtk_font_button_get_title(). func (v *FontButton) GetTitle() string { c := C.gtk_font_button_get_title(v.native()) defer C.free(unsafe.Pointer(c)) return goString(c) } /* * GtkFontChooserDialog */ // FontChooserDialog is a representation of GTK's GtkFontChooserDialog. type FontChooserDialog struct { Dialog // Interfaces FontChooser } // native returns a pointer to the underlying GtkFontChooserDialog. func (v *FontChooserDialog) native() *C.GtkFontChooserDialog { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFontChooserDialog(p) } func marshalFontChooserDialog(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapFontChooserDialog(glib.Take(unsafe.Pointer(c))), nil } func wrapFontChooserDialog(obj *glib.Object) *FontChooserDialog { if obj == nil { return nil } dialog := wrapDialog(obj) cc := wrapFontChooser(obj) return &FontChooserDialog{*dialog, *cc} } // FontChooserDialogNew() is a wrapper around gtk_font_chooser_dialog_new(). func FontChooserDialogNew(title string, parent IWindow) (*FontChooserDialog, error) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } c := C.gtk_font_chooser_dialog_new((*C.gchar)(cstr), w) if c == nil { return nil, nilPtrErr } return wrapFontChooserDialog(glib.Take(unsafe.Pointer(c))), nil } /* * GtkFontChooserWidget */ // TODO: // gtk_font_chooser_widget_new(). gotk3-0.6.2/gtk/gdk.go000066400000000000000000000030101431157473000144260ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import "github.com/gotk3/gotk3/gdk" func nativeGdkRectangle(rect gdk.Rectangle) *C.GdkRectangle { // Note: Here we can't use rect.GdkRectangle because it would return // C type prefixed with gdk package. A ways how to resolve this Go // issue with same C structs in different Go packages is documented // here https://github.com/golang/go/issues/13467 . // This is the easiest way how to resolve the problem. return &C.GdkRectangle{ x: C.int(rect.GetX()), y: C.int(rect.GetY()), width: C.int(rect.GetWidth()), height: C.int(rect.GetHeight()), } } func nativeGdkGeometry(geom gdk.Geometry) *C.GdkGeometry { // Note: Here we can't use geom.GdkGeometry because it would return // C type prefixed with gdk package. A ways how to resolve this Go // issue with same C structs in different Go packages is documented // here https://github.com/golang/go/issues/13467 . // This is the easiest way how to resolve the problem. return &C.GdkGeometry{ min_width: C.gint(geom.GetMinWidth()), min_height: C.gint(geom.GetMinHeight()), max_width: C.gint(geom.GetMaxWidth()), max_height: C.gint(geom.GetMaxHeight()), base_width: C.gint(geom.GetBaseWidth()), base_height: C.gint(geom.GetBaseHeight()), width_inc: C.gint(geom.GetWidthInc()), height_inc: C.gint(geom.GetHeightInc()), min_aspect: C.gdouble(geom.GetMinAspect()), max_aspect: C.gdouble(geom.GetMaxAspect()), win_gravity: C.GdkGravity(geom.GetWinGravity()), } } gotk3-0.6.2/gtk/glarea.go000066400000000000000000000127371431157473000151340ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14 // Supports building with gtk 3.16+ /* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package gtk // #include // #include "gtk_since_3_16.go.h" import "C" import ( "errors" "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_gl_area_get_type()), marshalGLArea}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkGLArea"] = wrapGLArea } /* * GtkGLArea */ // GLArea is a representation of GTK's GtkGLArea. type GLArea struct { Widget } // native returns a pointer to the underlying GtkGLArea. func (v *GLArea) native() *C.GtkGLArea { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkGLArea(p) } func marshalGLArea(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapGLArea(obj), nil } func wrapGLArea(obj *glib.Object) *GLArea { if obj == nil { return nil } return &GLArea{Widget{glib.InitiallyUnowned{obj}}} } func WidgetToGLArea(widget *Widget) (*GLArea, error) { obj := glib.Take(unsafe.Pointer(widget.GObject)) return wrapGLArea(obj), nil } // GLAreaNew is a wrapper around gtk_gl_area_new(). func GLAreaNew() (*GLArea, error) { c := C.gtk_gl_area_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapGLArea(obj), nil } // MajorVersion is a representation of OpenGL major version. type MajorVersion int // MinorVersion is a representation of OpenGL minor version. type MinorVersion int // GetRequiredVersion is a wrapper around gtk_gl_area_get_required_version(). func (v *GLArea) GetRequiredVersion() (MajorVersion, MinorVersion) { var major, minor int C.gtk_gl_area_get_required_version(v.native(), (*C.gint)(unsafe.Pointer(&major)), (*C.gint)(unsafe.Pointer(&minor))) return MajorVersion(major), MinorVersion(minor) } // SetRequiredVersion is a wrapper around gtk_gl_area_set_required_version(). func (v *GLArea) SetRequiredVersion(major, minor int) { C.gtk_gl_area_set_required_version(v.native(), (C.gint)(major), (C.gint)(minor)) } // TODO: // gtk_gl_area_set_has_alpha(). // gtk_gl_area_get_has_alpha(). // HasDepthBuffer is a wrapper around gtk_gl_area_get_has_depth_buffer(). func (v *GLArea) HasDepthBuffer() bool { return gobool(C.gtk_gl_area_get_has_depth_buffer(v.native())) } // SetHasDepthBuffer is a wrapper around gtk_gl_area_set_has_depth_buffer(). func (v *GLArea) SetHasDepthBuffer(hasDepthBuffer bool) { C.gtk_gl_area_set_has_depth_buffer(v.native(), gbool(hasDepthBuffer)) } // HasStencilBuffer is a wrapper around gtk_gl_area_get_has_stencil_buffer(). func (v *GLArea) HasStencilBuffer() bool { return gobool(C.gtk_gl_area_get_has_stencil_buffer(v.native())) } // SetHasStencilBuffer is a wrapper around gtk_gl_area_set_has_stencil_buffer(). func (v *GLArea) SetHasStencilBuffer(hasStencilBuffer bool) { C.gtk_gl_area_set_has_stencil_buffer(v.native(), gbool(hasStencilBuffer)) } // GetAutoRender is a wrapper around gtk_gl_area_get_auto_render(). func (v *GLArea) GetAutoRender() bool { return gobool(C.gtk_gl_area_get_auto_render(v.native())) } // SetAutoRender is a wrapper around gtk_gl_area_set_auto_render(). func (v *GLArea) SetAutoRender(autoRender bool) { C.gtk_gl_area_set_auto_render(v.native(), gbool(autoRender)) } // QueueRender is a wrapper around gtk_gl_area_queue_render(). func (v *GLArea) QueueRender() { C.gtk_gl_area_queue_render(v.native()) } // GetContext is a wrapper around gtk_gl_area_get_context(). func (v *GLArea) GetContext() (*gdk.GLContext, error) { c := C.gtk_gl_area_get_context(v.native()) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} return &(gdk.GLContext{obj}), nil } // MakeCurrent is a wrapper around gtk_gl_area_make_current(). func (v *GLArea) MakeCurrent() { C.gtk_gl_area_make_current(v.native()) } // AttachBuffers is a wrapper around gtk_gl_area_attach_buffers(). func (v *GLArea) AttachBuffers() { C.gtk_gl_area_attach_buffers(v.native()) } // GetError is a wrapper around gtk_gl_area_get_error(). func (v *GLArea) GetError() error { var err *C.GError = nil err = C.gtk_gl_area_get_error(v.native()) if err != nil { defer C.g_error_free(err) return errors.New(goString(err.message)) } return nil } // SetError is a wrapper around gtk_gl_area_set_error(). func (v *GLArea) SetError(domain glib.Quark, code int, err error) { cstr := (*C.gchar)(C.CString(err.Error())) defer C.free(unsafe.Pointer(cstr)) gerr := C.g_error_new_literal(C.GQuark(domain), C.gint(code), cstr) defer C.g_error_free(gerr) C.gtk_gl_area_set_error(v.native(), gerr) }gotk3-0.6.2/gtk/glarea_since_3_22.go000066400000000000000000000007251431157473000170340ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18,!gtk_3_20 // Supports building with gtk 3.22+ package gtk // #include import "C" // GetUseES is a wrapper around gtk_gl_area_get_use_es(). func (v *GLArea) GetUseES() bool { return gobool(C.gtk_gl_area_get_use_es(v.native())) } // SetUseES is a wrapper around gtk_gl_area_set_use_es(). func (v *GLArea) SetUseES(es bool) { C.gtk_gl_area_set_use_es(v.native(), gbool(es)) } gotk3-0.6.2/gtk/glib.go000066400000000000000000000006741431157473000146130ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func nativeGPermission(permission *glib.Permission) *C.GPermission { // Note: would return C type prefixed with glib package. // Go issue: here https://github.com/golang/go/issues/13467. var perm *C.GPermission if permission != nil { perm = (*C.GPermission)(unsafe.Pointer(permission.Native())) } return perm } gotk3-0.6.2/gtk/gtk.go000066400000000000000000013040121431157473000144550ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // Go bindings for GTK+ 3. Supports version 3.6 and later. // // Functions use the same names as the native C function calls, but use // CamelCase. In cases where native GTK uses pointers to values to // simulate multiple return values, Go's native multiple return values // are used instead. Whenever a native GTK call could return an // unexpected NULL pointer, an additional error is returned in the Go // binding. // // GTK's C API documentation can be very useful for understanding how the // functions in this package work and what each type is for. This // documentation can be found at https://developer.gnome.org/gtk3/. // // In addition to Go versions of the C GTK functions, every struct type // includes a method named Native (either by direct implementation, or // by means of struct embedding). These methods return a uintptr of the // native C object the binding type represents. These pointers may be // type switched to a native C pointer using unsafe and used with cgo // function calls outside this package. // // Memory management is handled in proper Go fashion, using runtime // finalizers to properly free memory when it is no longer needed. Each // time a Go type is created with a pointer to a GObject, a reference is // added for Go, sinking the floating reference when necessary. After // going out of scope and the next time Go's garbage collector is run, a // finalizer is run to remove Go's reference to the GObject. When this // reference count hits zero (when neither Go nor GTK holds ownership) // the object will be freed internally by GTK. package gtk // #cgo pkg-config: gdk-3.0 gio-2.0 glib-2.0 gobject-2.0 gtk+-3.0 // #include // #include // #include "gtk.go.h" import "C" import ( "errors" "fmt" "reflect" "runtime" "sync" "unsafe" "github.com/gotk3/gotk3/cairo" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/internal/callback" "github.com/gotk3/gotk3/pango" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.gtk_align_get_type()), marshalAlign}, {glib.Type(C.gtk_accel_flags_get_type()), marshalAccelFlags}, {glib.Type(C.gtk_accel_group_get_type()), marshalAccelGroup}, {glib.Type(C.gtk_accel_map_get_type()), marshalAccelMap}, {glib.Type(C.gtk_arrow_placement_get_type()), marshalArrowPlacement}, {glib.Type(C.gtk_arrow_type_get_type()), marshalArrowType}, {glib.Type(C.gtk_assistant_page_type_get_type()), marshalAssistantPageType}, {glib.Type(C.gtk_buttons_type_get_type()), marshalButtonsType}, {glib.Type(C.gtk_calendar_display_options_get_type()), marshalCalendarDisplayOptions}, {glib.Type(C.gtk_cell_renderer_accel_mode_get_type()), marshalCellRendererAccelMode}, {glib.Type(C.gtk_cell_renderer_mode_get_type()), marshalCellRendererMode}, {glib.Type(C.gtk_cell_renderer_state_get_type()), marshalCellRendererState}, {glib.Type(C.gtk_corner_type_get_type()), marshalCornerType}, {glib.Type(C.gtk_dest_defaults_get_type()), marshalDestDefaults}, {glib.Type(C.gtk_dialog_flags_get_type()), marshalDialogFlags}, {glib.Type(C.gtk_entry_icon_position_get_type()), marshalEntryIconPosition}, {glib.Type(C.gtk_file_chooser_action_get_type()), marshalFileChooserAction}, {glib.Type(C.gtk_icon_lookup_flags_get_type()), marshalSortType}, {glib.Type(C.gtk_icon_size_get_type()), marshalIconSize}, {glib.Type(C.gtk_image_type_get_type()), marshalImageType}, {glib.Type(C.gtk_input_hints_get_type()), marshalInputHints}, {glib.Type(C.gtk_input_purpose_get_type()), marshalInputPurpose}, {glib.Type(C.gtk_direction_type_get_type()), marshalDirectionType}, {glib.Type(C.gtk_justification_get_type()), marshalJustification}, {glib.Type(C.gtk_license_get_type()), marshalLicense}, {glib.Type(C.gtk_message_type_get_type()), marshalMessageType}, {glib.Type(C.gtk_orientation_get_type()), marshalOrientation}, {glib.Type(C.gtk_pack_type_get_type()), marshalPackType}, {glib.Type(C.gtk_path_type_get_type()), marshalPathType}, {glib.Type(C.gtk_policy_type_get_type()), marshalPolicyType}, {glib.Type(C.gtk_position_type_get_type()), marshalPositionType}, {glib.Type(C.gtk_relief_style_get_type()), marshalReliefStyle}, {glib.Type(C.gtk_response_type_get_type()), marshalResponseType}, {glib.Type(C.gtk_selection_mode_get_type()), marshalSelectionMode}, {glib.Type(C.gtk_scroll_type_get_type()), marshalScrollType}, {glib.Type(C.gtk_scroll_step_get_type()), marshalScrollStep}, {glib.Type(C.gtk_sensitivity_type_get_type()), marshalSensitivityType}, {glib.Type(C.gtk_shadow_type_get_type()), marshalShadowType}, {glib.Type(C.gtk_sort_type_get_type()), marshalSortType}, {glib.Type(C.gtk_spin_button_update_policy_get_type()), marshalSpinButtonUpdatePolicy}, {glib.Type(C.gtk_spin_type_get_type()), marshalSpinType}, {glib.Type(C.gtk_state_flags_get_type()), marshalStateFlags}, {glib.Type(C.gtk_target_flags_get_type()), marshalTargetFlags}, {glib.Type(C.gtk_text_direction_get_type()), marshalTextDirection}, {glib.Type(C.gtk_text_search_flags_get_type()), marshalTextSearchFlags}, {glib.Type(C.gtk_toolbar_style_get_type()), marshalToolbarStyle}, {glib.Type(C.gtk_tree_model_flags_get_type()), marshalTreeModelFlags}, {glib.Type(C.gtk_window_position_get_type()), marshalWindowPosition}, {glib.Type(C.gtk_window_type_get_type()), marshalWindowType}, {glib.Type(C.gtk_wrap_mode_get_type()), marshalWrapMode}, // Objects/Interfaces {glib.Type(C.gtk_accel_group_get_type()), marshalAccelGroup}, {glib.Type(C.gtk_accel_map_get_type()), marshalAccelMap}, {glib.Type(C.gtk_adjustment_get_type()), marshalAdjustment}, {glib.Type(C.gtk_application_get_type()), marshalApplication}, {glib.Type(C.gtk_application_window_get_type()), marshalApplicationWindow}, {glib.Type(C.gtk_assistant_get_type()), marshalAssistant}, {glib.Type(C.gtk_bin_get_type()), marshalBin}, {glib.Type(C.gtk_builder_get_type()), marshalBuilder}, {glib.Type(C.gtk_button_get_type()), marshalButton}, {glib.Type(C.gtk_button_box_get_type()), marshalButtonBox}, {glib.Type(C.gtk_box_get_type()), marshalBox}, {glib.Type(C.gtk_calendar_get_type()), marshalCalendar}, {glib.Type(C.gtk_cell_layout_get_type()), marshalCellLayout}, {glib.Type(C.gtk_cell_editable_get_type()), marshalCellEditable}, {glib.Type(C.gtk_cell_renderer_get_type()), marshalCellRenderer}, {glib.Type(C.gtk_cell_renderer_spinner_get_type()), marshalCellRendererSpinner}, {glib.Type(C.gtk_cell_renderer_pixbuf_get_type()), marshalCellRendererPixbuf}, {glib.Type(C.gtk_cell_renderer_text_get_type()), marshalCellRendererText}, {glib.Type(C.gtk_cell_renderer_progress_get_type()), marshalCellRendererProgress}, {glib.Type(C.gtk_cell_renderer_toggle_get_type()), marshalCellRendererToggle}, {glib.Type(C.gtk_cell_renderer_combo_get_type()), marshalCellRendererCombo}, {glib.Type(C.gtk_cell_renderer_accel_get_type()), marshalCellRendererAccel}, {glib.Type(C.gtk_cell_renderer_spin_get_type()), marshalCellRendererSpin}, {glib.Type(C.gtk_check_button_get_type()), marshalCheckButton}, {glib.Type(C.gtk_check_menu_item_get_type()), marshalCheckMenuItem}, {glib.Type(C.gtk_clipboard_get_type()), marshalClipboard}, {glib.Type(C.gtk_container_get_type()), marshalContainer}, {glib.Type(C.gtk_dialog_get_type()), marshalDialog}, {glib.Type(C.gtk_drawing_area_get_type()), marshalDrawingArea}, {glib.Type(C.gtk_editable_get_type()), marshalEditable}, {glib.Type(C.gtk_entry_get_type()), marshalEntry}, {glib.Type(C.gtk_entry_buffer_get_type()), marshalEntryBuffer}, {glib.Type(C.gtk_entry_completion_get_type()), marshalEntryCompletion}, {glib.Type(C.gtk_event_box_get_type()), marshalEventBox}, {glib.Type(C.gtk_expander_get_type()), marshalExpander}, {glib.Type(C.gtk_file_chooser_get_type()), marshalFileChooser}, {glib.Type(C.gtk_file_chooser_button_get_type()), marshalFileChooserButton}, {glib.Type(C.gtk_file_chooser_dialog_get_type()), marshalFileChooserDialog}, {glib.Type(C.gtk_file_chooser_widget_get_type()), marshalFileChooserWidget}, {glib.Type(C.gtk_frame_get_type()), marshalFrame}, {glib.Type(C.gtk_aspect_frame_get_type()), marshalAspectFrame}, {glib.Type(C.gtk_grid_get_type()), marshalGrid}, {glib.Type(C.gtk_icon_view_get_type()), marshalIconView}, {glib.Type(C.gtk_image_get_type()), marshalImage}, {glib.Type(C.gtk_label_get_type()), marshalLabel}, {glib.Type(C.gtk_link_button_get_type()), marshalLinkButton}, {glib.Type(C.gtk_lock_button_get_type()), marshalLockButton}, {glib.Type(C.gtk_layout_get_type()), marshalLayout}, {glib.Type(C.gtk_tree_model_sort_get_type()), marshalTreeModelSort}, {glib.Type(C.gtk_list_store_get_type()), marshalListStore}, {glib.Type(C.gtk_menu_get_type()), marshalMenu}, {glib.Type(C.gtk_menu_bar_get_type()), marshalMenuBar}, {glib.Type(C.gtk_menu_button_get_type()), marshalMenuButton}, {glib.Type(C.gtk_menu_item_get_type()), marshalMenuItem}, {glib.Type(C.gtk_menu_shell_get_type()), marshalMenuShell}, {glib.Type(C.gtk_message_dialog_get_type()), marshalMessageDialog}, {glib.Type(C.gtk_notebook_get_type()), marshalNotebook}, {glib.Type(C.gtk_offscreen_window_get_type()), marshalOffscreenWindow}, {glib.Type(C.gtk_orientable_get_type()), marshalOrientable}, {glib.Type(C.gtk_overlay_get_type()), marshalOverlay}, {glib.Type(C.gtk_paned_get_type()), marshalPaned}, {glib.Type(C.gtk_progress_bar_get_type()), marshalProgressBar}, {glib.Type(C.gtk_radio_button_get_type()), marshalRadioButton}, {glib.Type(C.gtk_radio_menu_item_get_type()), marshalRadioMenuItem}, {glib.Type(C.gtk_range_get_type()), marshalRange}, {glib.Type(C.gtk_scale_button_get_type()), marshalScaleButton}, {glib.Type(C.gtk_scale_get_type()), marshalScale}, {glib.Type(C.gtk_scrollbar_get_type()), marshalScrollbar}, {glib.Type(C.gtk_scrolled_window_get_type()), marshalScrolledWindow}, {glib.Type(C.gtk_search_entry_get_type()), marshalSearchEntry}, {glib.Type(C.gtk_selection_data_get_type()), marshalSelectionData}, {glib.Type(C.gtk_separator_get_type()), marshalSeparator}, {glib.Type(C.gtk_separator_menu_item_get_type()), marshalSeparatorMenuItem}, {glib.Type(C.gtk_separator_tool_item_get_type()), marshalSeparatorToolItem}, {glib.Type(C.gtk_spin_button_get_type()), marshalSpinButton}, {glib.Type(C.gtk_spinner_get_type()), marshalSpinner}, {glib.Type(C.gtk_statusbar_get_type()), marshalStatusbar}, {glib.Type(C.gtk_switch_get_type()), marshalSwitch}, {glib.Type(C.gtk_text_view_get_type()), marshalTextView}, {glib.Type(C.gtk_text_tag_get_type()), marshalTextTag}, {glib.Type(C.gtk_text_tag_table_get_type()), marshalTextTagTable}, {glib.Type(C.gtk_text_buffer_get_type()), marshalTextBuffer}, {glib.Type(C.gtk_toggle_button_get_type()), marshalToggleButton}, {glib.Type(C.gtk_toolbar_get_type()), marshalToolbar}, {glib.Type(C.gtk_tool_button_get_type()), marshalToolButton}, {glib.Type(C.gtk_toggle_tool_button_get_type()), marshalToggleToolButton}, {glib.Type(C.gtk_tool_item_get_type()), marshalToolItem}, {glib.Type(C.gtk_tooltip_get_type()), marshalTooltip}, {glib.Type(C.gtk_tree_model_get_type()), marshalTreeModel}, {glib.Type(C.gtk_tree_sortable_get_type()), marshalTreeSortable}, {glib.Type(C.gtk_tree_selection_get_type()), marshalTreeSelection}, {glib.Type(C.gtk_tree_store_get_type()), marshalTreeStore}, {glib.Type(C.gtk_tree_view_get_type()), marshalTreeView}, {glib.Type(C.gtk_tree_view_column_get_type()), marshalTreeViewColumn}, {glib.Type(C.gtk_cell_area_get_type()), marshalCellArea}, {glib.Type(C.gtk_cell_area_context_get_type()), marshalCellAreaContext}, {glib.Type(C.gtk_cell_area_box_get_type()), marshalCellAreaBox}, {glib.Type(C.gtk_viewport_get_type()), marshalViewport}, {glib.Type(C.gtk_volume_button_get_type()), marshalVolumeButton}, {glib.Type(C.gtk_widget_get_type()), marshalWidget}, {glib.Type(C.gtk_window_get_type()), marshalWindow}, {glib.Type(C.gtk_window_group_get_type()), marshalWindowGroup}, // Boxed {glib.Type(C.gtk_target_entry_get_type()), marshalTargetEntry}, {glib.Type(C.gtk_text_iter_get_type()), marshalTextIter}, {glib.Type(C.gtk_text_mark_get_type()), marshalTextMark}, {glib.Type(C.gtk_tree_iter_get_type()), marshalTreeIter}, {glib.Type(C.gtk_tree_path_get_type()), marshalTreePath}, } glib.RegisterGValueMarshalers(tm) } /* * Callback helpers */ //export gotk3_callbackDelete func gotk3_callbackDelete(callbackID C.gpointer) { callback.Delete(uintptr(callbackID)) } /* * Type conversions */ func gbool(b bool) C.gboolean { if b { return C.gboolean(1) } return C.gboolean(0) } func gobool(b C.gboolean) bool { return b != C.FALSE } func cGSList(clist *glib.SList) *C.GSList { if clist == nil { return nil } return (*C.GSList)(unsafe.Pointer(clist.Native())) } func free(str ...interface{}) { for _, s := range str { switch x := s.(type) { case *C.char: C.free(unsafe.Pointer(x)) case []*C.char: for _, cp := range x { C.free(unsafe.Pointer(cp)) } /* case C.gpointer: C.g_free(C.gpointer(c)) */ default: fmt.Printf("utils.go free(): Unknown type: %T\n", x) } } } // nextguchar increments guchar by 1. Hopefully, this could be inlined by the Go // compiler. func nextguchar(guchar *C.guchar) *C.guchar { return (*C.guchar)(unsafe.Pointer(uintptr(unsafe.Pointer(guchar)) + 1)) } // ucharString returns a copy of the given guchar pointer. The pointer guchar // array is assumed to have valid UTF-8. func ucharString(guchar *C.guchar) string { // Seek and find the string length. var strlen int for ptr := guchar; *ptr != 0; ptr = nextguchar(ptr) { strlen++ } // Array of unsigned char means GoString is unavailable, so maybe this is // fine. var data []byte sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data)) sliceHeader.Len = strlen sliceHeader.Cap = strlen sliceHeader.Data = uintptr(unsafe.Pointer(guchar)) // Return a copy of the string. return string(data) } // nextgcharptr increments gcharptr by 1. Hopefully, this could be inlined by // the Go compiler. func nextgcharptr(gcharptr **C.gchar) **C.gchar { return (**C.gchar)(unsafe.Pointer(uintptr(unsafe.Pointer(gcharptr)) + 1)) } func goString(cstr *C.gchar) string { return C.GoString((*C.char)(cstr)) } // same implementation as package glib func toGoStringArray(c **C.gchar) []string { if c == nil { return nil } // free when done defer C.g_strfreev(c) strsLen := 0 for scan := c; *scan != nil; scan = nextgcharptr(scan) { strsLen++ } strs := make([]string, strsLen) for i := range strs { strs[i] = C.GoString((*C.char)(*c)) c = nextgcharptr(c) } return strs } // Wrapper function for TestBoolConvs since cgo can't be used with // testing package func testBoolConvs() error { b := gobool(gbool(true)) if b != true { return errors.New("Unexpected bool conversion result") } cb := gbool(gobool(C.gboolean(0))) if cb != C.gboolean(0) { return errors.New("Unexpected bool conversion result") } return nil } /* * Unexported vars */ var nilPtrErr = errors.New("cgo returned unexpected nil pointer") /* * Constants */ // Align is a representation of GTK's GtkAlign. type Align int const ( ALIGN_FILL Align = C.GTK_ALIGN_FILL ALIGN_START Align = C.GTK_ALIGN_START ALIGN_END Align = C.GTK_ALIGN_END ALIGN_CENTER Align = C.GTK_ALIGN_CENTER ) func marshalAlign(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Align(c), nil } // ArrowPlacement is a representation of GTK's GtkArrowPlacement. type ArrowPlacement int const ( ARROWS_BOTH ArrowPlacement = C.GTK_ARROWS_BOTH ARROWS_START ArrowPlacement = C.GTK_ARROWS_START ARROWS_END ArrowPlacement = C.GTK_ARROWS_END ) func marshalArrowPlacement(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ArrowPlacement(c), nil } // ArrowType is a representation of GTK's GtkArrowType. type ArrowType int const ( ARROW_UP ArrowType = C.GTK_ARROW_UP ARROW_DOWN ArrowType = C.GTK_ARROW_DOWN ARROW_LEFT ArrowType = C.GTK_ARROW_LEFT ARROW_RIGHT ArrowType = C.GTK_ARROW_RIGHT ARROW_NONE ArrowType = C.GTK_ARROW_NONE ) func marshalArrowType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ArrowType(c), nil } // AssistantPageType is a representation of GTK's GtkAssistantPageType. type AssistantPageType int const ( ASSISTANT_PAGE_CONTENT AssistantPageType = C.GTK_ASSISTANT_PAGE_CONTENT ASSISTANT_PAGE_INTRO AssistantPageType = C.GTK_ASSISTANT_PAGE_INTRO ASSISTANT_PAGE_CONFIRM AssistantPageType = C.GTK_ASSISTANT_PAGE_CONFIRM ASSISTANT_PAGE_SUMMARY AssistantPageType = C.GTK_ASSISTANT_PAGE_SUMMARY ASSISTANT_PAGE_PROGRESS AssistantPageType = C.GTK_ASSISTANT_PAGE_PROGRESS ASSISTANT_PAGE_CUSTOM AssistantPageType = C.GTK_ASSISTANT_PAGE_CUSTOM ) func marshalAssistantPageType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return AssistantPageType(c), nil } // ButtonsType is a representation of GTK's GtkButtonsType. type ButtonsType int const ( BUTTONS_NONE ButtonsType = C.GTK_BUTTONS_NONE BUTTONS_OK ButtonsType = C.GTK_BUTTONS_OK BUTTONS_CLOSE ButtonsType = C.GTK_BUTTONS_CLOSE BUTTONS_CANCEL ButtonsType = C.GTK_BUTTONS_CANCEL BUTTONS_YES_NO ButtonsType = C.GTK_BUTTONS_YES_NO BUTTONS_OK_CANCEL ButtonsType = C.GTK_BUTTONS_OK_CANCEL ) func marshalButtonsType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ButtonsType(c), nil } // SensitivityType is a representation of GTK's GtkSensitivityType type SensitivityType int const ( SENSITIVITY_AUTO SensitivityType = C.GTK_SENSITIVITY_AUTO SENSITIVITY_ON SensitivityType = C.GTK_SENSITIVITY_ON SENSITIVITY_OFF SensitivityType = C.GTK_SENSITIVITY_OFF ) func marshalSensitivityType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return SensitivityType(c), nil } // CalendarDisplayOptions is a representation of GTK's GtkCalendarDisplayOptions type CalendarDisplayOptions int const ( CALENDAR_SHOW_HEADING CalendarDisplayOptions = C.GTK_CALENDAR_SHOW_HEADING CALENDAR_SHOW_DAY_NAMES CalendarDisplayOptions = C.GTK_CALENDAR_SHOW_DAY_NAMES CALENDAR_NO_MONTH_CHANGE CalendarDisplayOptions = C.GTK_CALENDAR_NO_MONTH_CHANGE CALENDAR_SHOW_WEEK_NUMBERS CalendarDisplayOptions = C.GTK_CALENDAR_SHOW_WEEK_NUMBERS CALENDAR_SHOW_DETAILS CalendarDisplayOptions = C.GTK_CALENDAR_SHOW_DETAILS ) func marshalCalendarDisplayOptions(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return CalendarDisplayOptions(c), nil } // DestDefaults is a representation of GTK's GtkDestDefaults. type DestDefaults int const ( DEST_DEFAULT_MOTION DestDefaults = C.GTK_DEST_DEFAULT_MOTION DEST_DEFAULT_HIGHLIGHT DestDefaults = C.GTK_DEST_DEFAULT_HIGHLIGHT DEST_DEFAULT_DROP DestDefaults = C.GTK_DEST_DEFAULT_DROP DEST_DEFAULT_ALL DestDefaults = C.GTK_DEST_DEFAULT_ALL ) func marshalDestDefaults(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return DestDefaults(c), nil } // DialogFlags is a representation of GTK's GtkDialogFlags. type DialogFlags int const ( DIALOG_MODAL DialogFlags = C.GTK_DIALOG_MODAL DIALOG_DESTROY_WITH_PARENT DialogFlags = C.GTK_DIALOG_DESTROY_WITH_PARENT ) func marshalDialogFlags(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return DialogFlags(c), nil } // EntryIconPosition is a representation of GTK's GtkEntryIconPosition. type EntryIconPosition int const ( ENTRY_ICON_PRIMARY EntryIconPosition = C.GTK_ENTRY_ICON_PRIMARY ENTRY_ICON_SECONDARY EntryIconPosition = C.GTK_ENTRY_ICON_SECONDARY ) func marshalEntryIconPosition(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return EntryIconPosition(c), nil } // FileChooserAction is a representation of GTK's GtkFileChooserAction. type FileChooserAction int const ( FILE_CHOOSER_ACTION_OPEN FileChooserAction = C.GTK_FILE_CHOOSER_ACTION_OPEN FILE_CHOOSER_ACTION_SAVE FileChooserAction = C.GTK_FILE_CHOOSER_ACTION_SAVE FILE_CHOOSER_ACTION_SELECT_FOLDER FileChooserAction = C.GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER FILE_CHOOSER_ACTION_CREATE_FOLDER FileChooserAction = C.GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER ) func marshalFileChooserAction(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return FileChooserAction(c), nil } // IconLookupFlags is a representation of GTK's GtkIconLookupFlags. type IconLookupFlags int const ( ICON_LOOKUP_NO_SVG IconLookupFlags = C.GTK_ICON_LOOKUP_NO_SVG ICON_LOOKUP_FORCE_SVG IconLookupFlags = C.GTK_ICON_LOOKUP_FORCE_SVG ICON_LOOKUP_USE_BUILTIN IconLookupFlags = C.GTK_ICON_LOOKUP_USE_BUILTIN ICON_LOOKUP_GENERIC_FALLBACK IconLookupFlags = C.GTK_ICON_LOOKUP_GENERIC_FALLBACK ICON_LOOKUP_FORCE_SIZE IconLookupFlags = C.GTK_ICON_LOOKUP_FORCE_SIZE ) func marshalIconLookupFlags(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return IconLookupFlags(c), nil } // IconSize is a representation of GTK's GtkIconSize. type IconSize int const ( ICON_SIZE_INVALID IconSize = C.GTK_ICON_SIZE_INVALID ICON_SIZE_MENU IconSize = C.GTK_ICON_SIZE_MENU ICON_SIZE_SMALL_TOOLBAR IconSize = C.GTK_ICON_SIZE_SMALL_TOOLBAR ICON_SIZE_LARGE_TOOLBAR IconSize = C.GTK_ICON_SIZE_LARGE_TOOLBAR ICON_SIZE_BUTTON IconSize = C.GTK_ICON_SIZE_BUTTON ICON_SIZE_DND IconSize = C.GTK_ICON_SIZE_DND ICON_SIZE_DIALOG IconSize = C.GTK_ICON_SIZE_DIALOG ) func marshalIconSize(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return IconSize(c), nil } // ImageType is a representation of GTK's GtkImageType. type ImageType int const ( IMAGE_EMPTY ImageType = C.GTK_IMAGE_EMPTY IMAGE_PIXBUF ImageType = C.GTK_IMAGE_PIXBUF IMAGE_STOCK ImageType = C.GTK_IMAGE_STOCK IMAGE_ICON_SET ImageType = C.GTK_IMAGE_ICON_SET IMAGE_ANIMATION ImageType = C.GTK_IMAGE_ANIMATION IMAGE_ICON_NAME ImageType = C.GTK_IMAGE_ICON_NAME IMAGE_GICON ImageType = C.GTK_IMAGE_GICON ) // TODO: add GTK_IMAGE_SURFACE for GTK 3.10 func marshalImageType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ImageType(c), nil } // InputHints is a representation of GTK's GtkInputHints. type InputHints int const ( INPUT_HINT_NONE InputHints = C.GTK_INPUT_HINT_NONE INPUT_HINT_SPELLCHECK InputHints = C.GTK_INPUT_HINT_SPELLCHECK INPUT_HINT_NO_SPELLCHECK InputHints = C.GTK_INPUT_HINT_NO_SPELLCHECK INPUT_HINT_WORD_COMPLETION InputHints = C.GTK_INPUT_HINT_WORD_COMPLETION INPUT_HINT_LOWERCASE InputHints = C.GTK_INPUT_HINT_LOWERCASE INPUT_HINT_UPPERCASE_CHARS InputHints = C.GTK_INPUT_HINT_UPPERCASE_CHARS INPUT_HINT_UPPERCASE_WORDS InputHints = C.GTK_INPUT_HINT_UPPERCASE_WORDS INPUT_HINT_UPPERCASE_SENTENCES InputHints = C.GTK_INPUT_HINT_UPPERCASE_SENTENCES INPUT_HINT_INHIBIT_OSK InputHints = C.GTK_INPUT_HINT_INHIBIT_OSK ) // TODO: // GTK_INPUT_HINT_VERTICAL_WRITING Since 3.18 // GTK_INPUT_HINT_EMOJI Since 3.22.20 // GTK_INPUT_HINT_NO_EMOJI Since 3.22.20 func marshalInputHints(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return InputHints(c), nil } // InputPurpose is a representation of GTK's GtkInputPurpose. type InputPurpose int const ( INPUT_PURPOSE_FREE_FORM InputPurpose = C.GTK_INPUT_PURPOSE_FREE_FORM INPUT_PURPOSE_ALPHA InputPurpose = C.GTK_INPUT_PURPOSE_ALPHA INPUT_PURPOSE_DIGITS InputPurpose = C.GTK_INPUT_PURPOSE_DIGITS INPUT_PURPOSE_NUMBER InputPurpose = C.GTK_INPUT_PURPOSE_NUMBER INPUT_PURPOSE_PHONE InputPurpose = C.GTK_INPUT_PURPOSE_PHONE INPUT_PURPOSE_URL InputPurpose = C.GTK_INPUT_PURPOSE_URL INPUT_PURPOSE_EMAIL InputPurpose = C.GTK_INPUT_PURPOSE_EMAIL INPUT_PURPOSE_NAME InputPurpose = C.GTK_INPUT_PURPOSE_NAME INPUT_PURPOSE_PASSWORD InputPurpose = C.GTK_INPUT_PURPOSE_PASSWORD INPUT_PURPOSE_PIN InputPurpose = C.GTK_INPUT_PURPOSE_PIN ) func marshalInputPurpose(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return InputPurpose(c), nil } // TODO: // GtkBaselinePosition // GtkDeleteType // DirectionType is a representation of GTK's GtkDirectionType. type DirectionType int const ( DIR_TAB_FORWARD DirectionType = C.GTK_DIR_TAB_FORWARD DIR_TAB_BACKWARD DirectionType = C.GTK_DIR_TAB_BACKWARD DIR_UP DirectionType = C.GTK_DIR_UP DIR_DOWN DirectionType = C.GTK_DIR_DOWN DIR_LEFT DirectionType = C.GTK_DIR_LEFT DIR_RIGHT DirectionType = C.GTK_DIR_RIGHT ) func marshalDirectionType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return DirectionType(c), nil } // Justification is a representation of GTK's GtkJustification. type Justification int const ( JUSTIFY_LEFT Justification = C.GTK_JUSTIFY_LEFT JUSTIFY_RIGHT Justification = C.GTK_JUSTIFY_RIGHT JUSTIFY_CENTER Justification = C.GTK_JUSTIFY_CENTER JUSTIFY_FILL Justification = C.GTK_JUSTIFY_FILL ) func marshalJustification(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Justification(c), nil } // License is a representation of GTK's GtkLicense. type License int const ( LICENSE_UNKNOWN License = C.GTK_LICENSE_UNKNOWN LICENSE_CUSTOM License = C.GTK_LICENSE_CUSTOM LICENSE_GPL_2_0 License = C.GTK_LICENSE_GPL_2_0 LICENSE_GPL_3_0 License = C.GTK_LICENSE_GPL_3_0 LICENSE_LGPL_2_1 License = C.GTK_LICENSE_LGPL_2_1 LICENSE_LGPL_3_0 License = C.GTK_LICENSE_LGPL_3_0 LICENSE_BSD License = C.GTK_LICENSE_BSD LICENSE_MIT_X11 License = C.GTK_LICENSE_MIT_X11 LICENSE_GTK_ARTISTIC License = C.GTK_LICENSE_ARTISTIC ) func marshalLicense(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return License(c), nil } // MessageType is a representation of GTK's GtkMessageType. type MessageType int const ( MESSAGE_INFO MessageType = C.GTK_MESSAGE_INFO MESSAGE_WARNING MessageType = C.GTK_MESSAGE_WARNING MESSAGE_QUESTION MessageType = C.GTK_MESSAGE_QUESTION MESSAGE_ERROR MessageType = C.GTK_MESSAGE_ERROR MESSAGE_OTHER MessageType = C.GTK_MESSAGE_OTHER ) func marshalMessageType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return MessageType(c), nil } // TODO: // GtkMovementStep // Orientation is a representation of GTK's GtkOrientation. type Orientation int const ( ORIENTATION_HORIZONTAL Orientation = C.GTK_ORIENTATION_HORIZONTAL ORIENTATION_VERTICAL Orientation = C.GTK_ORIENTATION_VERTICAL ) func marshalOrientation(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Orientation(c), nil } // PackType is a representation of GTK's GtkPackType. type PackType int const ( PACK_START PackType = C.GTK_PACK_START PACK_END PackType = C.GTK_PACK_END ) func marshalPackType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PackType(c), nil } // PathType is a representation of GTK's GtkPathType. type PathType int const ( PATH_WIDGET PathType = C.GTK_PATH_WIDGET PATH_WIDGET_CLASS PathType = C.GTK_PATH_WIDGET_CLASS PATH_CLASS PathType = C.GTK_PATH_CLASS ) func marshalPathType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PathType(c), nil } // PolicyType is a representation of GTK's GtkPolicyType. type PolicyType int const ( POLICY_ALWAYS PolicyType = C.GTK_POLICY_ALWAYS POLICY_AUTOMATIC PolicyType = C.GTK_POLICY_AUTOMATIC POLICY_NEVER PolicyType = C.GTK_POLICY_NEVER ) func marshalPolicyType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PolicyType(c), nil } // SpinButtonUpdatePolicy is a representation of GTK's GtkSpinButtonUpdatePolicy. type SpinButtonUpdatePolicy int const ( UPDATE_ALWAYS SpinButtonUpdatePolicy = C.GTK_UPDATE_ALWAYS UPDATE_IF_VALID SpinButtonUpdatePolicy = C.GTK_UPDATE_IF_VALID ) func marshalSpinButtonUpdatePolicy(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return SpinButtonUpdatePolicy(c), nil } // SpinType is a representation of GTK's GtkSpinType. type SpinType int const ( SPIN_STEP_FORWARD SpinType = C.GTK_SPIN_STEP_FORWARD SPIN_STEP_BACKWARD SpinType = C.GTK_SPIN_STEP_BACKWARD SPIN_PAGE_BACKWARD SpinType = C.GTK_SPIN_PAGE_BACKWARD SPIN_HOME SpinType = C.GTK_SPIN_HOME SPIN_END SpinType = C.GTK_SPIN_END SPIN_USER_DEFINED SpinType = C.GTK_SPIN_USER_DEFINED ) func marshalSpinType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return SpinType(c), nil } // TreeViewGridLine is a representation of GTK's GtkTreeViewGridLines. type TreeViewGridLines int const ( TREE_VIEW_GRID_LINES_NONE TreeViewGridLines = C.GTK_TREE_VIEW_GRID_LINES_NONE TREE_VIEW_GRID_LINES_HORIZONTAL TreeViewGridLines = C.GTK_TREE_VIEW_GRID_LINES_HORIZONTAL TREE_VIEW_GRID_LINES_VERTICAL TreeViewGridLines = C.GTK_TREE_VIEW_GRID_LINES_VERTICAL TREE_VIEW_GRID_LINES_BOTH TreeViewGridLines = C.GTK_TREE_VIEW_GRID_LINES_BOTH ) // CellRendererAccelMode is a representation of GtkCellRendererAccelMode type CellRendererAccelMode int const ( // CELL_RENDERER_ACCEL_MODE_GTK is documented as GTK+ accelerators mode CELL_RENDERER_ACCEL_MODE_GTK CellRendererAccelMode = C.GTK_CELL_RENDERER_ACCEL_MODE_GTK // CELL_RENDERER_ACCEL_MODE_OTHER is documented as Other accelerator mode CELL_RENDERER_ACCEL_MODE_OTHER CellRendererAccelMode = C.GTK_CELL_RENDERER_ACCEL_MODE_OTHER ) func marshalCellRendererAccelMode(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return CellRendererAccelMode(c), nil } // CellRendererState is a representation of GTK's GtkCellRendererState type CellRendererState int const ( CELL_RENDERER_SELECTED CellRendererState = C.GTK_CELL_RENDERER_SELECTED CELL_RENDERER_PRELIT CellRendererState = C.GTK_CELL_RENDERER_PRELIT CELL_RENDERER_INSENSITIVE CellRendererState = C.GTK_CELL_RENDERER_INSENSITIVE CELL_RENDERER_SORTED CellRendererState = C.GTK_CELL_RENDERER_SORTED CELL_RENDERER_FOCUSED CellRendererState = C.GTK_CELL_RENDERER_FOCUSED CELL_RENDERER_EXPANDABLE CellRendererState = C.GTK_CELL_RENDERER_EXPANDABLE // since 3.4 CELL_RENDERER_EXPANDED CellRendererState = C.GTK_CELL_RENDERER_EXPANDED // since 3.4 ) func marshalCellRendererState(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return CellRendererState(c), nil } // CellRendererMode is a representation of GTK's GtkCellRendererMode type CellRendererMode int const ( CELL_RENDERER_MODE_INERT CellRendererMode = C.GTK_CELL_RENDERER_MODE_INERT CELL_RENDERER_MODE_ACTIVATABLE CellRendererMode = C.GTK_CELL_RENDERER_MODE_ACTIVATABLE CELL_RENDERER_MODE_EDITABLE CellRendererMode = C.GTK_CELL_RENDERER_MODE_EDITABLE ) func marshalCellRendererMode(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return CellRendererMode(c), nil } // PositionType is a representation of GTK's GtkPositionType. type PositionType int const ( POS_LEFT PositionType = C.GTK_POS_LEFT POS_RIGHT PositionType = C.GTK_POS_RIGHT POS_TOP PositionType = C.GTK_POS_TOP POS_BOTTOM PositionType = C.GTK_POS_BOTTOM ) func marshalPositionType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PositionType(c), nil } // ReliefStyle is a representation of GTK's GtkReliefStyle. type ReliefStyle int const ( RELIEF_NORMAL ReliefStyle = C.GTK_RELIEF_NORMAL RELIEF_HALF ReliefStyle = C.GTK_RELIEF_HALF RELIEF_NONE ReliefStyle = C.GTK_RELIEF_NONE ) func marshalReliefStyle(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ReliefStyle(c), nil } // ResponseType is a representation of GTK's GtkResponseType. type ResponseType int const ( RESPONSE_NONE ResponseType = C.GTK_RESPONSE_NONE RESPONSE_REJECT ResponseType = C.GTK_RESPONSE_REJECT RESPONSE_ACCEPT ResponseType = C.GTK_RESPONSE_ACCEPT RESPONSE_DELETE_EVENT ResponseType = C.GTK_RESPONSE_DELETE_EVENT RESPONSE_OK ResponseType = C.GTK_RESPONSE_OK RESPONSE_CANCEL ResponseType = C.GTK_RESPONSE_CANCEL RESPONSE_CLOSE ResponseType = C.GTK_RESPONSE_CLOSE RESPONSE_YES ResponseType = C.GTK_RESPONSE_YES RESPONSE_NO ResponseType = C.GTK_RESPONSE_NO RESPONSE_APPLY ResponseType = C.GTK_RESPONSE_APPLY RESPONSE_HELP ResponseType = C.GTK_RESPONSE_HELP ) func marshalResponseType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ResponseType(c), nil } // ScrollType is a representation of GTK's GtkScrollType. type ScrollType int const ( SCROLL_NONE ScrollType = C.GTK_SCROLL_NONE SCROLL_JUMP ScrollType = C.GTK_SCROLL_JUMP SCROLL_STEP_BACKWARD ScrollType = C.GTK_SCROLL_STEP_BACKWARD SCROLL_STEP_FORWARD ScrollType = C.GTK_SCROLL_STEP_FORWARD SCROLL_PAGE_BACKWARD ScrollType = C.GTK_SCROLL_PAGE_BACKWARD SCROLL_PAGE_FORWARD ScrollType = C.GTK_SCROLL_PAGE_FORWARD SCROLL_STEP_UP ScrollType = C.GTK_SCROLL_STEP_UP SCROLL_STEP_DOWN ScrollType = C.GTK_SCROLL_STEP_DOWN SCROLL_PAGE_UP ScrollType = C.GTK_SCROLL_PAGE_UP SCROLL_PAGE_DOWN ScrollType = C.GTK_SCROLL_PAGE_DOWN SCROLL_STEP_LEFT ScrollType = C.GTK_SCROLL_STEP_LEFT SCROLL_STEP_RIGHT ScrollType = C.GTK_SCROLL_STEP_RIGHT SCROLL_PAGE_LEFT ScrollType = C.GTK_SCROLL_PAGE_LEFT SCROLL_PAGE_RIGHT ScrollType = C.GTK_SCROLL_PAGE_RIGHT SCROLL_START ScrollType = C.GTK_SCROLL_START SCROLL_END ScrollType = C.GTK_SCROLL_END ) func marshalScrollType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ScrollType(c), nil } // ScrollStep is a representation of GTK's GtkScrollStep. type ScrollStep int const ( SCROLL_STEPS ScrollStep = C.GTK_SCROLL_STEPS SCROLL_PAGES ScrollStep = C.GTK_SCROLL_PAGES SCROLL_ENDS ScrollStep = C.GTK_SCROLL_ENDS SCROLL_HORIZONTAL_STEPS ScrollStep = C.GTK_SCROLL_HORIZONTAL_STEPS SCROLL_HORIZONTAL_PAGES ScrollStep = C.GTK_SCROLL_HORIZONTAL_PAGES SCROLL_HORIZONTAL_ENDS ScrollStep = C.GTK_SCROLL_HORIZONTAL_ENDS ) func marshalScrollStep(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ScrollStep(c), nil } // SelectionMode is a representation of GTK's GtkSelectionMode. type SelectionMode int const ( SELECTION_NONE SelectionMode = C.GTK_SELECTION_NONE SELECTION_SINGLE SelectionMode = C.GTK_SELECTION_SINGLE SELECTION_BROWSE SelectionMode = C.GTK_SELECTION_BROWSE SELECTION_MULTIPLE SelectionMode = C.GTK_SELECTION_MULTIPLE ) func marshalSelectionMode(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return SelectionMode(c), nil } // ShadowType is a representation of GTK's GtkShadowType. type ShadowType int const ( SHADOW_NONE ShadowType = C.GTK_SHADOW_NONE SHADOW_IN ShadowType = C.GTK_SHADOW_IN SHADOW_OUT ShadowType = C.GTK_SHADOW_OUT SHADOW_ETCHED_IN ShadowType = C.GTK_SHADOW_ETCHED_IN SHADOW_ETCHED_OUT ShadowType = C.GTK_SHADOW_ETCHED_OUT ) func marshalShadowType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ShadowType(c), nil } // SizeGroupMode is a representation of GTK's GtkSizeGroupMode type SizeGroupMode int const ( SIZE_GROUP_NONE SizeGroupMode = C.GTK_SIZE_GROUP_NONE SIZE_GROUP_HORIZONTAL SizeGroupMode = C.GTK_SIZE_GROUP_HORIZONTAL SIZE_GROUP_VERTICAL SizeGroupMode = C.GTK_SIZE_GROUP_VERTICAL SIZE_GROUP_BOTH SizeGroupMode = C.GTK_SIZE_GROUP_BOTH ) func marshalSizeGroupMode(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return SizeGroupMode(c), nil } // SortType is a representation of GTK's GtkSortType. type SortType int const ( SORT_ASCENDING SortType = C.GTK_SORT_ASCENDING SORT_DESCENDING = C.GTK_SORT_DESCENDING ) // Use as column id in SetSortColumnId to specify ListStore sorted // by default column or unsorted const ( SORT_COLUMN_DEFAULT int = -1 SORT_COLUMN_UNSORTED int = -2 ) func marshalSortType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return SortType(c), nil } // StateFlags is a representation of GTK's GtkStateFlags. type StateFlags int const ( STATE_FLAG_NORMAL StateFlags = C.GTK_STATE_FLAG_NORMAL STATE_FLAG_ACTIVE StateFlags = C.GTK_STATE_FLAG_ACTIVE STATE_FLAG_PRELIGHT StateFlags = C.GTK_STATE_FLAG_PRELIGHT STATE_FLAG_SELECTED StateFlags = C.GTK_STATE_FLAG_SELECTED STATE_FLAG_INSENSITIVE StateFlags = C.GTK_STATE_FLAG_INSENSITIVE STATE_FLAG_INCONSISTENT StateFlags = C.GTK_STATE_FLAG_INCONSISTENT STATE_FLAG_FOCUSED StateFlags = C.GTK_STATE_FLAG_FOCUSED STATE_FLAG_BACKDROP StateFlags = C.GTK_STATE_FLAG_BACKDROP ) func marshalStateFlags(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return StateFlags(c), nil } // TextDirection is a representation of GTK's GtkTextDirection. type TextDirection int const ( TEXT_DIR_NONE TextDirection = C.GTK_TEXT_DIR_NONE TEXT_DIR_LTR TextDirection = C.GTK_TEXT_DIR_LTR TEXT_DIR_RTL TextDirection = C.GTK_TEXT_DIR_RTL ) func marshalTextDirection(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return TextDirection(c), nil } // TargetFlags is a representation of GTK's GtkTargetFlags. type TargetFlags int const ( TARGET_SAME_APP TargetFlags = C.GTK_TARGET_SAME_APP TARGET_SAME_WIDGET TargetFlags = C.GTK_TARGET_SAME_WIDGET TARGET_OTHER_APP TargetFlags = C.GTK_TARGET_OTHER_APP TARGET_OTHER_WIDGET TargetFlags = C.GTK_TARGET_OTHER_WIDGET ) func marshalTargetFlags(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return TargetFlags(c), nil } // ToolbarStyle is a representation of GTK's GtkToolbarStyle. type ToolbarStyle int const ( TOOLBAR_ICONS ToolbarStyle = C.GTK_TOOLBAR_ICONS TOOLBAR_TEXT ToolbarStyle = C.GTK_TOOLBAR_TEXT TOOLBAR_BOTH ToolbarStyle = C.GTK_TOOLBAR_BOTH TOOLBAR_BOTH_HORIZ ToolbarStyle = C.GTK_TOOLBAR_BOTH_HORIZ ) func marshalToolbarStyle(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ToolbarStyle(c), nil } // TreeModelFlags is a representation of GTK's GtkTreeModelFlags. type TreeModelFlags int const ( TREE_MODEL_ITERS_PERSIST TreeModelFlags = C.GTK_TREE_MODEL_ITERS_PERSIST TREE_MODEL_LIST_ONLY TreeModelFlags = C.GTK_TREE_MODEL_LIST_ONLY ) func marshalTreeModelFlags(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return TreeModelFlags(c), nil } // WindowPosition is a representation of GTK's GtkWindowPosition. type WindowPosition int const ( WIN_POS_NONE WindowPosition = C.GTK_WIN_POS_NONE WIN_POS_CENTER WindowPosition = C.GTK_WIN_POS_CENTER WIN_POS_MOUSE WindowPosition = C.GTK_WIN_POS_MOUSE WIN_POS_CENTER_ALWAYS WindowPosition = C.GTK_WIN_POS_CENTER_ALWAYS WIN_POS_CENTER_ON_PARENT WindowPosition = C.GTK_WIN_POS_CENTER_ON_PARENT ) func marshalWindowPosition(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return WindowPosition(c), nil } // WindowType is a representation of GTK's GtkWindowType. type WindowType int const ( WINDOW_TOPLEVEL WindowType = C.GTK_WINDOW_TOPLEVEL WINDOW_POPUP WindowType = C.GTK_WINDOW_POPUP ) func marshalWindowType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return WindowType(c), nil } // WrapMode is a representation of GTK's GtkWrapMode. type WrapMode int const ( WRAP_NONE WrapMode = C.GTK_WRAP_NONE WRAP_CHAR WrapMode = C.GTK_WRAP_CHAR WRAP_WORD WrapMode = C.GTK_WRAP_WORD WRAP_WORD_CHAR WrapMode = C.GTK_WRAP_WORD_CHAR ) func marshalWrapMode(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return WrapMode(c), nil } // TextSearchFlags is a representation of GTK's GtkTextSearchFlags. type TextSearchFlags int const ( TEXT_SEARCH_VISIBLE_ONLY TextSearchFlags = C.GTK_TEXT_SEARCH_VISIBLE_ONLY TEXT_SEARCH_TEXT_ONLY TextSearchFlags = C.GTK_TEXT_SEARCH_TEXT_ONLY TEXT_SEARCH_CASE_INSENSITIVE TextSearchFlags = C.GTK_TEXT_SEARCH_CASE_INSENSITIVE ) func marshalTextSearchFlags(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return TextSearchFlags(c), nil } // CornerType is a representation of GTK's GtkCornerType. type CornerType int const ( CORNER_TOP_LEFT CornerType = C.GTK_CORNER_TOP_LEFT CORNER_BOTTOM_LEFT CornerType = C.GTK_CORNER_BOTTOM_LEFT CORNER_TOP_RIGHT CornerType = C.GTK_CORNER_TOP_RIGHT CORNER_BOTTOM_RIGHT CornerType = C.GTK_CORNER_BOTTOM_RIGHT ) func marshalCornerType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return CornerType(c), nil } /* * Init and main event loop */ /* Init() is a wrapper around gtk_init() and must be called before any other GTK calls and is used to initialize everything necessary. In addition to setting up GTK for usage, a pointer to a slice of strings may be passed in to parse standard GTK command line arguments. args will be modified to remove any flags that were handled. Alternatively, nil may be passed in to not perform any command line parsing. */ func Init(args *[]string) { if args != nil { argc := C.int(len(*args)) argv := C.make_strings(argc) defer C.destroy_strings(argv) for i, arg := range *args { cstr := C.CString(arg) C.set_string(argv, C.int(i), (*C.gchar)(cstr)) } C.gtk_init((*C.int)(unsafe.Pointer(&argc)), (***C.char)(unsafe.Pointer(&argv))) unhandled := make([]string, argc) for i := 0; i < int(argc); i++ { cstr := C.get_string(argv, C.int(i)) unhandled[i] = goString(cstr) C.free(unsafe.Pointer(cstr)) } *args = unhandled } else { C.gtk_init(nil, nil) } } /* InitCheck() is a wrapper around gtk_init_check() and works exactly like Init() only that it doesn't terminate the program if initialization fails. */ func InitCheck(args *[]string) error { success := false if args != nil { argc := C.int(len(*args)) argv := C.make_strings(argc) defer C.destroy_strings(argv) for i, arg := range *args { cstr := C.CString(arg) C.set_string(argv, C.int(i), (*C.gchar)(cstr)) } success = gobool(C.gtk_init_check((*C.int)(unsafe.Pointer(&argc)), (***C.char)(unsafe.Pointer(&argv)))) unhandled := make([]string, argc) for i := 0; i < int(argc); i++ { cstr := C.get_string(argv, C.int(i)) unhandled[i] = goString(cstr) C.free(unsafe.Pointer(cstr)) } *args = unhandled } else { success = gobool(C.gtk_init_check(nil, nil)) } if success { return nil } else { return errors.New("Unable to initialize GTK") } } // Main() is a wrapper around gtk_main() and runs the GTK main loop, // blocking until MainQuit() is called. func Main() { C.gtk_main() } // MainIteration is a wrapper around gtk_main_iteration. func MainIteration() bool { return gobool(C.gtk_main_iteration()) } // MainIterationDo is a wrapper around gtk_main_iteration_do. func MainIterationDo(blocking bool) bool { return gobool(C.gtk_main_iteration_do(gbool(blocking))) } // EventsPending is a wrapper around gtk_events_pending. func EventsPending() bool { return gobool(C.gtk_events_pending()) } // MainQuit() is a wrapper around gtk_main_quit() is used to terminate // the GTK main loop (started by Main()). func MainQuit() { C.gtk_main_quit() } /* * GtkAdjustment */ // Adjustment is a representation of GTK's GtkAdjustment. type Adjustment struct { glib.InitiallyUnowned } // native returns a pointer to the underlying GtkAdjustment. func (v *Adjustment) native() *C.GtkAdjustment { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAdjustment(p) } func marshalAdjustment(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapAdjustment(obj), nil } func wrapAdjustment(obj *glib.Object) *Adjustment { if obj == nil { return nil } return &Adjustment{glib.InitiallyUnowned{obj}} } // AdjustmentNew is a wrapper around gtk_adjustment_new(). func AdjustmentNew(value, lower, upper, stepIncrement, pageIncrement, pageSize float64) (*Adjustment, error) { c := C.gtk_adjustment_new(C.gdouble(value), C.gdouble(lower), C.gdouble(upper), C.gdouble(stepIncrement), C.gdouble(pageIncrement), C.gdouble(pageSize)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapAdjustment(obj), nil } // GetValue is a wrapper around gtk_adjustment_get_value(). func (v *Adjustment) GetValue() float64 { c := C.gtk_adjustment_get_value(v.native()) return float64(c) } // SetValue is a wrapper around gtk_adjustment_set_value(). func (v *Adjustment) SetValue(value float64) { C.gtk_adjustment_set_value(v.native(), C.gdouble(value)) } // GetLower is a wrapper around gtk_adjustment_get_lower(). func (v *Adjustment) GetLower() float64 { c := C.gtk_adjustment_get_lower(v.native()) return float64(c) } // GetPageSize is a wrapper around gtk_adjustment_get_page_size(). func (v *Adjustment) GetPageSize() float64 { return float64(C.gtk_adjustment_get_page_size(v.native())) } // SetPageSize is a wrapper around gtk_adjustment_set_page_size(). func (v *Adjustment) SetPageSize(value float64) { C.gtk_adjustment_set_page_size(v.native(), C.gdouble(value)) } // Configure is a wrapper around gtk_adjustment_configure(). func (v *Adjustment) Configure(value, lower, upper, stepIncrement, pageIncrement, pageSize float64) { C.gtk_adjustment_configure(v.native(), C.gdouble(value), C.gdouble(lower), C.gdouble(upper), C.gdouble(stepIncrement), C.gdouble(pageIncrement), C.gdouble(pageSize)) } // SetLower is a wrapper around gtk_adjustment_set_lower(). func (v *Adjustment) SetLower(value float64) { C.gtk_adjustment_set_lower(v.native(), C.gdouble(value)) } // GetUpper is a wrapper around gtk_adjustment_get_upper(). func (v *Adjustment) GetUpper() float64 { c := C.gtk_adjustment_get_upper(v.native()) return float64(c) } // SetUpper is a wrapper around gtk_adjustment_set_upper(). func (v *Adjustment) SetUpper(value float64) { C.gtk_adjustment_set_upper(v.native(), C.gdouble(value)) } // GetPageIncrement is a wrapper around gtk_adjustment_get_page_increment(). func (v *Adjustment) GetPageIncrement() float64 { c := C.gtk_adjustment_get_page_increment(v.native()) return float64(c) } // SetPageIncrement is a wrapper around gtk_adjustment_set_page_increment(). func (v *Adjustment) SetPageIncrement(value float64) { C.gtk_adjustment_set_page_increment(v.native(), C.gdouble(value)) } // GetStepIncrement is a wrapper around gtk_adjustment_get_step_increment(). func (v *Adjustment) GetStepIncrement() float64 { c := C.gtk_adjustment_get_step_increment(v.native()) return float64(c) } // SetStepIncrement is a wrapper around gtk_adjustment_set_step_increment(). func (v *Adjustment) SetStepIncrement(value float64) { C.gtk_adjustment_set_step_increment(v.native(), C.gdouble(value)) } // GetMinimumIncrement is a wrapper around gtk_adjustment_get_minimum_increment(). func (v *Adjustment) GetMinimumIncrement() float64 { c := C.gtk_adjustment_get_minimum_increment(v.native()) return float64(c) } /* void gtk_adjustment_clamp_page () void gtk_adjustment_changed () void gtk_adjustment_value_changed () void gtk_adjustment_configure () */ /* * GtkAssistant */ // Assistant is a representation of GTK's GtkAssistant. type Assistant struct { Window } // native returns a pointer to the underlying GtkAssistant. func (v *Assistant) native() *C.GtkAssistant { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAssistant(p) } func marshalAssistant(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapAssistant(obj), nil } func wrapAssistant(obj *glib.Object) *Assistant { if obj == nil { return nil } return &Assistant{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} } // AssistantNew is a wrapper around gtk_assistant_new(). func AssistantNew() (*Assistant, error) { c := C.gtk_assistant_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapAssistant(obj), nil } // GetCurrentPage is a wrapper around gtk_assistant_get_current_page(). func (v *Assistant) GetCurrentPage() int { c := C.gtk_assistant_get_current_page(v.native()) return int(c) } // SetCurrentPage is a wrapper around gtk_assistant_set_current_page(). func (v *Assistant) SetCurrentPage(pageNum int) { C.gtk_assistant_set_current_page(v.native(), C.gint(pageNum)) } // GetNPages is a wrapper around gtk_assistant_get_n_pages(). func (v *Assistant) GetNPages() int { c := C.gtk_assistant_get_n_pages(v.native()) return int(c) } // GetNthPage is a wrapper around gtk_assistant_get_nth_page(). func (v *Assistant) GetNthPage(pageNum int) (IWidget, error) { c := C.gtk_assistant_get_nth_page(v.native(), C.gint(pageNum)) if c == nil { return nil, fmt.Errorf("page %d is out of bounds", pageNum) } return castWidget(c) } // PrependPage is a wrapper around gtk_assistant_prepend_page(). func (v *Assistant) PrependPage(page IWidget) int { c := C.gtk_assistant_prepend_page(v.native(), page.toWidget()) return int(c) } // AppendPage is a wrapper around gtk_assistant_append_page(). func (v *Assistant) AppendPage(page IWidget) int { c := C.gtk_assistant_append_page(v.native(), page.toWidget()) return int(c) } // InsertPage is a wrapper around gtk_assistant_insert_page(). func (v *Assistant) InsertPage(page IWidget, position int) int { c := C.gtk_assistant_insert_page(v.native(), page.toWidget(), C.gint(position)) return int(c) } // RemovePage is a wrapper around gtk_assistant_remove_page(). func (v *Assistant) RemovePage(pageNum int) { C.gtk_assistant_remove_page(v.native(), C.gint(pageNum)) } // TODO: gtk_assistant_set_forward_page_func // SetPageType is a wrapper around gtk_assistant_set_page_type(). func (v *Assistant) SetPageType(page IWidget, ptype AssistantPageType) { C.gtk_assistant_set_page_type(v.native(), page.toWidget(), C.GtkAssistantPageType(ptype)) } // GetPageType is a wrapper around gtk_assistant_get_page_type(). func (v *Assistant) GetPageType(page IWidget) AssistantPageType { c := C.gtk_assistant_get_page_type(v.native(), page.toWidget()) return AssistantPageType(c) } // SetPageTitle is a wrapper around gtk_assistant_set_page_title(). func (v *Assistant) SetPageTitle(page IWidget, title string) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) C.gtk_assistant_set_page_title(v.native(), page.toWidget(), (*C.gchar)(cstr)) } // GetPageTitle is a wrapper around gtk_assistant_get_page_title(). func (v *Assistant) GetPageTitle(page IWidget) string { return goString(C.gtk_assistant_get_page_title(v.native(), page.toWidget())) } // SetPageComplete is a wrapper around gtk_assistant_set_page_complete(). func (v *Assistant) SetPageComplete(page IWidget, complete bool) { C.gtk_assistant_set_page_complete(v.native(), page.toWidget(), gbool(complete)) } // GetPageComplete is a wrapper around gtk_assistant_get_page_complete(). func (v *Assistant) GetPageComplete(page IWidget) bool { c := C.gtk_assistant_get_page_complete(v.native(), page.toWidget()) return gobool(c) } // AddActionWidget is a wrapper around gtk_assistant_add_action_widget(). func (v *Assistant) AddActionWidget(child IWidget) { C.gtk_assistant_add_action_widget(v.native(), child.toWidget()) } // RemoveActionWidget is a wrapper around gtk_assistant_remove_action_widget(). func (v *Assistant) RemoveActionWidget(child IWidget) { C.gtk_assistant_remove_action_widget(v.native(), child.toWidget()) } // UpdateButtonsState is a wrapper around gtk_assistant_update_buttons_state(). func (v *Assistant) UpdateButtonsState() { C.gtk_assistant_update_buttons_state(v.native()) } // Commit is a wrapper around gtk_assistant_commit(). func (v *Assistant) Commit() { C.gtk_assistant_commit(v.native()) } // NextPage is a wrapper around gtk_assistant_next_page(). func (v *Assistant) NextPage() { C.gtk_assistant_next_page(v.native()) } // PreviousPage is a wrapper around gtk_assistant_previous_page(). func (v *Assistant) PreviousPage() { C.gtk_assistant_previous_page(v.native()) } /* * GtkBin */ // Bin is a representation of GTK's GtkBin. type Bin struct { Container } // native returns a pointer to the underlying GtkBin. func (v *Bin) native() *C.GtkBin { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkBin(p) } func marshalBin(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapBin(obj), nil } func wrapBin(obj *glib.Object) *Bin { if obj == nil { return nil } return &Bin{Container{Widget{glib.InitiallyUnowned{obj}}}} } // GetChild is a wrapper around gtk_bin_get_child(). func (v *Bin) GetChild() (IWidget, error) { c := C.gtk_bin_get_child(v.native()) if c == nil { return nil, nil } return castWidget(c) } /* * GtkBuilder */ // Builder is a representation of GTK's GtkBuilder. type Builder struct { *glib.Object } // native() returns a pointer to the underlying GtkBuilder. func (b *Builder) native() *C.GtkBuilder { if b == nil || b.GObject == nil { return nil } p := unsafe.Pointer(b.GObject) return C.toGtkBuilder(p) } func marshalBuilder(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return &Builder{obj}, nil } // BuilderNew is a wrapper around gtk_builder_new(). func BuilderNew() (*Builder, error) { c := C.gtk_builder_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return &Builder{obj}, nil } // AddFromFile is a wrapper around gtk_builder_add_from_file(). func (b *Builder) AddFromFile(filename string) error { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil res := C.gtk_builder_add_from_file(b.native(), (*C.gchar)(cstr), &err) if res == 0 { defer C.g_error_free(err) return errors.New(goString(err.message)) } return nil } // AddFromResource is a wrapper around gtk_builder_add_from_resource(). func (b *Builder) AddFromResource(path string) error { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil res := C.gtk_builder_add_from_resource(b.native(), (*C.gchar)(cstr), &err) if res == 0 { defer C.g_error_free(err) return errors.New(goString(err.message)) } return nil } // AddFromString is a wrapper around gtk_builder_add_from_string(). func (b *Builder) AddFromString(str string) error { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) length := (C.gsize)(len(str)) var err *C.GError = nil res := C.gtk_builder_add_from_string(b.native(), (*C.gchar)(cstr), length, &err) if res == 0 { defer C.g_error_free(err) return errors.New(goString(err.message)) } return nil } // GetObject is a wrapper around gtk_builder_get_object(). The returned result // is an IObject, so it will need to be type-asserted to the appropriate type before // being used. For example, to get an object and type assert it as a window: // // obj, err := builder.GetObject("window") // if err != nil { // // object not found // return // } // if w, ok := obj.(*gtk.Window); ok { // // do stuff with w here // } else { // // not a *gtk.Window // } // func (b *Builder) GetObject(name string) (glib.IObject, error) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_builder_get_object(b.native(), (*C.gchar)(cstr)) if c == nil { return nil, errors.New("object '" + name + "' not found") } obj, err := cast(c) if err != nil { return nil, err } return obj, nil } var ( builderSignals = struct { sync.RWMutex m map[*C.GtkBuilder]map[string]interface{} }{ m: make(map[*C.GtkBuilder]map[string]interface{}), } ) // ConnectSignals is a wrapper around gtk_builder_connect_signals_full(). func (b *Builder) ConnectSignals(signals map[string]interface{}) { builderSignals.Lock() builderSignals.m[b.native()] = signals builderSignals.Unlock() C._gtk_builder_connect_signals_full(b.native()) } /* * GtkBuildable */ // TODO: // GtkBuildableIface // gtk_buildable_set_name(). // gtk_buildable_get_name(). // gtk_buildable_add_child(). // gtk_buildable_set_buildable_property(). // gtk_buildable_construct_child(). // gtk_buildable_custom_tag_start(). // gtk_buildable_custom_tag_end(). // gtk_buildable_custom_finished(). // gtk_buildable_parser_finished(). // gtk_buildable_get_internal_child(). /* * GtkButton */ // Button is a representation of GTK's GtkButton. type Button struct { Bin // Interfaces IActionable } // native() returns a pointer to the underlying GtkButton. func (v *Button) native() *C.GtkButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkButton(p) } func marshalButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapButton(obj), nil } func wrapButton(obj *glib.Object) *Button { if obj == nil { return nil } actionable := &Actionable{obj} return &Button{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}, actionable} } // ButtonNew() is a wrapper around gtk_button_new(). func ButtonNew() (*Button, error) { c := C.gtk_button_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapButton(obj), nil } // ButtonNewWithLabel() is a wrapper around gtk_button_new_with_label(). func ButtonNewWithLabel(label string) (*Button, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_button_new_with_label((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapButton(obj), nil } // ButtonNewWithMnemonic() is a wrapper around gtk_button_new_with_mnemonic(). func ButtonNewWithMnemonic(label string) (*Button, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_button_new_with_mnemonic((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapButton(obj), nil } // Clicked() is a wrapper around gtk_button_clicked(). func (v *Button) Clicked() { C.gtk_button_clicked(v.native()) } // SetRelief() is a wrapper around gtk_button_set_relief(). func (v *Button) SetRelief(newStyle ReliefStyle) { C.gtk_button_set_relief(v.native(), C.GtkReliefStyle(newStyle)) } // GetRelief() is a wrapper around gtk_button_get_relief(). func (v *Button) GetRelief() ReliefStyle { c := C.gtk_button_get_relief(v.native()) return ReliefStyle(c) } // SetLabel() is a wrapper around gtk_button_set_label(). func (v *Button) SetLabel(label string) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) C.gtk_button_set_label(v.native(), (*C.gchar)(cstr)) } // GetLabel() is a wrapper around gtk_button_get_label(). func (v *Button) GetLabel() (string, error) { c := C.gtk_button_get_label(v.native()) if c == nil { return "", nilPtrErr } return goString(c), nil } // SetUseUnderline() is a wrapper around gtk_button_set_use_underline(). func (v *Button) SetUseUnderline(useUnderline bool) { C.gtk_button_set_use_underline(v.native(), gbool(useUnderline)) } // GetUseUnderline() is a wrapper around gtk_button_get_use_underline(). func (v *Button) GetUseUnderline() bool { c := C.gtk_button_get_use_underline(v.native()) return gobool(c) } // SetImage() is a wrapper around gtk_button_set_image(). func (v *Button) SetImage(image IWidget) { C.gtk_button_set_image(v.native(), image.toWidget()) } // GetImage() is a wrapper around gtk_button_get_image(). func (v *Button) GetImage() (IWidget, error) { c := C.gtk_button_get_image(v.native()) if c == nil { return nil, nil } return castWidget(c) } // SetImagePosition() is a wrapper around gtk_button_set_image_position(). func (v *Button) SetImagePosition(position PositionType) { C.gtk_button_set_image_position(v.native(), C.GtkPositionType(position)) } // GetImagePosition() is a wrapper around gtk_button_get_image_position(). func (v *Button) GetImagePosition() PositionType { c := C.gtk_button_get_image_position(v.native()) return PositionType(c) } // SetAlwaysShowImage() is a wrapper around gtk_button_set_always_show_image(). func (v *Button) SetAlwaysShowImage(alwaysShow bool) { C.gtk_button_set_always_show_image(v.native(), gbool(alwaysShow)) } // GetAlwaysShowImage() is a wrapper around gtk_button_get_always_show_image(). func (v *Button) GetAlwaysShowImage() bool { c := C.gtk_button_get_always_show_image(v.native()) return gobool(c) } // GetEventWindow() is a wrapper around gtk_button_get_event_window(). func (v *Button) GetEventWindow() (*gdk.Window, error) { c := C.gtk_button_get_event_window(v.native()) if c == nil { return nil, nilPtrErr } w := &gdk.Window{glib.Take(unsafe.Pointer(c))} return w, nil } /* * GtkColorButton */ // ColorButton is a representation of GTK's GtkColorButton. type ColorButton struct { Button // Interfaces ColorChooser } // Native returns a pointer to the underlying GtkColorButton. func (v *ColorButton) native() *C.GtkColorButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkColorButton(p) } func wrapColorButton(obj *glib.Object) *ColorButton { if obj == nil { return nil } cc := wrapColorChooser(obj) actionable := wrapActionable(obj) return &ColorButton{Button{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}, actionable}, *cc} } // ColorButtonNew is a wrapper around gtk_color_button_new(). func ColorButtonNew() (*ColorButton, error) { c := C.gtk_color_button_new() if c == nil { return nil, nilPtrErr } return wrapColorButton(glib.Take(unsafe.Pointer(c))), nil } // ColorButtonNewWithRGBA is a wrapper around gtk_color_button_new_with_rgba(). func ColorButtonNewWithRGBA(gdkColor *gdk.RGBA) (*ColorButton, error) { c := C.gtk_color_button_new_with_rgba((*C.GdkRGBA)(unsafe.Pointer(gdkColor.Native()))) if c == nil { return nil, nilPtrErr } return wrapColorButton(glib.Take(unsafe.Pointer(c))), nil } // SetTitle is a wrapper around gtk_color_button_set_title(). func (v *ColorButton) SetTitle(title string) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) C.gtk_color_button_set_title(v.native(), (*C.gchar)(cstr)) } // GetTitle is a wrapper around gtk_color_button_get_title(). func (v *ColorButton) GetTitle() string { c := C.gtk_color_button_get_title(v.native()) defer C.free(unsafe.Pointer(c)) return goString(c) } /* * GtkBox */ // Box is a representation of GTK's GtkBox. type Box struct { Container } // native() returns a pointer to the underlying GtkBox. func (v *Box) native() *C.GtkBox { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkBox(p) } func marshalBox(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapBox(obj), nil } func wrapBox(obj *glib.Object) *Box { if obj == nil { return nil } return &Box{Container{Widget{glib.InitiallyUnowned{obj}}}} } func (v *Box) toOrientable() *C.GtkOrientable { if v == nil { return nil } return C.toGtkOrientable(unsafe.Pointer(v.GObject)) } // GetOrientation() is a wrapper around C.gtk_orientable_get_orientation() for a GtkBox func (v *Box) GetOrientation() Orientation { return Orientation(C.gtk_orientable_get_orientation(v.toOrientable())) } // SetOrientation() is a wrapper around C.gtk_orientable_set_orientation() for a GtkBox func (v *Box) SetOrientation(o Orientation) { C.gtk_orientable_set_orientation(v.toOrientable(), C.GtkOrientation(o)) } // BoxNew() is a wrapper around gtk_box_new(). func BoxNew(orientation Orientation, spacing int) (*Box, error) { c := C.gtk_box_new(C.GtkOrientation(orientation), C.gint(spacing)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapBox(obj), nil } // PackStart() is a wrapper around gtk_box_pack_start(). func (v *Box) PackStart(child IWidget, expand, fill bool, padding uint) { C.gtk_box_pack_start(v.native(), child.toWidget(), gbool(expand), gbool(fill), C.guint(padding)) } // PackEnd() is a wrapper around gtk_box_pack_end(). func (v *Box) PackEnd(child IWidget, expand, fill bool, padding uint) { C.gtk_box_pack_end(v.native(), child.toWidget(), gbool(expand), gbool(fill), C.guint(padding)) } // GetHomogeneous() is a wrapper around gtk_box_get_homogeneous(). func (v *Box) GetHomogeneous() bool { c := C.gtk_box_get_homogeneous(v.native()) return gobool(c) } // SetHomogeneous() is a wrapper around gtk_box_set_homogeneous(). func (v *Box) SetHomogeneous(homogeneous bool) { C.gtk_box_set_homogeneous(v.native(), gbool(homogeneous)) } // GetSpacing() is a wrapper around gtk_box_get_spacing(). func (v *Box) GetSpacing() int { c := C.gtk_box_get_spacing(v.native()) return int(c) } // SetSpacing() is a wrapper around gtk_box_set_spacing() func (v *Box) SetSpacing(spacing int) { C.gtk_box_set_spacing(v.native(), C.gint(spacing)) } // ReorderChild() is a wrapper around gtk_box_reorder_child(). func (v *Box) ReorderChild(child IWidget, position int) { C.gtk_box_reorder_child(v.native(), child.toWidget(), C.gint(position)) } // QueryChildPacking() is a wrapper around gtk_box_query_child_packing(). func (v *Box) QueryChildPacking(child IWidget) (expand, fill bool, padding uint, packType PackType) { var cexpand, cfill C.gboolean var cpadding C.guint var cpackType C.GtkPackType C.gtk_box_query_child_packing(v.native(), child.toWidget(), &cexpand, &cfill, &cpadding, &cpackType) return gobool(cexpand), gobool(cfill), uint(cpadding), PackType(cpackType) } // SetChildPacking() is a wrapper around gtk_box_set_child_packing(). func (v *Box) SetChildPacking(child IWidget, expand, fill bool, padding uint, packType PackType) { C.gtk_box_set_child_packing(v.native(), child.toWidget(), gbool(expand), gbool(fill), C.guint(padding), C.GtkPackType(packType)) } /* * GtkCalendar */ // Calendar is a representation of GTK's GtkCalendar. type Calendar struct { Widget } // native() returns a pointer to the underlying GtkCalendar. func (v *Calendar) native() *C.GtkCalendar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCalendar(p) } func marshalCalendar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCalendar(obj), nil } func wrapCalendar(obj *glib.Object) *Calendar { if obj == nil { return nil } return &Calendar{Widget{glib.InitiallyUnowned{obj}}} } // TODO: // GtkCalendarDetailFunc // CalendarNew is a wrapper around gtk_calendar_new(). func CalendarNew() (*Calendar, error) { c := C.gtk_calendar_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCalendar(obj), nil } // SelectMonth is a wrapper around gtk_calendar_select_month(). func (v *Calendar) SelectMonth(month, year uint) { C.gtk_calendar_select_month(v.native(), C.guint(month), C.guint(year)) } // SelectDay is a wrapper around gtk_calendar_select_day(). func (v *Calendar) SelectDay(day uint) { C.gtk_calendar_select_day(v.native(), C.guint(day)) } // MarkDay is a wrapper around gtk_calendar_mark_day(). func (v *Calendar) MarkDay(day uint) { C.gtk_calendar_mark_day(v.native(), C.guint(day)) } // UnmarkDay is a wrapper around gtk_calendar_unmark_day(). func (v *Calendar) UnmarkDay(day uint) { C.gtk_calendar_unmark_day(v.native(), C.guint(day)) } // GetDayIsMarked is a wrapper around gtk_calendar_get_day_is_marked(). func (v *Calendar) GetDayIsMarked(day uint) bool { c := C.gtk_calendar_get_day_is_marked(v.native(), C.guint(day)) return gobool(c) } // ClearMarks is a wrapper around gtk_calendar_clear_marks(). func (v *Calendar) ClearMarks() { C.gtk_calendar_clear_marks(v.native()) } // GetDisplayOptions is a wrapper around gtk_calendar_get_display_options(). func (v *Calendar) GetDisplayOptions() CalendarDisplayOptions { c := C.gtk_calendar_get_display_options(v.native()) return CalendarDisplayOptions(c) } // SetDisplayOptions is a wrapper around gtk_calendar_set_display_options(). func (v *Calendar) SetDisplayOptions(flags CalendarDisplayOptions) { C.gtk_calendar_set_display_options(v.native(), C.GtkCalendarDisplayOptions(flags)) } // GetDate is a wrapper around gtk_calendar_get_date(). func (v *Calendar) GetDate() (year, month, day uint) { var cyear, cmonth, cday C.guint C.gtk_calendar_get_date(v.native(), &cyear, &cmonth, &cday) return uint(cyear), uint(cmonth), uint(cday) } // TODO: // gtk_calendar_set_detail_func(). // GetDetailWidthChars is a wrapper around gtk_calendar_get_detail_width_chars(). func (v *Calendar) GetDetailWidthChars() int { c := C.gtk_calendar_get_detail_width_chars(v.native()) return int(c) } // SetDetailWidthChars is a wrapper around gtk_calendar_set_detail_width_chars(). func (v *Calendar) SetDetailWidthChars(chars int) { C.gtk_calendar_set_detail_width_chars(v.native(), C.gint(chars)) } // GetDetailHeightRows is a wrapper around gtk_calendar_get_detail_height_rows(). func (v *Calendar) GetDetailHeightRows() int { c := C.gtk_calendar_get_detail_height_rows(v.native()) return int(c) } // SetDetailHeightRows is a wrapper around gtk_calendar_set_detail_height_rows(). func (v *Calendar) SetDetailHeightRows(rows int) { C.gtk_calendar_set_detail_height_rows(v.native(), C.gint(rows)) } /* * GtkCellLayout */ // CellLayout is a representation of GTK's GtkCellLayout GInterface. type CellLayout struct { *glib.Object } // ICellLayout is an interface type implemented by all structs // embedding a CellLayout. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkCellLayout. type ICellLayout interface { toCellLayout() *C.GtkCellLayout } // native() returns a pointer to the underlying GObject as a GtkCellLayout. func (v *CellLayout) native() *C.GtkCellLayout { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellLayout(p) } func marshalCellLayout(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellLayout(obj), nil } func wrapCellLayout(obj *glib.Object) *CellLayout { if obj == nil { return nil } return &CellLayout{obj} } func (v *CellLayout) toCellLayout() *C.GtkCellLayout { if v == nil { return nil } return v.native() } // PackStart is a wrapper around gtk_cell_layout_pack_start(). func (v *CellLayout) PackStart(cell ICellRenderer, expand bool) { C.gtk_cell_layout_pack_start(v.native(), cell.toCellRenderer(), gbool(expand)) } // AddAttribute is a wrapper around gtk_cell_layout_add_attribute(). func (v *CellLayout) AddAttribute(cell ICellRenderer, attribute string, column int) { cstr := C.CString(attribute) defer C.free(unsafe.Pointer(cstr)) C.gtk_cell_layout_add_attribute(v.native(), cell.toCellRenderer(), (*C.gchar)(cstr), C.gint(column)) } // ClearAttributes is a wrapper around gtk_cell_layout_clear_attributes() func (v *CellLayout) ClearAttributes(cell ICellRenderer) { C.gtk_cell_layout_clear_attributes(v.native(), cell.toCellRenderer()) } /* * GtkCellView */ // TODO: // GtkCellView // gtk_cell_view_new(). // gtk_cell_view_new_with_context(). // gtk_cell_view_new_with_text(). // gtk_cell_view_new_with_markup(). // gtk_cell_view_new_with_pixbuf(). // gtk_cell_view_set_model(). // gtk_cell_view_get_model(). // gtk_cell_view_set_displayed_row(). // gtk_cell_view_get_displayed_row(). // gtk_cell_view_set_background_rgba(). // gtk_cell_view_set_draw_sensitive(). // gtk_cell_view_get_draw_sensitive(). // gtk_cell_view_set_fit_model(). // gtk_cell_view_get_fit_model(). /* * GtkCellEditable */ // CellEditable is a representation of GTK's GtkCellEditable GInterface. type CellEditable struct { glib.InitiallyUnowned // Widget } // ICellEditable is an interface type implemented by all structs // embedding an CellEditable. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkCellEditable. type ICellEditable interface { toCellEditable() *C.GtkCellEditable ToEntry() *Entry } // native() returns a pointer to the underlying GObject as a GtkCellEditable. func (v *CellEditable) native() *C.GtkCellEditable { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellEditable(p) } func marshalCellEditable(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellEditable(obj), nil } func wrapCellEditable(obj *glib.Object) *CellEditable { if obj == nil { return nil } // return &CellEditable{Widget{glib.InitiallyUnowned{obj}}} return &CellEditable{glib.InitiallyUnowned{obj}} } func (v *CellEditable) toCellEditable() *C.GtkCellEditable { if v == nil { return nil } return v.native() } // ToEntry is a helper tool, e.g: it returns *gtk.CellEditable as a *gtk.Entry // that embedding this CellEditable instance, then it can be used with // CellRendererText to adding EntryCompletion tools or intercepting EntryBuffer, // (to bypass "canceled" signal for example) then record entry, and much more. func (v *CellEditable) ToEntry() *Entry { return &Entry{Widget{glib.InitiallyUnowned{v.Object}}, Editable{v.Object}, *v} } // StartEditing is a wrapper around gtk_cell_editable_start_editing(). func (v *CellEditable) StartEditing(event *gdk.Event) { C.gtk_cell_editable_start_editing(v.native(), (*C.GdkEvent)(unsafe.Pointer(event.Native()))) } // EditingDone is a wrapper around gtk_cell_editable_editing_done(). func (v *CellEditable) EditingDone() { C.gtk_cell_editable_editing_done(v.native()) } // RemoveWidget is a wrapper around gtk_cell_editable_remove_widget(). func (v *CellEditable) RemoveWidget() { C.gtk_cell_editable_remove_widget(v.native()) } /* * GtkCellRenderer */ // CellRenderer is a representation of GTK's GtkCellRenderer. type CellRenderer struct { glib.InitiallyUnowned } // ICellRenderer is an interface type implemented by all structs // embedding a CellRenderer. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkCellRenderer. type ICellRenderer interface { toCellRenderer() *C.GtkCellRenderer } // native returns a pointer to the underlying GtkCellRenderer. func (v *CellRenderer) native() *C.GtkCellRenderer { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellRenderer(p) } func (v *CellRenderer) toCellRenderer() *C.GtkCellRenderer { if v == nil { return nil } return v.native() } func marshalCellRenderer(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellRenderer(obj), nil } func wrapCellRenderer(obj *glib.Object) *CellRenderer { if obj == nil { return nil } return &CellRenderer{glib.InitiallyUnowned{obj}} } // Activate is a wrapper around gtk_cell_renderer_activate(). func (v *CellRenderer) Activate(event *gdk.Event, widget IWidget, path string, backgroundArea, cellArea *gdk.Rectangle, flags CellRendererState) bool { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) e := (*C.GdkEvent)(unsafe.Pointer(event.Native())) c := C.gtk_cell_renderer_activate(v.native(), e, widget.toWidget(), (*C.gchar)(cstr), nativeGdkRectangle(*backgroundArea), nativeGdkRectangle(*cellArea), C.GtkCellRendererState(flags)) return gobool(c) } // StartEditing is a wrapper around gtk_cell_renderer_start_editing(). func (v *CellRenderer) StartEditing(event *gdk.Event, widget IWidget, path string, backgroundArea, cellArea *gdk.Rectangle, flags CellRendererState) (ICellEditable, error) { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) e := (*C.GdkEvent)(unsafe.Pointer(event.Native())) c := C.gtk_cell_renderer_start_editing(v.native(), e, widget.toWidget(), (*C.gchar)(cstr), nativeGdkRectangle(*backgroundArea), nativeGdkRectangle(*cellArea), C.GtkCellRendererState(flags)) return castCellEditable(c) } // StopEditing is a wrapper around gtk_cell_renderer_stop_editing(). func (v *CellRenderer) StopEditing(canceled bool) { C.gtk_cell_renderer_stop_editing(v.native(), gbool(canceled)) } // GetVisible is a wrapper around gtk_cell_renderer_get_visible(). func (v *CellRenderer) GetVisible() bool { return gobool(C.gtk_cell_renderer_get_visible(v.native())) } // SetVisible is a wrapper around gtk_cell_renderer_set_visible(). func (v *CellRenderer) SetVisible(visible bool) { C.gtk_cell_renderer_set_visible(v.native(), gbool(visible)) } // GetSensitive is a wrapper around gtk_cell_renderer_get_sensitive(). func (v *CellRenderer) GetSensitive() bool { return gobool(C.gtk_cell_renderer_get_sensitive(v.native())) } // SetSentitive is a wrapper around gtk_cell_renderer_set_sensitive(). func (v *CellRenderer) SetSentitive(sensitive bool) { C.gtk_cell_renderer_set_sensitive(v.native(), gbool(sensitive)) } // IsActivatable is a wrapper around gtk_cell_renderer_is_activatable(). func (v *CellRenderer) IsActivatable() bool { return gobool(C.gtk_cell_renderer_is_activatable(v.native())) } // GetState is a wrapper around gtk_cell_renderer_get_state(). func (v *CellRenderer) GetState(widget IWidget, flags CellRendererState) StateFlags { return StateFlags(C.gtk_cell_renderer_get_state(v.native(), widget.toWidget(), C.GtkCellRendererState(flags))) } // SetAlignment is a wrapper around gtk_tree_view_column_set_alignment(). func (v *CellRenderer) SetAlignment(xalign float64, yalign float64) { C.gtk_cell_renderer_set_alignment(v.native(), C.gfloat(xalign), C.gfloat(yalign)) } // TODO: gtk_cell_renderer_get_aligned_area // TODO: gtk_cell_renderer_get_size // TODO: gtk_cell_renderer_render // TODO: gtk_cell_renderer_activate // TODO: gtk_cell_renderer_start_editing // TODO: gtk_cell_renderer_stop_editing // TODO: gtk_cell_renderer_get_fixed_size // TODO: gtk_cell_renderer_set_fixed_size // TODO: gtk_cell_renderer_get_visible // TODO: gtk_cell_renderer_set_visible // TODO: gtk_cell_renderer_get_sensitive // TODO: gtk_cell_renderer_set_sensitive // TODO: gtk_cell_renderer_get_alignment // TODO: gtk_cell_renderer_set_alignment // TODO: gtk_cell_renderer_get_padding // TODO: gtk_cell_renderer_set_padding // TODO: gtk_cell_renderer_get_state // TODO: gtk_cell_renderer_is_activatable // TODO: gtk_cell_renderer_get_preferred_height // TODO: gtk_cell_renderer_get_preferred_height_for_width // TODO: gtk_cell_renderer_get_preferred_size // TODO: gtk_cell_renderer_get_preferred_width // TODO: gtk_cell_renderer_get_preferred_width_for_height // TODO: gtk_cell_renderer_get_request_mode /* * GtkCellRendererSpinner */ // CellRendererSpinner is a representation of GTK's GtkCellRendererSpinner. type CellRendererSpinner struct { CellRenderer } // native returns a pointer to the underlying GtkCellRendererSpinner. func (v *CellRendererSpinner) native() *C.GtkCellRendererSpinner { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellRendererSpinner(p) } func marshalCellRendererSpinner(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererSpinner(obj), nil } func wrapCellRendererSpinner(obj *glib.Object) *CellRendererSpinner { if obj == nil { return nil } return &CellRendererSpinner{CellRenderer{glib.InitiallyUnowned{obj}}} } // CellRendererSpinnerNew is a wrapper around gtk_cell_renderer_spinner_new(). func CellRendererSpinnerNew() (*CellRendererSpinner, error) { c := C.gtk_cell_renderer_spinner_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererSpinner(obj), nil } /* * GtkCellRendererPixbuf */ // CellRendererPixbuf is a representation of GTK's GtkCellRendererPixbuf. type CellRendererPixbuf struct { CellRenderer } // native returns a pointer to the underlying GtkCellRendererPixbuf. func (v *CellRendererPixbuf) native() *C.GtkCellRendererPixbuf { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellRendererPixbuf(p) } func marshalCellRendererPixbuf(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererPixbuf(obj), nil } func wrapCellRendererPixbuf(obj *glib.Object) *CellRendererPixbuf { if obj == nil { return nil } return &CellRendererPixbuf{CellRenderer{glib.InitiallyUnowned{obj}}} } // CellRendererPixbufNew is a wrapper around gtk_cell_renderer_pixbuf_new(). func CellRendererPixbufNew() (*CellRendererPixbuf, error) { c := C.gtk_cell_renderer_pixbuf_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererPixbuf(obj), nil } /* * GtkCellRendererProgress */ // CellRendererProgress is a representation of GTK's GtkCellRendererProgress. type CellRendererProgress struct { CellRenderer } // native returns a pointer to the underlying GtkCellRendererProgress. func (v *CellRendererProgress) native() *C.GtkCellRendererProgress { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellRendererProgress(p) } func marshalCellRendererProgress(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererProgress(obj), nil } func wrapCellRendererProgress(obj *glib.Object) *CellRendererProgress { if obj == nil { return nil } return &CellRendererProgress{CellRenderer{glib.InitiallyUnowned{obj}}} } // CellRendererProgressNew is a wrapper around gtk_cell_renderer_progress_new(). func CellRendererProgressNew() (*CellRendererProgress, error) { c := C.gtk_cell_renderer_progress_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererProgress(obj), nil } /* * GtkCellRendererText */ // CellRendererText is a representation of GTK's GtkCellRendererText. type CellRendererText struct { CellRenderer } // native returns a pointer to the underlying GtkCellRendererText. func (v *CellRendererText) native() *C.GtkCellRendererText { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellRendererText(p) } func marshalCellRendererText(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererText(obj), nil } func wrapCellRendererText(obj *glib.Object) *CellRendererText { if obj == nil { return nil } return &CellRendererText{CellRenderer{glib.InitiallyUnowned{obj}}} } // CellRendererTextNew is a wrapper around gtk_cell_renderer_text_new(). func CellRendererTextNew() (*CellRendererText, error) { c := C.gtk_cell_renderer_text_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererText(obj), nil } // SetFixedHeightFromFont is a wrapper around gtk_cell_renderer_text_set_fixed_height_from_font func (v *CellRendererText) SetFixedHeightFromFont(numberOfRows int) { C.gtk_cell_renderer_text_set_fixed_height_from_font(v.native(), C.gint(numberOfRows)) } /* * GtkCellRendererToggle */ // CellRendererToggle is a representation of GTK's GtkCellRendererToggle. type CellRendererToggle struct { CellRenderer } // native returns a pointer to the underlying GtkCellRendererToggle. func (v *CellRendererToggle) native() *C.GtkCellRendererToggle { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellRendererToggle(p) } func (v *CellRendererToggle) toCellRenderer() *C.GtkCellRenderer { if v == nil { return nil } return v.CellRenderer.native() } func marshalCellRendererToggle(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererToggle(obj), nil } func wrapCellRendererToggle(obj *glib.Object) *CellRendererToggle { if obj == nil { return nil } return &CellRendererToggle{CellRenderer{glib.InitiallyUnowned{obj}}} } // CellRendererToggleNew is a wrapper around gtk_cell_renderer_toggle_new(). func CellRendererToggleNew() (*CellRendererToggle, error) { c := C.gtk_cell_renderer_toggle_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererToggle(obj), nil } // SetRadio is a wrapper around gtk_cell_renderer_toggle_set_radio(). func (v *CellRendererToggle) SetRadio(set bool) { C.gtk_cell_renderer_toggle_set_radio(v.native(), gbool(set)) } // GetRadio is a wrapper around gtk_cell_renderer_toggle_get_radio(). func (v *CellRendererToggle) GetRadio() bool { c := C.gtk_cell_renderer_toggle_get_radio(v.native()) return gobool(c) } // SetActive is a wrapper around gtk_cell_renderer_toggle_set_active(). func (v *CellRendererToggle) SetActive(active bool) { C.gtk_cell_renderer_toggle_set_active(v.native(), gbool(active)) } // GetActive is a wrapper around gtk_cell_renderer_toggle_get_active(). func (v *CellRendererToggle) GetActive() bool { c := C.gtk_cell_renderer_toggle_get_active(v.native()) return gobool(c) } // SetActivatable is a wrapper around gtk_cell_renderer_toggle_set_activatable(). func (v *CellRendererToggle) SetActivatable(activatable bool) { C.gtk_cell_renderer_toggle_set_activatable(v.native(), gbool(activatable)) } // GetActivatable is a wrapper around gtk_cell_renderer_toggle_get_activatable(). func (v *CellRendererToggle) GetActivatable() bool { c := C.gtk_cell_renderer_toggle_get_activatable(v.native()) return gobool(c) } /* * GtkCellRendererAccel */ // CellRendererAccel is a representation of GtkCellRendererAccel. type CellRendererAccel struct { CellRendererText } // native returns a pointer to the underlying GtkCellRendererAccel. func (v *CellRendererAccel) native() *C.GtkCellRendererAccel { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellRendererAccel(p) } func marshalCellRendererAccel(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererAccel(obj), nil } func wrapCellRendererAccel(obj *glib.Object) *CellRendererAccel { if obj == nil { return nil } return &CellRendererAccel{CellRendererText{CellRenderer{glib.InitiallyUnowned{obj}}}} } // CellRendererAccelNew is a wrapper around gtk_cell_renderer_accel_new(). func CellRendererAccelNew() (*CellRendererAccel, error) { c := C.gtk_cell_renderer_accel_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererAccel(obj), nil } /* * GtkCellRendererCombo */ // CellRendererCombo is a representation of GtkCellRendererCombo. type CellRendererCombo struct { CellRendererText } // native returns a pointer to the underlying GtkCellRendererCombo. func (v *CellRendererCombo) native() *C.GtkCellRendererCombo { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellRendererCombo(p) } func marshalCellRendererCombo(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererCombo(obj), nil } func wrapCellRendererCombo(obj *glib.Object) *CellRendererCombo { if obj == nil { return nil } return &CellRendererCombo{CellRendererText{CellRenderer{glib.InitiallyUnowned{obj}}}} } // CellRendererComboNew is a wrapper around gtk_cell_renderer_combo_new(). func CellRendererComboNew() (*CellRendererCombo, error) { c := C.gtk_cell_renderer_combo_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererCombo(obj), nil } /* * GtkCellRendererSpin */ // CellRendererSpin is a representation of GtkCellRendererSpin. type CellRendererSpin struct { CellRendererText } // native returns a pointer to the underlying GtkCellRendererSpin. func (v *CellRendererSpin) native() *C.GtkCellRendererSpin { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCellRendererSpin(p) } func marshalCellRendererSpin(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererSpin(obj), nil } func wrapCellRendererSpin(obj *glib.Object) *CellRendererSpin { if obj == nil { return nil } return &CellRendererSpin{CellRendererText{CellRenderer{glib.InitiallyUnowned{obj}}}} } // CellRendererSpinNew is a wrapper around gtk_cell_renderer_spin_new(). func CellRendererSpinNew() (*CellRendererSpin, error) { c := C.gtk_cell_renderer_spin_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCellRendererSpin(obj), nil } /* * GtkCheckButton */ // CheckButton is a wrapper around GTK's GtkCheckButton. type CheckButton struct { ToggleButton } // native returns a pointer to the underlying GtkCheckButton. func (v *CheckButton) native() *C.GtkCheckButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCheckButton(p) } func marshalCheckButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCheckButton(obj), nil } func wrapCheckButton(obj *glib.Object) *CheckButton { if obj == nil { return nil } actionable := wrapActionable(obj) return &CheckButton{ToggleButton{Button{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}, actionable}}} } // CheckButtonNew is a wrapper around gtk_check_button_new(). func CheckButtonNew() (*CheckButton, error) { c := C.gtk_check_button_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCheckButton(obj), nil } // CheckButtonNewWithLabel is a wrapper around // gtk_check_button_new_with_label(). func CheckButtonNewWithLabel(label string) (*CheckButton, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_check_button_new_with_label((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapCheckButton(glib.Take(unsafe.Pointer(c))), nil } // CheckButtonNewWithMnemonic is a wrapper around // gtk_check_button_new_with_mnemonic(). func CheckButtonNewWithMnemonic(label string) (*CheckButton, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_check_button_new_with_mnemonic((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCheckButton(obj), nil } /* * GtkCheckMenuItem */ type CheckMenuItem struct { MenuItem } // native returns a pointer to the underlying GtkCheckMenuItem. func (v *CheckMenuItem) native() *C.GtkCheckMenuItem { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCheckMenuItem(p) } func marshalCheckMenuItem(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapCheckMenuItem(obj), nil } func wrapCheckMenuItem(obj *glib.Object) *CheckMenuItem { if obj == nil { return nil } return &CheckMenuItem{MenuItem{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}}} } // CheckMenuItemNew is a wrapper around gtk_check_menu_item_new(). func CheckMenuItemNew() (*CheckMenuItem, error) { c := C.gtk_check_menu_item_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCheckMenuItem(obj), nil } // CheckMenuItemNewWithLabel is a wrapper around gtk_check_menu_item_new_with_label(). func CheckMenuItemNewWithLabel(label string) (*CheckMenuItem, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_check_menu_item_new_with_label((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCheckMenuItem(obj), nil } // CheckMenuItemNewWithMnemonic is a wrapper around gtk_check_menu_item_new_with_mnemonic(). func CheckMenuItemNewWithMnemonic(label string) (*CheckMenuItem, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_check_menu_item_new_with_mnemonic((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCheckMenuItem(obj), nil } // GetActive is a wrapper around gtk_check_menu_item_get_active(). func (v *CheckMenuItem) GetActive() bool { c := C.gtk_check_menu_item_get_active(v.native()) return gobool(c) } // SetActive is a wrapper around gtk_check_menu_item_set_active(). func (v *CheckMenuItem) SetActive(isActive bool) { C.gtk_check_menu_item_set_active(v.native(), gbool(isActive)) } // Toggled is a wrapper around gtk_check_menu_item_toggled(). func (v *CheckMenuItem) Toggled() { C.gtk_check_menu_item_toggled(v.native()) } // GetInconsistent is a wrapper around gtk_check_menu_item_get_inconsistent(). func (v *CheckMenuItem) GetInconsistent() bool { c := C.gtk_check_menu_item_get_inconsistent(v.native()) return gobool(c) } // SetInconsistent is a wrapper around gtk_check_menu_item_set_inconsistent(). func (v *CheckMenuItem) SetInconsistent(setting bool) { C.gtk_check_menu_item_set_inconsistent(v.native(), gbool(setting)) } // SetDrawAsRadio is a wrapper around gtk_check_menu_item_set_draw_as_radio(). func (v *CheckMenuItem) SetDrawAsRadio(drawAsRadio bool) { C.gtk_check_menu_item_set_draw_as_radio(v.native(), gbool(drawAsRadio)) } // GetDrawAsRadio is a wrapper around gtk_check_menu_item_get_draw_as_radio(). func (v *CheckMenuItem) GetDrawAsRadio() bool { c := C.gtk_check_menu_item_get_draw_as_radio(v.native()) return gobool(c) } /* * GtkClipboard */ // Clipboard is a wrapper around GTK's GtkClipboard. type Clipboard struct { *glib.Object } // native returns a pointer to the underlying GtkClipboard. func (v *Clipboard) native() *C.GtkClipboard { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkClipboard(p) } func marshalClipboard(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapClipboard(obj), nil } func wrapClipboard(obj *glib.Object) *Clipboard { if obj == nil { return nil } return &Clipboard{obj} } // Store is a wrapper around gtk_clipboard_store func (v *Clipboard) Store() { C.gtk_clipboard_store(v.native()) } // ClipboardGet() is a wrapper around gtk_clipboard_get(). func ClipboardGet(atom gdk.Atom) (*Clipboard, error) { c := C.gtk_clipboard_get(C.GdkAtom(unsafe.Pointer(atom))) if c == nil { return nil, nilPtrErr } cb := &Clipboard{glib.Take(unsafe.Pointer(c))} return cb, nil } // ClipboardGetForDisplay() is a wrapper around gtk_clipboard_get_for_display(). func ClipboardGetForDisplay(display *gdk.Display, atom gdk.Atom) (*Clipboard, error) { displayPtr := (*C.GdkDisplay)(unsafe.Pointer(display.Native())) c := C.gtk_clipboard_get_for_display(displayPtr, C.GdkAtom(unsafe.Pointer(atom))) if c == nil { return nil, nilPtrErr } cb := &Clipboard{glib.Take(unsafe.Pointer(c))} return cb, nil } // WaitIsTextAvailable is a wrapper around gtk_clipboard_wait_is_text_available func (v *Clipboard) WaitIsTextAvailable() bool { c := C.gtk_clipboard_wait_is_text_available(v.native()) return gobool(c) } // WaitForText is a wrapper around gtk_clipboard_wait_for_text func (v *Clipboard) WaitForText() (string, error) { c := C.gtk_clipboard_wait_for_text(v.native()) if c == nil { return "", nilPtrErr } defer C.g_free(C.gpointer(c)) return goString(c), nil } // SetText() is a wrapper around gtk_clipboard_set_text(). func (v *Clipboard) SetText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_clipboard_set_text(v.native(), (*C.gchar)(cstr), C.gint(len(text))) } // WaitIsRichTextAvailable is a wrapper around gtk_clipboard_wait_is_rich_text_available func (v *Clipboard) WaitIsRichTextAvailable(buf *TextBuffer) bool { c := C.gtk_clipboard_wait_is_rich_text_available(v.native(), buf.native()) return gobool(c) } // WaitIsUrisAvailable is a wrapper around gtk_clipboard_wait_is_uris_available func (v *Clipboard) WaitIsUrisAvailable() bool { c := C.gtk_clipboard_wait_is_uris_available(v.native()) return gobool(c) } // WaitIsImageAvailable is a wrapper around gtk_clipboard_wait_is_image_available func (v *Clipboard) WaitIsImageAvailable() bool { c := C.gtk_clipboard_wait_is_image_available(v.native()) return gobool(c) } // SetImage is a wrapper around gtk_clipboard_set_image func (v *Clipboard) SetImage(pixbuf *gdk.Pixbuf) { C.gtk_clipboard_set_image(v.native(), (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native()))) } // WaitForImage is a wrapper around gtk_clipboard_wait_for_image func (v *Clipboard) WaitForImage() (*gdk.Pixbuf, error) { c := C.gtk_clipboard_wait_for_image(v.native()) if c == nil { return nil, nilPtrErr } p := &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))} return p, nil } // WaitIsTargetAvailable is a wrapper around gtk_clipboard_wait_is_target_available func (v *Clipboard) WaitIsTargetAvailable(target gdk.Atom) bool { c := C.gtk_clipboard_wait_is_target_available(v.native(), C.GdkAtom(unsafe.Pointer(target))) return gobool(c) } // WaitForContents is a wrapper around gtk_clipboard_wait_for_contents func (v *Clipboard) WaitForContents(target gdk.Atom) (*SelectionData, error) { c := C.gtk_clipboard_wait_for_contents(v.native(), C.GdkAtom(unsafe.Pointer(target))) if c == nil { return nil, nilPtrErr } p := &SelectionData{c} runtime.SetFinalizer(p, func(l *SelectionData) { glib.FinalizerStrategy(l.free) }) return p, nil } /* * GtkContainer */ // Container is a representation of GTK's GtkContainer. type Container struct { Widget } // native returns a pointer to the underlying GtkContainer. func (v *Container) native() *C.GtkContainer { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkContainer(p) } func marshalContainer(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapContainer(obj), nil } func wrapContainer(obj *glib.Object) *Container { if obj == nil { return nil } return &Container{Widget{glib.InitiallyUnowned{obj}}} } // Add is a wrapper around gtk_container_add(). func (v *Container) Add(w IWidget) { C.gtk_container_add(v.native(), w.toWidget()) } // Remove is a wrapper around gtk_container_remove(). func (v *Container) Remove(w IWidget) { C.gtk_container_remove(v.native(), w.toWidget()) } // TODO: gtk_container_add_with_properties // CheckResize is a wrapper around gtk_container_check_resize(). func (v *Container) CheckResize() { C.gtk_container_check_resize(v.native()) } // TODO: gtk_container_foreach // GetChildren is a wrapper around gtk_container_get_children(). func (v *Container) GetChildren() *glib.List { clist := C.gtk_container_get_children(v.native()) if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return wrapWidget(glib.Take(ptr)) }) return glist } // TODO: gtk_container_get_path_for_child // GetFocusChild is a wrapper around gtk_container_get_focus_child(). func (v *Container) GetFocusChild() (IWidget, error) { c := C.gtk_container_get_focus_child(v.native()) if c == nil { return nil, nil } return castWidget(c) } // SetFocusChild is a wrapper around gtk_container_set_focus_child(). func (v *Container) SetFocusChild(child IWidget) { C.gtk_container_set_focus_child(v.native(), child.toWidget()) } // GetFocusVAdjustment is a wrapper around gtk_container_get_focus_vadjustment(). func (v *Container) GetFocusVAdjustment() *Adjustment { c := C.gtk_container_get_focus_vadjustment(v.native()) if c == nil { return nil } obj := glib.Take(unsafe.Pointer(c)) return wrapAdjustment(obj) } // SetFocusVAdjustment is a wrapper around gtk_container_set_focus_vadjustment(). func (v *Container) SetFocusVAdjustment(adjustment *Adjustment) { C.gtk_container_set_focus_vadjustment(v.native(), adjustment.native()) } // GetFocusHAdjustment is a wrapper around gtk_container_get_focus_hadjustment(). func (v *Container) GetFocusHAdjustment() *Adjustment { c := C.gtk_container_get_focus_hadjustment(v.native()) if c == nil { return nil } obj := glib.Take(unsafe.Pointer(c)) return wrapAdjustment(obj) } // SetFocusHAdjustment is a wrapper around gtk_container_set_focus_hadjustment(). func (v *Container) SetFocusHAdjustment(adjustment *Adjustment) { C.gtk_container_set_focus_hadjustment(v.native(), adjustment.native()) } // ChildType is a wrapper around gtk_container_child_type(). func (v *Container) ChildType() glib.Type { c := C.gtk_container_child_type(v.native()) return glib.Type(c) } // TODO: // gtk_container_child_get(). // gtk_container_child_set(). // ChildNotify is a wrapper around gtk_container_child_notify(). func (v *Container) ChildNotify(child IWidget, childProperty string) { cstr := C.CString(childProperty) defer C.free(unsafe.Pointer(cstr)) C.gtk_container_child_notify(v.native(), child.toWidget(), (*C.gchar)(cstr)) } // ChildGetProperty is a wrapper around gtk_container_child_get_property(). func (v *Container) ChildGetProperty(child IWidget, name string, valueType glib.Type) (interface{}, error) { gv, e := glib.ValueInit(valueType) if e != nil { return nil, e } cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_container_child_get_property(v.native(), child.toWidget(), (*C.gchar)(cstr), (*C.GValue)(unsafe.Pointer(gv.Native()))) return gv.GoValue() } // ChildSetProperty is a wrapper around gtk_container_child_set_property(). func (v *Container) ChildSetProperty(child IWidget, name string, value interface{}) error { gv, e := glib.GValue(value) if e != nil { return e } cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_container_child_set_property(v.native(), child.toWidget(), (*C.gchar)(cstr), (*C.GValue)(unsafe.Pointer(gv.Native()))) return nil } // TODO: // gtk_container_child_get_valist(). // gtk_container_child_set_valist(). // gtk_container_child_notify_by_pspec(). // gtk_container_forall(). // GetBorderWidth is a wrapper around gtk_container_get_border_width(). func (v *Container) GetBorderWidth() uint { c := C.gtk_container_get_border_width(v.native()) return uint(c) } // SetBorderWidth is a wrapper around gtk_container_set_border_width(). func (v *Container) SetBorderWidth(borderWidth uint) { C.gtk_container_set_border_width(v.native(), C.guint(borderWidth)) } // PropagateDraw is a wrapper around gtk_container_propagate_draw(). func (v *Container) PropagateDraw(child IWidget, cr *cairo.Context) { context := (*C.cairo_t)(unsafe.Pointer(cr.Native())) C.gtk_container_propagate_draw(v.native(), child.toWidget(), context) } // TODO: // gtk_container_class_find_child_property(). // gtk_container_class_install_child_property(). // gtk_container_class_install_child_properties(). // gtk_container_class_list_child_properties(). // gtk_container_class_handle_border_width(). // GtkResizeMode // GdkCairoSetSourcePixBuf() is a wrapper around gdk_cairo_set_source_pixbuf(). func GdkCairoSetSourcePixBuf(cr *cairo.Context, pixbuf *gdk.Pixbuf, pixbufX, pixbufY float64) { context := (*C.cairo_t)(unsafe.Pointer(cr.Native())) ptr := (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native())) C.gdk_cairo_set_source_pixbuf(context, ptr, C.gdouble(pixbufX), C.gdouble(pixbufY)) } /* * GtkCssProvider */ // CssProvider is a representation of GTK's GtkCssProvider. type CssProvider struct { *glib.Object } func (v *CssProvider) toStyleProvider() *C.GtkStyleProvider { if v == nil { return nil } return C.toGtkStyleProvider(unsafe.Pointer(v.native())) } // native returns a pointer to the underlying GtkCssProvider. func (v *CssProvider) native() *C.GtkCssProvider { if v == nil || v.Object == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkCssProvider(p) } func wrapCssProvider(obj *glib.Object) *CssProvider { if obj == nil { return nil } return &CssProvider{obj} } // CssProviderNew is a wrapper around gtk_css_provider_new(). func CssProviderNew() (*CssProvider, error) { c := C.gtk_css_provider_new() if c == nil { return nil, nilPtrErr } return wrapCssProvider(glib.Take(unsafe.Pointer(c))), nil } // LoadFromPath is a wrapper around gtk_css_provider_load_from_path(). func (v *CssProvider) LoadFromPath(path string) error { cpath := C.CString(path) defer C.free(unsafe.Pointer(cpath)) var gerr *C.GError if C.gtk_css_provider_load_from_path(v.native(), (*C.gchar)(cpath), &gerr) == 0 { defer C.g_error_free(gerr) return errors.New(goString(gerr.message)) } return nil } // LoadFromData is a wrapper around gtk_css_provider_load_from_data(). func (v *CssProvider) LoadFromData(data string) error { cdata := C.CString(data) defer C.free(unsafe.Pointer(cdata)) var gerr *C.GError if C.gtk_css_provider_load_from_data(v.native(), (*C.gchar)(unsafe.Pointer(cdata)), C.gssize(len(data)), &gerr) == 0 { defer C.g_error_free(gerr) return errors.New(goString(gerr.message)) } return nil } // ToString is a wrapper around gtk_css_provider_to_string(). func (v *CssProvider) ToString() (string, error) { c := C.gtk_css_provider_to_string(v.native()) if c == nil { return "", nilPtrErr } return C.GoString(c), nil } // CssProviderGetNamed is a wrapper around gtk_css_provider_get_named(). func CssProviderGetNamed(name string, variant string) (*CssProvider, error) { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) cvariant := C.CString(variant) defer C.free(unsafe.Pointer(cvariant)) c := C.gtk_css_provider_get_named((*C.gchar)(cname), (*C.gchar)(cvariant)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCssProvider(obj), nil } /* * GtkDialog */ // Dialog is a representation of GTK's GtkDialog. type Dialog struct { Window } // native returns a pointer to the underlying GtkDialog. func (v *Dialog) native() *C.GtkDialog { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkDialog(p) } func marshalDialog(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapDialog(obj), nil } func wrapDialog(obj *glib.Object) *Dialog { if obj == nil { return nil } return &Dialog{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} } // DialogNew() is a wrapper around gtk_dialog_new(). func DialogNew() (*Dialog, error) { c := C.gtk_dialog_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapDialog(obj), nil } // Run() is a wrapper around gtk_dialog_run(). func (v *Dialog) Run() ResponseType { c := C.gtk_dialog_run(v.native()) return ResponseType(c) } // Response() is a wrapper around gtk_dialog_response(). func (v *Dialog) Response(response ResponseType) { C.gtk_dialog_response(v.native(), C.gint(response)) } // AddButton() is a wrapper around gtk_dialog_add_button(). text may // be either the literal button text, or if using GTK 3.8 or earlier, a // Stock type converted to a string. func (v *Dialog) AddButton(text string, id ResponseType) (*Button, error) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_dialog_add_button(v.native(), (*C.gchar)(cstr), C.gint(id)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapButton(obj), nil } // TODO: // gtk_dialog_add_buttons(). // AddActionWidget() is a wrapper around gtk_dialog_add_action_widget(). func (v *Dialog) AddActionWidget(child IWidget, id ResponseType) { C.gtk_dialog_add_action_widget(v.native(), child.toWidget(), C.gint(id)) } // SetDefaultResponse() is a wrapper around gtk_dialog_set_default_response(). func (v *Dialog) SetDefaultResponse(id ResponseType) { C.gtk_dialog_set_default_response(v.native(), C.gint(id)) } // SetResponseSensitive() is a wrapper around gtk_dialog_set_response_sensitive(). func (v *Dialog) SetResponseSensitive(id ResponseType, setting bool) { C.gtk_dialog_set_response_sensitive(v.native(), C.gint(id), gbool(setting)) } // GetResponseForWidget is a wrapper around gtk_dialog_get_response_for_widget(). func (v *Dialog) GetResponseForWidget(widget IWidget) ResponseType { c := C.gtk_dialog_get_response_for_widget(v.native(), widget.toWidget()) return ResponseType(c) } // GetWidgetForResponse is a wrapper around gtk_dialog_get_widget_for_response(). func (v *Dialog) GetWidgetForResponse(id ResponseType) (IWidget, error) { c := C.gtk_dialog_get_widget_for_response(v.native(), C.gint(id)) if c == nil { return nil, nil } return castWidget(c) } // GetContentArea() is a wrapper around gtk_dialog_get_content_area(). func (v *Dialog) GetContentArea() (*Box, error) { c := C.gtk_dialog_get_content_area(v.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) b := &Box{Container{Widget{glib.InitiallyUnowned{obj}}}} return b, nil } // DialogNewWithButtons() is a wrapper around gtk_dialog_new_with_buttons(). // i.e: []interface{}{"Accept", gtk.RESPONSE_ACCEPT}. func DialogNewWithButtons(title string, parent IWindow, flags DialogFlags, buttons ...[]interface{}) (dialog *Dialog, err error) { cstr := (*C.gchar)(C.CString(title)) defer C.free(unsafe.Pointer(cstr)) var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } var cbutton *C.gchar = nil c := C._gtk_dialog_new_with_buttons(cstr, w, C.GtkDialogFlags(flags), cbutton) if c == nil { return nil, nilPtrErr } dialog = wrapDialog(glib.Take(unsafe.Pointer(c))) for idx := 0; idx < len(buttons); idx++ { cbutton = (*C.gchar)(C.CString(buttons[idx][0].(string))) defer C.free(unsafe.Pointer(cbutton)) if C.gtk_dialog_add_button(dialog.native(), cbutton, C.gint(buttons[idx][1].(ResponseType))) == nil { return nil, nilPtrErr } } return } /* * GtkDrawingArea */ // DrawingArea is a representation of GTK's GtkDrawingArea. type DrawingArea struct { Widget } // native returns a pointer to the underlying GtkDrawingArea. func (v *DrawingArea) native() *C.GtkDrawingArea { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkDrawingArea(p) } func marshalDrawingArea(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapDrawingArea(obj), nil } func wrapDrawingArea(obj *glib.Object) *DrawingArea { if obj == nil { return nil } return &DrawingArea{Widget{glib.InitiallyUnowned{obj}}} } // DrawingAreaNew is a wrapper around gtk_drawing_area_new(). func DrawingAreaNew() (*DrawingArea, error) { c := C.gtk_drawing_area_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapDrawingArea(obj), nil } /* * GtkEditable */ // Editable is a representation of GTK's GtkEditable GInterface. type Editable struct { *glib.Object } // IEditable is an interface type implemented by all structs // embedding an Editable. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkEditable. type IEditable interface { toEditable() *C.GtkEditable } // native() returns a pointer to the underlying GObject as a GtkEditable. func (v *Editable) native() *C.GtkEditable { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkEditable(p) } func marshalEditable(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapEditable(obj), nil } func wrapEditable(obj *glib.Object) *Editable { if obj == nil { return nil } return &Editable{obj} } func (v *Editable) toEditable() *C.GtkEditable { if v == nil { return nil } return v.native() } // SelectRegion is a wrapper around gtk_editable_select_region(). func (v *Editable) SelectRegion(startPos, endPos int) { C.gtk_editable_select_region(v.native(), C.gint(startPos), C.gint(endPos)) } // GetSelectionBounds is a wrapper around gtk_editable_get_selection_bounds(). func (v *Editable) GetSelectionBounds() (start, end int, nonEmpty bool) { var cstart, cend C.gint c := C.gtk_editable_get_selection_bounds(v.native(), &cstart, &cend) return int(cstart), int(cend), gobool(c) } // InsertText is a wrapper around gtk_editable_insert_text(). The returned // int is the position after the inserted text. func (v *Editable) InsertText(newText string, position int) int { cstr := C.CString(newText) defer C.free(unsafe.Pointer(cstr)) pos := new(C.gint) *pos = C.gint(position) C.gtk_editable_insert_text(v.native(), (*C.gchar)(cstr), C.gint(len(newText)), pos) return int(*pos) } // DeleteText is a wrapper around gtk_editable_delete_text(). func (v *Editable) DeleteText(startPos, endPos int) { C.gtk_editable_delete_text(v.native(), C.gint(startPos), C.gint(endPos)) } // GetChars is a wrapper around gtk_editable_get_chars(). func (v *Editable) GetChars(startPos, endPos int) string { c := C.gtk_editable_get_chars(v.native(), C.gint(startPos), C.gint(endPos)) defer C.free(unsafe.Pointer(c)) return goString(c) } // CutClipboard is a wrapper around gtk_editable_cut_clipboard(). func (v *Editable) CutClipboard() { C.gtk_editable_cut_clipboard(v.native()) } // CopyClipboard is a wrapper around gtk_editable_copy_clipboard(). func (v *Editable) CopyClipboard() { C.gtk_editable_copy_clipboard(v.native()) } // PasteClipboard is a wrapper around gtk_editable_paste_clipboard(). func (v *Editable) PasteClipboard() { C.gtk_editable_paste_clipboard(v.native()) } // DeleteSelection is a wrapper around gtk_editable_delete_selection(). func (v *Editable) DeleteSelection() { C.gtk_editable_delete_selection(v.native()) } // SetPosition is a wrapper around gtk_editable_set_position(). func (v *Editable) SetPosition(position int) { C.gtk_editable_set_position(v.native(), C.gint(position)) } // GetPosition is a wrapper around gtk_editable_get_position(). func (v *Editable) GetPosition() int { c := C.gtk_editable_get_position(v.native()) return int(c) } // SetEditable is a wrapper around gtk_editable_set_editable(). func (v *Editable) SetEditable(isEditable bool) { C.gtk_editable_set_editable(v.native(), gbool(isEditable)) } // GetEditable is a wrapper around gtk_editable_get_editable(). func (v *Editable) GetEditable() bool { c := C.gtk_editable_get_editable(v.native()) return gobool(c) } /* * GtkEntry */ // Entry is a representation of GTK's GtkEntry. type Entry struct { Widget // Interfaces Editable CellEditable } type IEntry interface { toEntry() *C.GtkEntry } func (v *Entry) toEntry() *C.GtkEntry { return v.native() } // native returns a pointer to the underlying GtkEntry. func (v *Entry) native() *C.GtkEntry { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkEntry(p) } func marshalEntry(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapEntry(obj), nil } func wrapEntry(obj *glib.Object) *Entry { if obj == nil { return nil } e := wrapEditable(obj) ce := wrapCellEditable(obj) return &Entry{Widget{glib.InitiallyUnowned{obj}}, *e, *ce} } // EntryNew() is a wrapper around gtk_entry_new(). func EntryNew() (*Entry, error) { c := C.gtk_entry_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapEntry(obj), nil } // EntryNewWithBuffer() is a wrapper around gtk_entry_new_with_buffer(). func EntryNewWithBuffer(buffer *EntryBuffer) (*Entry, error) { c := C.gtk_entry_new_with_buffer(buffer.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapEntry(obj), nil } // GetBuffer() is a wrapper around gtk_entry_get_buffer(). func (v *Entry) GetBuffer() (*EntryBuffer, error) { c := C.gtk_entry_get_buffer(v.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return &EntryBuffer{obj}, nil } // SetBuffer() is a wrapper around gtk_entry_set_buffer(). func (v *Entry) SetBuffer(buffer *EntryBuffer) { C.gtk_entry_set_buffer(v.native(), buffer.native()) } // SetText() is a wrapper around gtk_entry_set_text(). func (v *Entry) SetText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_entry_set_text(v.native(), (*C.gchar)(cstr)) } // GetText() is a wrapper around gtk_entry_get_text(). func (v *Entry) GetText() (string, error) { c := C.gtk_entry_get_text(v.native()) if c == nil { return "", nilPtrErr } return goString(c), nil } // GetTextLength() is a wrapper around gtk_entry_get_text_length(). func (v *Entry) GetTextLength() uint16 { c := C.gtk_entry_get_text_length(v.native()) return uint16(c) } // GetTextArea is a wrapper around gtk_entry_get_text_area(). func (v *Entry) GetTextArea() *gdk.Rectangle { var cRect *C.GdkRectangle C.gtk_entry_get_text_area(v.native(), cRect) textArea := gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) return textArea } // SetVisibility is a wrapper around gtk_entry_set_visibility(). func (v *Entry) SetVisibility(visible bool) { C.gtk_entry_set_visibility(v.native(), gbool(visible)) } // SetInvisibleChar is a wrapper around gtk_entry_set_invisible_char(). func (v *Entry) SetInvisibleChar(ch rune) { C.gtk_entry_set_invisible_char(v.native(), C.gunichar(ch)) } // UnsetInvisibleChar is a wrapper around gtk_entry_unset_invisible_char(). func (v *Entry) UnsetInvisibleChar() { C.gtk_entry_unset_invisible_char(v.native()) } // SetMaxLength is a wrapper around gtk_entry_set_max_length(). func (v *Entry) SetMaxLength(len int) { C.gtk_entry_set_max_length(v.native(), C.gint(len)) } // GetActivatesDefault is a wrapper around gtk_entry_get_activates_default(). func (v *Entry) GetActivatesDefault() bool { c := C.gtk_entry_get_activates_default(v.native()) return gobool(c) } // GetHasFrame is a wrapper around gtk_entry_get_has_frame(). func (v *Entry) GetHasFrame() bool { c := C.gtk_entry_get_has_frame(v.native()) return gobool(c) } // GetWidthChars is a wrapper around gtk_entry_get_width_chars(). func (v *Entry) GetWidthChars() int { c := C.gtk_entry_get_width_chars(v.native()) return int(c) } // SetActivatesDefault is a wrapper around gtk_entry_set_activates_default(). func (v *Entry) SetActivatesDefault(setting bool) { C.gtk_entry_set_activates_default(v.native(), gbool(setting)) } // SetHasFrame is a wrapper around gtk_entry_set_has_frame(). func (v *Entry) SetHasFrame(setting bool) { C.gtk_entry_set_has_frame(v.native(), gbool(setting)) } // SetWidthChars is a wrapper around gtk_entry_set_width_chars(). func (v *Entry) SetWidthChars(nChars int) { C.gtk_entry_set_width_chars(v.native(), C.gint(nChars)) } // GetInvisibleChar is a wrapper around gtk_entry_get_invisible_char(). func (v *Entry) GetInvisibleChar() rune { c := C.gtk_entry_get_invisible_char(v.native()) return rune(c) } // SetAlignment is a wrapper around gtk_entry_set_alignment(). func (v *Entry) SetAlignment(xalign float32) { C.gtk_entry_set_alignment(v.native(), C.gfloat(xalign)) } // GetAlignment is a wrapper around gtk_entry_get_alignment(). func (v *Entry) GetAlignment() float32 { c := C.gtk_entry_get_alignment(v.native()) return float32(c) } // SetPlaceholderText is a wrapper around gtk_entry_set_placeholder_text(). func (v *Entry) SetPlaceholderText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_entry_set_placeholder_text(v.native(), (*C.gchar)(cstr)) } // GetPlaceholderText is a wrapper around gtk_entry_get_placeholder_text(). func (v *Entry) GetPlaceholderText() (string, error) { c := C.gtk_entry_get_placeholder_text(v.native()) if c == nil { return "", nilPtrErr } return goString(c), nil } // SetOverwriteMode is a wrapper around gtk_entry_set_overwrite_mode(). func (v *Entry) SetOverwriteMode(overwrite bool) { C.gtk_entry_set_overwrite_mode(v.native(), gbool(overwrite)) } // GetOverwriteMode is a wrapper around gtk_entry_get_overwrite_mode(). func (v *Entry) GetOverwriteMode() bool { c := C.gtk_entry_get_overwrite_mode(v.native()) return gobool(c) } // GetLayout is a wrapper around gtk_entry_get_layout(). func (v *Entry) GetLayout() *pango.Layout { c := C.gtk_entry_get_layout(v.native()) return pango.WrapLayout(uintptr(unsafe.Pointer(c))) } // GetLayoutOffsets is a wrapper around gtk_entry_get_layout_offsets(). func (v *Entry) GetLayoutOffsets() (x, y int) { var gx, gy C.gint C.gtk_entry_get_layout_offsets(v.native(), &gx, &gy) return int(gx), int(gy) } // LayoutIndexToTextIndex is a wrapper around gtk_entry_layout_index_to_text_index(). func (v *Entry) LayoutIndexToTextIndex(layoutIndex int) int { c := C.gtk_entry_layout_index_to_text_index(v.native(), C.gint(layoutIndex)) return int(c) } // TextIndexToLayoutIndex is a wrapper around gtk_entry_text_index_to_layout_index(). func (v *Entry) TextIndexToLayoutIndex(textIndex int) int { c := C.gtk_entry_text_index_to_layout_index(v.native(), C.gint(textIndex)) return int(c) } // TODO: depends on PandoAttrList // SetAttributes is a wrapper around gtk_entry_set_attributes(). // func (v *Entry) SetAttributes(attrList *pango.AttrList) { // C.gtk_entry_set_attributes(v.native(), (*C.PangoAttrList)(unsafe.Pointer(attrList.Native()))) // } // TODO: depends on PandoAttrList // GetAttributes is a wrapper around gtk_entry_get_attributes(). // func (v *Entry) GetAttributes() (*pango.AttrList, error) { // c := C.gtk_entry_get_attributes(v.native()) // if c == nil { // return nil, nilPtrErr // } // return &pango.AttrList{unsafe.Pointer(c)}, nil // } // GetMaxLength is a wrapper around gtk_entry_get_max_length(). func (v *Entry) GetMaxLength() int { c := C.gtk_entry_get_max_length(v.native()) return int(c) } // GetVisibility is a wrapper around gtk_entry_get_visibility(). func (v *Entry) GetVisibility() bool { c := C.gtk_entry_get_visibility(v.native()) return gobool(c) } // SetCompletion is a wrapper around gtk_entry_set_completion(). func (v *Entry) SetCompletion(completion *EntryCompletion) { C.gtk_entry_set_completion(v.native(), completion.native()) } // GetCompletion is a wrapper around gtk_entry_get_completion(). func (v *Entry) GetCompletion() (*EntryCompletion, error) { c := C.gtk_entry_get_completion(v.native()) if c == nil { return nil, nilPtrErr } e := &EntryCompletion{glib.Take(unsafe.Pointer(c))} return e, nil } // SetCursorHAdjustment is a wrapper around gtk_entry_set_cursor_hadjustment(). func (v *Entry) SetCursorHAdjustment(adjustment *Adjustment) { C.gtk_entry_set_cursor_hadjustment(v.native(), adjustment.native()) } // GetCursorHAdjustment is a wrapper around gtk_entry_get_cursor_hadjustment(). func (v *Entry) GetCursorHAdjustment() (*Adjustment, error) { c := C.gtk_entry_get_cursor_hadjustment(v.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return &Adjustment{glib.InitiallyUnowned{obj}}, nil } // SetProgressFraction is a wrapper around gtk_entry_set_progress_fraction(). func (v *Entry) SetProgressFraction(fraction float64) { C.gtk_entry_set_progress_fraction(v.native(), C.gdouble(fraction)) } // GetProgressFraction is a wrapper around gtk_entry_get_progress_fraction(). func (v *Entry) GetProgressFraction() float64 { c := C.gtk_entry_get_progress_fraction(v.native()) return float64(c) } // SetProgressPulseStep is a wrapper around gtk_entry_set_progress_pulse_step(). func (v *Entry) SetProgressPulseStep(fraction float64) { C.gtk_entry_set_progress_pulse_step(v.native(), C.gdouble(fraction)) } // GetProgressPulseStep is a wrapper around gtk_entry_get_progress_pulse_step(). func (v *Entry) GetProgressPulseStep() float64 { c := C.gtk_entry_get_progress_pulse_step(v.native()) return float64(c) } // ProgressPulse is a wrapper around gtk_entry_progress_pulse(). func (v *Entry) ProgressPulse() { C.gtk_entry_progress_pulse(v.native()) } // IMContextFilterKeypress is a wrapper around gtk_entry_im_context_filter_keypress(). func (v *Entry) IMContextFilterKeypress(eventKey *gdk.EventKey) bool { key := (*C.GdkEventKey)(unsafe.Pointer(eventKey.Native())) c := C.gtk_entry_im_context_filter_keypress(v.native(), key) return gobool(c) } // ResetIMContext is a wrapper around gtk_entry_reset_im_context(). func (v *Entry) ResetIMContext() { C.gtk_entry_reset_im_context(v.native()) } // SetIconFromPixbuf is a wrapper around gtk_entry_set_icon_from_pixbuf(). func (v *Entry) SetIconFromPixbuf(iconPos EntryIconPosition, pixbuf *gdk.Pixbuf) { var pb *C.GdkPixbuf if pixbuf != nil { pb = (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native())) } C.gtk_entry_set_icon_from_pixbuf(v.native(), C.GtkEntryIconPosition(iconPos), pb) } // SetIconFromIconName is a wrapper around gtk_entry_set_icon_from_icon_name(). func (v *Entry) SetIconFromIconName(iconPos EntryIconPosition, name string) { var icon *C.gchar if name != "" { n := C.CString(name) defer C.free(unsafe.Pointer(n)) icon = (*C.gchar)(n) } C.gtk_entry_set_icon_from_icon_name(v.native(), C.GtkEntryIconPosition(iconPos), icon) } // RemoveIcon is a convenience func to set a nil pointer to the icon name. func (v *Entry) RemoveIcon(iconPos EntryIconPosition) { C.gtk_entry_set_icon_from_icon_name(v.native(), C.GtkEntryIconPosition(iconPos), nil) } // TODO: Needs gio/GIcon implemented first // SetIconFromGIcon is a wrapper around gtk_entry_set_icon_from_gicon(). func (v *Entry) SetIconFromGIcon(iconPos EntryIconPosition, icon *glib.Icon) { C.gtk_entry_set_icon_from_gicon(v.native(), C.GtkEntryIconPosition(iconPos), (*C.GIcon)(icon.NativePrivate())) } // GetIconStorageType is a wrapper around gtk_entry_get_icon_storage_type(). func (v *Entry) GetIconStorageType(iconPos EntryIconPosition) ImageType { c := C.gtk_entry_get_icon_storage_type(v.native(), C.GtkEntryIconPosition(iconPos)) return ImageType(c) } // GetIconPixbuf is a wrapper around gtk_entry_get_icon_pixbuf(). func (v *Entry) GetIconPixbuf(iconPos EntryIconPosition) (*gdk.Pixbuf, error) { c := C.gtk_entry_get_icon_pixbuf(v.native(), C.GtkEntryIconPosition(iconPos)) if c == nil { return nil, nilPtrErr } return &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))}, nil } // GetIconName is a wrapper around gtk_entry_get_icon_name(). func (v *Entry) GetIconName(iconPos EntryIconPosition) (string, error) { c := C.gtk_entry_get_icon_name(v.native(), C.GtkEntryIconPosition(iconPos)) if c == nil { return "", nilPtrErr } return goString(c), nil } // GetIconGIcon is a wrapper around gtk_entry_get_icon_gicon(). func (v *Entry) GetIconGIcon(iconPos EntryIconPosition) (*glib.Icon, error) { c := C.gtk_entry_get_icon_gicon(v.native(), C.GtkEntryIconPosition(iconPos)) if c == nil { return nil, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} i := &glib.Icon{obj} runtime.SetFinalizer(i, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return i, nil } // SetIconActivatable is a wrapper around gtk_entry_set_icon_activatable(). func (v *Entry) SetIconActivatable(iconPos EntryIconPosition, activatable bool) { C.gtk_entry_set_icon_activatable(v.native(), C.GtkEntryIconPosition(iconPos), gbool(activatable)) } // GetIconActivatable is a wrapper around gtk_entry_get_icon_activatable(). func (v *Entry) GetIconActivatable(iconPos EntryIconPosition) bool { c := C.gtk_entry_get_icon_activatable(v.native(), C.GtkEntryIconPosition(iconPos)) return gobool(c) } // SetIconSensitive is a wrapper around gtk_entry_set_icon_sensitive(). func (v *Entry) SetIconSensitive(iconPos EntryIconPosition, sensitive bool) { C.gtk_entry_set_icon_sensitive(v.native(), C.GtkEntryIconPosition(iconPos), gbool(sensitive)) } // GetIconSensitive is a wrapper around gtk_entry_get_icon_sensitive(). func (v *Entry) GetIconSensitive(iconPos EntryIconPosition) bool { c := C.gtk_entry_get_icon_sensitive(v.native(), C.GtkEntryIconPosition(iconPos)) return gobool(c) } // GetIconAtPos is a wrapper around gtk_entry_get_icon_at_pos(). func (v *Entry) GetIconAtPos(x, y int) int { c := C.gtk_entry_get_icon_at_pos(v.native(), C.gint(x), C.gint(y)) return int(c) } // SetIconTooltipText is a wrapper around gtk_entry_set_icon_tooltip_text(). func (v *Entry) SetIconTooltipText(iconPos EntryIconPosition, tooltip string) { var text *C.gchar if tooltip != "" { cstr := C.CString(tooltip) defer C.free(unsafe.Pointer(cstr)) text = cstr } C.gtk_entry_set_icon_tooltip_text(v.native(), C.GtkEntryIconPosition(iconPos), text) } // GetIconTooltipText is a wrapper around gtk_entry_get_icon_tooltip_text(). func (v *Entry) GetIconTooltipText(iconPos EntryIconPosition) (string, error) { c := C.gtk_entry_get_icon_tooltip_text(v.native(), C.GtkEntryIconPosition(iconPos)) if c == nil { return "", nilPtrErr } return goString(c), nil } // SetIconTooltipMarkup is a wrapper around gtk_entry_set_icon_tooltip_markup(). func (v *Entry) SetIconTooltipMarkup(iconPos EntryIconPosition, tooltip string) { var text *C.gchar if tooltip != "" { cstr := C.CString(tooltip) defer C.free(unsafe.Pointer(cstr)) text = cstr } C.gtk_entry_set_icon_tooltip_markup(v.native(), C.GtkEntryIconPosition(iconPos), text) } // GetIconTooltipMarkup is a wrapper around gtk_entry_get_icon_tooltip_markup(). func (v *Entry) GetIconTooltipMarkup(iconPos EntryIconPosition) (string, error) { c := C.gtk_entry_get_icon_tooltip_markup(v.native(), C.GtkEntryIconPosition(iconPos)) if c == nil { return "", nilPtrErr } return goString(c), nil } // TODO: depends on GtkTargetList // SetIconDragSource is a wrapper around gtk_entry_set_icon_drag_source(). // func (v *Entry) SetIconDragSource(iconPos EntryIconPosition, targetList *TargetList, action gdk.DragAction) { // C.gtk_entry_set_icon_drag_source(v.native(), C.GtkEntryIconPosition(iconPos), // targetList.native(), C.GdkDragAction(action)) // } // GetCurrentIconDragSource is a wrapper around gtk_entry_get_current_icon_drag_source(). func (v *Entry) GetCurrentIconDragSource() int { c := C.gtk_entry_get_current_icon_drag_source(v.native()) return int(c) } // GetIconArea is a wrapper around gtk_entry_get_icon_area(). func (v *Entry) GetIconArea(iconPos EntryIconPosition) *gdk.Rectangle { var cRect *C.GdkRectangle C.gtk_entry_get_icon_area(v.native(), C.GtkEntryIconPosition(iconPos), cRect) iconArea := gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) return iconArea } // SetInputPurpose is a wrapper around gtk_entry_set_input_purpose(). func (v *Entry) SetInputPurpose(purpose InputPurpose) { C.gtk_entry_set_input_purpose(v.native(), C.GtkInputPurpose(purpose)) } // GetInputPurpose is a wrapper around gtk_entry_get_input_purpose(). func (v *Entry) GetInputPurpose() InputPurpose { c := C.gtk_entry_get_input_purpose(v.native()) return InputPurpose(c) } // SetInputHints is a wrapper around gtk_entry_set_input_hints(). func (v *Entry) SetInputHints(hints InputHints) { C.gtk_entry_set_input_hints(v.native(), C.GtkInputHints(hints)) } // GetInputHints is a wrapper around gtk_entry_get_input_hints(). func (v *Entry) GetInputHints() InputHints { c := C.gtk_entry_get_input_hints(v.native()) return InputHints(c) } /* * GtkEntryBuffer */ // EntryBuffer is a representation of GTK's GtkEntryBuffer. type EntryBuffer struct { *glib.Object } // native returns a pointer to the underlying GtkEntryBuffer. func (v *EntryBuffer) native() *C.GtkEntryBuffer { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkEntryBuffer(p) } func marshalEntryBuffer(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapEntryBuffer(obj), nil } func wrapEntryBuffer(obj *glib.Object) *EntryBuffer { if obj == nil { return nil } return &EntryBuffer{obj} } // EntryBufferNew() is a wrapper around gtk_entry_buffer_new(). func EntryBufferNew(initialChars string, nInitialChars int) (*EntryBuffer, error) { cstr := C.CString(initialChars) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_entry_buffer_new((*C.gchar)(cstr), C.gint(nInitialChars)) if c == nil { return nil, nilPtrErr } e := wrapEntryBuffer(glib.Take(unsafe.Pointer(c))) return e, nil } // GetText() is a wrapper around gtk_entry_buffer_get_text(). A // non-nil error is returned in the case that gtk_entry_buffer_get_text // returns NULL to differentiate between NULL and an empty string. func (v *EntryBuffer) GetText() (string, error) { c := C.gtk_entry_buffer_get_text(v.native()) if c == nil { return "", nilPtrErr } return goString(c), nil } // SetText() is a wrapper around gtk_entry_buffer_set_text(). func (v *EntryBuffer) SetText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_entry_buffer_set_text(v.native(), (*C.gchar)(cstr), C.gint(len(text))) } // GetBytes() is a wrapper around gtk_entry_buffer_get_bytes(). func (v *EntryBuffer) GetBytes() uint { c := C.gtk_entry_buffer_get_bytes(v.native()) return uint(c) } // GetLength() is a wrapper around gtk_entry_buffer_get_length(). func (v *EntryBuffer) GetLength() uint { c := C.gtk_entry_buffer_get_length(v.native()) return uint(c) } // GetMaxLength() is a wrapper around gtk_entry_buffer_get_max_length(). func (v *EntryBuffer) GetMaxLength() int { c := C.gtk_entry_buffer_get_max_length(v.native()) return int(c) } // SetMaxLength() is a wrapper around gtk_entry_buffer_set_max_length(). func (v *EntryBuffer) SetMaxLength(maxLength int) { C.gtk_entry_buffer_set_max_length(v.native(), C.gint(maxLength)) } // InsertText() is a wrapper around gtk_entry_buffer_insert_text(). func (v *EntryBuffer) InsertText(position uint, text string) uint { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_entry_buffer_insert_text(v.native(), C.guint(position), (*C.gchar)(cstr), C.gint(len(text))) return uint(c) } // DeleteText() is a wrapper around gtk_entry_buffer_delete_text(). func (v *EntryBuffer) DeleteText(position uint, nChars int) uint { c := C.gtk_entry_buffer_delete_text(v.native(), C.guint(position), C.gint(nChars)) return uint(c) } // EmitDeletedText() is a wrapper around gtk_entry_buffer_emit_deleted_text(). func (v *EntryBuffer) EmitDeletedText(pos, nChars uint) { C.gtk_entry_buffer_emit_deleted_text(v.native(), C.guint(pos), C.guint(nChars)) } // EmitInsertedText() is a wrapper around gtk_entry_buffer_emit_inserted_text(). func (v *EntryBuffer) EmitInsertedText(pos uint, text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_entry_buffer_emit_inserted_text(v.native(), C.guint(pos), (*C.gchar)(cstr), C.guint(len(text))) } /* * GtkEntryCompletion */ // EntryCompletion is a representation of GTK's GtkEntryCompletion. type EntryCompletion struct { *glib.Object } // native returns a pointer to the underlying GtkEntryCompletion. func (v *EntryCompletion) native() *C.GtkEntryCompletion { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkEntryCompletion(p) } func marshalEntryCompletion(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapEntryCompletion(obj), nil } func wrapEntryCompletion(obj *glib.Object) *EntryCompletion { if obj == nil { return nil } return &EntryCompletion{obj} } // TODO: // GtkEntryCompletionMatchFunc // EntryCompletionNew is a wrapper around gtk_entry_completion_new func EntryCompletionNew() (*EntryCompletion, error) { c := C.gtk_entry_completion_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapEntryCompletion(obj), nil } // TODO: // gtk_entry_completion_new_with_area(). // gtk_entry_completion_get_entry(). // SetModel is a wrapper around gtk_entry_completion_set_model func (v *EntryCompletion) SetModel(model ITreeModel) { var mptr *C.GtkTreeModel if model != nil { mptr = model.toTreeModel() } C.gtk_entry_completion_set_model(v.native(), mptr) } // GetModel is a wrapper around gtk_entry_completion_get_model func (v *EntryCompletion) GetModel() (ITreeModel, error) { c := C.gtk_entry_completion_get_model(v.native()) if c == nil { return nil, nilPtrErr } return castTreeModel(c) } // TODO: // gtk_entry_completion_set_match_func(). // SetMinimumKeyLength is a wrapper around gtk_entry_completion_set_minimum_key_length func (v *EntryCompletion) SetMinimumKeyLength(minimumLength int) { C.gtk_entry_completion_set_minimum_key_length(v.native(), C.gint(minimumLength)) } // GetMinimumKeyLength is a wrapper around gtk_entry_completion_get_minimum_key_length func (v *EntryCompletion) GetMinimumKeyLength() int { c := C.gtk_entry_completion_get_minimum_key_length(v.native()) return int(c) } // TODO: // gtk_entry_completion_compute_prefix(). // gtk_entry_completion_complete(). // gtk_entry_completion_get_completion_prefix(). // gtk_entry_completion_insert_prefix(). // gtk_entry_completion_insert_action_text(). // gtk_entry_completion_insert_action_markup(). // gtk_entry_completion_delete_action(). // SetTextColumn is a wrapper around gtk_entry_completion_set_text_column func (v *EntryCompletion) SetTextColumn(textColumn int) { C.gtk_entry_completion_set_text_column(v.native(), C.gint(textColumn)) } // GetTextColumn is a wrapper around gtk_entry_completion_get_text_column func (v *EntryCompletion) GetTextColumn() int { c := C.gtk_entry_completion_get_text_column(v.native()) return int(c) } // SetInlineCompletion is a wrapper around gtk_entry_completion_set_inline_completion func (v *EntryCompletion) SetInlineCompletion(inlineCompletion bool) { C.gtk_entry_completion_set_inline_completion(v.native(), gbool(inlineCompletion)) } // GetInlineCompletion is a wrapper around gtk_entry_completion_get_inline_completion func (v *EntryCompletion) GetInlineCompletion() bool { c := C.gtk_entry_completion_get_inline_completion(v.native()) return gobool(c) } // TODO // gtk_entry_completion_set_inline_selection(). // gtk_entry_completion_get_inline_selection(). // SetPopupCompletion is a wrapper around gtk_entry_completion_set_popup_completion func (v *EntryCompletion) SetPopupCompletion(popupCompletion bool) { C.gtk_entry_completion_set_popup_completion(v.native(), gbool(popupCompletion)) } // GetPopupCompletion is a wrapper around gtk_entry_completion_get_popup_completion func (v *EntryCompletion) GetPopupCompletion() bool { c := C.gtk_entry_completion_get_popup_completion(v.native()) return gobool(c) } // SetPopupSetWidth is a wrapper around gtk_entry_completion_set_popup_set_width func (v *EntryCompletion) SetPopupSetWidth(popupSetWidth bool) { C.gtk_entry_completion_set_popup_set_width(v.native(), gbool(popupSetWidth)) } // GetPopupSetWidth is a wrapper around gtk_entry_completion_get_popup_set_width func (v *EntryCompletion) GetPopupSetWidth() bool { c := C.gtk_entry_completion_get_popup_set_width(v.native()) return gobool(c) } // TODO: // gtk_entry_completion_set_popup_single_match(). // gtk_entry_completion_get_popup_single_match(). /* * GtkEventBox */ // EventBox is a representation of GTK's GtkEventBox. type EventBox struct { Bin } // native returns a pointer to the underlying GtkEventBox. func (v *EventBox) native() *C.GtkEventBox { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkEventBox(p) } func marshalEventBox(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapEventBox(obj), nil } func wrapEventBox(obj *glib.Object) *EventBox { if obj == nil { return nil } return &EventBox{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // EventBoxNew is a wrapper around gtk_event_box_new(). func EventBoxNew() (*EventBox, error) { c := C.gtk_event_box_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapEventBox(obj), nil } // SetAboveChild is a wrapper around gtk_event_box_set_above_child(). func (v *EventBox) SetAboveChild(aboveChild bool) { C.gtk_event_box_set_above_child(v.native(), gbool(aboveChild)) } // GetAboveChild is a wrapper around gtk_event_box_get_above_child(). func (v *EventBox) GetAboveChild() bool { c := C.gtk_event_box_get_above_child(v.native()) return gobool(c) } // SetVisibleWindow is a wrapper around gtk_event_box_set_visible_window(). func (v *EventBox) SetVisibleWindow(visibleWindow bool) { C.gtk_event_box_set_visible_window(v.native(), gbool(visibleWindow)) } // GetVisibleWindow is a wrapper around gtk_event_box_get_visible_window(). func (v *EventBox) GetVisibleWindow() bool { c := C.gtk_event_box_get_visible_window(v.native()) return gobool(c) } /* * GtkExpander */ // Expander is a representation of GTK's GtkExpander. type Expander struct { Bin } // native returns a pointer to the underlying GtkExpander. func (v *Expander) native() *C.GtkExpander { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkExpander(p) } func marshalExpander(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapExpander(obj), nil } func wrapExpander(obj *glib.Object) *Expander { if obj == nil { return nil } return &Expander{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // ExpanderNew is a wrapper around gtk_expander_new(). func ExpanderNew(label string) (*Expander, error) { var cstr *C.gchar if label != "" { cstr = (*C.gchar)(C.CString(label)) defer C.free(unsafe.Pointer(cstr)) } c := C.gtk_expander_new(cstr) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapExpander(obj), nil } // TODO: // gtk_expander_new_with_mnemonic(). // SetExpanded is a wrapper around gtk_expander_set_expanded(). func (v *Expander) SetExpanded(expanded bool) { C.gtk_expander_set_expanded(v.native(), gbool(expanded)) } // GetExpanded is a wrapper around gtk_expander_get_expanded(). func (v *Expander) GetExpanded() bool { c := C.gtk_expander_get_expanded(v.native()) return gobool(c) } // SetLabel is a wrapper around gtk_expander_set_label(). func (v *Expander) SetLabel(label string) { var cstr *C.char if label != "" { cstr = C.CString(label) defer C.free(unsafe.Pointer(cstr)) } C.gtk_expander_set_label(v.native(), (*C.gchar)(cstr)) } // GetLabel is a wrapper around gtk_expander_get_label(). func (v *Expander) GetLabel() string { c := C.gtk_expander_get_label(v.native()) return goString(c) } // TODO: // gtk_expander_set_use_underline(). // gtk_expander_get_use_underline(). // gtk_expander_set_use_markup(). // gtk_expander_get_use_markup(). // SetLabelWidget is a wrapper around gtk_expander_set_label_widget(). func (v *Expander) SetLabelWidget(widget IWidget) { C.gtk_expander_set_label_widget(v.native(), widget.toWidget()) } // TODO: // gtk_expander_get_label_widget(). // gtk_expander_set_label_fill(). // gtk_expander_get_label_fill(). // gtk_expander_set_resize_toplevel(). // gtk_expander_get_resize_toplevel(). /* * GtkFileChooser */ // FileChoser is a representation of GTK's GtkFileChooser GInterface. type FileChooser struct { *glib.Object } // native returns a pointer to the underlying GObject as a GtkFileChooser. func (v *FileChooser) native() *C.GtkFileChooser { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFileChooser(p) } func marshalFileChooser(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFileChooser(obj), nil } func wrapFileChooser(obj *glib.Object) *FileChooser { if obj == nil { return nil } return &FileChooser{obj} } // SetFilename is a wrapper around gtk_file_chooser_set_filename(). func (v *FileChooser) SetFilename(filename string) bool { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_file_chooser_set_filename(v.native(), cstr) return gobool(c) } // GetFilename is a wrapper around gtk_file_chooser_get_filename(). func (v *FileChooser) GetFilename() string { c := C.gtk_file_chooser_get_filename(v.native()) s := goString(c) defer C.g_free((C.gpointer)(c)) return s } // SelectFilename is a wrapper around gtk_file_chooser_select_filename(). func (v *FileChooser) SelectFilename(filename string) bool { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_file_chooser_select_filename(v.native(), cstr) return gobool(c) } // UnselectFilename is a wrapper around gtk_file_chooser_unselect_filename(). func (v *FileChooser) UnselectFilename(filename string) { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) C.gtk_file_chooser_unselect_filename(v.native(), cstr) } // SelectAll is a wrapper around gtk_file_chooser_select_all(). func (v *FileChooser) SelectAll() { C.gtk_file_chooser_select_all(v.native()) } // UnselectAll is a wrapper around gtk_file_chooser_unselect_all(). func (v *FileChooser) UnselectAll() { C.gtk_file_chooser_unselect_all(v.native()) } // GetFilenames is a wrapper around gtk_file_chooser_get_filenames(). func (v *FileChooser) GetFilenames() ([]string, error) { clist := C.gtk_file_chooser_get_filenames(v.native()) if clist == nil { return nil, nilPtrErr } slist := glib.WrapSList(uintptr(unsafe.Pointer(clist))) defer slist.Free() var filenames = make([]string, 0, slist.Length()) for ; slist.DataRaw() != nil; slist = slist.Next() { w := (*C.char)(slist.DataRaw()) defer C.free(unsafe.Pointer(w)) filenames = append(filenames, C.GoString(w)) } return filenames, nil } // GetURIs is a wrapper around gtk_file_chooser_get_uris(). func (v FileChooser) GetURIs() ([]string, error) { // TODO: do the same as in (v *FileChooser) GetFilenames() clist := C.gtk_file_chooser_get_uris(v.native()) if clist == nil { return nil, nilPtrErr } slist := glib.WrapSList(uintptr(unsafe.Pointer(clist))) defer slist.Free() var uris = make([]string, 0, slist.Length()) for ; slist.DataRaw() != nil; slist = slist.Next() { w := (*C.char)(slist.DataRaw()) defer C.free(unsafe.Pointer(w)) uris = append(uris, C.GoString(w)) } return uris, nil } // SetDoOverwriteConfirmation is a wrapper around gtk_file_chooser_set_do_overwrite_confirmation(). func (v *FileChooser) SetDoOverwriteConfirmation(value bool) { C.gtk_file_chooser_set_do_overwrite_confirmation(v.native(), gbool(value)) } // GetDoOverwriteConfirmation is a wrapper around gtk_file_chooser_get_do_overwrite_confirmation(). func (v *FileChooser) GetDoOverwriteConfirmation() bool { c := C.gtk_file_chooser_get_do_overwrite_confirmation(v.native()) return gobool(c) } // SetAction is a wrapper around gtk_file_chooser_set_action(). func (v *FileChooser) SetAction(action FileChooserAction) { C.gtk_file_chooser_set_action(v.native(), C.GtkFileChooserAction(action)) } // GetAction is a wrapper around gtk_file_chooser_get_action(). func (v *FileChooser) GetAction() FileChooserAction { return FileChooserAction(C.gtk_file_chooser_get_action(v.native())) } // SetCreateFolders is a wrapper around gtk_file_chooser_set_create_folders(). func (v *FileChooser) SetCreateFolders(value bool) { C.gtk_file_chooser_set_create_folders(v.native(), gbool(value)) } // GetCreateFolders is a wrapper around gtk_file_chooser_get_create_folders(). func (v *FileChooser) GetCreateFolders() bool { c := C.gtk_file_chooser_get_create_folders(v.native()) return gobool(c) } // SetCurrentName is a wrapper around gtk_file_chooser_set_current_name(). func (v *FileChooser) SetCurrentName(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_file_chooser_set_current_name(v.native(), (*C.gchar)(cstr)) return } // SetCurrentFolder is a wrapper around gtk_file_chooser_set_current_folder(). func (v *FileChooser) SetCurrentFolder(folder string) bool { cstr := C.CString(folder) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_file_chooser_set_current_folder(v.native(), (*C.gchar)(cstr)) return gobool(c) } // GetCurrentFolder is a wrapper around gtk_file_chooser_get_current_folder(). func (v *FileChooser) GetCurrentFolder() (string, error) { c := C.gtk_file_chooser_get_current_folder(v.native()) if c == nil { return "", nilPtrErr } defer C.free(unsafe.Pointer(c)) return goString(c), nil } // SetPreviewWidget is a wrapper around gtk_file_chooser_set_preview_widget(). func (v *FileChooser) SetPreviewWidget(widget IWidget) { C.gtk_file_chooser_set_preview_widget(v.native(), widget.toWidget()) } // GetPreviewWidget is a wrapper around gtk_file_chooser_get_preview_widget(). func (v *FileChooser) GetPreviewWidget() (IWidget, error) { c := C.gtk_file_chooser_get_preview_widget(v.native()) if c == nil { return nil, nilPtrErr } return castWidget(c) } // SetPreviewWidgetActive is a wrapper around gtk_file_chooser_set_preview_widget_active(). func (v *FileChooser) SetPreviewWidgetActive(active bool) { C.gtk_file_chooser_set_preview_widget_active(v.native(), gbool(active)) } // GetPreviewWidgetActive is a wrapper around gtk_file_chooser_get_preview_widget_active(). func (v *FileChooser) GetPreviewWidgetActive() bool { c := C.gtk_file_chooser_get_preview_widget_active(v.native()) return gobool(c) } // GetPreviewFilename is a wrapper around gtk_file_chooser_get_preview_filename(). func (v *FileChooser) GetPreviewFilename() string { c := C.gtk_file_chooser_get_preview_filename(v.native()) defer C.free(unsafe.Pointer(c)) return C.GoString(c) } // GetURI is a wrapper around gtk_file_chooser_get_uri(). func (v *FileChooser) GetURI() string { c := C.gtk_file_chooser_get_uri(v.native()) s := goString(c) defer C.g_free((C.gpointer)(c)) return s } // AddFilter is a wrapper around gtk_file_chooser_add_filter(). func (v *FileChooser) AddFilter(filter *FileFilter) { C.gtk_file_chooser_add_filter(v.native(), filter.native()) } // RemoveFilter is a wrapper around gtk_file_chooser_remove_filter(). func (v *FileChooser) RemoveFilter(filter *FileFilter) { C.gtk_file_chooser_remove_filter(v.native(), filter.native()) } // SetFilter is a wrapper around gtk_file_chooser_set_filter(). func (v *FileChooser) SetFilter(filter *FileFilter) { C.gtk_file_chooser_set_filter(v.native(), filter.native()) } // AddShortcutFolder is a wrapper around gtk_file_chooser_add_shortcut_folder(). func (v *FileChooser) AddShortcutFolder(folder string) bool { cstr := C.CString(folder) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_file_chooser_add_shortcut_folder(v.native(), cstr, nil) return gobool(c) } // SetLocalOnly is a wrapper around gtk_file_chooser_set_local_only(). func (v *FileChooser) SetLocalOnly(value bool) { C.gtk_file_chooser_set_local_only(v.native(), gbool(value)) } // GetLocalOnly is a wrapper around gtk_file_chooser_get_local_only(). func (v *FileChooser) GetLocalOnly() bool { c := C.gtk_file_chooser_get_local_only(v.native()) return gobool(c) } // SetSelectMultiple is a wrapper around gtk_file_chooser_set_select_multiple(). func (v *FileChooser) SetSelectMultiple(value bool) { C.gtk_file_chooser_set_select_multiple(v.native(), gbool(value)) } // GetSelectMultiple is a wrapper around gtk_file_chooser_get_select_multiple(). func (v *FileChooser) GetSelectMultiple() bool { c := C.gtk_file_chooser_get_select_multiple(v.native()) return gobool(c) } // SetExtraWidget is a wrapper around gtk_file_chooser_set_extra_widget(). func (v *FileChooser) SetExtraWidget(widget IWidget) { C.gtk_file_chooser_set_extra_widget(v.native(), widget.toWidget()) } // GetExtraWidget is a wrapper around gtk_file_chooser_get_extra_widget(). func (v *FileChooser) GetExtraWidget() (IWidget, error) { c := C.gtk_file_chooser_get_extra_widget(v.native()) if c == nil { return nil, nilPtrErr } return castWidget(c) } /* * GtkFileChooserButton */ // FileChooserButton is a representation of GTK's GtkFileChooserButton. type FileChooserButton struct { Box // Interfaces FileChooser } // native returns a pointer to the underlying GtkFileChooserButton. func (v *FileChooserButton) native() *C.GtkFileChooserButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFileChooserButton(p) } func marshalFileChooserButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFileChooserButton(obj), nil } func wrapFileChooserButton(obj *glib.Object) *FileChooserButton { if obj == nil { return nil } fc := wrapFileChooser(obj) return &FileChooserButton{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}, *fc} } // FileChooserButtonNew is a wrapper around gtk_file_chooser_button_new(). func FileChooserButtonNew(title string, action FileChooserAction) (*FileChooserButton, error) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_file_chooser_button_new((*C.gchar)(cstr), (C.GtkFileChooserAction)(action)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapFileChooserButton(obj), nil } // FileChooserButtonNewWithDialog is a wrapper around gtk_file_chooser_button_new_with_dialog(). func FileChooserButtonNewWithDialog(dialog IWidget) (*FileChooserButton, error) { c := C.gtk_file_chooser_button_new_with_dialog(dialog.toWidget()) if c == nil { return nil, nilPtrErr } return wrapFileChooserButton(glib.Take(unsafe.Pointer(c))), nil } // GetTitle is a wrapper around gtk_file_chooser_button_get_title(). func (v *FileChooserButton) GetTitle() string { // docs say: The returned value should not be modified or freed. return goString(C.gtk_file_chooser_button_get_title(v.native())) } // SetTitle is a wrapper around gtk_file_chooser_button_set_title(). func (v *FileChooserButton) SetTitle(title string) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) C.gtk_file_chooser_button_set_title(v.native(), (*C.gchar)(cstr)) } // GetWidthChars is a wrapper around gtk_file_chooser_button_get_width_chars(). func (v *FileChooserButton) GetWidthChars() int { return int(C.gtk_file_chooser_button_get_width_chars(v.native())) } // SetWidthChars is a wrapper around gtk_file_chooser_button_set_width_chars(). func (v *FileChooserButton) SetWidthChars(width int) { C.gtk_file_chooser_button_set_width_chars(v.native(), C.gint(width)) } /* * GtkFileChooserDialog */ // FileChooserDialog is a representation of GTK's GtkFileChooserDialog. type FileChooserDialog struct { Dialog // Interfaces FileChooser } // native returns a pointer to the underlying GtkFileChooserDialog. func (v *FileChooserDialog) native() *C.GtkFileChooserDialog { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFileChooserDialog(p) } func marshalFileChooserDialog(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFileChooserDialog(obj), nil } func wrapFileChooserDialog(obj *glib.Object) *FileChooserDialog { if obj == nil { return nil } fc := wrapFileChooser(obj) return &FileChooserDialog{Dialog{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}}, *fc} } // FileChooserDialogNewWith1Button is a wrapper around gtk_file_chooser_dialog_new() with one button. func FileChooserDialogNewWith1Button( title string, parent IWindow, action FileChooserAction, first_button_text string, first_button_id ResponseType) (*FileChooserDialog, error) { var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } c_title := C.CString(title) defer C.free(unsafe.Pointer(c_title)) c_first_button_text := C.CString(first_button_text) defer C.free(unsafe.Pointer(c_first_button_text)) c := C.gtk_file_chooser_dialog_new_1( (*C.gchar)(c_title), w, C.GtkFileChooserAction(action), (*C.gchar)(c_first_button_text), C.int(first_button_id)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapFileChooserDialog(obj), nil } // FileChooserDialogNewWith2Buttons is a wrapper around gtk_file_chooser_dialog_new() with two buttons. func FileChooserDialogNewWith2Buttons( title string, parent IWindow, action FileChooserAction, first_button_text string, first_button_id ResponseType, second_button_text string, second_button_id ResponseType) (*FileChooserDialog, error) { var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } c_title := C.CString(title) defer C.free(unsafe.Pointer(c_title)) c_first_button_text := C.CString(first_button_text) defer C.free(unsafe.Pointer(c_first_button_text)) c_second_button_text := C.CString(second_button_text) defer C.free(unsafe.Pointer(c_second_button_text)) c := C.gtk_file_chooser_dialog_new_2( (*C.gchar)(c_title), w, C.GtkFileChooserAction(action), (*C.gchar)(c_first_button_text), C.int(first_button_id), (*C.gchar)(c_second_button_text), C.int(second_button_id)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapFileChooserDialog(obj), nil } /* * GtkFileChooserWidget */ // FileChooserWidget is a representation of GTK's GtkFileChooserWidget. type FileChooserWidget struct { Box // Interfaces FileChooser } // native returns a pointer to the underlying GtkFileChooserWidget. func (v *FileChooserWidget) native() *C.GtkFileChooserWidget { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFileChooserWidget(p) } func marshalFileChooserWidget(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFileChooserWidget(obj), nil } func wrapFileChooserWidget(obj *glib.Object) *FileChooserWidget { if obj == nil { return nil } fc := wrapFileChooser(obj) return &FileChooserWidget{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}, *fc} } // FileChooserWidgetNew is a wrapper around gtk_file_chooser_widget_new(). func FileChooserWidgetNew(action FileChooserAction) (*FileChooserWidget, error) { c := C.gtk_file_chooser_widget_new((C.GtkFileChooserAction)(action)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapFileChooserWidget(obj), nil } /* * GtkFileFilter */ // FileChoser is a representation of GTK's GtkFileFilter GInterface. type FileFilter struct { *glib.Object } // native returns a pointer to the underlying GObject as a GtkFileFilter. func (v *FileFilter) native() *C.GtkFileFilter { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFileFilter(p) } func marshalFileFilter(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFileFilter(obj), nil } func wrapFileFilter(obj *glib.Object) *FileFilter { if obj == nil { return nil } return &FileFilter{obj} } // FileFilterNew is a wrapper around gtk_file_filter_new(). func FileFilterNew() (*FileFilter, error) { c := C.gtk_file_filter_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapFileFilter(obj), nil } // SetName is a wrapper around gtk_file_filter_set_name(). func (v *FileFilter) SetName(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_file_filter_set_name(v.native(), (*C.gchar)(cstr)) } // GetName is a wrapper around gtk_file_filter_get_name(). func (v *FileFilter) GetName() (name string) { cstr := C.gtk_file_filter_get_name(v.native()) if cstr != nil { name = goString(cstr) } return } // AddMimeType is a wrapper around gtk_file_filter_add_mime_type(). func (v *FileFilter) AddMimeType(mimeType string) { cstr := C.CString(mimeType) defer C.free(unsafe.Pointer(cstr)) C.gtk_file_filter_add_mime_type(v.native(), (*C.gchar)(cstr)) } // AddPattern is a wrapper around gtk_file_filter_add_pattern(). func (v *FileFilter) AddPattern(pattern string) { cstr := C.CString(pattern) defer C.free(unsafe.Pointer(cstr)) C.gtk_file_filter_add_pattern(v.native(), (*C.gchar)(cstr)) } // AddPixbufFormats is a wrapper around gtk_file_filter_add_pixbuf_formats(). func (v *FileFilter) AddPixbufFormats() { C.gtk_file_filter_add_pixbuf_formats(v.native()) } /* * GtkFrame */ // Frame is a representation of GTK's GtkFrame. type Frame struct { Bin } // native returns a pointer to the underlying GtkFrame. func (v *Frame) native() *C.GtkFrame { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFrame(p) } func marshalFrame(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFrame(obj), nil } func wrapFrame(obj *glib.Object) *Frame { if obj == nil { return nil } return &Frame{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // FrameNew is a wrapper around gtk_frame_new(). func FrameNew(label string) (*Frame, error) { var cstr *C.char if label != "" { cstr = C.CString(label) defer C.free(unsafe.Pointer(cstr)) } c := C.gtk_frame_new((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapFrame(obj), nil } // SetLabel is a wrapper around gtk_frame_set_label(). func (v *Frame) SetLabel(label string) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) C.gtk_frame_set_label(v.native(), (*C.gchar)(cstr)) } // SetLabelWidget is a wrapper around gtk_frame_set_label_widget(). func (v *Frame) SetLabelWidget(labelWidget IWidget) { C.gtk_frame_set_label_widget(v.native(), labelWidget.toWidget()) } // SetLabelAlign is a wrapper around gtk_frame_set_label_align(). func (v *Frame) SetLabelAlign(xAlign, yAlign float32) { C.gtk_frame_set_label_align(v.native(), C.gfloat(xAlign), C.gfloat(yAlign)) } // SetShadowType is a wrapper around gtk_frame_set_shadow_type(). func (v *Frame) SetShadowType(t ShadowType) { C.gtk_frame_set_shadow_type(v.native(), C.GtkShadowType(t)) } // GetLabel is a wrapper around gtk_frame_get_label(). func (v *Frame) GetLabel() string { c := C.gtk_frame_get_label(v.native()) return goString(c) } // GetLabelAlign is a wrapper around gtk_frame_get_label_align(). func (v *Frame) GetLabelAlign() (xAlign, yAlign float32) { var x, y C.gfloat C.gtk_frame_get_label_align(v.native(), &x, &y) return float32(x), float32(y) } // GetLabelWidget is a wrapper around gtk_frame_get_label_widget(). func (v *Frame) GetLabelWidget() (IWidget, error) { c := C.gtk_frame_get_label_widget(v.native()) if c == nil { return nil, nil } return castWidget(c) } // GetShadowType is a wrapper around gtk_frame_get_shadow_type(). func (v *Frame) GetShadowType() ShadowType { c := C.gtk_frame_get_shadow_type(v.native()) return ShadowType(c) } /* * GtkAspectFrame */ // AspectFrame is a representation of GTK's GtkAspectFrame. type AspectFrame struct { Frame } // native returns a pointer to the underlying GtkAspectFrame. func (v *AspectFrame) native() *C.GtkAspectFrame { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAspectFrame(p) } func marshalAspectFrame(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapAspectFrame(obj), nil } func wrapAspectFrame(obj *glib.Object) *AspectFrame { if obj == nil { return nil } return &AspectFrame{Frame{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} } // AspectFrameNew is a wrapper around gtk_aspect_frame_new(). func AspectFrameNew(label string, xalign, yalign, ratio float32, obeyChild bool) (*AspectFrame, error) { var cstr *C.char if label != "" { cstr = C.CString(label) defer C.free(unsafe.Pointer(cstr)) } c := C.gtk_aspect_frame_new((*C.gchar)(cstr), (C.gfloat)(xalign), (C.gfloat)(yalign), (C.gfloat)(ratio), gbool(obeyChild)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapAspectFrame(obj), nil } // TODO: // gtk_aspect_frame_set(). /* * GtkGrid */ // Grid is a representation of GTK's GtkGrid. type Grid struct { Container // Interfaces Orientable } // native returns a pointer to the underlying GtkGrid. func (v *Grid) native() *C.GtkGrid { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkGrid(p) } func (v *Grid) toOrientable() *C.GtkOrientable { if v == nil { return nil } return C.toGtkOrientable(unsafe.Pointer(v.GObject)) } func marshalGrid(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapGrid(obj), nil } func wrapGrid(obj *glib.Object) *Grid { if obj == nil { return nil } o := wrapOrientable(obj) return &Grid{Container{Widget{glib.InitiallyUnowned{obj}}}, *o} } // GridNew() is a wrapper around gtk_grid_new(). func GridNew() (*Grid, error) { c := C.gtk_grid_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapGrid(obj), nil } // Attach() is a wrapper around gtk_grid_attach(). func (v *Grid) Attach(child IWidget, left, top, width, height int) { C.gtk_grid_attach(v.native(), child.toWidget(), C.gint(left), C.gint(top), C.gint(width), C.gint(height)) } // AttachNextTo() is a wrapper around gtk_grid_attach_next_to(). func (v *Grid) AttachNextTo(child, sibling IWidget, side PositionType, width, height int) { C.gtk_grid_attach_next_to(v.native(), child.toWidget(), sibling.toWidget(), C.GtkPositionType(side), C.gint(width), C.gint(height)) } // GetChildAt() is a wrapper around gtk_grid_get_child_at(). func (v *Grid) GetChildAt(left, top int) (IWidget, error) { c := C.gtk_grid_get_child_at(v.native(), C.gint(left), C.gint(top)) if c == nil { return nil, nil } return castWidget(c) } // InsertRow() is a wrapper around gtk_grid_insert_row(). func (v *Grid) InsertRow(position int) { C.gtk_grid_insert_row(v.native(), C.gint(position)) } // InsertColumn() is a wrapper around gtk_grid_insert_column(). func (v *Grid) InsertColumn(position int) { C.gtk_grid_insert_column(v.native(), C.gint(position)) } // InsertNextTo() is a wrapper around gtk_grid_insert_next_to() func (v *Grid) InsertNextTo(sibling IWidget, side PositionType) { C.gtk_grid_insert_next_to(v.native(), sibling.toWidget(), C.GtkPositionType(side)) } // SetRowHomogeneous() is a wrapper around gtk_grid_set_row_homogeneous(). func (v *Grid) SetRowHomogeneous(homogeneous bool) { C.gtk_grid_set_row_homogeneous(v.native(), gbool(homogeneous)) } // GetRowHomogeneous() is a wrapper around gtk_grid_get_row_homogeneous(). func (v *Grid) GetRowHomogeneous() bool { c := C.gtk_grid_get_row_homogeneous(v.native()) return gobool(c) } // SetRowSpacing() is a wrapper around gtk_grid_set_row_spacing(). func (v *Grid) SetRowSpacing(spacing uint) { C.gtk_grid_set_row_spacing(v.native(), C.guint(spacing)) } // GetRowSpacing() is a wrapper around gtk_grid_get_row_spacing(). func (v *Grid) GetRowSpacing() uint { c := C.gtk_grid_get_row_spacing(v.native()) return uint(c) } // SetColumnHomogeneous() is a wrapper around gtk_grid_set_column_homogeneous(). func (v *Grid) SetColumnHomogeneous(homogeneous bool) { C.gtk_grid_set_column_homogeneous(v.native(), gbool(homogeneous)) } // GetColumnHomogeneous() is a wrapper around gtk_grid_get_column_homogeneous(). func (v *Grid) GetColumnHomogeneous() bool { c := C.gtk_grid_get_column_homogeneous(v.native()) return gobool(c) } // SetColumnSpacing() is a wrapper around gtk_grid_set_column_spacing(). func (v *Grid) SetColumnSpacing(spacing uint) { C.gtk_grid_set_column_spacing(v.native(), C.guint(spacing)) } // GetColumnSpacing() is a wrapper around gtk_grid_get_column_spacing(). func (v *Grid) GetColumnSpacing() uint { c := C.gtk_grid_get_column_spacing(v.native()) return uint(c) } /* * GtkIconTheme */ // IconTheme is a representation of GTK's GtkIconTheme type IconTheme struct { Theme *C.GtkIconTheme } // IconThemeNew is a wrapper around gtk_icon_theme_new(). func IconThemeNew() (*IconTheme, error) { c := C.gtk_icon_theme_new() if c == nil { return nil, nilPtrErr } return &IconTheme{c}, nil } // IconThemeGetDefault is a wrapper around gtk_icon_theme_get_default(). func IconThemeGetDefault() (*IconTheme, error) { c := C.gtk_icon_theme_get_default() if c == nil { return nil, nilPtrErr } return &IconTheme{c}, nil } // IconThemeGetForScreen is a wrapper around gtk_icon_theme_get_for_screen(). func IconThemeGetForScreen(screen gdk.Screen) (*IconTheme, error) { cScreen := (*C.GdkScreen)(unsafe.Pointer(screen.Native())) c := C.gtk_icon_theme_get_for_screen(cScreen) if c == nil { return nil, nilPtrErr } return &IconTheme{c}, nil } // LoadIcon is a wrapper around gtk_icon_theme_load_icon(). func (v *IconTheme) LoadIcon(iconName string, size int, flags IconLookupFlags) (*gdk.Pixbuf, error) { cstr := C.CString(iconName) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil c := C.gtk_icon_theme_load_icon(v.Theme, (*C.gchar)(cstr), C.gint(size), C.GtkIconLookupFlags(flags), &err) if c == nil { defer C.g_error_free(err) return nil, errors.New(goString(err.message)) } return &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))}, nil } // HasIcon is a wrapper around gtk_icon_theme_has_icon(). func (v *IconTheme) HasIcon(iconName string) bool { cstr := C.CString(iconName) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_icon_theme_has_icon(v.Theme, (*C.gchar)(cstr)) return gobool(c) } // AddResourcePath is a wrapper around gtk_icon_theme_add_resource_path(). func (v *IconTheme) AddResourcePath(path string) { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) C.gtk_icon_theme_add_resource_path(v.Theme, (*C.gchar)(cstr)) } // AppendSearchPath is a wrapper around gtk_icon_theme_append_search_path(). func (v *IconTheme) AppendSearchPath(path string) { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) C.gtk_icon_theme_append_search_path(v.Theme, (*C.gchar)(cstr)) } /* * GtkImage */ // Image is a representation of GTK's GtkImage. type Image struct { Widget } // native returns a pointer to the underlying GtkImage. func (v *Image) native() *C.GtkImage { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkImage(p) } func marshalImage(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapImage(obj), nil } func wrapImage(obj *glib.Object) *Image { if obj == nil { return nil } return &Image{Widget{glib.InitiallyUnowned{obj}}} } // ImageNew() is a wrapper around gtk_image_new(). func ImageNew() (*Image, error) { c := C.gtk_image_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapImage(obj), nil } // ImageNewFromFile() is a wrapper around gtk_image_new_from_file(). func ImageNewFromFile(filename string) (*Image, error) { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_image_new_from_file((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapImage(obj), nil } // ImageNewFromResource() is a wrapper around gtk_image_new_from_resource(). func ImageNewFromResource(resourcePath string) (*Image, error) { cstr := C.CString(resourcePath) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_image_new_from_resource((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapImage(obj), nil } // ImageNewFromPixbuf is a wrapper around gtk_image_new_from_pixbuf(). func ImageNewFromPixbuf(pixbuf *gdk.Pixbuf) (*Image, error) { c := C.gtk_image_new_from_pixbuf((*C.GdkPixbuf)(pixbuf.NativePrivate())) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapImage(obj), nil } // ImageNewFromIconName() is a wrapper around gtk_image_new_from_icon_name(). func ImageNewFromIconName(iconName string, size IconSize) (*Image, error) { cstr := C.CString(iconName) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_image_new_from_icon_name((*C.gchar)(cstr), C.GtkIconSize(size)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapImage(obj), nil } // ImageNewFromGIcon is a wrapper around gtk_image_new_from_gicon() func ImageNewFromGIcon(icon *glib.Icon, size IconSize) (*Image, error) { c := C.gtk_image_new_from_gicon( (*C.GIcon)(icon.NativePrivate()), C.GtkIconSize(size)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapImage(obj), nil } // Clear() is a wrapper around gtk_image_clear(). func (v *Image) Clear() { C.gtk_image_clear(v.native()) } // SetFromFile() is a wrapper around gtk_image_set_from_file(). func (v *Image) SetFromFile(filename string) { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) C.gtk_image_set_from_file(v.native(), (*C.gchar)(cstr)) } // SetFromResource() is a wrapper around gtk_image_set_from_resource(). func (v *Image) SetFromResource(resourcePath string) { cstr := C.CString(resourcePath) defer C.free(unsafe.Pointer(cstr)) C.gtk_image_set_from_resource(v.native(), (*C.gchar)(cstr)) } // SetFromFixbuf is a wrapper around gtk_image_set_from_pixbuf(). func (v *Image) SetFromPixbuf(pixbuf *gdk.Pixbuf) { pbptr := (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native())) C.gtk_image_set_from_pixbuf(v.native(), pbptr) } // SetFromIconName() is a wrapper around gtk_image_set_from_icon_name(). func (v *Image) SetFromIconName(iconName string, size IconSize) { cstr := C.CString(iconName) defer C.free(unsafe.Pointer(cstr)) C.gtk_image_set_from_icon_name(v.native(), (*C.gchar)(cstr), C.GtkIconSize(size)) } // SetFromGIcon is a wrapper around gtk_image_set_from_gicon() func (v *Image) SetFromGIcon(icon *glib.Icon, size IconSize) { C.gtk_image_set_from_gicon( v.native(), (*C.GIcon)(icon.NativePrivate()), C.GtkIconSize(size)) } // SetPixelSize() is a wrapper around gtk_image_set_pixel_size(). func (v *Image) SetPixelSize(pixelSize int) { C.gtk_image_set_pixel_size(v.native(), C.gint(pixelSize)) } // GetStorageType() is a wrapper around gtk_image_get_storage_type(). func (v *Image) GetStorageType() ImageType { c := C.gtk_image_get_storage_type(v.native()) return ImageType(c) } // GetPixbuf() is a wrapper around gtk_image_get_pixbuf(). func (v *Image) GetPixbuf() *gdk.Pixbuf { c := C.gtk_image_get_pixbuf(v.native()) if c == nil { return nil } pb := &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))} return pb } // GetAnimation() is a wrapper around gtk_image_get_animation() func (v *Image) GetAnimation() *gdk.PixbufAnimation { c := C.gtk_image_get_animation(v.native()) if c == nil { return nil } return &gdk.PixbufAnimation{glib.Take(unsafe.Pointer(c))} } // ImageNewFromAnimation() is a wrapper around gtk_image_new_from_animation() func ImageNewFromAnimation(animation *gdk.PixbufAnimation) (*Image, error) { c := C.gtk_image_new_from_animation((*C.GdkPixbufAnimation)(animation.NativePrivate())) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapImage(obj), nil } // SetFromAnimation is a wrapper around gtk_image_set_from_animation(). func (v *Image) SetFromAnimation(animation *gdk.PixbufAnimation) { pbaptr := (*C.GdkPixbufAnimation)(unsafe.Pointer(animation.NativePrivate())) C.gtk_image_set_from_animation(v.native(), pbaptr) } // GetIconName() is a wrapper around gtk_image_get_icon_name(). func (v *Image) GetIconName() (string, IconSize) { var iconName *C.gchar var size C.GtkIconSize C.gtk_image_get_icon_name(v.native(), &iconName, &size) return goString(iconName), IconSize(size) } // GetGIcon is a wrapper around gtk_image_get_gicon() func (v *Image) GetGIcon() (*glib.Icon, IconSize, error) { var gicon *C.GIcon var size *C.GtkIconSize C.gtk_image_get_gicon( v.native(), &gicon, size) if gicon == nil { return nil, ICON_SIZE_INVALID, nilPtrErr } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(gicon))} i := &glib.Icon{obj} runtime.SetFinalizer(i, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return i, IconSize(*size), nil } // GetPixelSize() is a wrapper around gtk_image_get_pixel_size(). func (v *Image) GetPixelSize() int { c := C.gtk_image_get_pixel_size(v.native()) return int(c) } // added by terrak /* * GtkLayout */ // Layout is a representation of GTK's GtkLayout. type Layout struct { Container } // native returns a pointer to the underlying GtkDrawingArea. func (v *Layout) native() *C.GtkLayout { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkLayout(p) } func marshalLayout(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapLayout(obj), nil } func wrapLayout(obj *glib.Object) *Layout { if obj == nil { return nil } return &Layout{Container{Widget{glib.InitiallyUnowned{obj}}}} } // LayoutNew is a wrapper around gtk_layout_new(). func LayoutNew(hadjustment, vadjustment *Adjustment) (*Layout, error) { c := C.gtk_layout_new(hadjustment.native(), vadjustment.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapLayout(obj), nil } // Layout.Put is a wrapper around gtk_layout_put(). func (v *Layout) Put(w IWidget, x, y int) { C.gtk_layout_put(v.native(), w.toWidget(), C.gint(x), C.gint(y)) } // Layout.Move is a wrapper around gtk_layout_move(). func (v *Layout) Move(w IWidget, x, y int) { C.gtk_layout_move(v.native(), w.toWidget(), C.gint(x), C.gint(y)) } // Layout.SetSize is a wrapper around gtk_layout_set_size func (v *Layout) SetSize(width, height uint) { C.gtk_layout_set_size(v.native(), C.guint(width), C.guint(height)) } // Layout.GetSize is a wrapper around gtk_layout_get_size func (v *Layout) GetSize() (width, height uint) { var w, h C.guint C.gtk_layout_get_size(v.native(), &w, &h) return uint(w), uint(h) } // TODO: // gtk_layout_get_bin_window(). /* * GtkLinkButton */ // LinkButton is a representation of GTK's GtkLinkButton. type LinkButton struct { Button } // native returns a pointer to the underlying GtkLinkButton. func (v *LinkButton) native() *C.GtkLinkButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkLinkButton(p) } func marshalLinkButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapLinkButton(obj), nil } func wrapLinkButton(obj *glib.Object) *LinkButton { if obj == nil { return nil } actionable := wrapActionable(obj) return &LinkButton{Button{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}, actionable}} } // LinkButtonNew is a wrapper around gtk_link_button_new(). func LinkButtonNew(label string) (*LinkButton, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_link_button_new((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapLinkButton(glib.Take(unsafe.Pointer(c))), nil } // LinkButtonNewWithLabel is a wrapper around gtk_link_button_new_with_label(). func LinkButtonNewWithLabel(uri, label string) (*LinkButton, error) { curi := C.CString(uri) defer C.free(unsafe.Pointer(curi)) clabel := C.CString(label) defer C.free(unsafe.Pointer(clabel)) c := C.gtk_link_button_new_with_label((*C.gchar)(curi), (*C.gchar)(clabel)) if c == nil { return nil, nilPtrErr } return wrapLinkButton(glib.Take(unsafe.Pointer(c))), nil } // GetUri is a wrapper around gtk_link_button_get_uri(). func (v *LinkButton) GetUri() string { c := C.gtk_link_button_get_uri(v.native()) return goString(c) } // SetUri is a wrapper around gtk_link_button_set_uri(). func (v *LinkButton) SetUri(uri string) { cstr := C.CString(uri) C.gtk_link_button_set_uri(v.native(), (*C.gchar)(cstr)) } // GetVisited is a wrapper around gtk_link_button_get_visited(). func (v *LinkButton) GetVisited() bool { c := C.gtk_link_button_get_visited(v.native()) return gobool(c) } // SetVisited is a wrapper around gtk_link_button_set_visited(). func (v *LinkButton) SetVisited(visited bool) { C.gtk_link_button_set_visited(v.native(), gbool(visited)) } /* * GtkLockButton */ // LockButton is a representation of GTK's GtkLockButton. type LockButton struct { Button } // native returns a pointer to the underlying GtkLockButton. func (v *LockButton) native() *C.GtkLockButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkLockButton(p) } func marshalLockButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapLockButton(obj), nil } func wrapLockButton(obj *glib.Object) *LockButton { if obj == nil { return nil } actionable := wrapActionable(obj) return &LockButton{Button{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}, actionable}} } // LockButtonNew is a wrapper around gtk_lock_button_new(). func LockButtonNew(permission *glib.Permission) (*LockButton, error) { c := C.gtk_lock_button_new(nativeGPermission(permission)) if c == nil { return nil, nilPtrErr } return wrapLockButton(glib.Take(unsafe.Pointer(c))), nil } // GetPermission is a wrapper around gtk_lock_button_get_permission(). func (v *LockButton) GetPermission() *glib.Permission { c := C.gtk_lock_button_get_permission(v.native()) return glib.WrapPermission(unsafe.Pointer(c)) } // SetPermission is a wrapper around gtk_lock_button_set_permission(). func (v *LockButton) SetPermission(permission *glib.Permission) { C.gtk_lock_button_set_permission(v.native(), nativeGPermission(permission)) } /* * GtkListStore */ // ListStore is a representation of GTK's GtkListStore. type ListStore struct { *glib.Object // Interfaces TreeModel TreeSortable } // native returns a pointer to the underlying GtkListStore. func (v *ListStore) native() *C.GtkListStore { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkListStore(p) } func marshalListStore(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapListStore(obj), nil } func wrapListStore(obj *glib.Object) *ListStore { if obj == nil { return nil } tm := wrapTreeModel(obj) ts := wrapTreeSortable(obj) return &ListStore{obj, *tm, *ts} } func (v *ListStore) toTreeModel() *C.GtkTreeModel { if v == nil { return nil } return C.toGtkTreeModel(unsafe.Pointer(v.GObject)) } func (v *ListStore) toTreeSortable() *C.GtkTreeSortable { if v == nil { return nil } return C.toGtkTreeSortable(unsafe.Pointer(v.GObject)) } // ListStoreNew is a wrapper around gtk_list_store_newv(). func ListStoreNew(types ...glib.Type) (*ListStore, error) { gtypes := C.alloc_types(C.int(len(types))) for n, val := range types { C.set_type(gtypes, C.int(n), C.GType(val)) } defer C.g_free(C.gpointer(gtypes)) c := C.gtk_list_store_newv(C.gint(len(types)), gtypes) if c == nil { return nil, nilPtrErr } ls := wrapListStore(glib.Take(unsafe.Pointer(c))) return ls, nil } // Remove is a wrapper around gtk_list_store_remove(). func (v *ListStore) Remove(iter *TreeIter) bool { c := C.gtk_list_store_remove(v.native(), iter.native()) return gobool(c) } // SetColumnTypes is a wrapper around gtk_list_store_set_column_types(). // The size of glib.Type must match the number of columns func (v *ListStore) SetColumnTypes(types ...glib.Type) { gtypes := C.alloc_types(C.int(len(types))) for n, val := range types { C.set_type(gtypes, C.int(n), C.GType(val)) } defer C.g_free(C.gpointer(gtypes)) C.gtk_list_store_set_column_types(v.native(), C.gint(len(types)), gtypes) } // Set() is a wrapper around gtk_list_store_set_value() but provides // a function similar to gtk_list_store_set() in that multiple columns // may be set by one call. The length of columns and values slices must // match, or Set() will return a non-nil error. // // As an example, a call to: // store.Set(iter, []int{0, 1}, []interface{}{"Foo", "Bar"}) // is functionally equivalent to calling the native C GTK function: // gtk_list_store_set(store, iter, 0, "Foo", 1, "Bar", -1); func (v *ListStore) Set(iter *TreeIter, columns []int, values []interface{}) error { if len(columns) != len(values) { return errors.New("columns and values lengths do not match") } for i, val := range values { v.SetValue(iter, columns[i], val) } return nil } // SetValue is a wrapper around gtk_list_store_set_value(). func (v *ListStore) SetValue(iter *TreeIter, column int, value interface{}) error { switch value.(type) { case *gdk.Pixbuf: pix := value.(*gdk.Pixbuf) C._gtk_list_store_set(v.native(), iter.native(), C.gint(column), unsafe.Pointer(pix.Native())) default: gv, err := glib.GValue(value) if err != nil { return err } C.gtk_list_store_set_value(v.native(), iter.native(), C.gint(column), (*C.GValue)(unsafe.Pointer(gv.Native()))) } return nil } // func (v *ListStore) Model(model ITreeModel) { // obj := &glib.Object{glib.ToGObject(unsafe.Pointer(model.toTreeModel()))} // v.TreeModel = *wrapTreeModel(obj) //} func (v *ListStore) SetCols(iter *TreeIter, cols Cols) error { for key, value := range cols { err := v.SetValue(iter, key, value) if err != nil { return err } } return nil } // Convenient map for Columns and values (See ListStore, TreeStore) type Cols map[int]interface{} // InsertWithValues() is a wrapper around gtk_list_store_insert_with_valuesv(). func (v *ListStore) InsertWithValues(iter *TreeIter, position int, inColumns []int, inValues []interface{}) error { length := len(inColumns) if len(inValues) < length { length = len(inValues) } var cColumns []C.gint var cValues []C.GValue for i := 0; i < length; i++ { cColumns = append(cColumns, C.gint(inColumns[i])) gv, err := glib.GValue(inValues[i]) if err != nil { return err } var cvp *C.GValue = (*C.GValue)(unsafe.Pointer(gv.Native())) cValues = append(cValues, *cvp) } var cColumnsPointer *C.gint if len(cColumns) > 0 { cColumnsPointer = &cColumns[0] } var cValuesPointer *C.GValue if len(cValues) > 0 { cValuesPointer = &cValues[0] } C.gtk_list_store_insert_with_valuesv(v.native(), iter.native(), C.gint(position), cColumnsPointer, cValuesPointer, C.gint(length)) return nil } // Insert() is a wrapper around gtk_list_store_insert(). func (v *ListStore) Insert(position int) *TreeIter { var ti C.GtkTreeIter C.gtk_list_store_insert(v.native(), &ti, C.gint(position)) iter := &TreeIter{ti} return iter } // InsertBefore() is a wrapper around gtk_list_store_insert_before(). func (v *ListStore) InsertBefore(sibling *TreeIter) *TreeIter { var ti C.GtkTreeIter C.gtk_list_store_insert_before(v.native(), &ti, sibling.native()) iter := &TreeIter{ti} return iter } // InsertAfter() is a wrapper around gtk_list_store_insert_after(). func (v *ListStore) InsertAfter(sibling *TreeIter) *TreeIter { var ti C.GtkTreeIter C.gtk_list_store_insert_after(v.native(), &ti, sibling.native()) iter := &TreeIter{ti} return iter } // Prepend() is a wrapper around gtk_list_store_prepend(). func (v *ListStore) Prepend() *TreeIter { var ti C.GtkTreeIter C.gtk_list_store_prepend(v.native(), &ti) iter := &TreeIter{ti} return iter } // Append() is a wrapper around gtk_list_store_append(). func (v *ListStore) Append() *TreeIter { var ti C.GtkTreeIter C.gtk_list_store_append(v.native(), &ti) iter := &TreeIter{ti} return iter } // Clear() is a wrapper around gtk_list_store_clear(). func (v *ListStore) Clear() { C.gtk_list_store_clear(v.native()) } // IterIsValid() is a wrapper around gtk_list_store_iter_is_valid(). func (v *ListStore) IterIsValid(iter *TreeIter) bool { c := C.gtk_list_store_iter_is_valid(v.native(), iter.native()) return gobool(c) } // TODO(jrick) /* func (v *ListStore) Reorder(newOrder []int) { } */ // Swap() is a wrapper around gtk_list_store_swap(). func (v *ListStore) Swap(a, b *TreeIter) { C.gtk_list_store_swap(v.native(), a.native(), b.native()) } // MoveBefore() is a wrapper around gtk_list_store_move_before(). func (v *ListStore) MoveBefore(iter, position *TreeIter) { C.gtk_list_store_move_before(v.native(), iter.native(), position.native()) } // MoveAfter() is a wrapper around gtk_list_store_move_after(). func (v *ListStore) MoveAfter(iter, position *TreeIter) { C.gtk_list_store_move_after(v.native(), iter.native(), position.native()) } /* * GtkMenuBar */ // MenuBar is a representation of GTK's GtkMenuBar. type MenuBar struct { MenuShell } // native() returns a pointer to the underlying GtkMenuBar. func (v *MenuBar) native() *C.GtkMenuBar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkMenuBar(p) } func marshalMenuBar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapMenuBar(obj), nil } func wrapMenuBar(obj *glib.Object) *MenuBar { if obj == nil { return nil } return &MenuBar{MenuShell{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // MenuBarNew() is a wrapper around gtk_menu_bar_new(). func MenuBarNew() (*MenuBar, error) { c := C.gtk_menu_bar_new() if c == nil { return nil, nilPtrErr } return wrapMenuBar(glib.Take(unsafe.Pointer(c))), nil } /* * GtkMenuButton */ // MenuButton is a representation of GTK's GtkMenuButton. type MenuButton struct { ToggleButton } // native returns a pointer to the underlying GtkMenuButton. func (v *MenuButton) native() *C.GtkMenuButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkMenuButton(p) } func marshalMenuButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapMenuButton(obj), nil } func wrapMenuButton(obj *glib.Object) *MenuButton { if obj == nil { return nil } actionable := wrapActionable(obj) return &MenuButton{ToggleButton{Button{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}, actionable}}} } // MenuButtonNew is a wrapper around gtk_menu_button_new(). func MenuButtonNew() (*MenuButton, error) { c := C.gtk_menu_button_new() if c == nil { return nil, nilPtrErr } return wrapMenuButton(glib.Take(unsafe.Pointer(c))), nil } // SetPopup is a wrapper around gtk_menu_button_set_popup(). func (v *MenuButton) SetPopup(menu IMenu) { C.gtk_menu_button_set_popup(v.native(), menu.toWidget()) } // GetPopup is a wrapper around gtk_menu_button_get_popup(). func (v *MenuButton) GetPopup() *Menu { c := C.gtk_menu_button_get_popup(v.native()) if c == nil { return nil } return wrapMenu(glib.Take(unsafe.Pointer(c))) } // SetMenuModel is a wrapper around gtk_menu_button_set_menu_model(). func (v *MenuButton) SetMenuModel(menuModel *glib.MenuModel) { C.gtk_menu_button_set_menu_model(v.native(), C.toGMenuModel(unsafe.Pointer(menuModel.Native()))) } // GetMenuModel is a wrapper around gtk_menu_button_get_menu_model(). func (v *MenuButton) GetMenuModel() *glib.MenuModel { c := C.gtk_menu_button_get_menu_model(v.native()) if c == nil { return nil } return &glib.MenuModel{glib.Take(unsafe.Pointer(c))} } // SetDirection is a wrapper around gtk_menu_button_set_direction(). func (v *MenuButton) SetDirection(direction ArrowType) { C.gtk_menu_button_set_direction(v.native(), C.GtkArrowType(direction)) } // GetDirection is a wrapper around gtk_menu_button_get_direction(). func (v *MenuButton) GetDirection() ArrowType { c := C.gtk_menu_button_get_direction(v.native()) return ArrowType(c) } // SetAlignWidget is a wrapper around gtk_menu_button_set_align_widget(). func (v *MenuButton) SetAlignWidget(alignWidget IWidget) { C.gtk_menu_button_set_align_widget(v.native(), alignWidget.toWidget()) } // GetAlignWidget is a wrapper around gtk_menu_button_get_align_widget(). func (v *MenuButton) GetAlignWidget() (IWidget, error) { c := C.gtk_menu_button_get_align_widget(v.native()) if c == nil { return nil, nil } return castWidget(c) } /* * GtkMenuItem */ // MenuItem is a representation of GTK's GtkMenuItem. type MenuItem struct { Bin } // IMenuItem is an interface type implemented by all structs // embedding a MenuItem. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkMenuItem. type IMenuItem interface { toMenuItem() *C.GtkMenuItem toWidget() *C.GtkWidget } // native returns a pointer to the underlying GtkMenuItem. func (v *MenuItem) native() *C.GtkMenuItem { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkMenuItem(p) } func (v *MenuItem) toMenuItem() *C.GtkMenuItem { if v == nil { return nil } return v.native() } func marshalMenuItem(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapMenuItem(obj), nil } func wrapMenuItem(obj *glib.Object) *MenuItem { if obj == nil { return nil } return &MenuItem{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // MenuItemNew() is a wrapper around gtk_menu_item_new(). func MenuItemNew() (*MenuItem, error) { c := C.gtk_menu_item_new() if c == nil { return nil, nilPtrErr } return wrapMenuItem(glib.Take(unsafe.Pointer(c))), nil } // MenuItemNewWithLabel() is a wrapper around gtk_menu_item_new_with_label(). func MenuItemNewWithLabel(label string) (*MenuItem, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_menu_item_new_with_label((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapMenuItem(glib.Take(unsafe.Pointer(c))), nil } // MenuItemNewWithMnemonic() is a wrapper around gtk_menu_item_new_with_mnemonic(). func MenuItemNewWithMnemonic(label string) (*MenuItem, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_menu_item_new_with_mnemonic((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapMenuItem(glib.Take(unsafe.Pointer(c))), nil } // SetSubmenu() is a wrapper around gtk_menu_item_set_submenu(). func (v *MenuItem) SetSubmenu(submenu IWidget) { C.gtk_menu_item_set_submenu(v.native(), submenu.toWidget()) } // GetSubmenu is a wrapper around gtk_menu_item_get_submenu(). func (v *MenuItem) GetSubmenu() (IMenu, error) { c := C.gtk_menu_item_get_submenu(v.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapMenu(obj), nil } // SetLabel is a wrapper around gtk_menu_item_set_label(). func (v *MenuItem) SetLabel(label string) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) C.gtk_menu_item_set_label(v.native(), (*C.gchar)(cstr)) } // GetLabel is a wrapper around gtk_menu_item_get_label(). func (v *MenuItem) GetLabel() string { l := C.gtk_menu_item_get_label(v.native()) return goString(l) } // SetUseUnderline() is a wrapper around gtk_menu_item_set_use_underline() func (v *MenuItem) SetUseUnderline(settings bool) { C.gtk_menu_item_set_use_underline(v.native(), gbool(settings)) } // GetUseUnderline() is a wrapper around gtk_menu_item_get_use_underline() func (v *MenuItem) GetUseUnderline() bool { c := C.gtk_menu_item_get_use_underline(v.native()) return gobool(c) } // Select is a wrapper around gtk_menu_item_select() func (v *MenuItem) Select() { C.gtk_menu_item_select(v.native()) } // Deselect is a wrapper around gtk_menu_item_deselect() func (v *MenuItem) Deselect() { C.gtk_menu_item_deselect(v.native()) } // Activate is a wrapper around gtk_menu_item_activate() func (v *MenuItem) Activate() { C.gtk_menu_item_activate(v.native()) } // ToggleSizeRequest is a wrapper around gtk_menu_item_toggle_size_request() func (v *MenuItem) ToggleSizeRequest(requisition int) int { cint := new(C.gint) *cint = C.gint(requisition) C.gtk_menu_item_toggle_size_request(v.native(), cint) return int(*cint) } // ToggleSizeAllocate is a wrapper around gtk_menu_item_toggle_size_allocate() func (v *MenuItem) ToggleSizeAllocate(allocation int) { C.gtk_menu_item_toggle_size_allocate(v.native(), C.gint(allocation)) } // GetReserveIndicator is a wrapper around gtk_menu_item_get_reserve_indicator(). func (v *MenuItem) GetReserveIndicator() bool { return gobool(C.gtk_menu_item_get_reserve_indicator(v.native())) } // SetReserveIndicator is a wrapper around gtk_menu_item_set_reserve_indicator(). func (v *MenuItem) SetReserveIndicator(reserve bool) { C.gtk_menu_item_set_reserve_indicator(v.native(), gbool(reserve)) } /* * GtkMessageDialog */ // MessageDialog is a representation of GTK's GtkMessageDialog. type MessageDialog struct { Dialog } // native returns a pointer to the underlying GtkMessageDialog. func (v *MessageDialog) native() *C.GtkMessageDialog { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkMessageDialog(p) } func marshalMessageDialog(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapMessageDialog(obj), nil } func wrapMessageDialog(obj *glib.Object) *MessageDialog { if obj == nil { return nil } return &MessageDialog{Dialog{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}}} } // MessageDialogNew() is a wrapper around gtk_message_dialog_new(). // The text is created and formatted by the format specifier and any // additional arguments. func MessageDialogNew(parent IWindow, flags DialogFlags, mType MessageType, buttons ButtonsType, format string, args ...interface{}) *MessageDialog { s := fmt.Sprintf(format, args...) cstr := C.CString(s) defer C.free(unsafe.Pointer(cstr)) var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } c := C._gtk_message_dialog_new(w, C.GtkDialogFlags(flags), C.GtkMessageType(mType), C.GtkButtonsType(buttons), cstr) return wrapMessageDialog(glib.Take(unsafe.Pointer(c))) } // MessageDialogNewWithMarkup is a wrapper around // gtk_message_dialog_new_with_markup(). func MessageDialogNewWithMarkup(parent IWindow, flags DialogFlags, mType MessageType, buttons ButtonsType, format string, args ...interface{}) *MessageDialog { s := fmt.Sprintf(format, args...) cstr := C.CString(s) defer C.free(unsafe.Pointer(cstr)) var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } c := C._gtk_message_dialog_new_with_markup(w, C.GtkDialogFlags(flags), C.GtkMessageType(mType), C.GtkButtonsType(buttons), cstr) return wrapMessageDialog(glib.Take(unsafe.Pointer(c))) } // SetMarkup is a wrapper around gtk_message_dialog_set_markup(). func (v *MessageDialog) SetMarkup(str string) { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) C.gtk_message_dialog_set_markup(v.native(), (*C.gchar)(cstr)) } // FormatSecondaryText is a wrapper around // gtk_message_dialog_format_secondary_text(). func (v *MessageDialog) FormatSecondaryText(format string, args ...interface{}) { s := fmt.Sprintf(format, args...) cstr := C.CString(s) defer C.free(unsafe.Pointer(cstr)) C._gtk_message_dialog_format_secondary_text(v.native(), (*C.gchar)(cstr)) } // FormatSecondaryMarkup is a wrapper around // gtk_message_dialog_format_secondary_text(). func (v *MessageDialog) FormatSecondaryMarkup(format string, args ...interface{}) { s := fmt.Sprintf(format, args...) cstr := C.CString(s) defer C.free(unsafe.Pointer(cstr)) C._gtk_message_dialog_format_secondary_markup(v.native(), (*C.gchar)(cstr)) } // GetMessageArea() is a wrapper around gtk_message_dialog_get_message_area(). func (v *MessageDialog) GetMessageArea() (*Box, error) { c := C.gtk_message_dialog_get_message_area(v.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) b := &Box{Container{Widget{glib.InitiallyUnowned{obj}}}} return b, nil } /* * GtkNotebook */ // Notebook is a representation of GTK's GtkNotebook. type Notebook struct { Container } // native returns a pointer to the underlying GtkNotebook. func (v *Notebook) native() *C.GtkNotebook { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkNotebook(p) } func marshalNotebook(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapNotebook(obj), nil } func wrapNotebook(obj *glib.Object) *Notebook { if obj == nil { return nil } return &Notebook{Container{Widget{glib.InitiallyUnowned{obj}}}} } // NotebookNew() is a wrapper around gtk_notebook_new(). func NotebookNew() (*Notebook, error) { c := C.gtk_notebook_new() if c == nil { return nil, nilPtrErr } return wrapNotebook(glib.Take(unsafe.Pointer(c))), nil } // AppendPage() is a wrapper around gtk_notebook_append_page(). func (v *Notebook) AppendPage(child IWidget, tabLabel IWidget) int { cTabLabel := nullableWidget(tabLabel) c := C.gtk_notebook_append_page(v.native(), child.toWidget(), cTabLabel) return int(c) } // AppendPageMenu() is a wrapper around gtk_notebook_append_page_menu(). func (v *Notebook) AppendPageMenu(child IWidget, tabLabel IWidget, menuLabel IWidget) int { c := C.gtk_notebook_append_page_menu(v.native(), child.toWidget(), tabLabel.toWidget(), menuLabel.toWidget()) return int(c) } // PrependPage() is a wrapper around gtk_notebook_prepend_page(). func (v *Notebook) PrependPage(child IWidget, tabLabel IWidget) int { cTabLabel := nullableWidget(tabLabel) c := C.gtk_notebook_prepend_page(v.native(), child.toWidget(), cTabLabel) return int(c) } // PrependPageMenu() is a wrapper around gtk_notebook_prepend_page_menu(). func (v *Notebook) PrependPageMenu(child IWidget, tabLabel IWidget, menuLabel IWidget) int { c := C.gtk_notebook_prepend_page_menu(v.native(), child.toWidget(), tabLabel.toWidget(), menuLabel.toWidget()) return int(c) } // InsertPage() is a wrapper around gtk_notebook_insert_page(). func (v *Notebook) InsertPage(child IWidget, tabLabel IWidget, position int) int { label := nullableWidget(tabLabel) c := C.gtk_notebook_insert_page(v.native(), child.toWidget(), label, C.gint(position)) return int(c) } // InsertPageMenu() is a wrapper around gtk_notebook_insert_page_menu(). func (v *Notebook) InsertPageMenu(child IWidget, tabLabel IWidget, menuLabel IWidget, position int) int { c := C.gtk_notebook_insert_page_menu(v.native(), child.toWidget(), tabLabel.toWidget(), menuLabel.toWidget(), C.gint(position)) return int(c) } // RemovePage() is a wrapper around gtk_notebook_remove_page(). func (v *Notebook) RemovePage(pageNum int) { C.gtk_notebook_remove_page(v.native(), C.gint(pageNum)) } // PageNum() is a wrapper around gtk_notebook_page_num(). func (v *Notebook) PageNum(child IWidget) int { c := C.gtk_notebook_page_num(v.native(), child.toWidget()) return int(c) } // NextPage() is a wrapper around gtk_notebook_next_page(). func (v *Notebook) NextPage() { C.gtk_notebook_next_page(v.native()) } // PrevPage() is a wrapper around gtk_notebook_prev_page(). func (v *Notebook) PrevPage() { C.gtk_notebook_prev_page(v.native()) } // ReorderChild() is a wrapper around gtk_notebook_reorder_child(). func (v *Notebook) ReorderChild(child IWidget, position int) { C.gtk_notebook_reorder_child(v.native(), child.toWidget(), C.gint(position)) } // SetTabPos() is a wrapper around gtk_notebook_set_tab_pos(). func (v *Notebook) SetTabPos(pos PositionType) { C.gtk_notebook_set_tab_pos(v.native(), C.GtkPositionType(pos)) } // SetShowTabs() is a wrapper around gtk_notebook_set_show_tabs(). func (v *Notebook) SetShowTabs(showTabs bool) { C.gtk_notebook_set_show_tabs(v.native(), gbool(showTabs)) } // SetShowBorder() is a wrapper around gtk_notebook_set_show_border(). func (v *Notebook) SetShowBorder(showBorder bool) { C.gtk_notebook_set_show_border(v.native(), gbool(showBorder)) } // SetScrollable() is a wrapper around gtk_notebook_set_scrollable(). func (v *Notebook) SetScrollable(scrollable bool) { C.gtk_notebook_set_scrollable(v.native(), gbool(scrollable)) } // PopupEnable() is a wrapper around gtk_notebook_popup_enable(). func (v *Notebook) PopupEnable() { C.gtk_notebook_popup_enable(v.native()) } // PopupDisable() is a wrapper around gtk_notebook_popup_disable(). func (v *Notebook) PopupDisable() { C.gtk_notebook_popup_disable(v.native()) } // GetCurrentPage() is a wrapper around gtk_notebook_get_current_page(). func (v *Notebook) GetCurrentPage() int { c := C.gtk_notebook_get_current_page(v.native()) return int(c) } // GetMenuLabel() is a wrapper around gtk_notebook_get_menu_label(). func (v *Notebook) GetMenuLabel(child IWidget) (IWidget, error) { c := C.gtk_notebook_get_menu_label(v.native(), child.toWidget()) if c == nil { return nil, nil } return castWidget(c) } // GetNthPage() is a wrapper around gtk_notebook_get_nth_page(). func (v *Notebook) GetNthPage(pageNum int) (IWidget, error) { c := C.gtk_notebook_get_nth_page(v.native(), C.gint(pageNum)) if c == nil { return nil, fmt.Errorf("page %d is out of bounds", pageNum) } return castWidget(c) } // GetNPages() is a wrapper around gtk_notebook_get_n_pages(). func (v *Notebook) GetNPages() int { c := C.gtk_notebook_get_n_pages(v.native()) return int(c) } // GetTabLabel() is a wrapper around gtk_notebook_get_tab_label(). func (v *Notebook) GetTabLabel(child IWidget) (IWidget, error) { c := C.gtk_notebook_get_tab_label(v.native(), child.toWidget()) if c == nil { return nil, nil } return castWidget(c) } // SetMenuLabel() is a wrapper around gtk_notebook_set_menu_label(). func (v *Notebook) SetMenuLabel(child, menuLabel IWidget) { C.gtk_notebook_set_menu_label(v.native(), child.toWidget(), menuLabel.toWidget()) } // SetMenuLabelText() is a wrapper around gtk_notebook_set_menu_label_text(). func (v *Notebook) SetMenuLabelText(child IWidget, menuText string) { cstr := C.CString(menuText) defer C.free(unsafe.Pointer(cstr)) C.gtk_notebook_set_menu_label_text(v.native(), child.toWidget(), (*C.gchar)(cstr)) } // SetTabLabel() is a wrapper around gtk_notebook_set_tab_label(). func (v *Notebook) SetTabLabel(child, tabLabel IWidget) { C.gtk_notebook_set_tab_label(v.native(), child.toWidget(), tabLabel.toWidget()) } // SetTabLabelText() is a wrapper around gtk_notebook_set_tab_label_text(). func (v *Notebook) SetTabLabelText(child IWidget, tabText string) { cstr := C.CString(tabText) defer C.free(unsafe.Pointer(cstr)) C.gtk_notebook_set_tab_label_text(v.native(), child.toWidget(), (*C.gchar)(cstr)) } // SetTabReorderable() is a wrapper around gtk_notebook_set_tab_reorderable(). func (v *Notebook) SetTabReorderable(child IWidget, reorderable bool) { C.gtk_notebook_set_tab_reorderable(v.native(), child.toWidget(), gbool(reorderable)) } // SetTabDetachable() is a wrapper around gtk_notebook_set_tab_detachable(). func (v *Notebook) SetTabDetachable(child IWidget, detachable bool) { C.gtk_notebook_set_tab_detachable(v.native(), child.toWidget(), gbool(detachable)) } // GetMenuLabelText() is a wrapper around gtk_notebook_get_menu_label_text(). func (v *Notebook) GetMenuLabelText(child IWidget) (string, error) { c := C.gtk_notebook_get_menu_label_text(v.native(), child.toWidget()) if c == nil { return "", errors.New("No menu label for widget") } return goString(c), nil } // GetScrollable() is a wrapper around gtk_notebook_get_scrollable(). func (v *Notebook) GetScrollable() bool { c := C.gtk_notebook_get_scrollable(v.native()) return gobool(c) } // GetShowBorder() is a wrapper around gtk_notebook_get_show_border(). func (v *Notebook) GetShowBorder() bool { c := C.gtk_notebook_get_show_border(v.native()) return gobool(c) } // GetShowTabs() is a wrapper around gtk_notebook_get_show_tabs(). func (v *Notebook) GetShowTabs() bool { c := C.gtk_notebook_get_show_tabs(v.native()) return gobool(c) } // GetTabLabelText() is a wrapper around gtk_notebook_get_tab_label_text(). func (v *Notebook) GetTabLabelText(child IWidget) (string, error) { c := C.gtk_notebook_get_tab_label_text(v.native(), child.toWidget()) if c == nil { return "", errors.New("No tab label for widget") } return goString(c), nil } // GetTabPos() is a wrapper around gtk_notebook_get_tab_pos(). func (v *Notebook) GetTabPos() PositionType { c := C.gtk_notebook_get_tab_pos(v.native()) return PositionType(c) } // GetTabReorderable() is a wrapper around gtk_notebook_get_tab_reorderable(). func (v *Notebook) GetTabReorderable(child IWidget) bool { c := C.gtk_notebook_get_tab_reorderable(v.native(), child.toWidget()) return gobool(c) } // GetTabDetachable() is a wrapper around gtk_notebook_get_tab_detachable(). func (v *Notebook) GetTabDetachable(child IWidget) bool { c := C.gtk_notebook_get_tab_detachable(v.native(), child.toWidget()) return gobool(c) } // SetCurrentPage() is a wrapper around gtk_notebook_set_current_page(). func (v *Notebook) SetCurrentPage(pageNum int) { C.gtk_notebook_set_current_page(v.native(), C.gint(pageNum)) } // SetGroupName() is a wrapper around gtk_notebook_set_group_name(). func (v *Notebook) SetGroupName(groupName string) { cstr := C.CString(groupName) defer C.free(unsafe.Pointer(cstr)) C.gtk_notebook_set_group_name(v.native(), (*C.gchar)(cstr)) } // GetGroupName() is a wrapper around gtk_notebook_get_group_name(). func (v *Notebook) GetGroupName() (string, error) { c := C.gtk_notebook_get_group_name(v.native()) if c == nil { return "", errors.New("No group name") } return goString(c), nil } // SetActionWidget() is a wrapper around gtk_notebook_set_action_widget(). func (v *Notebook) SetActionWidget(widget IWidget, packType PackType) { C.gtk_notebook_set_action_widget(v.native(), widget.toWidget(), C.GtkPackType(packType)) } // GetActionWidget() is a wrapper around gtk_notebook_get_action_widget(). func (v *Notebook) GetActionWidget(packType PackType) (IWidget, error) { c := C.gtk_notebook_get_action_widget(v.native(), C.GtkPackType(packType)) if c == nil { return nil, nil } return castWidget(c) } /* * GtkOffscreenWindow */ // OffscreenWindow is a representation of GTK's GtkOffscreenWindow. type OffscreenWindow struct { Window } // native returns a pointer to the underlying GtkOffscreenWindow. func (v *OffscreenWindow) native() *C.GtkOffscreenWindow { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkOffscreenWindow(p) } func marshalOffscreenWindow(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapOffscreenWindow(obj), nil } func wrapOffscreenWindow(obj *glib.Object) *OffscreenWindow { if obj == nil { return nil } return &OffscreenWindow{Window{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}}} } // OffscreenWindowNew is a wrapper around gtk_offscreen_window_new(). func OffscreenWindowNew() (*OffscreenWindow, error) { c := C.gtk_offscreen_window_new() if c == nil { return nil, nilPtrErr } return wrapOffscreenWindow(glib.Take(unsafe.Pointer(c))), nil } // GetSurface is a wrapper around gtk_offscreen_window_get_surface(). // The returned surface is safe to use over window resizes. func (v *OffscreenWindow) GetSurface() (*cairo.Surface, error) { c := C.gtk_offscreen_window_get_surface(v.native()) if c == nil { return nil, nilPtrErr } cairoPtr := (uintptr)(unsafe.Pointer(c)) s := cairo.NewSurface(cairoPtr, true) return s, nil } // GetPixbuf is a wrapper around gtk_offscreen_window_get_pixbuf(). func (v *OffscreenWindow) GetPixbuf() (*gdk.Pixbuf, error) { c := C.gtk_offscreen_window_get_pixbuf(v.native()) if c == nil { return nil, nilPtrErr } // Pixbuf is returned with ref count of 1, so don't increment. // Is it a floating reference? pb := &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))} return pb, nil } /* * GtkOrientable */ // Orientable is a representation of GTK's GtkOrientable GInterface. type Orientable struct { *glib.Object } // IOrientable is an interface type implemented by all structs // embedding an Orientable. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkOrientable. type IOrientable interface { toOrientable() *C.GtkOrientable } // native returns a pointer to the underlying GObject as a GtkOrientable. func (v *Orientable) native() *C.GtkOrientable { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkOrientable(p) } func marshalOrientable(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapOrientable(obj), nil } func wrapOrientable(obj *glib.Object) *Orientable { if obj == nil { return nil } return &Orientable{obj} } // GetOrientation is a wrapper around gtk_orientable_get_orientation(). func (v *Orientable) GetOrientation() Orientation { c := C.gtk_orientable_get_orientation(v.native()) return Orientation(c) } // SetOrientation is a wrapper around gtk_orientable_set_orientation(). func (v *Orientable) SetOrientation(orientation Orientation) { C.gtk_orientable_set_orientation(v.native(), C.GtkOrientation(orientation)) } /* * GtkOverlay */ // Overlay is a representation of GTK's GtkOverlay. type Overlay struct { Bin } // native returns a pointer to the underlying GtkOverlay. func (v *Overlay) native() *C.GtkOverlay { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkOverlay(p) } func marshalOverlay(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapOverlay(obj), nil } func wrapOverlay(obj *glib.Object) *Overlay { if obj == nil { return nil } return &Overlay{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // OverlayNew() is a wrapper around gtk_overlay_new(). func OverlayNew() (*Overlay, error) { c := C.gtk_overlay_new() if c == nil { return nil, nilPtrErr } return wrapOverlay(glib.Take(unsafe.Pointer(c))), nil } // AddOverlay() is a wrapper around gtk_overlay_add_overlay(). func (v *Overlay) AddOverlay(widget IWidget) { C.gtk_overlay_add_overlay(v.native(), widget.toWidget()) } /* * GtkPaned */ // Paned is a representation of GTK's GtkPaned. type Paned struct { Bin } // native returns a pointer to the underlying GtkPaned. func (v *Paned) native() *C.GtkPaned { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkPaned(p) } func marshalPaned(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapPaned(obj), nil } func wrapPaned(obj *glib.Object) *Paned { if obj == nil { return nil } return &Paned{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // PanedNew() is a wrapper around gtk_paned_new(). func PanedNew(orientation Orientation) (*Paned, error) { c := C.gtk_paned_new(C.GtkOrientation(orientation)) if c == nil { return nil, nilPtrErr } return wrapPaned(glib.Take(unsafe.Pointer(c))), nil } // Add1() is a wrapper around gtk_paned_add1(). func (v *Paned) Add1(child IWidget) { C.gtk_paned_add1(v.native(), child.toWidget()) } // Add2() is a wrapper around gtk_paned_add2(). func (v *Paned) Add2(child IWidget) { C.gtk_paned_add2(v.native(), child.toWidget()) } // Pack1() is a wrapper around gtk_paned_pack1(). func (v *Paned) Pack1(child IWidget, resize, shrink bool) { C.gtk_paned_pack1(v.native(), child.toWidget(), gbool(resize), gbool(shrink)) } // Pack2() is a wrapper around gtk_paned_pack2(). func (v *Paned) Pack2(child IWidget, resize, shrink bool) { C.gtk_paned_pack2(v.native(), child.toWidget(), gbool(resize), gbool(shrink)) } // SetPosition() is a wrapper around gtk_paned_set_position(). func (v *Paned) SetPosition(position int) { C.gtk_paned_set_position(v.native(), C.gint(position)) } // GetChild1() is a wrapper around gtk_paned_get_child1(). func (v *Paned) GetChild1() (IWidget, error) { c := C.gtk_paned_get_child1(v.native()) if c == nil { return nil, nil } return castWidget(c) } // GetChild2() is a wrapper around gtk_paned_get_child2(). func (v *Paned) GetChild2() (IWidget, error) { c := C.gtk_paned_get_child2(v.native()) if c == nil { return nil, nil } return castWidget(c) } // GetHandleWindow() is a wrapper around gtk_paned_get_handle_window(). func (v *Paned) GetHandleWindow() (*Window, error) { c := C.gtk_paned_get_handle_window(v.native()) if c == nil { return nil, nilPtrErr } return wrapWindow(glib.Take(unsafe.Pointer(c))), nil } // GetPosition() is a wrapper around gtk_paned_get_position(). func (v *Paned) GetPosition() int { return int(C.gtk_paned_get_position(v.native())) } /* * GtkInvisible */ // TODO: // gtk_invisible_new(). // gtk_invisible_new_for_screen(). // gtk_invisible_set_screen(). // gtk_invisible_get_screen(). /* * GtkProgressBar */ // ProgressBar is a representation of GTK's GtkProgressBar. type ProgressBar struct { Widget // Interfaces Orientable } // native returns a pointer to the underlying GtkProgressBar. func (v *ProgressBar) native() *C.GtkProgressBar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkProgressBar(p) } func marshalProgressBar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapProgressBar(obj), nil } func wrapProgressBar(obj *glib.Object) *ProgressBar { if obj == nil { return nil } o := wrapOrientable(obj) return &ProgressBar{Widget{glib.InitiallyUnowned{obj}}, *o} } // ProgressBarNew is a wrapper around gtk_progress_bar_new(). func ProgressBarNew() (*ProgressBar, error) { c := C.gtk_progress_bar_new() if c == nil { return nil, nilPtrErr } return wrapProgressBar(glib.Take(unsafe.Pointer(c))), nil } // SetFraction is a wrapper around gtk_progress_bar_set_fraction(). func (v *ProgressBar) SetFraction(fraction float64) { C.gtk_progress_bar_set_fraction(v.native(), C.gdouble(fraction)) } // GetFraction is a wrapper around gtk_progress_bar_get_fraction(). func (v *ProgressBar) GetFraction() float64 { c := C.gtk_progress_bar_get_fraction(v.native()) return float64(c) } // SetShowText is a wrapper around gtk_progress_bar_set_show_text(). func (v *ProgressBar) SetShowText(showText bool) { C.gtk_progress_bar_set_show_text(v.native(), gbool(showText)) } // GetShowText is a wrapper around gtk_progress_bar_get_show_text(). func (v *ProgressBar) GetShowText() bool { c := C.gtk_progress_bar_get_show_text(v.native()) return gobool(c) } // SetText is a wrapper around gtk_progress_bar_set_text(). func (v *ProgressBar) SetText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_progress_bar_set_text(v.native(), (*C.gchar)(cstr)) } // TODO: // gtk_progress_bar_get_text(). // gtk_progress_bar_set_ellipsize(). // gtk_progress_bar_get_ellipsize(). // SetPulseStep is a wrapper around gtk_progress_bar_set_pulse_step(). func (v *ProgressBar) SetPulseStep(fraction float64) { C.gtk_progress_bar_set_pulse_step(v.native(), C.gdouble(fraction)) } // GetPulseStep is a wrapper around gtk_progress_bar_get_pulse_step(). func (v *ProgressBar) GetPulseStep() float64 { c := C.gtk_progress_bar_get_pulse_step(v.native()) return float64(c) } // Pulse is a wrapper arountd gtk_progress_bar_pulse(). func (v *ProgressBar) Pulse() { C.gtk_progress_bar_pulse(v.native()) } // SetInverted is a wrapper around gtk_progress_bar_set_inverted(). func (v *ProgressBar) SetInverted(inverted bool) { C.gtk_progress_bar_set_inverted(v.native(), gbool(inverted)) } // GetInverted is a wrapper around gtk_progress_bar_get_inverted(). func (v *ProgressBar) GetInverted() bool { c := C.gtk_progress_bar_get_inverted(v.native()) return gobool(c) } /* * GtkRadioButton */ // RadioButton is a representation of GTK's GtkRadioButton. type RadioButton struct { CheckButton } // native returns a pointer to the underlying GtkRadioButton. func (v *RadioButton) native() *C.GtkRadioButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkRadioButton(p) } func marshalRadioButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapRadioButton(obj), nil } func wrapRadioButton(obj *glib.Object) *RadioButton { if obj == nil { return nil } actionable := wrapActionable(obj) return &RadioButton{CheckButton{ToggleButton{Button{Bin{Container{ Widget{glib.InitiallyUnowned{obj}}}}, actionable}}}} } // RadioButtonNew is a wrapper around gtk_radio_button_new(). func RadioButtonNew(group *glib.SList) (*RadioButton, error) { c := C.gtk_radio_button_new(cGSList(group)) if c == nil { return nil, nilPtrErr } return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil } // RadioButtonNewFromWidget is a wrapper around gtk_radio_button_new_from_widget(). func RadioButtonNewFromWidget(radioGroupMember *RadioButton) (*RadioButton, error) { c := C.gtk_radio_button_new_from_widget(radioGroupMember.native()) if c == nil { return nil, nilPtrErr } return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil } // RadioButtonNewWithLabel is a wrapper around gtk_radio_button_new_with_label(). func RadioButtonNewWithLabel(group *glib.SList, label string) (*RadioButton, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_radio_button_new_with_label(cGSList(group), (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil } // RadioButtonNewWithLabelFromWidget is a wrapper around gtk_radio_button_new_with_label_from_widget(). func RadioButtonNewWithLabelFromWidget(radioGroupMember *RadioButton, label string) (*RadioButton, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) var cradio *C.GtkRadioButton if radioGroupMember != nil { cradio = radioGroupMember.native() } c := C.gtk_radio_button_new_with_label_from_widget(cradio, (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil } // RadioButtonNewWithMnemonic is a wrapper around gtk_radio_button_new_with_mnemonic(). func RadioButtonNewWithMnemonic(group *glib.SList, label string) (*RadioButton, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_radio_button_new_with_mnemonic(cGSList(group), (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil } // RadioButtonNewWithMnemonicFromWidget is a wrapper around gtk_radio_button_new_with_mnemonic_from_widget(). func RadioButtonNewWithMnemonicFromWidget(radioGroupMember *RadioButton, label string) (*RadioButton, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) var cradio *C.GtkRadioButton if radioGroupMember != nil { cradio = radioGroupMember.native() } c := C.gtk_radio_button_new_with_mnemonic_from_widget(cradio, (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapRadioButton(glib.Take(unsafe.Pointer(c))), nil } // SetGroup is a wrapper around gtk_radio_button_set_group(). func (v *RadioButton) SetGroup(group *glib.SList) { C.gtk_radio_button_set_group(v.native(), cGSList(group)) } // GetGroup is a wrapper around gtk_radio_button_get_group(). func (v *RadioButton) GetGroup() (*glib.SList, error) { c := C.gtk_radio_button_get_group(v.native()) if c == nil { return nil, nilPtrErr } // TODO: call DataWrapper on SList and wrap them to gtk.RadioButton return glib.WrapSList(uintptr(unsafe.Pointer(c))), nil } // JoinGroup is a wrapper around gtk_radio_button_join_group(). func (v *RadioButton) JoinGroup(groupSource *RadioButton) { var cgroup *C.GtkRadioButton if groupSource != nil { cgroup = groupSource.native() } C.gtk_radio_button_join_group(v.native(), cgroup) } /* * GtkRadioMenuItem */ // RadioMenuItem is a representation of GTK's GtkRadioMenuItem. type RadioMenuItem struct { CheckMenuItem } // native returns a pointer to the underlying GtkRadioMenuItem. func (v *RadioMenuItem) native() *C.GtkRadioMenuItem { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkRadioMenuItem(p) } func marshalRadioMenuItem(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapRadioMenuItem(obj), nil } func wrapRadioMenuItem(obj *glib.Object) *RadioMenuItem { if obj == nil { return nil } return &RadioMenuItem{CheckMenuItem{MenuItem{Bin{Container{ Widget{glib.InitiallyUnowned{obj}}}}}}} } // RadioMenuItemNew is a wrapper around gtk_radio_menu_item_new(). func RadioMenuItemNew(group *glib.SList) (*RadioMenuItem, error) { c := C.gtk_radio_menu_item_new(cGSList(group)) if c == nil { return nil, nilPtrErr } return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil } // RadioMenuItemNewWithLabel is a wrapper around gtk_radio_menu_item_new_with_label(). func RadioMenuItemNewWithLabel(group *glib.SList, label string) (*RadioMenuItem, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_radio_menu_item_new_with_label(cGSList(group), (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil } // RadioMenuItemNewWithMnemonic is a wrapper around gtk_radio_menu_item_new_with_mnemonic(). func RadioMenuItemNewWithMnemonic(group *glib.SList, label string) (*RadioMenuItem, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_radio_menu_item_new_with_mnemonic(cGSList(group), (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil } // RadioMenuItemNewFromWidget is a wrapper around gtk_radio_menu_item_new_from_widget(). func RadioMenuItemNewFromWidget(group *RadioMenuItem) (*RadioMenuItem, error) { c := C.gtk_radio_menu_item_new_from_widget(group.native()) if c == nil { return nil, nilPtrErr } return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil } // RadioMenuItemNewWithLabelFromWidget is a wrapper around gtk_radio_menu_item_new_with_label_from_widget(). func RadioMenuItemNewWithLabelFromWidget(group *RadioMenuItem, label string) (*RadioMenuItem, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_radio_menu_item_new_with_label_from_widget(group.native(), (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil } // RadioMenuItemNewWithMnemonicFromWidget is a wrapper around gtk_radio_menu_item_new_with_mnemonic_from_widget(). func RadioMenuItemNewWithMnemonicFromWidget(group *RadioMenuItem, label string) (*RadioMenuItem, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_radio_menu_item_new_with_mnemonic_from_widget(group.native(), (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapRadioMenuItem(glib.Take(unsafe.Pointer(c))), nil } // SetGroup is a wrapper around gtk_radio_menu_item_set_group(). func (v *RadioMenuItem) SetGroup(group *glib.SList) { C.gtk_radio_menu_item_set_group(v.native(), cGSList(group)) } // GetGroup is a wrapper around gtk_radio_menu_item_get_group(). func (v *RadioMenuItem) GetGroup() (*glib.SList, error) { c := C.gtk_radio_menu_item_get_group(v.native()) if c == nil { return nil, nilPtrErr } // TODO: call DataWrapper on SList and wrap them to gtk.RadioMenuItem return glib.WrapSList(uintptr(unsafe.Pointer(c))), nil } /* * GtkRange */ // Range is a representation of GTK's GtkRange. type Range struct { Widget } // native returns a pointer to the underlying GtkRange. func (v *Range) native() *C.GtkRange { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkRange(p) } func marshalRange(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapRange(obj), nil } func wrapRange(obj *glib.Object) *Range { if obj == nil { return nil } return &Range{Widget{glib.InitiallyUnowned{obj}}} } // GetFillLevel is a wrapper around gtk_range_get_fill_level(). func (v *Range) GetFillLevel() float64 { return float64(C.gtk_range_get_fill_level(v.native())) } // GetRestrictToFillLevel is a wrapper around gtk_range_get_restrict_to_fill_level(). func (v *Range) GetRestrictToFillLevel() bool { return gobool(C.gtk_range_get_restrict_to_fill_level(v.native())) } // GetShowFillLevel is a wrapper around gtk_range_get_show_fill_level(). func (v *Range) GetShowFillLevel() bool { return gobool(C.gtk_range_get_show_fill_level(v.native())) } // SetFillLevel is a wrapper around gtk_range_set_fill_level(). func (v *Range) SetFillLevel(fill_level float64) { C.gtk_range_set_fill_level(v.native(), C.gdouble(fill_level)) } // RestrictToFillLevel is a wrapper around gtk_range_set_restrict_to_fill_level(). func (v *Range) RestrictToFillLevel(restrict_to_fill_level bool) { C.gtk_range_set_restrict_to_fill_level(v.native(), gbool(restrict_to_fill_level)) } // SetShowFillLevel is a wrapper around gtk_range_set_show_fill_level(). func (v *Range) SetShowFillLevel(show_fill_level bool) { C.gtk_range_set_show_fill_level(v.native(), gbool(show_fill_level)) } // GetAdjustment is a wrapper around gtk_range_get_adjustment(). func (v *Range) GetAdjustment() *Adjustment { c := C.gtk_range_get_adjustment(v.native()) if c == nil { return nil } obj := glib.Take(unsafe.Pointer(c)) return wrapAdjustment(obj) } // SetAdjustment is a wrapper around gtk_range_set_adjustment(). func (v *Range) SetAdjustment(adjustment *Adjustment) { C.gtk_range_set_adjustment(v.native(), adjustment.native()) } // GetValue is a wrapper around gtk_range_get_value(). func (v *Range) GetValue() float64 { c := C.gtk_range_get_value(v.native()) return float64(c) } // SetValue is a wrapper around gtk_range_set_value(). func (v *Range) SetValue(value float64) { C.gtk_range_set_value(v.native(), C.gdouble(value)) } // SetIncrements is a wrapper around gtk_range_set_increments(). func (v *Range) SetIncrements(step, page float64) { C.gtk_range_set_increments(v.native(), C.gdouble(step), C.gdouble(page)) } // SetRange is a wrapper around gtk_range_set_range(). func (v *Range) SetRange(min, max float64) { C.gtk_range_set_range(v.native(), C.gdouble(min), C.gdouble(max)) } // GetInverted is a wrapper around gtk_range_get_inverted(). func (v *Range) GetInverted() bool { c := C.gtk_range_get_inverted(v.native()) return gobool(c) } // SetInverted is a wrapper around gtk_range_set_inverted(). func (v *Range) SetInverted(inverted bool) { C.gtk_range_set_inverted(v.native(), gbool(inverted)) } // GetRoundDigits is a wrapper around gtk_range_get_round_digits(). func (v *Range) GetRoundDigits() int { return int(C.gtk_range_get_round_digits(v.native())) } // SetRoundDigits is a wrapper around gtk_range_set_round_digits(). func (v *Range) SetRoundDigits(round_digits int) { C.gtk_range_set_round_digits(v.native(), C.gint(round_digits)) } // SetLowerStepperSensitivity is a wrapper around gtk_range_set_lower_stepper_sensitivity(). func (v *Range) SetLowerStepperSensitivity(sensitivity SensitivityType) { C.gtk_range_set_lower_stepper_sensitivity( v.native(), C.GtkSensitivityType(sensitivity)) } // GetLowerStepperSensitivity is a wrapper around gtk_range_get_lower_stepper_sensitivity(). func (v *Range) GetLowerStepperSensitivity() SensitivityType { return SensitivityType(C.gtk_range_get_lower_stepper_sensitivity( v.native())) } // SetUpperStepperSensitivity is a wrapper around gtk_range_set_upper_stepper_sensitivity(). func (v *Range) SetUpperStepperSensitivity(sensitivity SensitivityType) { C.gtk_range_set_upper_stepper_sensitivity( v.native(), C.GtkSensitivityType(sensitivity)) } // GetUpperStepperSensitivity is a wrapper around gtk_range_get_upper_stepper_sensitivity(). func (v *Range) GetUpperStepperSensitivity() SensitivityType { return SensitivityType(C.gtk_range_get_upper_stepper_sensitivity( v.native())) } // GetFlippable is a wrapper around gtk_range_get_flippable(). func (v *Range) GetFlippable() bool { return gobool(C.gtk_range_get_flippable(v.native())) } // SetFlippable is a wrapper around gtk_range_set_flippable(). func (v *Range) SetFlippable(flippable bool) { C.gtk_range_set_flippable(v.native(), gbool(flippable)) } // GetRangeRect is a wrapper around gtk_range_get_range_rect(). func (v *Range) GetRangeRect() *gdk.Rectangle { var cRect *C.GdkRectangle C.gtk_range_get_range_rect(v.native(), cRect) return gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) } // GetSliderRange is a wrapper around gtk_range_get_slider_range(). func (v *Range) GetSliderRange() (int, int) { var cStart, cEnd C.gint C.gtk_range_get_slider_range(v.native(), &cStart, &cEnd) return int(cStart), int(cEnd) } // GetSliderFixedSize is a wrapper gtk_range_get_slider_size_fixed(). func (v *Range) GetSliderFixedSize() bool { return gobool(C.gtk_range_get_slider_size_fixed(v.native())) } // SetSliderFixedSize is a wrapper around gtk_range_set_slider_size_fixed(). func (v *Range) SetSliderFixedSize(size_fixed bool) { C.gtk_range_set_slider_size_fixed(v.native(), gbool(size_fixed)) } // IRecentChooser is an interface type implemented by all structs // embedding a RecentChooser. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkWidget. type IRecentChooser interface { toRecentChooser() *C.GtkRecentChooser } /* * GtkRecentChooser */ // RecentChooser is a representation of GTK's GtkRecentChooser. type RecentChooser struct { *glib.Object } // native returns a pointer to the underlying GtkRecentChooser. func (v *RecentChooser) native() *C.GtkRecentChooser { if v == nil || v.Object == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkRecentChooser(p) } func wrapRecentChooser(obj *glib.Object) *RecentChooser { if obj == nil { return nil } return &RecentChooser{obj} } func (v *RecentChooser) toRecentChooser() *C.GtkRecentChooser { return v.native() } func (v *RecentChooser) GetCurrentUri() string { curi := C.gtk_recent_chooser_get_current_uri(v.native()) return goString(curi) } func (v *RecentChooser) AddFilter(filter *RecentFilter) { C.gtk_recent_chooser_add_filter(v.native(), filter.native()) } func (v *RecentChooser) RemoveFilter(filter *RecentFilter) { C.gtk_recent_chooser_remove_filter(v.native(), filter.native()) } /* * GtkRecentChooserWidget */ // TODO: // gtk_recent_chooser_widget_new(). // gtk_recent_chooser_widget_new_for_manager(). /* * GtkRecentChooserMenu */ // RecentChooserMenu is a representation of GTK's GtkRecentChooserMenu. type RecentChooserMenu struct { Menu RecentChooser } // native returns a pointer to the underlying GtkRecentManager. func (v *RecentChooserMenu) native() *C.GtkRecentChooserMenu { if v == nil || v.Object == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkRecentChooserMenu(p) } func wrapRecentChooserMenu(obj *glib.Object) *RecentChooserMenu { if obj == nil { return nil } return &RecentChooserMenu{ Menu{MenuShell{Container{Widget{glib.InitiallyUnowned{obj}}}}}, RecentChooser{obj}, } } /* * GtkRecentFilter */ // RecentFilter is a representation of GTK's GtkRecentFilter. type RecentFilter struct { glib.InitiallyUnowned } // native returns a pointer to the underlying GtkRecentFilter. func (v *RecentFilter) native() *C.GtkRecentFilter { if v == nil || v.Object == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkRecentFilter(p) } func wrapRecentFilter(obj *glib.Object) *RecentFilter { if obj == nil { return nil } return &RecentFilter{glib.InitiallyUnowned{obj}} } // RecentFilterNew is a wrapper around gtk_recent_filter_new(). func RecentFilterNew() (*RecentFilter, error) { c := C.gtk_recent_filter_new() if c == nil { return nil, nilPtrErr } return wrapRecentFilter(glib.Take(unsafe.Pointer(c))), nil } /* * GtkRecentManager */ // RecentManager is a representation of GTK's GtkRecentManager. type RecentManager struct { *glib.Object } // native returns a pointer to the underlying GtkRecentManager. func (v *RecentManager) native() *C.GtkRecentManager { if v == nil || v.Object == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkRecentManager(p) } func marshalRecentManager(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapRecentManager(obj), nil } func wrapRecentManager(obj *glib.Object) *RecentManager { if obj == nil { return nil } return &RecentManager{obj} } // RecentManagerGetDefault is a wrapper around gtk_recent_manager_get_default(). func RecentManagerGetDefault() (*RecentManager, error) { c := C.gtk_recent_manager_get_default() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) v := wrapRecentManager(obj) return v, nil } // AddItem is a wrapper around gtk_recent_manager_add_item(). func (v *RecentManager) AddItem(fileURI string) bool { cstr := C.CString(fileURI) defer C.free(unsafe.Pointer(cstr)) cok := C.gtk_recent_manager_add_item(v.native(), (*C.gchar)(cstr)) return gobool(cok) } /* * GtkScale */ // Scale is a representation of GTK's GtkScale. type Scale struct { Range } // native returns a pointer to the underlying GtkScale. func (v *Scale) native() *C.GtkScale { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkScale(p) } func marshalScale(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapScale(obj), nil } func wrapScale(obj *glib.Object) *Scale { if obj == nil { return nil } return &Scale{Range{Widget{glib.InitiallyUnowned{obj}}}} } // ScaleNew is a wrapper around gtk_scale_new(). func ScaleNew(orientation Orientation, adjustment *Adjustment) (*Scale, error) { c := C.gtk_scale_new(C.GtkOrientation(orientation), adjustment.native()) if c == nil { return nil, nilPtrErr } return wrapScale(glib.Take(unsafe.Pointer(c))), nil } // ScaleNewWithRange is a wrapper around gtk_scale_new_with_range(). func ScaleNewWithRange(orientation Orientation, min, max, step float64) (*Scale, error) { c := C.gtk_scale_new_with_range(C.GtkOrientation(orientation), C.gdouble(min), C.gdouble(max), C.gdouble(step)) if c == nil { return nil, nilPtrErr } return wrapScale(glib.Take(unsafe.Pointer(c))), nil } // TODO: // gtk_scale_set_digits(). // SetDrawValue is a wrapper around gtk_scale_set_draw_value(). func (v *Scale) SetDrawValue(drawValue bool) { C.gtk_scale_set_draw_value(v.native(), gbool(drawValue)) } // TODO: // gtk_scale_set_has_origin(). // gtk_scale_set_value_pos(). // gtk_scale_get_digits(). // gtk_scale_get_draw_value(). // gtk_scale_get_has_origin(). // gtk_scale_get_value_pos(). // gtk_scale_get_layout(). // gtk_scale_get_layout_offsets(). // AddMark is a wrpaper around gtk_scale_add_mark. func (v *Scale) AddMark(value float64, pos PositionType, markup string) { var markupchar *C.gchar if markup != "" { markupchar = (*C.gchar)(C.CString(markup)) defer C.free(unsafe.Pointer(markupchar)) } C.gtk_scale_add_mark(v.native(), C.gdouble(value), C.GtkPositionType(pos), markupchar) } // ClearMarks is a wrapper around gtk_scale_clear_marks. func (v *Scale) ClearMarks() { C.gtk_scale_clear_marks(v.native()) } /* * GtkScaleButton */ // ScaleButton is a representation of GTK's GtkScaleButton. type ScaleButton struct { Button } // native returns a pointer to the underlying GtkScaleButton. func (v *ScaleButton) native() *C.GtkScaleButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkScaleButton(p) } func marshalScaleButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapScaleButton(obj), nil } func wrapScaleButton(obj *glib.Object) *ScaleButton { if obj == nil { return nil } actionable := wrapActionable(obj) return &ScaleButton{Button{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}, actionable}} } // ScaleButtonNew is a wrapper around gtk_scale_button_new(). func ScaleButtonNew(size IconSize, min, max, step float64, icons []string) (*ScaleButton, error) { cicons := make([]*C.gchar, len(icons)) for i, icon := range icons { cicons[i] = (*C.gchar)(C.CString(icon)) defer C.free(unsafe.Pointer(cicons[i])) } cicons = append(cicons, nil) c := C.gtk_scale_button_new(C.GtkIconSize(size), C.gdouble(min), C.gdouble(max), C.gdouble(step), &cicons[0]) if c == nil { return nil, nilPtrErr } return wrapScaleButton(glib.Take(unsafe.Pointer(c))), nil } // GetPopup is a wrapper around gtk_scale_button_get_popup(). func (v *ScaleButton) GetPopup() (IWidget, error) { c := C.gtk_scale_button_get_popup(v.native()) if c == nil { return nil, nilPtrErr } return castWidget(c) } // GetValue is a wrapper around gtk_scale_button_get_value(). func (v *ScaleButton) GetValue() float64 { return float64(C.gtk_scale_button_get_value(v.native())) } // SetValue is a wrapper around gtk_scale_button_set_value(). func (v *ScaleButton) SetValue(value float64) { C.gtk_scale_button_set_value(v.native(), C.gdouble(value)) } // SetIcons is a wrapper around gtk_scale_button_set_icons(). func (v *ScaleButton) SetIcons() []string { var iconNames *C.gchar = nil C.gtk_scale_button_set_icons(v.native(), &iconNames) return toGoStringArray(&iconNames) } // GetAdjustment is a wrapper around gtk_scale_button_get_adjustment(). func (v *ScaleButton) GetAdjustment() *Adjustment { c := C.gtk_scale_button_get_adjustment(v.native()) obj := glib.Take(unsafe.Pointer(c)) return &Adjustment{glib.InitiallyUnowned{obj}} } // SetAdjustment is a wrapper around gtk_scale_button_set_adjustment(). func (v *ScaleButton) SetAdjustment(adjustment *Adjustment) { C.gtk_scale_button_set_adjustment(v.native(), adjustment.native()) } // GetPlusButton is a wrapper around gtk_scale_button_get_plus_button(). func (v *ScaleButton) GetPlusButton() (IWidget, error) { c := C.gtk_scale_button_get_plus_button(v.native()) if c == nil { return nil, nilPtrErr } return castWidget(c) } // GetMinusButton is a wrapper around gtk_scale_button_get_minus_button(). func (v *ScaleButton) GetMinusButton() (IWidget, error) { c := C.gtk_scale_button_get_minus_button(v.native()) if c == nil { return nil, nilPtrErr } return castWidget(c) } /* * GtkScrollable */ // IScrollable is an interface type implemented by all structs // embedding a Scrollable. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkScrollable. type IScrollable interface { toScrollable() *C.GtkScrollable } // Scrollable is a representation of GTK's GtkScrollable GInterface. type Scrollable struct { *glib.Object } // native() returns a pointer to the underlying GObject as a GtkScrollable. func (v *Scrollable) native() *C.GtkScrollable { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkScrollable(p) } func wrapScrollable(obj *glib.Object) *Scrollable { if obj == nil { return nil } return &Scrollable{obj} } func (v *Scrollable) toScrollable() *C.GtkScrollable { if v == nil { return nil } return v.native() } // SetHAdjustment is a wrapper around gtk_scrollable_set_hadjustment(). func (v *Scrollable) SetHAdjustment(adjustment *Adjustment) { C.gtk_scrollable_set_hadjustment(v.native(), adjustment.native()) } // GetHAdjustment is a wrapper around gtk_scrollable_get_hadjustment(). func (v *Scrollable) GetHAdjustment() (*Adjustment, error) { c := C.gtk_scrollable_get_hadjustment(v.native()) if c == nil { return nil, nilPtrErr } return wrapAdjustment(glib.Take(unsafe.Pointer(c))), nil } // SetVAdjustment is a wrapper around gtk_scrollable_set_vadjustment(). func (v *Scrollable) SetVAdjustment(adjustment *Adjustment) { C.gtk_scrollable_set_vadjustment(v.native(), adjustment.native()) } // GetVAdjustment is a wrapper around gtk_scrollable_get_vadjustment(). func (v *Scrollable) GetVAdjustment() (*Adjustment, error) { c := C.gtk_scrollable_get_vadjustment(v.native()) if c == nil { return nil, nilPtrErr } return wrapAdjustment(glib.Take(unsafe.Pointer(c))), nil } /* * GtkScrollbar */ // Scrollbar is a representation of GTK's GtkScrollbar. type Scrollbar struct { Range } // native returns a pointer to the underlying GtkScrollbar. func (v *Scrollbar) native() *C.GtkScrollbar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkScrollbar(p) } func marshalScrollbar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapScrollbar(obj), nil } func wrapScrollbar(obj *glib.Object) *Scrollbar { if obj == nil { return nil } return &Scrollbar{Range{Widget{glib.InitiallyUnowned{obj}}}} } // ScrollbarNew is a wrapper around gtk_scrollbar_new(). func ScrollbarNew(orientation Orientation, adjustment *Adjustment) (*Scrollbar, error) { c := C.gtk_scrollbar_new(C.GtkOrientation(orientation), adjustment.native()) if c == nil { return nil, nilPtrErr } return wrapScrollbar(glib.Take(unsafe.Pointer(c))), nil } /* * GtkScrolledWindow */ // ScrolledWindow is a representation of GTK's GtkScrolledWindow. type ScrolledWindow struct { Bin } // native returns a pointer to the underlying GtkScrolledWindow. func (v *ScrolledWindow) native() *C.GtkScrolledWindow { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkScrolledWindow(p) } func marshalScrolledWindow(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapScrolledWindow(obj), nil } func wrapScrolledWindow(obj *glib.Object) *ScrolledWindow { if obj == nil { return nil } return &ScrolledWindow{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // ScrolledWindowNew() is a wrapper around gtk_scrolled_window_new(). func ScrolledWindowNew(hadjustment, vadjustment *Adjustment) (*ScrolledWindow, error) { c := C.gtk_scrolled_window_new(hadjustment.native(), vadjustment.native()) if c == nil { return nil, nilPtrErr } return wrapScrolledWindow(glib.Take(unsafe.Pointer(c))), nil } // GetPolicy() is a wrapper around gtk_scrolled_window_get_policy(). func (v *ScrolledWindow) GetPolicy() (hScrollbarPolicy, vScrollbarPolicy PolicyType) { var hScrPol, vScrPol C.GtkPolicyType C.gtk_scrolled_window_get_policy(v.native(), &hScrPol, &vScrPol) hScrollbarPolicy, vScrollbarPolicy = PolicyType(hScrPol), PolicyType(vScrPol) return } // SetPolicy() is a wrapper around gtk_scrolled_window_set_policy(). func (v *ScrolledWindow) SetPolicy(hScrollbarPolicy, vScrollbarPolicy PolicyType) { C.gtk_scrolled_window_set_policy(v.native(), C.GtkPolicyType(hScrollbarPolicy), C.GtkPolicyType(vScrollbarPolicy)) } // GetHAdjustment() is a wrapper around gtk_scrolled_window_get_hadjustment(). func (v *ScrolledWindow) GetHAdjustment() *Adjustment { c := C.gtk_scrolled_window_get_hadjustment(v.native()) if c == nil { return nil } return wrapAdjustment(glib.Take(unsafe.Pointer(c))) } // SetHAdjustment is a wrapper around gtk_scrolled_window_set_hadjustment(). func (v *ScrolledWindow) SetHAdjustment(adjustment *Adjustment) { C.gtk_scrolled_window_set_hadjustment(v.native(), adjustment.native()) } // GetVAdjustment() is a wrapper around gtk_scrolled_window_get_vadjustment(). func (v *ScrolledWindow) GetVAdjustment() *Adjustment { c := C.gtk_scrolled_window_get_vadjustment(v.native()) if c == nil { return nil } return wrapAdjustment(glib.Take(unsafe.Pointer(c))) } // SetVAdjustment is a wrapper around gtk_scrolled_window_set_vadjustment(). func (v *ScrolledWindow) SetVAdjustment(adjustment *Adjustment) { C.gtk_scrolled_window_set_vadjustment(v.native(), adjustment.native()) } // GetHScrollbar is a wrapper around gtk_scrolled_window_get_hscrollbar(). func (v *ScrolledWindow) GetHScrollbar() *Scrollbar { c := C.gtk_scrolled_window_get_hscrollbar(v.native()) if c == nil { return nil } return wrapScrollbar(glib.Take(unsafe.Pointer(c))) } // GetVScrollbar is a wrapper around gtk_scrolled_window_get_vscrollbar(). func (v *ScrolledWindow) GetVScrollbar() *Scrollbar { c := C.gtk_scrolled_window_get_vscrollbar(v.native()) if c == nil { return nil } return wrapScrollbar(glib.Take(unsafe.Pointer(c))) } // GetPlacement is a wrapper around gtk_scrolled_window_get_placement(). func (v *ScrolledWindow) GetPlacement() CornerType { c := C.gtk_scrolled_window_get_placement(v.native()) return CornerType(c) } // SetPlacement is a wrapper around gtk_scrolled_window_set_placement(). func (v *ScrolledWindow) SetPlacement(windowPlacement CornerType) { C.gtk_scrolled_window_set_placement(v.native(), C.GtkCornerType(windowPlacement)) } // UnsetPlacement is a wrapper around gtk_scrolled_window_unset_placement(). func (v *ScrolledWindow) UnsetPlacement() { C.gtk_scrolled_window_unset_placement(v.native()) } // GetShadowType is a wrapper around gtk_scrolled_window_get_shadow_type(). func (v *ScrolledWindow) GetShadowType() ShadowType { c := C.gtk_scrolled_window_get_shadow_type(v.native()) return ShadowType(c) } // SetShadowType is a wrapper around gtk_scrolled_window_set_shadow_type(). func (v *ScrolledWindow) SetShadowType(t ShadowType) { C.gtk_scrolled_window_set_shadow_type(v.native(), C.GtkShadowType(t)) } // GetKineticScrolling is a wrapper around gtk_scrolled_window_get_kinetic_scrolling(). func (v *ScrolledWindow) GetKineticScrolling() bool { c := C.gtk_scrolled_window_get_kinetic_scrolling(v.native()) return gobool(c) } // SetKineticScrolling is a wrapper around gtk_scrolled_window_set_kinetic_scrolling(). func (v *ScrolledWindow) SetKineticScrolling(kineticScrolling bool) { C.gtk_scrolled_window_set_kinetic_scrolling(v.native(), gbool(kineticScrolling)) } // GetCaptureButtonPress is a wrapper around gtk_scrolled_window_get_capture_button_press(). func (v *ScrolledWindow) GetCaptureButtonPress() bool { c := C.gtk_scrolled_window_get_capture_button_press(v.native()) return gobool(c) } // SetCaptureButtonPress is a wrapper around gtk_scrolled_window_set_capture_button_press(). func (v *ScrolledWindow) SetCaptureButtonPress(captureButtonPress bool) { C.gtk_scrolled_window_set_capture_button_press(v.native(), gbool(captureButtonPress)) } // GetMinContentWidth is a wrapper around gtk_scrolled_window_get_min_content_width(). func (v *ScrolledWindow) GetMinContentWidth() int { c := C.gtk_scrolled_window_get_min_content_width(v.native()) return int(c) } // SetMinContentWidth is a wrapper around gtk_scrolled_window_set_min_content_width(). func (v *ScrolledWindow) SetMinContentWidth(width int) { C.gtk_scrolled_window_set_min_content_width(v.native(), C.gint(width)) } // GetMinContentHeight is a wrapper around gtk_scrolled_window_get_min_content_height(). func (v *ScrolledWindow) GetMinContentHeight() int { c := C.gtk_scrolled_window_get_min_content_height(v.native()) return int(c) } // SetMinContentHeight is a wrapper around gtk_scrolled_window_set_min_content_height(). func (v *ScrolledWindow) SetMinContentHeight(width int) { C.gtk_scrolled_window_set_min_content_height(v.native(), C.gint(width)) } /* * GtkSearchEntry */ // SearchEntry is a reprensentation of GTK's GtkSearchEntry. type SearchEntry struct { Entry } // native returns a pointer to the underlying GtkSearchEntry. func (v *SearchEntry) native() *C.GtkSearchEntry { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSearchEntry(p) } func marshalSearchEntry(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapSearchEntry(obj), nil } func wrapSearchEntry(obj *glib.Object) *SearchEntry { if obj == nil { return nil } e := wrapEditable(obj) ce := wrapCellEditable(obj) return &SearchEntry{Entry{Widget{glib.InitiallyUnowned{obj}}, *e, *ce}} } // SearchEntryNew is a wrapper around gtk_search_entry_new(). func SearchEntryNew() (*SearchEntry, error) { c := C.gtk_search_entry_new() if c == nil { return nil, nilPtrErr } return wrapSearchEntry(glib.Take(unsafe.Pointer(c))), nil } /* * GtkSelectionData */ type SelectionData struct { GtkSelectionData *C.GtkSelectionData } func marshalSelectionData(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return (*SelectionData)(unsafe.Pointer(c)), nil } // native returns a pointer to the underlying GtkSelectionData. func (v *SelectionData) native() *C.GtkSelectionData { if v == nil { return nil } // I don't understand why we need this, but we do. c := (*C.GValue)(unsafe.Pointer(v)) p := (*C.GtkSelectionData)(unsafe.Pointer(c)) return p } // GetLength is a wrapper around gtk_selection_data_get_length(). func (v *SelectionData) GetLength() int { return int(C.gtk_selection_data_get_length(v.native())) } // GetData is a wrapper around gtk_selection_data_get_data_with_length(). // It returns a slice of the correct size with the copy of the selection's data. func (v *SelectionData) GetData() []byte { var length C.gint c := C.gtk_selection_data_get_data_with_length(v.native(), &length) // Only set if length is valid. if int(length) < 1 { return nil } var data []byte sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data)) sliceHeader.Len = int(length) sliceHeader.Cap = int(length) sliceHeader.Data = uintptr(unsafe.Pointer(c)) // Keep the SelectionData alive for as long as the byte slice is. runtime.SetFinalizer(&data, func(*[]byte) { runtime.KeepAlive(v) }) return data } // SetData is a wrapper around gtk_selection_data_set_data_with_length(). func (v *SelectionData) SetData(atom gdk.Atom, data []byte) { C.gtk_selection_data_set( v.native(), C.GdkAtom(unsafe.Pointer(atom)), C.gint(8), (*C.guchar)(&data[0]), C.gint(len(data)), ) } // GetText is a wrapper around gtk_selection_data_get_text(). It returns a copy // of the string from SelectionData and frees the C reference. func (v *SelectionData) GetText() string { charptr := C.gtk_selection_data_get_text(v.native()) if charptr == nil { return "" } defer C.g_free(C.gpointer(charptr)) return ucharString(charptr) } // SetText is a wrapper around gtk_selection_data_set_text(). func (v *SelectionData) SetText(text string) bool { textPtr := *(*[]byte)(unsafe.Pointer(&text)) return gobool(C.gtk_selection_data_set_text( v.native(), // https://play.golang.org/p/PmGaLDhRuEU // This is probably safe since we expect Gdk to copy the string anyway. (*C.gchar)(unsafe.Pointer(&textPtr[0])), C.int(len(text)), )) } // SetPixbuf is a wrapper around gtk_selection_data_set_pixbuf(). func (v *SelectionData) SetPixbuf(pixbuf *gdk.Pixbuf) bool { return gobool(C.gtk_selection_data_set_pixbuf( v.native(), (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native())), )) } // GetPixbuf is a wrapper around gtk_selection_data_get_pixbuf(). It returns nil // if the data is a recognized image type that could be converted to a new // Pixbuf. func (v *SelectionData) GetPixbuf() *gdk.Pixbuf { c := C.gtk_selection_data_get_pixbuf(v.native()) if c == nil { return nil } obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))} p := &gdk.Pixbuf{obj} runtime.SetFinalizer(p, func(_ interface{}) { glib.FinalizerStrategy(obj.Unref) }) return p } // SetURIs is a wrapper around gtk_selection_data_set_uris(). func (v *SelectionData) SetURIs(uris []string) bool { var clist = C.make_strings(C.int(len(uris))) for i := range uris { cstring := C.CString(uris[i]) // This defer will only run once the function exits, not once the loop // exits, so it's perfectly fine. defer C.free(unsafe.Pointer(cstring)) C.set_string(clist, C.int(i), (*C.gchar)(cstring)) } return gobool(C.gtk_selection_data_set_uris(v.native(), clist)) } // GetURIs is a wrapper around gtk_selection_data_get_uris(). func (v *SelectionData) GetURIs() []string { uriPtrs := C.gtk_selection_data_get_uris(v.native()) return toGoStringArray(uriPtrs) } func (v *SelectionData) free() { C.gtk_selection_data_free(v.native()) } // DragSetIconPixbuf is used for the "drag-begin" event. It is a wrapper around // gtk_drag_set_icon_pixbuf(). func DragSetIconPixbuf(context *gdk.DragContext, pixbuf *gdk.Pixbuf, hotX, hotY int) { ctx := unsafe.Pointer(context.Native()) pix := unsafe.Pointer(pixbuf.Native()) C.gtk_drag_set_icon_pixbuf((*C.GdkDragContext)(ctx), (*C.GdkPixbuf)(pix), C.gint(hotX), C.gint(hotY)) } // DragSetIconWidget is a wrapper around gtk_drag_set_icon_widget(). func DragSetIconWidget(context *gdk.DragContext, w IWidget, hotX, hotY int) { ctx := unsafe.Pointer(context.Native()) C.gtk_drag_set_icon_widget((*C.GdkDragContext)(ctx), w.toWidget(), C.gint(hotX), C.gint(hotY)) } // DragSetIconSurface is a wrapper around gtk_drag_set_icon_surface(). func DragSetIconSurface(context *gdk.DragContext, surface *cairo.Surface) { ctx := unsafe.Pointer(context.Native()) sur := unsafe.Pointer(surface.Native()) C.gtk_drag_set_icon_surface((*C.GdkDragContext)(ctx), (*C.cairo_surface_t)(sur)) } // DragSetIconName is a wrapper around gtk_drag_set_icon_name(). func DragSetIconName(context *gdk.DragContext, iconName string, hotX, hotY int) { ctx := unsafe.Pointer(context.Native()) ico := (*C.gchar)(C.CString(iconName)) defer C.free(unsafe.Pointer(ico)) C.gtk_drag_set_icon_name((*C.GdkDragContext)(ctx), ico, C.gint(hotX), C.gint(hotY)) } // DragSetIconDefault is a wrapper around gtk_drag_set_icon_default(). func DragSetIconDefault(context *gdk.DragContext) { ctx := unsafe.Pointer(context.Native()) C.gtk_drag_set_icon_default((*C.GdkDragContext)(ctx)) } /* * GtkSeparator */ // Separator is a representation of GTK's GtkSeparator. type Separator struct { Widget } // native returns a pointer to the underlying GtkSeperator. func (v *Separator) native() *C.GtkSeparator { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSeparator(p) } func marshalSeparator(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapSeparator(obj), nil } func wrapSeparator(obj *glib.Object) *Separator { if obj == nil { return nil } return &Separator{Widget{glib.InitiallyUnowned{obj}}} } // SeparatorNew is a wrapper around gtk_separator_new(). func SeparatorNew(orientation Orientation) (*Separator, error) { c := C.gtk_separator_new(C.GtkOrientation(orientation)) if c == nil { return nil, nilPtrErr } return wrapSeparator(glib.Take(unsafe.Pointer(c))), nil } /* * GtkSeparatorMenuItem */ // SeparatorMenuItem is a representation of GTK's GtkSeparatorMenuItem. type SeparatorMenuItem struct { MenuItem } // native returns a pointer to the underlying GtkSeparatorMenuItem. func (v *SeparatorMenuItem) native() *C.GtkSeparatorMenuItem { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSeparatorMenuItem(p) } func marshalSeparatorMenuItem(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapSeparatorMenuItem(obj), nil } func wrapSeparatorMenuItem(obj *glib.Object) *SeparatorMenuItem { if obj == nil { return nil } return &SeparatorMenuItem{MenuItem{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} } // SeparatorMenuItemNew is a wrapper around gtk_separator_menu_item_new(). func SeparatorMenuItemNew() (*SeparatorMenuItem, error) { c := C.gtk_separator_menu_item_new() if c == nil { return nil, nilPtrErr } return wrapSeparatorMenuItem(glib.Take(unsafe.Pointer(c))), nil } /* * GtkSeparatorToolItem */ // SeparatorToolItem is a representation of GTK's GtkSeparatorToolItem. type SeparatorToolItem struct { ToolItem } // native returns a pointer to the underlying GtkSeparatorToolItem. func (v *SeparatorToolItem) native() *C.GtkSeparatorToolItem { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSeparatorToolItem(p) } func marshalSeparatorToolItem(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapSeparatorToolItem(obj), nil } func wrapSeparatorToolItem(obj *glib.Object) *SeparatorToolItem { if obj == nil { return nil } return &SeparatorToolItem{ToolItem{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}}} } // SeparatorToolItemNew is a wrapper around gtk_separator_tool_item_new(). func SeparatorToolItemNew() (*SeparatorToolItem, error) { c := C.gtk_separator_tool_item_new() if c == nil { return nil, nilPtrErr } return wrapSeparatorToolItem(glib.Take(unsafe.Pointer(c))), nil } // SetDraw is a wrapper around gtk_separator_tool_item_set_draw(). func (v *SeparatorToolItem) SetDraw(draw bool) { C.gtk_separator_tool_item_set_draw(v.native(), gbool(draw)) } // GetDraw is a wrapper around gtk_separator_tool_item_get_draw(). func (v *SeparatorToolItem) GetDraw() bool { c := C.gtk_separator_tool_item_get_draw(v.native()) return gobool(c) } /* * GtkSizeGroup */ // SizeGroup is a representation of GTK's GtkSizeGroup type SizeGroup struct { *glib.Object } // native() returns a pointer to the underlying GtkSizeGroup func (v *SizeGroup) native() *C.GtkSizeGroup { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSizeGroup(p) } func marshalSizeGroup(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return &SizeGroup{obj}, nil } func wrapSizeGroup(obj *glib.Object) *SizeGroup { if obj == nil { return nil } return &SizeGroup{obj} } // SizeGroupNew is a wrapper around gtk_size_group_new(). func SizeGroupNew(mode SizeGroupMode) (*SizeGroup, error) { c := C.gtk_size_group_new(C.GtkSizeGroupMode(mode)) if c == nil { return nil, nilPtrErr } return wrapSizeGroup(glib.Take(unsafe.Pointer(c))), nil } func (v *SizeGroup) SetMode(mode SizeGroupMode) { C.gtk_size_group_set_mode(v.native(), C.GtkSizeGroupMode(mode)) } func (v *SizeGroup) GetMode() SizeGroupMode { return SizeGroupMode(C.gtk_size_group_get_mode(v.native())) } func (v *SizeGroup) AddWidget(widget IWidget) { C.gtk_size_group_add_widget(v.native(), widget.toWidget()) } func (v *SizeGroup) RemoveWidget(widget IWidget) { C.gtk_size_group_remove_widget(v.native(), widget.toWidget()) } func (v *SizeGroup) GetWidgets() *glib.SList { c := C.gtk_size_group_get_widgets(v.native()) if c == nil { return nil } // TODO: call DataWrapper on SList and wrap them to gtk.IWidget // see (v *Container) GetFocusChain() return glib.WrapSList(uintptr(unsafe.Pointer(c))) } /* * GtkSpinButton */ // SpinButton is a representation of GTK's GtkSpinButton. type SpinButton struct { Entry Orientable } // native returns a pointer to the underlying GtkSpinButton. func (v *SpinButton) native() *C.GtkSpinButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSpinButton(p) } func marshalSpinButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapSpinButton(obj), nil } func wrapSpinButton(obj *glib.Object) *SpinButton { if obj == nil { return nil } e := wrapEditable(obj) ce := wrapCellEditable(obj) o := wrapOrientable(obj) return &SpinButton{Entry{Widget{glib.InitiallyUnowned{obj}}, *e, *ce}, *o} } // Configure is a wrapper around gtk_spin_button_configure(). func (v *SpinButton) Configure(adjustment *Adjustment, climbRate float64, digits uint) { C.gtk_spin_button_configure(v.native(), adjustment.native(), C.gdouble(climbRate), C.guint(digits)) } // SpinButtonNew is a wrapper around gtk_spin_button_new(). func SpinButtonNew(adjustment *Adjustment, climbRate float64, digits uint) (*SpinButton, error) { c := C.gtk_spin_button_new(adjustment.native(), C.gdouble(climbRate), C.guint(digits)) if c == nil { return nil, nilPtrErr } return wrapSpinButton(glib.Take(unsafe.Pointer(c))), nil } // SpinButtonNewWithRange is a wrapper around gtk_spin_button_new_with_range(). func SpinButtonNewWithRange(min, max, step float64) (*SpinButton, error) { c := C.gtk_spin_button_new_with_range(C.gdouble(min), C.gdouble(max), C.gdouble(step)) if c == nil { return nil, nilPtrErr } return wrapSpinButton(glib.Take(unsafe.Pointer(c))), nil } // SetAdjustment() is a wrapper around gtk_spin_button_set_adjustment(). func (v *SpinButton) SetAdjustment(adjustment *Adjustment) { C.gtk_spin_button_set_adjustment(v.native(), adjustment.native()) } // GetAdjustment() is a wrapper around gtk_spin_button_get_adjustment func (v *SpinButton) GetAdjustment() *Adjustment { c := C.gtk_spin_button_get_adjustment(v.native()) if c == nil { return nil } return wrapAdjustment(glib.Take(unsafe.Pointer(c))) } // SetDigits() is a wrapper around gtk_spin_button_set_digits(). func (v *SpinButton) SetDigits(digits uint) { C.gtk_spin_button_set_digits(v.native(), C.guint(digits)) } // SetIncrements() is a wrapper around gtk_spin_button_set_increments(). func (v *SpinButton) SetIncrements(step, page float64) { C.gtk_spin_button_set_increments(v.native(), C.gdouble(step), C.gdouble(page)) } // SetRange is a wrapper around gtk_spin_button_set_range(). func (v *SpinButton) SetRange(min, max float64) { C.gtk_spin_button_set_range(v.native(), C.gdouble(min), C.gdouble(max)) } // SetValue() is a wrapper around gtk_spin_button_set_value(). func (v *SpinButton) SetValue(value float64) { C.gtk_spin_button_set_value(v.native(), C.gdouble(value)) } // GetValue() is a wrapper around gtk_spin_button_get_value(). func (v *SpinButton) GetValue() float64 { c := C.gtk_spin_button_get_value(v.native()) return float64(c) } // GetValueAsInt is a wrapper around gtk_spin_button_get_value_as_int(). func (v *SpinButton) GetValueAsInt() int { c := C.gtk_spin_button_get_value_as_int(v.native()) return int(c) } // SetUpdatePolicy() is a wrapper around gtk_spin_button_set_update_policy(). func (v *SpinButton) SetUpdatePolicy(policy SpinButtonUpdatePolicy) { C.gtk_spin_button_set_update_policy( v.native(), C.GtkSpinButtonUpdatePolicy(policy)) } // SetNumeric() is a wrapper around gtk_spin_button_set_numeric(). func (v *SpinButton) SetNumeric(numeric bool) { C.gtk_spin_button_set_numeric(v.native(), gbool(numeric)) } // Spin() is a wrapper around gtk_spin_button_spin(). func (v *SpinButton) Spin(direction SpinType, increment float64) { C.gtk_spin_button_spin( v.native(), C.GtkSpinType(direction), C.gdouble(increment)) } // gtk_spin_button_set_wrap(). // gtk_spin_button_set_snap_to_ticks(). // Update() is a wrapper around gtk_spin_button_update(). func (v *SpinButton) Update() { C.gtk_spin_button_update(v.native()) } // GetDigits() is a wrapper around gtk_spin_button_get_digits(). func (v *SpinButton) GetDigits() uint { return uint(C.gtk_spin_button_get_digits(v.native())) } // gtk_spin_button_get_increments(). // gtk_spin_button_get_numeric(). // gtk_spin_button_get_range(). // gtk_spin_button_get_snap_to_ticks(). // GetUpdatePolicy() is a wrapper around gtk_spin_button_get_update_policy(). func (v *SpinButton) GetUpdatePolicy() SpinButtonUpdatePolicy { return SpinButtonUpdatePolicy( C.gtk_spin_button_get_update_policy( v.native())) } // gtk_spin_button_get_wrap(). /* * GtkSpinner */ // Spinner is a representation of GTK's GtkSpinner. type Spinner struct { Widget } // native returns a pointer to the underlying GtkSpinner. func (v *Spinner) native() *C.GtkSpinner { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSpinner(p) } func marshalSpinner(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapSpinner(obj), nil } func wrapSpinner(obj *glib.Object) *Spinner { if obj == nil { return nil } return &Spinner{Widget{glib.InitiallyUnowned{obj}}} } // SpinnerNew is a wrapper around gtk_spinner_new(). func SpinnerNew() (*Spinner, error) { c := C.gtk_spinner_new() if c == nil { return nil, nilPtrErr } return wrapSpinner(glib.Take(unsafe.Pointer(c))), nil } // Start is a wrapper around gtk_spinner_start(). func (v *Spinner) Start() { C.gtk_spinner_start(v.native()) } // Stop is a wrapper around gtk_spinner_stop(). func (v *Spinner) Stop() { C.gtk_spinner_stop(v.native()) } /* * GtkStatusbar */ // Statusbar is a representation of GTK's GtkStatusbar type Statusbar struct { Box } // native returns a pointer to the underlying GtkStatusbar func (v *Statusbar) native() *C.GtkStatusbar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkStatusbar(p) } func marshalStatusbar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapStatusbar(obj), nil } func wrapStatusbar(obj *glib.Object) *Statusbar { if obj == nil { return nil } return &Statusbar{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // StatusbarNew() is a wrapper around gtk_statusbar_new(). func StatusbarNew() (*Statusbar, error) { c := C.gtk_statusbar_new() if c == nil { return nil, nilPtrErr } return wrapStatusbar(glib.Take(unsafe.Pointer(c))), nil } // GetContextId() is a wrapper around gtk_statusbar_get_context_id(). func (v *Statusbar) GetContextId(contextDescription string) uint { cstr := C.CString(contextDescription) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_statusbar_get_context_id(v.native(), (*C.gchar)(cstr)) return uint(c) } // Push() is a wrapper around gtk_statusbar_push(). func (v *Statusbar) Push(contextID uint, text string) uint { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_statusbar_push(v.native(), C.guint(contextID), (*C.gchar)(cstr)) return uint(c) } // Pop() is a wrapper around gtk_statusbar_pop(). func (v *Statusbar) Pop(contextID uint) { C.gtk_statusbar_pop(v.native(), C.guint(contextID)) } // GetMessageArea() is a wrapper around gtk_statusbar_get_message_area(). func (v *Statusbar) GetMessageArea() (*Box, error) { c := C.gtk_statusbar_get_message_area(v.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return &Box{Container{Widget{glib.InitiallyUnowned{obj}}}}, nil } // RemoveAll() is a wrapper around gtk_statusbar_remove_all() func (v *Statusbar) RemoveAll(contextID uint) { C.gtk_statusbar_remove_all(v.native(), C.guint(contextID)) } /* * GtkSwitch */ // Switch is a representation of GTK's GtkSwitch. type Switch struct { Widget } // native returns a pointer to the underlying GtkSwitch. func (v *Switch) native() *C.GtkSwitch { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSwitch(p) } func marshalSwitch(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapSwitch(obj), nil } func wrapSwitch(obj *glib.Object) *Switch { if obj == nil { return nil } return &Switch{Widget{glib.InitiallyUnowned{obj}}} } // SwitchNew is a wrapper around gtk_switch_new(). func SwitchNew() (*Switch, error) { c := C.gtk_switch_new() if c == nil { return nil, nilPtrErr } return wrapSwitch(glib.Take(unsafe.Pointer(c))), nil } // GetActive is a wrapper around gtk_switch_get_active(). func (v *Switch) GetActive() bool { c := C.gtk_switch_get_active(v.native()) return gobool(c) } // SetActive is a wrapper around gtk_switch_set_active(). func (v *Switch) SetActive(isActive bool) { C.gtk_switch_set_active(v.native(), gbool(isActive)) } /* * GtkTargetEntry */ // TargetEntry is a representation of GTK's GtkTargetEntry type TargetEntry C.GtkTargetEntry func marshalTargetEntry(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return (*TargetEntry)(unsafe.Pointer(c)), nil } func (v *TargetEntry) native() *C.GtkTargetEntry { return (*C.GtkTargetEntry)(unsafe.Pointer(v)) } // TargetEntryNew is a wrapper around gtk_target_entry_new(). func TargetEntryNew(target string, flags TargetFlags, info uint) (*TargetEntry, error) { cstr := C.CString(target) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_target_entry_new((*C.gchar)(cstr), C.guint(flags), C.guint(info)) if c == nil { return nil, nilPtrErr } t := (*TargetEntry)(unsafe.Pointer(c)) // causes setFinilizer error // runtime.SetFinalizer(t, func(v *TargetEntry) { glib.FinalizerStrategy(v.free) }) return t, nil } func (v *TargetEntry) free() { C.gtk_target_entry_free(v.native()) } /* * GtkTextTag */ type TextTag struct { *glib.Object } // native returns a pointer to the underlying GObject as a GtkTextTag. func (v *TextTag) native() *C.GtkTextTag { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTextTag(p) } func marshalTextTag(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTextTag(obj), nil } func wrapTextTag(obj *glib.Object) *TextTag { if obj == nil { return nil } return &TextTag{obj} } // TextTagNew is a wrapper around gtk_text_tag_new(). If name is empty, then the // tag is anonymous. func TextTagNew(name string) (*TextTag, error) { var gchar *C.gchar if name != "" { gchar = (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(gchar)) } c := C.gtk_text_tag_new(gchar) if c == nil { return nil, nilPtrErr } return wrapTextTag(glib.Take(unsafe.Pointer(c))), nil } // GetPriority() is a wrapper around gtk_text_tag_get_priority(). func (v *TextTag) GetPriority() int { return int(C.gtk_text_tag_get_priority(v.native())) } // SetPriority() is a wrapper around gtk_text_tag_set_priority(). func (v *TextTag) SetPriority(priority int) { C.gtk_text_tag_set_priority(v.native(), C.gint(priority)) } // Event() is a wrapper around gtk_text_tag_event(). func (v *TextTag) Event(eventObject *glib.Object, event *gdk.Event, iter *TextIter) bool { ok := C.gtk_text_tag_event(v.native(), (*C.GObject)(unsafe.Pointer(eventObject.Native())), (*C.GdkEvent)(unsafe.Pointer(event.Native())), (*C.GtkTextIter)(iter), ) return gobool(ok) } /* * GtkTextTagTable */ type TextTagTable struct { *glib.Object } // native returns a pointer to the underlying GObject as a GtkTextTagTable. func (v *TextTagTable) native() *C.GtkTextTagTable { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTextTagTable(p) } func marshalTextTagTable(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTextTagTable(obj), nil } func wrapTextTagTable(obj *glib.Object) *TextTagTable { if obj == nil { return nil } return &TextTagTable{obj} } func TextTagTableNew() (*TextTagTable, error) { c := C.gtk_text_tag_table_new() if c == nil { return nil, nilPtrErr } return wrapTextTagTable(glib.Take(unsafe.Pointer(c))), nil } // Add() is a wrapper around gtk_text_tag_table_add(). func (v *TextTagTable) Add(tag *TextTag) { C.gtk_text_tag_table_add(v.native(), tag.native()) //return gobool(c) // TODO version-separate } // Lookup() is a wrapper around gtk_text_tag_table_lookup(). func (v *TextTagTable) Lookup(name string) (*TextTag, error) { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) c := C.gtk_text_tag_table_lookup(v.native(), (*C.gchar)(cname)) if c == nil { return nil, nilPtrErr } return wrapTextTag(glib.Take(unsafe.Pointer(c))), nil } // Remove() is a wrapper around gtk_text_tag_table_remove(). func (v *TextTagTable) Remove(tag *TextTag) { C.gtk_text_tag_table_remove(v.native(), tag.native()) } /* * GtkTextBuffer */ // TextBuffer is a representation of GTK's GtkTextBuffer. type TextBuffer struct { *glib.Object } // native returns a pointer to the underlying GtkTextBuffer. func (v *TextBuffer) native() *C.GtkTextBuffer { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTextBuffer(p) } func marshalTextBuffer(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTextBuffer(obj), nil } func wrapTextBuffer(obj *glib.Object) *TextBuffer { if obj == nil { return nil } return &TextBuffer{obj} } // TextBufferNew() is a wrapper around gtk_text_buffer_new(). func TextBufferNew(table *TextTagTable) (*TextBuffer, error) { c := C.gtk_text_buffer_new(table.native()) if c == nil { return nil, nilPtrErr } e := wrapTextBuffer(glib.Take(unsafe.Pointer(c))) return e, nil } // ApplyTag() is a wrapper around gtk_text_buffer_apply_tag(). func (v *TextBuffer) ApplyTag(tag *TextTag, start, end *TextIter) { C.gtk_text_buffer_apply_tag(v.native(), tag.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) } // ApplyTagByName() is a wrapper around gtk_text_buffer_apply_tag_by_name(). func (v *TextBuffer) ApplyTagByName(name string, start, end *TextIter) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_text_buffer_apply_tag_by_name(v.native(), (*C.gchar)(cstr), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) } // SelectRange is a wrapper around gtk_text_buffer_select_range. func (v *TextBuffer) SelectRange(start, end *TextIter) { C.gtk_text_buffer_select_range(v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) } // CreateChildAnchor() is a wrapper around gtk_text_buffer_create_child_anchor(). // Since it copies garbage from the stack into the padding bytes of iter, // iter can't be reliably reused after this call unless GODEBUG=cgocheck=0. func (v *TextBuffer) CreateChildAnchor(iter *TextIter) (*TextChildAnchor, error) { c := C.gtk_text_buffer_create_child_anchor(v.native(), iter.native()) if c == nil { return nil, nilPtrErr } return wrapTextChildAnchor(glib.Take(unsafe.Pointer(c))), nil } // Delete() is a wrapper around gtk_text_buffer_delete(). func (v *TextBuffer) Delete(start, end *TextIter) { C.gtk_text_buffer_delete(v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) } func (v *TextBuffer) GetBounds() (start, end *TextIter) { start, end = new(TextIter), new(TextIter) C.gtk_text_buffer_get_bounds(v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) return } // GetCharCount() is a wrapper around gtk_text_buffer_get_char_count(). func (v *TextBuffer) GetCharCount() int { return int(C.gtk_text_buffer_get_char_count(v.native())) } // GetIterAtOffset() is a wrapper around gtk_text_buffer_get_iter_at_offset(). func (v *TextBuffer) GetIterAtOffset(charOffset int) *TextIter { var iter C.GtkTextIter C.gtk_text_buffer_get_iter_at_offset(v.native(), &iter, C.gint(charOffset)) return (*TextIter)(&iter) } // GetIterAtLine() is a wrapper around gtk_text_buffer_get_iter_at_line(). func (v *TextBuffer) GetIterAtLine(line int) *TextIter { var iter C.GtkTextIter C.gtk_text_buffer_get_iter_at_line(v.native(), &iter, C.gint(line)) return (*TextIter)(&iter) } // GetStartIter() is a wrapper around gtk_text_buffer_get_start_iter(). func (v *TextBuffer) GetStartIter() *TextIter { var iter C.GtkTextIter C.gtk_text_buffer_get_start_iter(v.native(), &iter) return (*TextIter)(&iter) } // GetEndIter() is a wrapper around gtk_text_buffer_get_end_iter(). func (v *TextBuffer) GetEndIter() *TextIter { var iter C.GtkTextIter C.gtk_text_buffer_get_end_iter(v.native(), &iter) return (*TextIter)(&iter) } // GetLineCount() is a wrapper around gtk_text_buffer_get_line_count(). func (v *TextBuffer) GetLineCount() int { return int(C.gtk_text_buffer_get_line_count(v.native())) } // GetModified() is a wrapper around gtk_text_buffer_get_modified(). func (v *TextBuffer) GetModified() bool { return gobool(C.gtk_text_buffer_get_modified(v.native())) } // GetTagTable() is a wrapper around gtk_text_buffer_get_tag_table(). func (v *TextBuffer) GetTagTable() (*TextTagTable, error) { c := C.gtk_text_buffer_get_tag_table(v.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapTextTagTable(obj), nil } func (v *TextBuffer) GetText(start, end *TextIter, includeHiddenChars bool) (string, error) { c := C.gtk_text_buffer_get_text( v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end), gbool(includeHiddenChars), ) if c == nil { return "", nilPtrErr } gostr := goString(c) C.g_free(C.gpointer(c)) return gostr, nil } // Insert() is a wrapper around gtk_text_buffer_insert(). func (v *TextBuffer) Insert(iter *TextIter, text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_text_buffer_insert(v.native(), (*C.GtkTextIter)(iter), (*C.gchar)(cstr), C.gint(len(text))) } // InsertPixbuf() is a wrapper around gtk_text_buffer_insert_pixbuf(). func (v *TextBuffer) InsertPixbuf(iter *TextIter, pixbuf *gdk.Pixbuf) { C.gtk_text_buffer_insert_pixbuf(v.native(), (*C.GtkTextIter)(iter), (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native()))) } // InsertAtCursor() is a wrapper around gtk_text_buffer_insert_at_cursor(). func (v *TextBuffer) InsertAtCursor(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_text_buffer_insert_at_cursor(v.native(), (*C.gchar)(cstr), C.gint(len(text))) } // InsertWithTag() is a wrapper around gtk_text_buffer_insert_with_tags() that supports only one tag // as cgo does not support functions with variable-argument lists (see https://github.com/golang/go/issues/975) func (v *TextBuffer) InsertWithTag(iter *TextIter, text string, tag *TextTag) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C._gtk_text_buffer_insert_with_tag(v.native(), (*C.GtkTextIter)(iter), (*C.gchar)(cstr), C.gint(len(text)), tag.native()) } // InsertWithTagByName() is a wrapper around gtk_text_buffer_insert_with_tags_by_name() that supports only one tag // as cgo does not support functions with variable-argument lists (see https://github.com/golang/go/issues/975) func (v *TextBuffer) InsertWithTagByName(iter *TextIter, text string, tagName string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) ctag := C.CString(tagName) defer C.free(unsafe.Pointer(ctag)) C._gtk_text_buffer_insert_with_tag_by_name(v.native(), (*C.GtkTextIter)(iter), (*C.gchar)(cstr), C.gint(len(text)), (*C.gchar)(ctag)) } // RemoveTag() is a wrapper around gtk_text_buffer_remove_tag(). func (v *TextBuffer) RemoveTag(tag *TextTag, start, end *TextIter) { C.gtk_text_buffer_remove_tag(v.native(), tag.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) } // RemoveAllTags() is a wrapper around gtk_text_buffer_remove_all_tags(). func (v *TextBuffer) RemoveAllTags(start, end *TextIter) { C.gtk_text_buffer_remove_all_tags(v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) } // SetModified() is a wrapper around gtk_text_buffer_set_modified(). func (v *TextBuffer) SetModified(setting bool) { C.gtk_text_buffer_set_modified(v.native(), gbool(setting)) } func (v *TextBuffer) SetText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_text_buffer_set_text(v.native(), (*C.gchar)(cstr), C.gint(len(text))) } // GetIterAtMark() is a wrapper around gtk_text_buffer_get_iter_at_mark(). func (v *TextBuffer) GetIterAtMark(mark *TextMark) *TextIter { var iter C.GtkTextIter C.gtk_text_buffer_get_iter_at_mark(v.native(), &iter, mark.native()) return (*TextIter)(&iter) } // CreateMark() is a wrapper around gtk_text_buffer_create_mark(). func (v *TextBuffer) CreateMark(mark_name string, where *TextIter, left_gravity bool) *TextMark { cstr := C.CString(mark_name) defer C.free(unsafe.Pointer(cstr)) ret := C.gtk_text_buffer_create_mark(v.native(), (*C.gchar)(cstr), (*C.GtkTextIter)(where), gbool(left_gravity)) return wrapTextMark(glib.Take(unsafe.Pointer(ret))) } // GetMark() is a wrapper around gtk_text_buffer_get_mark(). func (v *TextBuffer) GetMark(mark_name string) *TextMark { cstr := C.CString(mark_name) defer C.free(unsafe.Pointer(cstr)) ret := C.gtk_text_buffer_get_mark(v.native(), (*C.gchar)(cstr)) return wrapTextMark(glib.Take(unsafe.Pointer(ret))) } // DeleteMark() is a wrapper around gtk_text_buffer_delete_mark() func (v *TextBuffer) DeleteMark(mark *TextMark) { C.gtk_text_buffer_delete_mark(v.native(), mark.native()) } // DeleteMarkByName() is a wrapper around gtk_text_buffer_delete_mark_by_name() func (v *TextBuffer) DeleteMarkByName(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_text_buffer_delete_mark_by_name(v.native(), (*C.gchar)(cstr)) } // PlaceCursor() is a wrapper around gtk_text_buffer_place_cursor() func (v *TextBuffer) PlaceCursor(iter *TextIter) { C.gtk_text_buffer_place_cursor(v.native(), (*C.GtkTextIter)(iter)) } // GetHasSelection() is a variant solution around gtk_text_buffer_get_has_selection(). func (v *TextBuffer) GetHasSelection() bool { value, _ := v.GetProperty("has-selection") return value.(bool) } // DeleteSelection() is a wrapper around gtk_text_buffer_delete_selection(). func (v *TextBuffer) DeleteSelection(interactive, defaultEditable bool) bool { return gobool(C.gtk_text_buffer_delete_selection(v.native(), gbool(interactive), gbool(defaultEditable))) } // GetSelectionBound() is a wrapper around gtk_text_buffer_get_selection_bound(). func (v *TextBuffer) GetSelectionBound() *TextMark { ret := C.gtk_text_buffer_get_selection_bound(v.native()) return wrapTextMark(glib.Take(unsafe.Pointer(ret))) } // GetSelectionBounds() is a wrapper around gtk_text_buffer_get_selection_bounds(). func (v *TextBuffer) GetSelectionBounds() (start, end *TextIter, ok bool) { start, end = new(TextIter), new(TextIter) cbool := C.gtk_text_buffer_get_selection_bounds(v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) return start, end, gobool(cbool) } // GetIterAtLineOffset() is a wrapper around gtk_text_buffer_get_iter_at_line_offset(). func (v *TextBuffer) GetIterAtLineOffset(lineNumber, charOffset int) (iter *TextIter) { iter = new(TextIter) C.gtk_text_buffer_get_iter_at_line_offset(v.native(), (*C.GtkTextIter)(iter), (C.gint)(lineNumber), (C.gint)(charOffset)) return } // CreateTag() is a variant solution around gtk_text_buffer_create_tag(). func (v *TextBuffer) CreateTag(name string, props map[string]interface{}) (tag *TextTag) { var err error var tagTable *TextTagTable if tag, err = TextTagNew(name); err == nil { if tagTable, err = v.GetTagTable(); err == nil { tagTable.Add(tag) for p, v := range props { if err = tag.SetProperty(p, v); err != nil { err = errors.New(fmt.Sprintf("%s, %v: %v\n", err.Error(), p, v)) break } } } } if err != nil { fmt.Println(err.Error()) } return } // RemoveTagByName() is a wrapper around gtk_text_buffer_remove_tag_by_name() func (v *TextBuffer) RemoveTagByName(name string, start, end *TextIter) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_text_buffer_remove_tag_by_name(v.native(), (*C.gchar)(cstr), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) } // InsertMarkup() is a wrapper around gtk_text_buffer_register_serialize_tagset() func (v *TextBuffer) RegisterSerializeTagset(tagsetName string) gdk.Atom { cstr := C.CString(tagsetName) if len(tagsetName) == 0 { cstr = nil } defer C.free(unsafe.Pointer(cstr)) c := C.gtk_text_buffer_register_serialize_tagset(v.native(), (*C.gchar)(cstr)) return gdk.Atom(uintptr(unsafe.Pointer(c))) } // RegisterDeserializeTagset() is a wrapper around gtk_text_buffer_register_deserialize_tagset() func (v *TextBuffer) RegisterDeserializeTagset(tagsetName string) gdk.Atom { cstr := C.CString(tagsetName) if len(tagsetName) == 0 { cstr = nil } defer C.free(unsafe.Pointer(cstr)) c := C.gtk_text_buffer_register_deserialize_tagset(v.native(), (*C.gchar)(cstr)) return gdk.Atom(uintptr(unsafe.Pointer(c))) } // Serialize() is a wrapper around gtk_text_buffer_serialize() func (v *TextBuffer) Serialize(contentBuffer *TextBuffer, format gdk.Atom, start, end *TextIter) string { var length = new(C.gsize) ptr := C.gtk_text_buffer_serialize(v.native(), contentBuffer.native(), C.GdkAtom(unsafe.Pointer(format)), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end), length) return C.GoStringN((*C.char)(unsafe.Pointer(ptr)), (C.int)(*length)) } // Deserialize() is a wrapper around gtk_text_buffer_deserialize() func (v *TextBuffer) Deserialize(contentBuffer *TextBuffer, format gdk.Atom, iter *TextIter, data []byte) (ok bool, err error) { var length = (C.gsize)(len(data)) var cerr *C.GError = nil cbool := C.gtk_text_buffer_deserialize(v.native(), contentBuffer.native(), C.GdkAtom(unsafe.Pointer(format)), (*C.GtkTextIter)(iter), (*C.guint8)(unsafe.Pointer(&data[0])), length, &cerr) if !gobool(cbool) { defer C.g_error_free(cerr) return false, errors.New(goString(cerr.message)) } return gobool(cbool), nil } // GetInsert() is a wrapper around gtk_text_buffer_get_insert(). func (v *TextBuffer) GetInsert() *TextMark { ret := C.gtk_text_buffer_get_insert(v.native()) return wrapTextMark(glib.Take(unsafe.Pointer(ret))) } // CopyClipboard() is a wrapper around gtk_text_buffer_copy_clipboard(). func (v *TextBuffer) CopyClipboard(clipboard *Clipboard) { C.gtk_text_buffer_copy_clipboard(v.native(), clipboard.native()) } // CutClipboard() is a wrapper around gtk_text_buffer_cut_clipboard(). func (v *TextBuffer) CutClipboard(clipboard *Clipboard, defaultEditable bool) { C.gtk_text_buffer_cut_clipboard(v.native(), clipboard.native(), gbool(defaultEditable)) } // PasteClipboard() is a wrapper around gtk_text_buffer_paste_clipboard(). func (v *TextBuffer) PasteClipboard(clipboard *Clipboard, overrideLocation *TextIter, defaultEditable bool) { C.gtk_text_buffer_paste_clipboard(v.native(), clipboard.native(), (*C.GtkTextIter)(overrideLocation), gbool(defaultEditable)) } // AddSelectionClipboard() is a wrapper around gtk_text_buffer_add_selection_clipboard(). func (v *TextBuffer) AddSelectionClipboard(clipboard *Clipboard) { C.gtk_text_buffer_add_selection_clipboard(v.native(), clipboard.native()) } // RemoveSelectionClipboard() is a wrapper around gtk_text_buffer_remove_selection_clipboard(). func (v *TextBuffer) RemoveSelectionClipboard(clipboard *Clipboard) { C.gtk_text_buffer_remove_selection_clipboard(v.native(), clipboard.native()) } // GetIterAtLineIndex() is a wrapper around gtk_text_buffer_get_iter_at_line_index(). func (v *TextBuffer) GetIterAtLineIndex(lineNumber, charIndex int) (iter *TextIter) { iter = new(TextIter) C.gtk_text_buffer_get_iter_at_line_index(v.native(), (*C.GtkTextIter)(iter), (C.gint)(lineNumber), (C.gint)(charIndex)) return } // InsertInteractiveAtCursor() is a wrapper around gtk_text_buffer_insert_interactive_at_cursor(). func (v *TextBuffer) InsertInteractiveAtCursor(text string, editable bool) bool { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) return gobool(C.gtk_text_buffer_insert_interactive_at_cursor( v.native(), (*C.gchar)(cstr), C.gint(len(text)), gbool(editable))) } // InsertInteractive() is a wrapper around gtk_text_buffer_insert_interactive(). func (v *TextBuffer) InsertInteractive(iter *TextIter, text string, editable bool) bool { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) return gobool(C.gtk_text_buffer_insert_interactive( v.native(), (*C.GtkTextIter)(iter), (*C.gchar)(cstr), C.gint(len(text)), gbool(editable))) } // InsertRangeInteractive() is a wrapper around gtk_text_buffer_insert_range_interactive(). func (v *TextBuffer) InsertRangeInteractive(iter, start, end *TextIter, editable bool) bool { return gobool(C.gtk_text_buffer_insert_range_interactive( v.native(), (*C.GtkTextIter)(iter), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end), gbool(editable))) } // InsertRange() is a wrapper around gtk_text_buffer_insert_range(). func (v *TextBuffer) InsertRange(iter, start, end *TextIter) { C.gtk_text_buffer_insert_range( v.native(), (*C.GtkTextIter)(iter), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end)) } // DeleteInteractive() is a wrapper around gtk_text_buffer_delete_interactive(). func (v *TextBuffer) DeleteInteractive(start, end *TextIter, editable bool) bool { return gobool(C.gtk_text_buffer_delete_interactive( v.native(), (*C.GtkTextIter)(start), (*C.GtkTextIter)(end), gbool(editable))) } // BeginUserAction() is a wrapper around gtk_text_buffer_begin_user_action(). func (v *TextBuffer) BeginUserAction() { C.gtk_text_buffer_begin_user_action(v.native()) } // EndUserAction() is a wrapper around gtk_text_buffer_end_user_action(). func (v *TextBuffer) EndUserAction() { C.gtk_text_buffer_end_user_action(v.native()) } /* * GtkToggleButton */ // ToggleButton is a representation of GTK's GtkToggleButton. type ToggleButton struct { Button } // native returns a pointer to the underlying GtkToggleButton. func (v *ToggleButton) native() *C.GtkToggleButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkToggleButton(p) } func marshalToggleButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapToggleButton(obj), nil } func wrapToggleButton(obj *glib.Object) *ToggleButton { if obj == nil { return nil } actionable := wrapActionable(obj) return &ToggleButton{Button{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}, actionable}} } // ToggleButtonNew is a wrapper around gtk_toggle_button_new(). func ToggleButtonNew() (*ToggleButton, error) { c := C.gtk_toggle_button_new() if c == nil { return nil, nilPtrErr } return wrapToggleButton(glib.Take(unsafe.Pointer(c))), nil } // ToggleButtonNewWithLabel is a wrapper around // gtk_toggle_button_new_with_label(). func ToggleButtonNewWithLabel(label string) (*ToggleButton, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_toggle_button_new_with_label((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapToggleButton(glib.Take(unsafe.Pointer(c))), nil } // ToggleButtonNewWithMnemonic is a wrapper around // gtk_toggle_button_new_with_mnemonic(). func ToggleButtonNewWithMnemonic(label string) (*ToggleButton, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_toggle_button_new_with_mnemonic((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapToggleButton(glib.Take(unsafe.Pointer(c))), nil } // GetActive is a wrapper around gtk_toggle_button_get_active(). func (v *ToggleButton) GetActive() bool { c := C.gtk_toggle_button_get_active(v.native()) return gobool(c) } // SetActive is a wrapper around gtk_toggle_button_set_active(). func (v *ToggleButton) SetActive(isActive bool) { C.gtk_toggle_button_set_active(v.native(), gbool(isActive)) } // GetMode is a wrapper around gtk_toggle_button_get_mode(). func (v *ToggleButton) GetMode() bool { c := C.gtk_toggle_button_get_mode(v.native()) return gobool(c) } // SetMode is a wrapper around gtk_toggle_button_set_mode(). func (v *ToggleButton) SetMode(drawIndicator bool) { C.gtk_toggle_button_set_mode(v.native(), gbool(drawIndicator)) } // Toggled is a wrapper around gtk_toggle_button_toggled(). func (v *ToggleButton) Toggled() { C.gtk_toggle_button_toggled(v.native()) } // GetInconsistent gtk_toggle_button_get_inconsistent(). func (v *ToggleButton) GetInconsistent() bool { c := C.gtk_toggle_button_get_inconsistent(v.native()) return gobool(c) } // SetInconsistent gtk_toggle_button_set_inconsistent(). func (v *ToggleButton) SetInconsistent(setting bool) { C.gtk_toggle_button_set_inconsistent(v.native(), gbool(setting)) } /* * GtkToolbar */ // Toolbar is a representation of GTK's GtkToolbar. type Toolbar struct { Container } // native returns a pointer to the underlying GtkToolbar. func (v *Toolbar) native() *C.GtkToolbar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkToolbar(p) } func marshalToolbar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapToolbar(obj), nil } func wrapToolbar(obj *glib.Object) *Toolbar { if obj == nil { return nil } return &Toolbar{Container{Widget{glib.InitiallyUnowned{obj}}}} } // ToolbarNew is a wrapper around gtk_toolbar_new(). func ToolbarNew() (*Toolbar, error) { c := C.gtk_toolbar_new() if c == nil { return nil, nilPtrErr } return wrapToolbar(glib.Take(unsafe.Pointer(c))), nil } // Insert is a wrapper around gtk_toolbar_insert(). func (v *Toolbar) Insert(item IToolItem, pos int) { C.gtk_toolbar_insert(v.native(), item.toToolItem(), C.gint(pos)) } // GetItemIndex is a wrapper around gtk_toolbar_get_item_index(). func (v *Toolbar) GetItemIndex(item IToolItem) int { c := C.gtk_toolbar_get_item_index(v.native(), item.toToolItem()) return int(c) } // GetNItems is a wrapper around gtk_toolbar_get_n_items(). func (v *Toolbar) GetNItems() int { c := C.gtk_toolbar_get_n_items(v.native()) return int(c) } // GetNthItem is a wrapper around gtk_toolbar_get_nth_item(). func (v *Toolbar) GetNthItem(n int) *ToolItem { c := C.gtk_toolbar_get_nth_item(v.native(), C.gint(n)) if c == nil { return nil } return wrapToolItem(glib.Take(unsafe.Pointer(c))) } // GetDropIndex is a wrapper around gtk_toolbar_get_drop_index(). func (v *Toolbar) GetDropIndex(x, y int) int { c := C.gtk_toolbar_get_drop_index(v.native(), C.gint(x), C.gint(y)) return int(c) } // SetDropHighlightItem is a wrapper around gtk_toolbar_set_drop_highlight_item(). func (v *Toolbar) SetDropHighlightItem(toolItem IToolItem, index int) { C.gtk_toolbar_set_drop_highlight_item(v.native(), toolItem.toToolItem(), C.gint(index)) } // SetShowArrow is a wrapper around gtk_toolbar_set_show_arrow(). func (v *Toolbar) SetShowArrow(showArrow bool) { C.gtk_toolbar_set_show_arrow(v.native(), gbool(showArrow)) } // UnsetIconSize is a wrapper around gtk_toolbar_unset_icon_size(). func (v *Toolbar) UnsetIconSize() { C.gtk_toolbar_unset_icon_size(v.native()) } // GetShowArrow is a wrapper around gtk_toolbar_get_show_arrow(). func (v *Toolbar) GetShowArrow() bool { c := C.gtk_toolbar_get_show_arrow(v.native()) return gobool(c) } // GetStyle is a wrapper around gtk_toolbar_get_style(). func (v *Toolbar) GetStyle() ToolbarStyle { c := C.gtk_toolbar_get_style(v.native()) return ToolbarStyle(c) } // GetIconSize is a wrapper around gtk_toolbar_get_icon_size(). func (v *Toolbar) GetIconSize() IconSize { c := C.gtk_toolbar_get_icon_size(v.native()) return IconSize(c) } // GetReliefStyle is a wrapper around gtk_toolbar_get_relief_style(). func (v *Toolbar) GetReliefStyle() ReliefStyle { c := C.gtk_toolbar_get_relief_style(v.native()) return ReliefStyle(c) } // SetStyle is a wrapper around gtk_toolbar_set_style(). func (v *Toolbar) SetStyle(style ToolbarStyle) { C.gtk_toolbar_set_style(v.native(), C.GtkToolbarStyle(style)) } // SetIconSize is a wrapper around gtk_toolbar_set_icon_size(). func (v *Toolbar) SetIconSize(iconSize IconSize) { C.gtk_toolbar_set_icon_size(v.native(), C.GtkIconSize(iconSize)) } // UnsetStyle is a wrapper around gtk_toolbar_unset_style(). func (v *Toolbar) UnsetStyle() { C.gtk_toolbar_unset_style(v.native()) } /* * GtkToolButton */ // ToolButton is a representation of GTK's GtkToolButton. type ToolButton struct { ToolItem } // native returns a pointer to the underlying GtkToolButton. func (v *ToolButton) native() *C.GtkToolButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkToolButton(p) } func marshalToolButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapToolButton(obj), nil } func wrapToolButton(obj *glib.Object) *ToolButton { if obj == nil { return nil } return &ToolButton{ToolItem{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}}} } // ToolButtonNew is a wrapper around gtk_tool_button_new(). func ToolButtonNew(iconWidget IWidget, label string) (*ToolButton, error) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) w := nullableWidget(iconWidget) c := C.gtk_tool_button_new(w, (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapToolButton(glib.Take(unsafe.Pointer(c))), nil } // SetLabel is a wrapper around gtk_tool_button_set_label(). func (v *ToolButton) SetLabel(label string) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) C.gtk_tool_button_set_label(v.native(), (*C.gchar)(cstr)) } // GetLabel is a wrapper around gtk_tool_button_get_label(). func (v *ToolButton) GetLabel() string { c := C.gtk_tool_button_get_label(v.native()) return goString(c) } // SetUseUnderline is a wrapper around gtk_tool_button_set_use_underline(). func (v *ToolButton) SetGetUnderline(useUnderline bool) { C.gtk_tool_button_set_use_underline(v.native(), gbool(useUnderline)) } // GetUseUnderline is a wrapper around gtk_tool_button_get_use_underline(). func (v *ToolButton) GetuseUnderline() bool { c := C.gtk_tool_button_get_use_underline(v.native()) return gobool(c) } // SetIconName is a wrapper around gtk_tool_button_set_icon_name(). func (v *ToolButton) SetIconName(iconName string) { cstr := C.CString(iconName) defer C.free(unsafe.Pointer(cstr)) C.gtk_tool_button_set_icon_name(v.native(), (*C.gchar)(cstr)) } // GetIconName is a wrapper around gtk_tool_button_get_icon_name(). func (v *ToolButton) GetIconName() string { c := C.gtk_tool_button_get_icon_name(v.native()) return goString(c) } // SetIconWidget is a wrapper around gtk_tool_button_set_icon_widget(). func (v *ToolButton) SetIconWidget(iconWidget IWidget) { C.gtk_tool_button_set_icon_widget(v.native(), iconWidget.toWidget()) } // GetIconWidget is a wrapper around gtk_tool_button_get_icon_widget(). func (v *ToolButton) GetIconWidget() (IWidget, error) { c := C.gtk_tool_button_get_icon_widget(v.native()) if c == nil { return nil, nil } return castWidget(c) } // SetLabelWidget is a wrapper around gtk_tool_button_set_label_widget(). func (v *ToolButton) SetLabelWidget(labelWidget IWidget) { C.gtk_tool_button_set_label_widget(v.native(), labelWidget.toWidget()) } // GetLabelWidget is a wrapper around gtk_tool_button_get_label_widget(). func (v *ToolButton) GetLabelWidget() (IWidget, error) { c := C.gtk_tool_button_get_label_widget(v.native()) if c == nil { return nil, nil } return castWidget(c) } /* * GtkToggleToolButton */ // ToggleToolButton is a representation of GTK's GtkToggleToolButton. type ToggleToolButton struct { ToolButton } // native returns a pointer to the underlying GtkToggleToolButton. func (v *ToggleToolButton) native() *C.GtkToggleToolButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkToggleToolButton(p) } func marshalToggleToolButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapToggleToolButton(obj), nil } func wrapToggleToolButton(obj *glib.Object) *ToggleToolButton { if obj == nil { return nil } return &ToggleToolButton{ToolButton{ToolItem{Bin{Container{Widget{ glib.InitiallyUnowned{obj}}}}}}} } // ToggleToolButtonNew is a wrapper around gtk_toggle_tool_button_new(). func ToggleToolButtonNew() (*ToggleToolButton, error) { c := C.gtk_toggle_tool_button_new() if c == nil { return nil, nilPtrErr } return wrapToggleToolButton(glib.Take(unsafe.Pointer(c))), nil } // GetActive is a wrapper around gtk_toggle_tool_button_get_active(). func (v *ToggleToolButton) GetActive() bool { c := C.gtk_toggle_tool_button_get_active(v.native()) return gobool(c) } // SetActive is a wrapper around gtk_toggle_tool_button_set_active(). func (v *ToggleToolButton) SetActive(isActive bool) { C.gtk_toggle_tool_button_set_active(v.native(), gbool(isActive)) } /* * GtkToolItem */ // ToolItem is a representation of GTK's GtkToolItem. type ToolItem struct { Bin } // IToolItem is an interface type implemented by all structs embedding // a ToolItem. It is meant to be used as an argument type for wrapper // functions that wrap around a C GTK function taking a GtkToolItem. type IToolItem interface { toToolItem() *C.GtkToolItem } // native returns a pointer to the underlying GtkToolItem. func (v *ToolItem) native() *C.GtkToolItem { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkToolItem(p) } func (v *ToolItem) toToolItem() *C.GtkToolItem { return v.native() } func marshalToolItem(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapToolItem(obj), nil } func wrapToolItem(obj *glib.Object) *ToolItem { if obj == nil { return nil } return &ToolItem{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // ToolItemNew is a wrapper around gtk_tool_item_new(). func ToolItemNew() (*ToolItem, error) { c := C.gtk_tool_item_new() if c == nil { return nil, nilPtrErr } return wrapToolItem(glib.Take(unsafe.Pointer(c))), nil } // SetHomogeneous is a wrapper around gtk_tool_item_set_homogeneous(). func (v *ToolItem) SetHomogeneous(homogeneous bool) { C.gtk_tool_item_set_homogeneous(v.native(), gbool(homogeneous)) } // GetHomogeneous is a wrapper around gtk_tool_item_get_homogeneous(). func (v *ToolItem) GetHomogeneous() bool { c := C.gtk_tool_item_get_homogeneous(v.native()) return gobool(c) } // SetExpand is a wrapper around gtk_tool_item_set_expand(). func (v *ToolItem) SetExpand(expand bool) { C.gtk_tool_item_set_expand(v.native(), gbool(expand)) } // GetExpand is a wrapper around gtk_tool_item_get_expand(). func (v *ToolItem) GetExpand() bool { c := C.gtk_tool_item_get_expand(v.native()) return gobool(c) } // SetTooltipText is a wrapper around gtk_tool_item_set_tooltip_text(). func (v *ToolItem) SetTooltipText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_tool_item_set_tooltip_text(v.native(), (*C.gchar)(cstr)) } // SetTooltipMarkup is a wrapper around gtk_tool_item_set_tooltip_markup(). func (v *ToolItem) SetTooltipMarkup(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_tool_item_set_tooltip_markup(v.native(), (*C.gchar)(cstr)) } // SetUseDragWindow is a wrapper around gtk_tool_item_set_use_drag_window(). func (v *ToolItem) SetUseDragWindow(useDragWindow bool) { C.gtk_tool_item_set_use_drag_window(v.native(), gbool(useDragWindow)) } // GetUseDragWindow is a wrapper around gtk_tool_item_get_use_drag_window(). func (v *ToolItem) GetUseDragWindow() bool { c := C.gtk_tool_item_get_use_drag_window(v.native()) return gobool(c) } // SetVisibleHorizontal is a wrapper around gtk_tool_item_set_visible_horizontal(). func (v *ToolItem) SetVisibleHorizontal(visibleHorizontal bool) { C.gtk_tool_item_set_visible_horizontal(v.native(), gbool(visibleHorizontal)) } // GetVisibleHorizontal is a wrapper around gtk_tool_item_get_visible_horizontal(). func (v *ToolItem) GetVisibleHorizontal() bool { c := C.gtk_tool_item_get_visible_horizontal(v.native()) return gobool(c) } // SetVisibleVertical is a wrapper around gtk_tool_item_set_visible_vertical(). func (v *ToolItem) SetVisibleVertical(visibleVertical bool) { C.gtk_tool_item_set_visible_vertical(v.native(), gbool(visibleVertical)) } // GetVisibleVertical is a wrapper around gtk_tool_item_get_visible_vertical(). func (v *ToolItem) GetVisibleVertical() bool { c := C.gtk_tool_item_get_visible_vertical(v.native()) return gobool(c) } // SetIsImportant is a wrapper around gtk_tool_item_set_is_important(). func (v *ToolItem) SetIsImportant(isImportant bool) { C.gtk_tool_item_set_is_important(v.native(), gbool(isImportant)) } // GetIsImportant is a wrapper around gtk_tool_item_get_is_important(). func (v *ToolItem) GetIsImportant() bool { c := C.gtk_tool_item_get_is_important(v.native()) return gobool(c) } // TODO: gtk_tool_item_get_ellipsize_mode // GetIconSize is a wrapper around gtk_tool_item_get_icon_size(). func (v *ToolItem) GetIconSize() IconSize { c := C.gtk_tool_item_get_icon_size(v.native()) return IconSize(c) } // GetOrientation is a wrapper around gtk_tool_item_get_orientation(). func (v *ToolItem) GetOrientation() Orientation { c := C.gtk_tool_item_get_orientation(v.native()) return Orientation(c) } // GetToolbarStyle is a wrapper around gtk_tool_item_get_toolbar_style(). func (v *ToolItem) GetToolbarStyle() ToolbarStyle { c := C.gtk_tool_item_get_toolbar_style(v.native()) return ToolbarStyle(c) } // GetReliefStyle is a wrapper around gtk_tool_item_get_relief_style(). func (v *ToolItem) GetReliefStyle() ReliefStyle { c := C.gtk_tool_item_get_relief_style(v.native()) return ReliefStyle(c) } // GetTextAlignment is a wrapper around gtk_tool_item_get_text_alignment(). func (v *ToolItem) GetTextAlignment() float32 { c := C.gtk_tool_item_get_text_alignment(v.native()) return float32(c) } // GetTextOrientation is a wrapper around gtk_tool_item_get_text_orientation(). func (v *ToolItem) GetTextOrientation() Orientation { c := C.gtk_tool_item_get_text_orientation(v.native()) return Orientation(c) } // RetrieveProxyMenuItem is a wrapper around gtk_tool_item_retrieve_proxy_menu_item() func (v *ToolItem) RetrieveProxyMenuItem() *MenuItem { c := C.gtk_tool_item_retrieve_proxy_menu_item(v.native()) if c == nil { return nil } return wrapMenuItem(glib.Take(unsafe.Pointer(c))) } // TODO: // gtk_tool_item_get_proxy_menu_item(). // SetProxyMenuItem is a wrapper around gtk_tool_item_set_proxy_menu_item(). func (v *ToolItem) SetProxyMenuItem(menuItemId string, menuItem IMenuItem) { cstr := C.CString(menuItemId) defer C.free(unsafe.Pointer(cstr)) C.gtk_tool_item_set_proxy_menu_item(v.native(), (*C.gchar)(cstr), C.toGtkWidget(unsafe.Pointer(menuItem.toMenuItem()))) } // RebuildMenu is a wrapper around gtk_tool_item_rebuild_menu(). func (v *ToolItem) RebuildMenu() { C.gtk_tool_item_rebuild_menu(v.native()) } // ToolbarReconfigured is a wrapper around gtk_tool_item_toolbar_reconfigured(). func (v *ToolItem) ToolbarReconfigured() { C.gtk_tool_item_toolbar_reconfigured(v.native()) } // TODO: gtk_tool_item_get_text_size_group /* * GtkToolItemGroup */ // TODO: // gtk_tool_item_group_get_collapsed(). // gtk_tool_item_group_get_drop_item(). // gtk_tool_item_group_get_ellipsize(). // gtk_tool_item_group_get_item_position(). // gtk_tool_item_group_get_n_items(). // gtk_tool_item_group_get_label(). // gtk_tool_item_group_get_label_widget(). // gtk_tool_item_group_get_nth_item(). // gtk_tool_item_group_get_header_relief(). // gtk_tool_item_group_insert(). // gtk_tool_item_group_new(). // gtk_tool_item_group_set_collapsed(). // gtk_tool_item_group_set_ellipsize(). // gtk_tool_item_group_set_item_position(). // gtk_tool_item_group_set_label(). // gtk_tool_item_group_set_label_widget(). // gtk_tool_item_group_set_header_relief(). /* * GtkToolPalette */ // TODO: // gtk_tool_palette_new(). // gtk_tool_palette_get_exclusive(). // gtk_tool_palette_set_exclusive(). // gtk_tool_palette_get_expand(). // gtk_tool_palette_set_expand(). // gtk_tool_palette_get_group_position(). // gtk_tool_palette_set_group_position(). // gtk_tool_palette_get_icon_size(). // gtk_tool_palette_set_icon_size(). // gtk_tool_palette_unset_icon_size(). // gtk_tool_palette_get_style(). // gtk_tool_palette_set_style(). // gtk_tool_palette_unset_style(). // gtk_tool_palette_add_drag_dest(). // gtk_tool_palette_get_drag_item(). // gtk_tool_palette_get_drag_target_group(). // gtk_tool_palette_get_drag_target_item(). // gtk_tool_palette_get_drop_group(). // gtk_tool_palette_get_drop_item(). // gtk_tool_palette_set_drag_source(). // GtkToolPaletteDragTargets /* * GtkTreeIter */ // TreeIter is a representation of GTK's GtkTreeIter. type TreeIter struct { GtkTreeIter C.GtkTreeIter } // native returns a pointer to the underlying GtkTreeIter. func (v *TreeIter) native() *C.GtkTreeIter { if v == nil { return nil } return &v.GtkTreeIter } func marshalTreeIter(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return (*TreeIter)(unsafe.Pointer(c)), nil } func (v *TreeIter) free() { C.gtk_tree_iter_free(v.native()) } // Copy() is a wrapper around gtk_tree_iter_copy(). // // Caution: when this method is used together with selection.GetSelectedRows(), // it might cause random crash issue. See issue #590 and #610. func (v *TreeIter) Copy() (*TreeIter, error) { c := C.gtk_tree_iter_copy(v.native()) if c == nil { return nil, nilPtrErr } t := &TreeIter{*c} runtime.SetFinalizer(t, func(v *TreeIter) { glib.FinalizerStrategy(v.free) }) return t, nil } /* * GtkTreeModel */ // TreeModel is a representation of GTK's GtkTreeModel GInterface. type TreeModel struct { *glib.Object } // ITreeModel is an interface type implemented by all structs // embedding a TreeModel. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkTreeModel. type ITreeModel interface { toTreeModel() *C.GtkTreeModel ToTreeModel() *TreeModel } // native returns a pointer to the underlying GObject as a GtkTreeModel. func (v *TreeModel) native() *C.GtkTreeModel { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTreeModel(p) } func (v *TreeModel) toTreeModel() *C.GtkTreeModel { if v == nil { return nil } return v.native() } func marshalTreeModel(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTreeModel(obj), nil } func wrapTreeModel(obj *glib.Object) *TreeModel { if obj == nil { return nil } return &TreeModel{obj} } // ToTreeModel is a helper getter, e.g.: it returns *gtk.TreeStore/ListStore as a *gtk.TreeModel. // In other cases, where you have a gtk.ITreeModel, use the type assertion. func (v *TreeModel) ToTreeModel() *TreeModel { return v } // GetFlags() is a wrapper around gtk_tree_model_get_flags(). func (v *TreeModel) GetFlags() TreeModelFlags { c := C.gtk_tree_model_get_flags(v.native()) return TreeModelFlags(c) } // GetNColumns() is a wrapper around gtk_tree_model_get_n_columns(). func (v *TreeModel) GetNColumns() int { c := C.gtk_tree_model_get_n_columns(v.native()) return int(c) } // GetColumnType() is a wrapper around gtk_tree_model_get_column_type(). func (v *TreeModel) GetColumnType(index int) glib.Type { c := C.gtk_tree_model_get_column_type(v.native(), C.gint(index)) return glib.Type(c) } // GetIter() is a wrapper around gtk_tree_model_get_iter(). func (v *TreeModel) GetIter(path *TreePath) (*TreeIter, error) { var iter C.GtkTreeIter c := C.gtk_tree_model_get_iter(v.native(), &iter, path.native()) if !gobool(c) { return nil, errors.New("Unable to set iterator") } t := &TreeIter{iter} return t, nil } // GetIterFromString() is a wrapper around // gtk_tree_model_get_iter_from_string(). func (v *TreeModel) GetIterFromString(path string) (*TreeIter, error) { var iter C.GtkTreeIter cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_tree_model_get_iter_from_string(v.native(), &iter, (*C.gchar)(cstr)) if !gobool(c) { return nil, errors.New("Unable to set iterator") } t := &TreeIter{iter} return t, nil } // GetIterFirst() is a wrapper around gtk_tree_model_get_iter_first(). func (v *TreeModel) GetIterFirst() (*TreeIter, bool) { var iter C.GtkTreeIter c := C.gtk_tree_model_get_iter_first(v.native(), &iter) if !gobool(c) { return nil, false } t := &TreeIter{iter} return t, true } // GetPath() is a wrapper around gtk_tree_model_get_path(). func (v *TreeModel) GetPath(iter *TreeIter) (*TreePath, error) { c := C.gtk_tree_model_get_path(v.native(), iter.native()) if c == nil { return nil, nilPtrErr } p := &TreePath{c} runtime.SetFinalizer(p, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) return p, nil } // GetStringFromIter() is a wrapper around gtk_tree_model_get_string_from_iter(). func (v *TreeModel) GetStringFromIter(iter *TreeIter) string { c := C.gtk_tree_model_get_string_from_iter(v.native(), iter.native()) s := goString(c) defer C.g_free((C.gpointer)(c)) return s } // GetValue() is a wrapper around gtk_tree_model_get_value(). func (v *TreeModel) GetValue(iter *TreeIter, column int) (*glib.Value, error) { val, err := glib.ValueAlloc() if err != nil { return nil, err } C.gtk_tree_model_get_value( v.native(), iter.native(), C.gint(column), (*C.GValue)(unsafe.Pointer(val.Native()))) return val, nil } // IterHasChild() is a wrapper around gtk_tree_model_iter_has_child(). func (v *TreeModel) IterHasChild(iter *TreeIter) bool { c := C.gtk_tree_model_iter_has_child(v.native(), iter.native()) return gobool(c) } // IterNext() is a wrapper around gtk_tree_model_iter_next(). func (v *TreeModel) IterNext(iter *TreeIter) bool { c := C.gtk_tree_model_iter_next(v.native(), iter.native()) return gobool(c) } // IterPrevious is a wrapper around gtk_tree_model_iter_previous(). func (v *TreeModel) IterPrevious(iter *TreeIter) bool { c := C.gtk_tree_model_iter_previous(v.native(), iter.native()) return gobool(c) } // IterParent is a wrapper around gtk_tree_model_iter_parent(). func (v *TreeModel) IterParent(iter, child *TreeIter) bool { c := C.gtk_tree_model_iter_parent(v.native(), iter.native(), child.native()) return gobool(c) } // IterNthChild is a wrapper around gtk_tree_model_iter_nth_child(). func (v *TreeModel) IterNthChild(iter *TreeIter, parent *TreeIter, n int) bool { c := C.gtk_tree_model_iter_nth_child(v.native(), iter.native(), parent.native(), C.gint(n)) return gobool(c) } // IterChildren is a wrapper around gtk_tree_model_iter_children(). func (v *TreeModel) IterChildren(iter, child *TreeIter) bool { var cIter, cChild *C.GtkTreeIter if iter != nil { cIter = iter.native() } cChild = child.native() c := C.gtk_tree_model_iter_children(v.native(), cChild, cIter) return gobool(c) } // IterNChildren is a wrapper around gtk_tree_model_iter_n_children(). func (v *TreeModel) IterNChildren(iter *TreeIter) int { var cIter *C.GtkTreeIter if iter != nil { cIter = iter.native() } c := C.gtk_tree_model_iter_n_children(v.native(), cIter) return int(c) } // FilterNew is a wrapper around gtk_tree_model_filter_new(). func (v *TreeModel) FilterNew(root *TreePath) (*TreeModelFilter, error) { c := C.gtk_tree_model_filter_new(v.native(), root.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapTreeModelFilter(obj), nil } // TreeModelForeachFunc defines the function prototype for the foreach function (f arg) for // (* TreeModel).ForEach type TreeModelForeachFunc func(model *TreeModel, path *TreePath, iter *TreeIter) bool // ForEach() is a wrapper around gtk_tree_model_foreach () func (v *TreeModel) ForEach(f TreeModelForeachFunc) { id := callback.Assign(f) defer callback.Delete(id) C._gtk_tree_model_foreach(v.toTreeModel(), C.gpointer(id)) } /* * GtkTreeModelFilter */ // TreeModelFilter is a representation of GTK's GtkTreeModelFilter. type TreeModelFilter struct { *glib.Object // Interfaces TreeModel } func (v *TreeModelFilter) native() *C.GtkTreeModelFilter { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTreeModelFilter(p) } func (v *TreeModelFilter) toTreeModelFilter() *C.GtkTreeModelFilter { if v == nil { return nil } return v.native() } func marshalTreeModelFilter(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTreeModelFilter(obj), nil } func wrapTreeModelFilter(obj *glib.Object) *TreeModelFilter { if obj == nil { return nil } tm := wrapTreeModel(obj) return &TreeModelFilter{obj, *tm} } // SetVisibleColumn is a wrapper around gtk_tree_model_filter_set_visible_column(). func (v *TreeModelFilter) SetVisibleColumn(column int) { C.gtk_tree_model_filter_set_visible_column(v.native(), C.gint(column)) } // ConvertChildPathToPath is a wrapper around gtk_tree_model_filter_convert_child_path_to_path(). func (v *TreeModelFilter) ConvertChildPathToPath(childPath *TreePath) *TreePath { path := C.gtk_tree_model_filter_convert_child_path_to_path(v.native(), childPath.native()) if path == nil { return nil } p := &TreePath{path} runtime.SetFinalizer(p, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) return p } // ConvertChildIterToIter is a wrapper around gtk_tree_model_filter_convert_child_iter_to_iter(). func (v *TreeModelFilter) ConvertChildIterToIter(childIter *TreeIter) (*TreeIter, bool) { var iter C.GtkTreeIter ok := gobool(C.gtk_tree_model_filter_convert_child_iter_to_iter(v.native(), &iter, childIter.native())) t := &TreeIter{iter} return t, ok } // ConvertIterToChildIter is a wrapper around gtk_tree_model_filter_convert_child_iter_to_iter(). func (v *TreeModelFilter) ConvertIterToChildIter(filterIter *TreeIter) *TreeIter { var iter C.GtkTreeIter C.gtk_tree_model_filter_convert_iter_to_child_iter(v.native(), &iter, filterIter.native()) t := &TreeIter{iter} return t } // ConvertPathToChildPath is a wrapper around gtk_tree_model_filter_convert_path_to_child_path(). func (v *TreeModelFilter) ConvertPathToChildPath(filterPath *TreePath) *TreePath { path := C.gtk_tree_model_filter_convert_path_to_child_path(v.native(), filterPath.native()) if path == nil { return nil } p := &TreePath{path} runtime.SetFinalizer(p, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) return p } // Refilter is a wrapper around gtk_tree_model_filter_refilter(). func (v *TreeModelFilter) Refilter() { C.gtk_tree_model_filter_refilter(v.native()) } // TreeModelFilterVisibleFunc defines the function prototype for the filter visibility function (f arg) // to TreeModelFilter.SetVisibleFunc. type TreeModelFilterVisibleFunc func(model *TreeModel, iter *TreeIter) bool // SetVisibleFunc is a wrapper around gtk_tree_model_filter_set_visible_func(). func (v *TreeModelFilter) SetVisibleFunc(f TreeModelFilterVisibleFunc) { C._gtk_tree_model_filter_set_visible_func(v.native(), C.gpointer(callback.Assign(f))) } // Down() is a wrapper around gtk_tree_path_down() func (v *TreePath) Down() { C.gtk_tree_path_down(v.native()) } // IsAncestor() is a wrapper around gtk_tree_path_is_ancestor() func (v *TreePath) IsAncestor(descendant *TreePath) bool { return gobool(C.gtk_tree_path_is_ancestor(v.native(), descendant.native())) } // IsDescendant() is a wrapper around gtk_tree_path_is_descendant() func (v *TreePath) IsDescendant(ancestor *TreePath) bool { return gobool(C.gtk_tree_path_is_descendant(v.native(), ancestor.native())) } /* * GtkTreePath */ // TreePath is a representation of GTK's GtkTreePath. type TreePath struct { GtkTreePath *C.GtkTreePath } // Return a TreePath from the GList func TreePathFromList(list *glib.List) *TreePath { if list == nil { return nil } return &TreePath{(*C.GtkTreePath)(list.Data().(unsafe.Pointer))} } // native returns a pointer to the underlying GtkTreePath. func (v *TreePath) native() *C.GtkTreePath { if v == nil { return nil } return v.GtkTreePath } func marshalTreePath(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return &TreePath{(*C.GtkTreePath)(unsafe.Pointer(c))}, nil } func (v *TreePath) free() { C.gtk_tree_path_free(v.native()) } // GetIndices is a wrapper around gtk_tree_path_get_indices_with_depth func (v *TreePath) GetIndices() []int { var depth C.gint var goindices []int var ginthelp C.gint indices := uintptr(unsafe.Pointer(C.gtk_tree_path_get_indices_with_depth(v.native(), &depth))) size := unsafe.Sizeof(ginthelp) for i := 0; i < int(depth); i++ { goind := int(*((*C.gint)(unsafe.Pointer(indices)))) goindices = append(goindices, goind) indices += size } return goindices } // String is a wrapper around gtk_tree_path_to_string(). func (v *TreePath) String() string { c := C.gtk_tree_path_to_string(v.native()) return goString(c) } // TreePathNewFromString is a wrapper around gtk_tree_path_new_from_string(). func TreePathNewFromString(path string) (*TreePath, error) { cstr := C.CString(path) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_tree_path_new_from_string((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } t := &TreePath{c} runtime.SetFinalizer(t, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) return t, nil } // Next() is a wrapper around gtk_tree_path_next() func (v *TreePath) Next() { C.gtk_tree_path_next(v.native()) } // Prev() is a wrapper around gtk_tree_path_prev() func (v *TreePath) Prev() bool { return gobool(C.gtk_tree_path_prev(v.native())) } // Up() is a wrapper around gtk_tree_path_up() func (v *TreePath) Up() bool { return gobool(C.gtk_tree_path_up(v.native())) } // TreePathNewFirst() is a wrapper around gtk_tree_path_new_first(). func TreePathNewFirst() (*TreePath, error) { c := C.gtk_tree_path_new_first() if c == nil { return nil, nilPtrErr } t := &TreePath{c} runtime.SetFinalizer(t, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) return t, nil } // AppendIndex() is a wrapper around gtk_tree_path_append_index(). func (v *TreePath) AppendIndex(index int) { C.gtk_tree_path_append_index(v.native(), C.gint(index)) } // PrependIndex() is a wrapper around gtk_tree_path_prepend_index(). func (v *TreePath) PrependIndex(index int) { C.gtk_tree_path_prepend_index(v.native(), C.gint(index)) } // GetDepth() is a wrapper around gtk_tree_path_get_depth(). func (v *TreePath) GetDepth() int { return int(C.gtk_tree_path_get_depth(v.native())) } // Copy() is a wrapper around gtk_tree_path_copy(). func (v *TreePath) Copy() (*TreePath, error) { c := C.gtk_tree_path_copy(v.native()) if c == nil { return nil, nilPtrErr } t := &TreePath{c} runtime.SetFinalizer(t, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) return t, nil } // Compare() is a wrapper around gtk_tree_path_compare(). func (v *TreePath) Compare(b *TreePath) int { return int(C.gtk_tree_path_compare(v.native(), b.native())) } /* * GtkTreeSelection */ // TreeSelection is a representation of GTK's GtkTreeSelection. type TreeSelection struct { *glib.Object } // native returns a pointer to the underlying GtkTreeSelection. func (v *TreeSelection) native() *C.GtkTreeSelection { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTreeSelection(p) } func marshalTreeSelection(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTreeSelection(obj), nil } func wrapTreeSelection(obj *glib.Object) *TreeSelection { if obj == nil { return nil } return &TreeSelection{obj} } // GetSelected() is a wrapper around gtk_tree_selection_get_selected(). func (v *TreeSelection) GetSelected() (model ITreeModel, iter *TreeIter, ok bool) { var cmodel *C.GtkTreeModel var citer C.GtkTreeIter c := C.gtk_tree_selection_get_selected(v.native(), &cmodel, &citer) model = wrapTreeModel(glib.Take(unsafe.Pointer(cmodel))) iter = &TreeIter{citer} ok = gobool(c) return } // SelectPath is a wrapper around gtk_tree_selection_select_path(). func (v *TreeSelection) SelectPath(path *TreePath) { C.gtk_tree_selection_select_path(v.native(), path.native()) } // UnselectPath is a wrapper around gtk_tree_selection_unselect_path(). func (v *TreeSelection) UnselectPath(path *TreePath) { C.gtk_tree_selection_unselect_path(v.native(), path.native()) } // GetSelectedRows is a wrapper around gtk_tree_selection_get_selected_rows(). // All the elements of returned list are wrapped into (*gtk.TreePath) values. // // Please note that a runtime finalizer is only set on the head of the linked // list, and must be kept live while accessing any item in the list, or the // Go garbage collector will free the whole list. func (v *TreeSelection) GetSelectedRows(model ITreeModel) *glib.List { var pcmodel **C.GtkTreeModel if model != nil { cmodel := model.toTreeModel() pcmodel = &cmodel } clist := C.gtk_tree_selection_get_selected_rows(v.native(), pcmodel) if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return &TreePath{(*C.GtkTreePath)(ptr)} }) runtime.SetFinalizer(glist, func(glist *glib.List) { glib.FinalizerStrategy(func() { glist.FreeFull(func(item interface{}) { path := item.(*TreePath) C.gtk_tree_path_free(path.GtkTreePath) }) }) }) return glist } // CountSelectedRows() is a wrapper around gtk_tree_selection_count_selected_rows(). func (v *TreeSelection) CountSelectedRows() int { return int(C.gtk_tree_selection_count_selected_rows(v.native())) } // SelectIter is a wrapper around gtk_tree_selection_select_iter(). func (v *TreeSelection) SelectIter(iter *TreeIter) { C.gtk_tree_selection_select_iter(v.native(), iter.native()) } // SetMode() is a wrapper around gtk_tree_selection_set_mode(). func (v *TreeSelection) SetMode(m SelectionMode) { C.gtk_tree_selection_set_mode(v.native(), C.GtkSelectionMode(m)) } // GetMode() is a wrapper around gtk_tree_selection_get_mode(). func (v *TreeSelection) GetMode() SelectionMode { return SelectionMode(C.gtk_tree_selection_get_mode(v.native())) } // SelectAll() is a wrapper around gtk_tree_selection_select_all() func (v *TreeSelection) SelectAll() { C.gtk_tree_selection_select_all(v.native()) } // UnelectAll() is a wrapper around gtk_tree_selection_unselect_all() func (v *TreeSelection) UnselectAll() { C.gtk_tree_selection_unselect_all(v.native()) } // UnselectIter() is a wrapper around gtk_tree_selection_unselect_iter(). func (v *TreeSelection) UnselectIter(iter *TreeIter) { C.gtk_tree_selection_unselect_iter(v.native(), iter.native()) } // IterIsSelected() is a wrapper around gtk_tree_selection_iter_is_selected(). func (v *TreeSelection) IterIsSelected(iter *TreeIter) bool { return gobool(C.gtk_tree_selection_iter_is_selected(v.native(), iter.native())) } // SelectRange() is a wrapper around gtk_tree_selection_select_range(). func (v *TreeSelection) SelectRange(start, end *TreePath) { C.gtk_tree_selection_select_range(v.native(), start.native(), end.native()) } // UnselectRange() is a wrapper around gtk_tree_selection_unselect_range(). func (v *TreeSelection) UnselectRange(start, end *TreePath) { C.gtk_tree_selection_unselect_range(v.native(), start.native(), end.native()) } // PathIsSelected() is a wrapper around gtk_tree_selection_path_is_selected(). func (v *TreeSelection) PathIsSelected(path *TreePath) bool { return gobool(C.gtk_tree_selection_path_is_selected(v.native(), path.native())) } // TreeSelectionForeachFunc defines the function prototype for the selected_foreach function (f arg) for // (* TreeSelection).SelectedForEach type TreeSelectionForeachFunc func(model *TreeModel, path *TreePath, iter *TreeIter) // SelectedForEach() is a wrapper around gtk_tree_selection_selected_foreach() func (v *TreeSelection) SelectedForEach(f TreeSelectionForeachFunc) { id := callback.Assign(f) defer callback.Delete(id) C._gtk_tree_selection_selected_foreach(v.native(), C.gpointer(id)) } // TreeSelectionFunc defines the function prototype for the gtk_tree_selection_set_select_function // function (f arg) for (* TreeSelection).SetSelectFunction type TreeSelectionFunc func(selection *TreeSelection, model *TreeModel, path *TreePath, selected bool) bool // SetSelectFunction() is a wrapper around gtk_tree_selection_set_select_function() func (v *TreeSelection) SetSelectFunction(f TreeSelectionFunc) { C._gtk_tree_selection_set_select_function(v.native(), C.gpointer(callback.Assign(f))) } /* * GtkTreeRowReference */ // TreeRowReference is a representation of GTK's GtkTreeRowReference. type TreeRowReference struct { GtkTreeRowReference *C.GtkTreeRowReference } func (v *TreeRowReference) native() *C.GtkTreeRowReference { if v == nil { return nil } return v.GtkTreeRowReference } func (v *TreeRowReference) free() { C.gtk_tree_row_reference_free(v.native()) } // TreeRowReferenceNew is a wrapper around gtk_tree_row_reference_new(). func TreeRowReferenceNew(model *TreeModel, path *TreePath) (*TreeRowReference, error) { c := C.gtk_tree_row_reference_new(model.native(), path.native()) if c == nil { return nil, nilPtrErr } r := &TreeRowReference{c} runtime.SetFinalizer(r, func(v *TreeRowReference) { glib.FinalizerStrategy(v.free) }) return r, nil } // GetPath is a wrapper around gtk_tree_row_reference_get_path. func (v *TreeRowReference) GetPath() *TreePath { c := C.gtk_tree_row_reference_get_path(v.native()) if c == nil { return nil } t := &TreePath{c} runtime.SetFinalizer(t, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) return t } // GetModel is a wrapper around gtk_tree_row_reference_get_path. func (v *TreeRowReference) GetModel() (ITreeModel, error) { c := C.gtk_tree_row_reference_get_model(v.native()) if c == nil { return nil, nilPtrErr } return castTreeModel(c) } // Valid is a wrapper around gtk_tree_row_reference_valid. func (v *TreeRowReference) Valid() bool { c := C.gtk_tree_row_reference_valid(v.native()) return gobool(c) } /* * GtkTreeSortable */ // TreeSortable is a representation of GTK's GtkTreeSortable type TreeSortable struct { *glib.Object } // ITreeSortable is an interface type implemented by all structs // embedding a TreeSortable. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkTreeSortable. type ITreeSortable interface { toTreeSortable() *C.GtkTreeSortable } // native returns a pointer to the underlying GtkTreeSortable func (v *TreeSortable) native() *C.GtkTreeSortable { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTreeSortable(p) } func (v *TreeSortable) toTreeSortable() *C.GtkTreeSortable { if v == nil { return nil } return v.native() } func marshalTreeSortable(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTreeSortable(obj), nil } func wrapTreeSortable(obj *glib.Object) *TreeSortable { if obj == nil { return nil } return &TreeSortable{obj} } // TreeIterCompareFunc is a representation of GtkTreeIterCompareFunc. // It defines the function prototype for the sort function (f arg) for (* TreeSortable).SetSortFunc type TreeIterCompareFunc func(model *TreeModel, a, b *TreeIter) int // GetSortColumnId() is a wrapper around gtk_tree_sortable_get_sort_column_id(). func (v *TreeSortable) GetSortColumnId() (int, SortType, bool) { var column C.gint var order C.GtkSortType ok := gobool(C.gtk_tree_sortable_get_sort_column_id(v.native(), &column, &order)) return int(column), SortType(order), ok } // SetSortColumnId() is a wrapper around gtk_tree_sortable_set_sort_column_id(). func (v *TreeSortable) SetSortColumnId(column int, order SortType) { C.gtk_tree_sortable_set_sort_column_id(v.native(), C.gint(column), C.GtkSortType(order)) } // SetSortFunc() is a wrapper around gtk_tree_sortable_set_sort_func(). func (v *TreeSortable) SetSortFunc(sortColumn int, f TreeIterCompareFunc) { C._gtk_tree_sortable_set_sort_func(v.native(), C.gint(sortColumn), C.gpointer(callback.Assign(f))) } // SetDefaultSortFunc() is a wrapper around gtk_tree_sortable_set_default_sort_func(). func (v *TreeSortable) SetDefaultSortFunc(f TreeIterCompareFunc) { C._gtk_tree_sortable_set_default_sort_func(v.native(), C.gpointer(callback.Assign(f))) } func (v *TreeSortable) HasDefaultSortFunc() bool { return gobool(C.gtk_tree_sortable_has_default_sort_func(v.native())) } /* * GtkTreeModelSort */ // TreeModelSort is a representation of GTK's GtkTreeModelSort type TreeModelSort struct { *glib.Object // Interfaces TreeModel TreeSortable } // native returns a pointer to the underlying GtkTreeModelSort func (v *TreeModelSort) native() *C.GtkTreeModelSort { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTreeModelSort(p) } func marshalTreeModelSort(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTreeModelSort(obj), nil } func wrapTreeModelSort(obj *glib.Object) *TreeModelSort { if obj == nil { return nil } tm := wrapTreeModel(obj) ts := wrapTreeSortable(obj) return &TreeModelSort{obj, *tm, *ts} } func (v *TreeModelSort) toTreeModel() *C.GtkTreeModel { if v == nil { return nil } return C.toGtkTreeModel(unsafe.Pointer(v.GObject)) } func (v *TreeModelSort) toTreeSortable() *C.GtkTreeSortable { if v == nil { return nil } return C.toGtkTreeSortable(unsafe.Pointer(v.GObject)) } // TreeModelSortNew is a wrapper around gtk_tree_model_sort_new_with_model(): func TreeModelSortNew(model ITreeModel) (*TreeModelSort, error) { var mptr *C.GtkTreeModel if model != nil { mptr = model.toTreeModel() } c := C.gtk_tree_model_sort_new_with_model(mptr) if c == nil { return nil, nilPtrErr } tms := wrapTreeModelSort(glib.Take(unsafe.Pointer(c))) return tms, nil } // GetModel is a wrapper around gtk_tree_model_sort_get_model() func (v *TreeModelSort) GetModel() (ITreeModel, error) { c := C.gtk_tree_model_sort_get_model(v.native()) if c == nil { return nil, nilPtrErr } return castTreeModel(c) } // ConvertChildPathToPath is a wrapper around gtk_tree_model_sort_convert_child_path_to_path(). func (v *TreeModelSort) ConvertChildPathToPath(childPath *TreePath) *TreePath { path := C.gtk_tree_model_sort_convert_child_path_to_path(v.native(), childPath.native()) if path == nil { return nil } p := &TreePath{path} runtime.SetFinalizer(p, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) return p } // ConvertChildIterToIter is a wrapper around gtk_tree_model_sort_convert_child_iter_to_iter(). func (v *TreeModelSort) ConvertChildIterToIter(childIter *TreeIter) (*TreeIter, bool) { var iter C.GtkTreeIter ok := gobool(C.gtk_tree_model_sort_convert_child_iter_to_iter(v.native(), &iter, childIter.native())) t := &TreeIter{iter} return t, ok } // ConvertPathToChildPath is a wrapper around gtk_tree_model_sort_convert_path_to_child_path(). func (v *TreeModelSort) ConvertPathToChildPath(sortPath *TreePath) *TreePath { path := C.gtk_tree_model_sort_convert_path_to_child_path(v.native(), sortPath.native()) if path == nil { return nil } p := &TreePath{path} runtime.SetFinalizer(p, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) return p } // ConvertIterToChildIter is a wrapper around gtk_tree_model_sort_convert_iter_to_child_iter(). func (v *TreeModelSort) ConvertIterToChildIter(sortIter *TreeIter) *TreeIter { var iter C.GtkTreeIter C.gtk_tree_model_sort_convert_iter_to_child_iter(v.native(), &iter, sortIter.native()) t := &TreeIter{iter} return t } // ResetDefaultSortFunc is a wrapper around gtk_tree_model_sort_reset_default_sort_func(). func (v *TreeModelSort) ResetDefaultSortFunc() { C.gtk_tree_model_sort_reset_default_sort_func(v.native()) } // ClearCache is a wrapper around gtk_tree_model_sort_clear_cache(). func (v *TreeModelSort) ClearCache() { C.gtk_tree_model_sort_clear_cache(v.native()) } // IterIsValid is a wrapper around gtk_tree_model_sort_iter_is_valid(). func (v *TreeModelSort) IterIsValid(iter *TreeIter) bool { return gobool(C.gtk_tree_model_sort_iter_is_valid(v.native(), iter.native())) } /* * GtkTreeStore */ // TreeStore is a representation of GTK's GtkTreeStore. type TreeStore struct { *glib.Object // Interfaces TreeModel TreeSortable } // native returns a pointer to the underlying GtkTreeStore. func (v *TreeStore) native() *C.GtkTreeStore { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTreeStore(p) } func marshalTreeStore(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTreeStore(obj), nil } func wrapTreeStore(obj *glib.Object) *TreeStore { if obj == nil { return nil } tm := wrapTreeModel(obj) ts := wrapTreeSortable(obj) return &TreeStore{obj, *tm, *ts} } func (v *TreeStore) toTreeModel() *C.GtkTreeModel { if v == nil { return nil } return C.toGtkTreeModel(unsafe.Pointer(v.GObject)) } func (v *TreeStore) toTreeSortable() *C.GtkTreeSortable { if v == nil { return nil } return C.toGtkTreeSortable(unsafe.Pointer(v.GObject)) } // TreeStoreNew is a wrapper around gtk_tree_store_newv(). func TreeStoreNew(types ...glib.Type) (*TreeStore, error) { gtypes := C.alloc_types(C.int(len(types))) for n, val := range types { C.set_type(gtypes, C.int(n), C.GType(val)) } defer C.g_free(C.gpointer(gtypes)) c := C.gtk_tree_store_newv(C.gint(len(types)), gtypes) if c == nil { return nil, nilPtrErr } ts := wrapTreeStore(glib.Take(unsafe.Pointer(c))) return ts, nil } // Append is a wrapper around gtk_tree_store_append(). func (v *TreeStore) Append(parent *TreeIter) *TreeIter { var ti C.GtkTreeIter var cParent *C.GtkTreeIter if parent != nil { cParent = parent.native() } C.gtk_tree_store_append(v.native(), &ti, cParent) iter := &TreeIter{ti} return iter } // Prepend is a wrapper around gtk_tree_store_prepend(). func (v *TreeStore) Prepend(parent *TreeIter) *TreeIter { var ti C.GtkTreeIter var cParent *C.GtkTreeIter if parent != nil { cParent = parent.native() } C.gtk_tree_store_prepend(v.native(), &ti, cParent) iter := &TreeIter{ti} return iter } // Insert is a wrapper around gtk_tree_store_insert func (v *TreeStore) Insert(parent *TreeIter, position int) *TreeIter { var ti C.GtkTreeIter var cParent *C.GtkTreeIter if parent != nil { cParent = parent.native() } C.gtk_tree_store_insert(v.native(), &ti, cParent, C.gint(position)) iter := &TreeIter{ti} return iter } // SetValue is a wrapper around gtk_tree_store_set_value() func (v *TreeStore) SetValue(iter *TreeIter, column int, value interface{}) error { switch value.(type) { case *gdk.Pixbuf: pix := value.(*gdk.Pixbuf) C._gtk_tree_store_set(v.native(), iter.native(), C.gint(column), unsafe.Pointer(pix.Native())) default: gv, err := glib.GValue(value) if err != nil { return err } C.gtk_tree_store_set_value(v.native(), iter.native(), C.gint(column), (*C.GValue)(C.gpointer(gv.Native()))) } return nil } // Remove is a wrapper around gtk_tree_store_remove(). func (v *TreeStore) Remove(iter *TreeIter) bool { var ti *C.GtkTreeIter if iter != nil { ti = iter.native() } return 0 != C.gtk_tree_store_remove(v.native(), ti) } // Clear is a wrapper around gtk_tree_store_clear(). func (v *TreeStore) Clear() { C.gtk_tree_store_clear(v.native()) } // InsertBefore() is a wrapper around gtk_tree_store_insert_before(). func (v *TreeStore) InsertBefore(parent, sibling *TreeIter) *TreeIter { var ti C.GtkTreeIter C.gtk_tree_store_insert_before(v.native(), &ti, parent.native(), sibling.native()) iter := &TreeIter{ti} return iter } // InsertAfter() is a wrapper around gtk_tree_store_insert_after(). func (v *TreeStore) InsertAfter(parent, sibling *TreeIter) *TreeIter { var ti C.GtkTreeIter C.gtk_tree_store_insert_after(v.native(), &ti, parent.native(), sibling.native()) iter := &TreeIter{ti} return iter } // InsertWithValues() is a wrapper around gtk_tree_store_insert_with_valuesv(). func (v *TreeStore) InsertWithValues(iter, parent *TreeIter, position int, inColumns []int, inValues []interface{}) error { length := len(inColumns) if len(inValues) < length { length = len(inValues) } cColumns := make([]C.gint, 0, length) cValues := make([]C.GValue, 0, length) for i := 0; i < length; i++ { value := inValues[i] var gvalue *C.GValue switch value.(type) { case *gdk.Pixbuf: pix := value.(*gdk.Pixbuf) if pix == nil { continue } gvalue = (*C.GValue)(unsafe.Pointer(pix.Native())) default: gv, err := glib.GValue(value) if err != nil { return err } gvalue = (*C.GValue)(C.gpointer(gv.Native())) } cColumns = append(cColumns, C.gint(inColumns[i])) cValues = append(cValues, *gvalue) } var cColumnsPointer *C.gint if len(cColumns) > 0 { cColumnsPointer = &cColumns[0] } var cValuesPointer *C.GValue if len(cValues) > 0 { cValuesPointer = &cValues[0] } C.gtk_tree_store_insert_with_valuesv(v.native(), iter.native(), parent.native(), C.gint(position), cColumnsPointer, cValuesPointer, C.gint(len(cColumns))) return nil } // MoveBefore is a wrapper around gtk_tree_store_move_before(). func (v *TreeStore) MoveBefore(iter, position *TreeIter) { C.gtk_tree_store_move_before(v.native(), iter.native(), position.native()) } // MoveAfter is a wrapper around gtk_tree_store_move_after(). func (v *TreeStore) MoveAfter(iter, position *TreeIter) { C.gtk_tree_store_move_after(v.native(), iter.native(), position.native()) } // Swap is a wrapper around gtk_tree_store_swap(). func (v *TreeStore) Swap(a, b *TreeIter) { C.gtk_tree_store_swap(v.native(), a.native(), b.native()) } // SetColumnTypes is a wrapper around gtk_tree_store_set_column_types(). // The size of glib.Type must match the number of columns func (v *TreeStore) SetColumnTypes(types ...glib.Type) { gtypes := C.alloc_types(C.int(len(types))) for n, val := range types { C.set_type(gtypes, C.int(n), C.GType(val)) } defer C.g_free(C.gpointer(gtypes)) C.gtk_tree_store_set_column_types(v.native(), C.gint(len(types)), gtypes) } /* * GtkViewport */ // Viewport is a representation of GTK's GtkViewport GInterface. type Viewport struct { Bin // Interfaces Scrollable } // IViewport is an interface type implemented by all structs // embedding a Viewport. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkViewport. type IViewport interface { toViewport() *C.GtkViewport } // native() returns a pointer to the underlying GObject as a GtkViewport. func (v *Viewport) native() *C.GtkViewport { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkViewport(p) } func wrapViewport(obj *glib.Object) *Viewport { if obj == nil { return nil } b := wrapBin(obj) s := wrapScrollable(obj) return &Viewport{ Bin: *b, Scrollable: *s, } } func marshalViewport(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapViewport(obj), nil } func (v *Viewport) toViewport() *C.GtkViewport { if v == nil { return nil } return v.native() } // ViewportNew() is a wrapper around gtk_viewport_new(). func ViewportNew(hadjustment, vadjustment *Adjustment) (*Viewport, error) { c := C.gtk_viewport_new(hadjustment.native(), vadjustment.native()) if c == nil { return nil, nilPtrErr } return wrapViewport(glib.Take(unsafe.Pointer(c))), nil } // SetShadowType is a wrapper around gtk_viewport_set_shadow_type(). func (v *Viewport) SetShadowType(shadowType ShadowType) { C.gtk_viewport_set_shadow_type(v.native(), C.GtkShadowType(shadowType)) } // GetShadowType is a wrapper around gtk_viewport_get_shadow_type(). func (v *Viewport) GetShadowType() ShadowType { c := C.gtk_viewport_get_shadow_type(v.native()) return ShadowType(c) } // GetBinWindow is a wrapper around gtk_viewport_get_bin_window(). func (v *Viewport) GetBinWindow() *gdk.Window { c := C.gtk_viewport_get_bin_window(v.native()) if c == nil { return nil } return &gdk.Window{glib.Take(unsafe.Pointer(c))} } // GetViewWindow is a wrapper around gtk_viewport_get_view_window(). func (v *Viewport) GetViewWindow() *gdk.Window { c := C.gtk_viewport_get_view_window(v.native()) if c == nil { return nil } return &gdk.Window{glib.Take(unsafe.Pointer(c))} } /* * GtkVolumeButton */ // VolumeButton is a representation of GTK's GtkVolumeButton. type VolumeButton struct { ScaleButton } // native() returns a pointer to the underlying GtkVolumeButton. func (v *VolumeButton) native() *C.GtkVolumeButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkVolumeButton(p) } func marshalVolumeButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapVolumeButton(obj), nil } func wrapVolumeButton(obj *glib.Object) *VolumeButton { if obj == nil { return nil } actionable := wrapActionable(obj) return &VolumeButton{ScaleButton{Button{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}, actionable}}} } // VolumeButtonNew is a wrapper around gtk_volume_button_new(). func VolumeButtonNew() (*VolumeButton, error) { c := C.gtk_volume_button_new() if c == nil { return nil, nilPtrErr } return wrapVolumeButton(glib.Take(unsafe.Pointer(c))), nil } type WrapFn interface{} var WrapMap = map[string]WrapFn{ "GtkAccelGroup": wrapAccelGroup, "GtkAccelMao": wrapAccelMap, "GtkAdjustment": wrapAdjustment, "GtkApplicationWindow": wrapApplicationWindow, "GtkAssistant": wrapAssistant, "GtkBin": wrapBin, "GtkBox": wrapBox, "GtkButton": wrapButton, "GtkButtonBox": wrapButtonBox, "GtkCalendar": wrapCalendar, "GtkCellLayout": wrapCellLayout, "GtkCellEditable": wrapCellEditable, "GtkCellRenderer": wrapCellRenderer, "GtkCellRendererSpinner": wrapCellRendererSpinner, "GtkCellRendererPixbuf": wrapCellRendererPixbuf, "GtkCellRendererText": wrapCellRendererText, "GtkCellRendererProgress": wrapCellRendererProgress, "GtkCellRendererToggle": wrapCellRendererToggle, "GtkCellRendererCombo": wrapCellRendererCombo, "GtkCellRendererAccel": wrapCellRendererAccel, "GtkCellRendererSpin": wrapCellRendererSpin, "GtkCheckButton": wrapCheckButton, "GtkCheckMenuItem": wrapCheckMenuItem, "GtkClipboard": wrapClipboard, "GtkColorButton": wrapColorButton, "GtkContainer": wrapContainer, "GtkDialog": wrapDialog, "GtkDrawingArea": wrapDrawingArea, "GtkEditable": wrapEditable, "GtkEntry": wrapEntry, "GtkEntryBuffer": wrapEntryBuffer, "GtkEntryCompletion": wrapEntryCompletion, "GtkEventBox": wrapEventBox, "GtkExpander": wrapExpander, "GtkFrame": wrapFrame, "GtkFileChooser": wrapFileChooser, "GtkFileChooserButton": wrapFileChooserButton, "GtkFileChooserDialog": wrapFileChooserDialog, "GtkFileChooserWidget": wrapFileChooserWidget, "GtkGrid": wrapGrid, "GtkIconView": wrapIconView, "GtkImage": wrapImage, "GtkLabel": wrapLabel, "GtkLayout": wrapLayout, "GtkLinkButton": wrapLinkButton, "GtkListStore": wrapListStore, "GtkMenu": wrapMenu, "GtkMenuBar": wrapMenuBar, "GtkMenuButton": wrapMenuButton, "GtkMenuItem": wrapMenuItem, "GtkMenuShell": wrapMenuShell, "GtkMessageDialog": wrapMessageDialog, "GtkNotebook": wrapNotebook, "GtkOffscreenWindow": wrapOffscreenWindow, "GtkOrientable": wrapOrientable, "GtkOverlay": wrapOverlay, "GtkPaned": wrapPaned, "GtkProgressBar": wrapProgressBar, "GtkRadioButton": wrapRadioButton, "GtkRadioMenuItem": wrapRadioMenuItem, "GtkRange": wrapRange, "GtkRecentChooser": wrapRecentChooser, "GtkRecentChooserMenu": wrapRecentChooserMenu, "GtkRecentFilter": wrapRecentFilter, "GtkRecentManager": wrapRecentManager, "GtkScaleButton": wrapScaleButton, "GtkScale": wrapScale, "GtkScrollable": wrapScrollable, "GtkScrollbar": wrapScrollbar, "GtkScrolledWindow": wrapScrolledWindow, "GtkSearchEntry": wrapSearchEntry, "GtkSeparator": wrapSeparator, "GtkSeparatorMenuItem": wrapSeparatorMenuItem, "GtkSeparatorToolItem": wrapSeparatorToolItem, "GtkSpinButton": wrapSpinButton, "GtkSpinner": wrapSpinner, "GtkStatusbar": wrapStatusbar, "GtkSwitch": wrapSwitch, "GtkTextBuffer": wrapTextBuffer, "GtkTextChildAnchor": wrapTextChildAnchor, "GtkTextTag": wrapTextTag, "GtkTextTagTable": wrapTextTagTable, "GtkTextView": wrapTextView, "GtkToggleButton": wrapToggleButton, "GtkToolbar": wrapToolbar, "GtkToolButton": wrapToolButton, "GtkToggleToolButton": wrapToggleToolButton, "GtkToolItem": wrapToolItem, "GtkTreeModel": wrapTreeModel, "GtkTreeModelFilter": wrapTreeModelFilter, "GtkTreeModelSort": wrapTreeModelSort, "GtkTreeSelection": wrapTreeSelection, "GtkTreeStore": wrapTreeStore, "GtkTreeView": wrapTreeView, "GtkTreeViewColumn": wrapTreeViewColumn, "GtkViewport": wrapViewport, "GtkVolumeButton": wrapVolumeButton, "GtkWidget": wrapWidget, "GtkWindow": wrapWindow, } // castInternal casts the given object to the appropriate Go struct, but returns it as interface for later type assertions. // The className is the results of C.object_get_class_name(c) called on the native object. // The obj is the result of glib.Take(unsafe.Pointer(c)), used as a parameter for the wrapper functions. func castInternal(className string, obj *glib.Object) (interface{}, error) { fn, ok := WrapMap[className] if !ok { fn, ok = glib.WrapMap[className] if !ok { return nil, errors.New("unrecognized class name '" + className + "'") } } // Check that the wrapper function is actually a function rf := reflect.ValueOf(fn) if rf.Type().Kind() != reflect.Func { return nil, errors.New("wraper is not a function") } // Call the wraper function with the *glib.Object as first parameter // e.g. "wrapWindow(obj)" v := reflect.ValueOf(obj) rv := rf.Call([]reflect.Value{v}) // At most/max 1 return value if len(rv) != 1 { return nil, errors.New("wrapper did not return") } // Needs to be a pointer of some sort if k := rv[0].Kind(); k != reflect.Ptr { return nil, fmt.Errorf("wrong return type %s", k) } // Only get an interface value, type check will be done in more specific functions return rv[0].Interface(), nil } // cast takes a native GObject and casts it to the appropriate Go struct. //TODO change all wrapFns to return an IObject //^- not sure about this TODO. This may make some usages of the wrapper functions quite verbose, no? func cast(c *C.GObject) (glib.IObject, error) { ptr := unsafe.Pointer(c) var ( className = goString(C.object_get_class_name(C.toGObject(ptr))) obj = glib.Take(ptr) ) intf, err := castInternal(className, obj) if err != nil { return nil, err } ret, ok := intf.(glib.IObject) if !ok { return nil, errors.New("did not return an IObject") } return ret, nil } // castWidget takes a native GtkWidget and casts it to the appropriate Go struct. func castWidget(c *C.GtkWidget) (IWidget, error) { ptr := unsafe.Pointer(c) var ( className = goString(C.object_get_class_name(C.toGObject(ptr))) obj = glib.Take(ptr) ) intf, err := castInternal(className, obj) if err != nil { return nil, err } ret, ok := intf.(IWidget) if !ok { return nil, fmt.Errorf("expected value of type IWidget, got %T", intf) } return ret, nil } // castCellRenderer takes a native GtkCellRenderer and casts it to the appropriate Go struct. func castCellRenderer(c *C.GtkCellRenderer) (ICellRenderer, error) { ptr := unsafe.Pointer(c) var ( className = goString(C.object_get_class_name(C.toGObject(ptr))) obj = glib.Take(ptr) ) intf, err := castInternal(className, obj) if err != nil { return nil, err } ret, ok := intf.(ICellRenderer) if !ok { return nil, fmt.Errorf("expected value of type ICellRenderer, got %T", intf) } return ret, nil } // castTreeModel takes a native GtkCellTreeModel and casts it to the appropriate Go struct. func castTreeModel(c *C.GtkTreeModel) (ITreeModel, error) { ptr := unsafe.Pointer(c) var ( className = goString(C.object_get_class_name(C.toGObject(ptr))) obj = glib.Take(ptr) ) intf, err := castInternal(className, obj) if err != nil { return nil, err } ret, ok := intf.(ITreeModel) if !ok { return nil, fmt.Errorf("expected value of type ITreeModel, got %T", intf) } return ret, nil } // castCellEditable takes a native GtkCellEditable and casts it to the appropriate Go struct. func castCellEditable(c *C.GtkCellEditable) (ICellEditable, error) { ptr := unsafe.Pointer(c) var ( className = goString(C.object_get_class_name(C.toGObject(ptr))) obj = glib.Take(ptr) ) intf, err := castInternal(className, obj) if err != nil { return nil, err } ret, ok := intf.(ICellEditable) if !ok { return nil, fmt.Errorf("expected value of type ICellEditable, got %T", intf) } return ret, nil } gotk3-0.6.2/gtk/gtk.go.h000066400000000000000000000525151431157473000147120ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #pragma once #include #include #include // gotk3_callbackDelete satisfies the GDestroyNotify type. extern void gotk3_callbackDelete(gpointer callback_id); static GtkAboutDialog *toGtkAboutDialog(void *p) { return (GTK_ABOUT_DIALOG(p)); } static GtkAppChooser *toGtkAppChooser(void *p) { return (GTK_APP_CHOOSER(p)); } static GtkAppChooserButton *toGtkAppChooserButton(void *p) { return (GTK_APP_CHOOSER_BUTTON(p)); } static GtkAppChooserDialog *toGtkAppChooserDialog(void *p) { return (GTK_APP_CHOOSER_DIALOG(p)); } static GtkAppChooserWidget *toGtkAppChooserWidget(void *p) { return (GTK_APP_CHOOSER_WIDGET(p)); } static GtkApplication *toGtkApplication(void *p) { return (GTK_APPLICATION(p)); } static GtkApplicationWindow *toGtkApplicationWindow(void *p) { return (GTK_APPLICATION_WINDOW(p)); } static GtkAssistant *toGtkAssistant(void *p) { return (GTK_ASSISTANT(p)); } static GtkCalendar *toGtkCalendar(void *p) { return (GTK_CALENDAR(p)); } static GtkColorChooserDialog *toGtkColorChooserDialog(void *p) { return (GTK_COLOR_CHOOSER_DIALOG(p)); } static GtkFontChooserDialog *toGtkFontChooserDialog(void *p) { return (GTK_FONT_CHOOSER_DIALOG(p)); } static GtkDrawingArea *toGtkDrawingArea(void *p) { return (GTK_DRAWING_AREA(p)); } static GtkCellRendererSpinner *toGtkCellRendererSpinner(void *p) { return (GTK_CELL_RENDERER_SPINNER(p)); } static GtkEventBox *toGtkEventBox(void *p) { return (GTK_EVENT_BOX(p)); } static GtkGrid *toGtkGrid(void *p) { return (GTK_GRID(p)); } static GtkWidget *toGtkWidget(void *p) { return (GTK_WIDGET(p)); } static GtkContainer *toGtkContainer(void *p) { return (GTK_CONTAINER(p)); } static GtkOverlay *toGtkOverlay(void *p) { return (GTK_OVERLAY(p)); } static GtkPageSetup *toGtkPageSetup(void *p) { return (GTK_PAGE_SETUP(p)); } static GtkPaned *toGtkPaned(void *p) { return (GTK_PANED(p)); } static GtkPrintContext *toGtkPrintContext(void *p) { return (GTK_PRINT_CONTEXT(p)); } static GtkPrintOperation *toGtkPrintOperation(void *p) { return (GTK_PRINT_OPERATION(p)); } static GtkPrintOperationPreview *toGtkPrintOperationPreview(void *p) { return (GTK_PRINT_OPERATION_PREVIEW(p)); } static GtkPrintSettings *toGtkPrintSettings(void *p) { return (GTK_PRINT_SETTINGS(p)); } static GtkProgressBar *toGtkProgressBar(void *p) { return (GTK_PROGRESS_BAR(p)); } static GtkLevelBar *toGtkLevelBar(void *p) { return (GTK_LEVEL_BAR(p)); } static GtkBin *toGtkBin(void *p) { return (GTK_BIN(p)); } static GtkWindow *toGtkWindow(void *p) { return (GTK_WINDOW(p)); } static GtkWindowGroup *toGtkWindowGroup(void *p) { return (GTK_WINDOW_GROUP(p)); } static GtkBox *toGtkBox(void *p) { return (GTK_BOX(p)); } static GtkStatusbar *toGtkStatusbar(void *p) { return (GTK_STATUSBAR(p)); } static GtkLabel *toGtkLabel(void *p) { return (GTK_LABEL(p)); } static GtkNotebook *toGtkNotebook(void *p) { return (GTK_NOTEBOOK(p)); } static GtkEntry *toGtkEntry(void *p) { return (GTK_ENTRY(p)); } static GtkEntryBuffer *toGtkEntryBuffer(void *p) { return (GTK_ENTRY_BUFFER(p)); } static GtkEntryCompletion *toGtkEntryCompletion(void *p) { return (GTK_ENTRY_COMPLETION(p)); } static GtkAdjustment *toGtkAdjustment(void *p) { return (GTK_ADJUSTMENT(p)); } static GtkAccelGroup *toGtkAccelGroup(void *p) { return (GTK_ACCEL_GROUP(p)); } static GtkAccelMap *toGtkAccelMap(void *p) { return (GTK_ACCEL_MAP(p)); } static GtkTextTag *toGtkTextTag(void *p) { return (GTK_TEXT_TAG(p)); } static GtkIconView *toGtkIconView(void *p) { return (GTK_ICON_VIEW(p)); } static GtkImage *toGtkImage(void *p) { return (GTK_IMAGE(p)); } static GtkButtonBox *toGtkButtonBox(void *p) { return (GTK_BUTTON_BOX(p)); } static GtkButton *toGtkButton(void *p) { return (GTK_BUTTON(p)); } static GtkScaleButton *toGtkScaleButton(void *p) { return (GTK_SCALE_BUTTON(p)); } static GtkColorButton *toGtkColorButton(void *p) { return (GTK_COLOR_BUTTON(p)); } static GtkViewport *toGtkViewport(void *p) { return (GTK_VIEWPORT(p)); } static GtkVolumeButton *toGtkVolumeButton(void *p) { return (GTK_VOLUME_BUTTON(p)); } static GtkScrollable *toGtkScrollable(void *p) { return (GTK_SCROLLABLE(p)); } static GtkScrolledWindow *toGtkScrolledWindow(void *p) { return (GTK_SCROLLED_WINDOW(p)); } static GtkMenuItem *toGtkMenuItem(void *p) { return (GTK_MENU_ITEM(p)); } static GtkMenu *toGtkMenu(void *p) { return (GTK_MENU(p)); } static GtkMenuShell *toGtkMenuShell(void *p) { return (GTK_MENU_SHELL(p)); } static GtkMenuBar *toGtkMenuBar(void *p) { return (GTK_MENU_BAR(p)); } static GtkSizeGroup *toGtkSizeGroup(void *p) { return (GTK_SIZE_GROUP(p)); } static GtkSpinButton *toGtkSpinButton(void *p) { return (GTK_SPIN_BUTTON(p)); } static GtkSpinner *toGtkSpinner(void *p) { return (GTK_SPINNER(p)); } static GtkComboBox *toGtkComboBox(void *p) { return (GTK_COMBO_BOX(p)); } static GtkComboBoxText *toGtkComboBoxText(void *p) { return (GTK_COMBO_BOX_TEXT(p)); } static GtkLinkButton *toGtkLinkButton(void *p) { return (GTK_LINK_BUTTON(p)); } static GtkLockButton *toGtkLockButton(void *p) { return (GTK_LOCK_BUTTON(p)); } static GtkLayout *toGtkLayout(void *p) { return (GTK_LAYOUT(p)); } static GtkTreeModelSort *toGtkTreeModelSortable(void *p) { return (GTK_TREE_MODEL_SORT(p)); } static GtkListStore *toGtkListStore(void *p) { return (GTK_LIST_STORE(p)); } static GtkSwitch *toGtkSwitch(void *p) { return (GTK_SWITCH(p)); } static GtkTextView *toGtkTextView(void *p) { return (GTK_TEXT_VIEW(p)); } static GtkTextMark *toGtkTextMark(void *p) { return (GTK_TEXT_MARK(p)); } static GtkTextTagTable *toGtkTextTagTable(void *p) { return (GTK_TEXT_TAG_TABLE(p)); } static GtkTextBuffer *toGtkTextBuffer(void *p) { return (GTK_TEXT_BUFFER(p)); } static GtkTreeModel *toGtkTreeModel(void *p) { return (GTK_TREE_MODEL(p)); } static GtkTreeModelFilter *toGtkTreeModelFilter(void *p) { return (GTK_TREE_MODEL_FILTER(p)); } static GtkCellRenderer *toGtkCellRenderer(void *p) { return (GTK_CELL_RENDERER(p)); } static GtkCellEditable *toGtkCellEditable(void *p) { return (GTK_CELL_EDITABLE(p)); } static GtkCellRendererPixbuf *toGtkCellRendererPixbuf(void *p) { return (GTK_CELL_RENDERER_PIXBUF(p)); } static GtkCellRendererProgress *toGtkCellRendererProgress(void *p) { return (GTK_CELL_RENDERER_PROGRESS(p)); } static GtkCellRendererText *toGtkCellRendererText(void *p) { return (GTK_CELL_RENDERER_TEXT(p)); } static GtkCellRendererToggle *toGtkCellRendererToggle(void *p) { return (GTK_CELL_RENDERER_TOGGLE(p)); } static GtkCellRendererCombo *toGtkCellRendererCombo(void *p) { return (GTK_CELL_RENDERER_COMBO(p)); } static GtkCellRendererAccel *toGtkCellRendererAccel(void *p) { return (GTK_CELL_RENDERER_ACCEL(p)); } static GtkCellRendererSpin *toGtkCellRendererSpin(void *p) { return (GTK_CELL_RENDERER_SPIN(p)); } static GtkCellLayout *toGtkCellLayout(void *p) { return (GTK_CELL_LAYOUT(p)); } static GtkCellArea *toGtkCellArea(void *p) { return (GTK_CELL_AREA(p)); } static GtkCellAreaContext *toGtkCellAreaContext(void *p) { return (GTK_CELL_AREA_CONTEXT(p)); } static GtkCellAreaBox *toGtkCellAreaBox(void *p) { return (GTK_CELL_AREA_BOX(p)); } static GtkOrientable *toGtkOrientable(void *p) { return (GTK_ORIENTABLE(p)); } static GtkTreeStore *toGtkTreeStore(void *p) { return (GTK_TREE_STORE(p)); } static GtkTreeView *toGtkTreeView(void *p) { return (GTK_TREE_VIEW(p)); } static GtkTreeViewColumn *toGtkTreeViewColumn(void *p) { return (GTK_TREE_VIEW_COLUMN(p)); } static GtkTreeSelection *toGtkTreeSelection(void *p) { return (GTK_TREE_SELECTION(p)); } static GtkTreeModelSort *toGtkTreeModelSort(void *p) { return (GTK_TREE_MODEL_SORT(p)); } static GtkTreeSortable *toGtkTreeSortable(void *p) { return (GTK_TREE_SORTABLE(p)); } static GtkClipboard *toGtkClipboard(void *p) { return (GTK_CLIPBOARD(p)); } static GtkDialog *toGtkDialog(void *p) { return (GTK_DIALOG(p)); } static GtkMessageDialog *toGtkMessageDialog(void *p) { return (GTK_MESSAGE_DIALOG(p)); } static GtkBuilder *toGtkBuilder(void *p) { return (GTK_BUILDER(p)); } static GtkSeparatorMenuItem *toGtkSeparatorMenuItem(void *p) { return (GTK_SEPARATOR_MENU_ITEM(p)); } static GtkCheckButton *toGtkCheckButton(void *p) { return (GTK_CHECK_BUTTON(p)); } static GtkToggleButton *toGtkToggleButton(void *p) { return (GTK_TOGGLE_BUTTON(p)); } static GtkFontButton *toGtkFontButton(void *p) { return (GTK_FONT_BUTTON(p)); } static GtkFrame *toGtkFrame(void *p) { return (GTK_FRAME(p)); } static GtkAspectFrame *toGtkAspectFrame(void *p) { return (GTK_ASPECT_FRAME(p)); } static GtkSeparator *toGtkSeparator(void *p) { return (GTK_SEPARATOR(p)); } static GtkScale *toGtkScale(void *p) { return (GTK_SCALE(p)); } static GtkScrollbar *toGtkScrollbar(void *p) { return (GTK_SCROLLBAR(p)); } static GtkRange *toGtkRange(void *p) { return (GTK_RANGE(p)); } static GtkSearchEntry *toGtkSearchEntry(void *p) { return (GTK_SEARCH_ENTRY(p)); } static GtkOffscreenWindow *toGtkOffscreenWindow(void *p) { return (GTK_OFFSCREEN_WINDOW(p)); } static GtkExpander *toGtkExpander(void *p) { return (GTK_EXPANDER(p)); } static GtkFileChooser *toGtkFileChooser(void *p) { return (GTK_FILE_CHOOSER(p)); } static GtkFileChooserButton *toGtkFileChooserButton(void *p) { return (GTK_FILE_CHOOSER_BUTTON(p)); } static GtkFileChooserDialog *toGtkFileChooserDialog(void *p) { return (GTK_FILE_CHOOSER_DIALOG(p)); } static GtkFileChooserWidget *toGtkFileChooserWidget(void *p) { return (GTK_FILE_CHOOSER_WIDGET(p)); } static GtkFileFilter *toGtkFileFilter(void *p) { return (GTK_FILE_FILTER(p)); } static GtkMenuButton *toGtkMenuButton(void *p) { return (GTK_MENU_BUTTON(p)); } static GtkRadioButton *toGtkRadioButton(void *p) { return (GTK_RADIO_BUTTON(p)); } static GtkRecentChooser *toGtkRecentChooser(void *p) { return (GTK_RECENT_CHOOSER(p)); } static GtkRecentChooserMenu *toGtkRecentChooserMenu(void *p) { return (GTK_RECENT_CHOOSER_MENU(p)); } static GtkColorChooser *toGtkColorChooser(void *p) { return (GTK_COLOR_CHOOSER(p)); } static GtkFontChooser *toGtkFontChooser(void *p) { return (GTK_FONT_CHOOSER(p)); } static GtkRecentFilter *toGtkRecentFilter(void *p) { return (GTK_RECENT_FILTER(p)); } static GtkRecentManager *toGtkRecentManager(void *p) { return (GTK_RECENT_MANAGER(p)); } static GtkCheckMenuItem *toGtkCheckMenuItem(void *p) { return (GTK_CHECK_MENU_ITEM(p)); } static GtkRadioMenuItem *toGtkRadioMenuItem(void *p) { return (GTK_RADIO_MENU_ITEM(p)); } static GtkToolItem *toGtkToolItem(void *p) { return (GTK_TOOL_ITEM(p)); } static GtkToolbar *toGtkToolbar(void *p) { return (GTK_TOOLBAR(p)); } static GtkTooltip *toGtkTooltip(void *p) { return (GTK_TOOLTIP(p)); } static GtkEditable *toGtkEditable(void *p) { return (GTK_EDITABLE(p)); } static GtkToolButton *toGtkToolButton(void *p) { return (GTK_TOOL_BUTTON(p)); } static GtkToggleToolButton *toGtkToggleToolButton(void *p) { return (GTK_TOGGLE_TOOL_BUTTON(p)); } static GtkSeparatorToolItem *toGtkSeparatorToolItem(void *p) { return (GTK_SEPARATOR_TOOL_ITEM(p)); } static GtkCssProvider *toGtkCssProvider(void *p) { return (GTK_CSS_PROVIDER(p)); } static GtkStyleContext *toGtkStyleContext(void *p) { return (GTK_STYLE_CONTEXT(p)); } static GtkStyleProvider *toGtkStyleProvider(void *p) { return (GTK_STYLE_PROVIDER(p)); } static GtkInfoBar *toGtkInfoBar(void *p) { return (GTK_INFO_BAR(p)); } static GMenuModel *toGMenuModel(void *p) { return (G_MENU_MODEL(p)); } static GActionGroup *toGActionGroup(void *p) { return (G_ACTION_GROUP(p)); } static GdkPixbuf *toGdkPixbuf(void *p) { return (GDK_PIXBUF(p)); } static GdkScreen *toGdkScreen(void *p) { return (GDK_SCREEN(p)); } static GdkDevice *toGdkDevice(void *p) { return (GDK_DEVICE(p)); } static GObject *toGObject(void *p) { return (G_OBJECT(p)); } static GType *alloc_types(int n) { return ((GType *)g_new0(GType, n)); } static void set_type(GType *types, int n, GType t) { types[n] = t; } // _gtk_test_init is a wrapper to use gtk_test_init directly from go. // The variadic part on gtk_test_init is not used at the moment, according to // the documentation. static void _gtk_test_init(int *argcp, char ***argvp) { gtk_test_init(argcp, argvp); } static GtkTreeViewColumn *_gtk_tree_view_column_new_with_attributes_one( const gchar *title, GtkCellRenderer *renderer, const gchar *attribute, gint column) { GtkTreeViewColumn *tvc; tvc = gtk_tree_view_column_new_with_attributes(title, renderer, attribute, column, NULL); return (tvc); } static void _gtk_list_store_set(GtkListStore *list_store, GtkTreeIter *iter, gint column, void *value) { gtk_list_store_set(list_store, iter, column, value, -1); } static void _gtk_tree_store_set(GtkTreeStore *store, GtkTreeIter *iter, gint column, void *value) { gtk_tree_store_set(store, iter, column, value, -1); } extern gboolean substring_match_equal_func(GtkTreeModel *model, gint column, gchar *key, GtkTreeIter *iter, gpointer data); static GtkWidget *_gtk_message_dialog_new(GtkWindow *parent, GtkDialogFlags flags, GtkMessageType type, GtkButtonsType buttons, char *msg) { GtkWidget *w; w = gtk_message_dialog_new(parent, flags, type, buttons, "%s", msg); return (w); } static GtkWidget *_gtk_message_dialog_new_with_markup(GtkWindow *parent, GtkDialogFlags flags, GtkMessageType type, GtkButtonsType buttons, char *msg) { GtkWidget *w; w = gtk_message_dialog_new_with_markup(parent, flags, type, buttons, "%s", msg); return (w); } static void _gtk_message_dialog_format_secondary_text(GtkMessageDialog *message_dialog, const gchar *msg) { gtk_message_dialog_format_secondary_text(message_dialog, "%s", msg); } static void _gtk_message_dialog_format_secondary_markup(GtkMessageDialog *message_dialog, const gchar *msg) { gtk_message_dialog_format_secondary_markup(message_dialog, "%s", msg); } static const gchar *object_get_class_name(GObject *object) { return G_OBJECT_CLASS_NAME(G_OBJECT_GET_CLASS(object)); } static GtkWidget *gtk_file_chooser_dialog_new_1(const gchar *title, GtkWindow *parent, GtkFileChooserAction action, const gchar *first_button_text, int first_button_id) { return gtk_file_chooser_dialog_new(title, parent, action, first_button_text, first_button_id, NULL); } static GtkWidget *gtk_file_chooser_dialog_new_2( const gchar *title, GtkWindow *parent, GtkFileChooserAction action, const gchar *first_button_text, int first_button_id, const gchar *second_button_text, int second_button_id) { return gtk_file_chooser_dialog_new(title, parent, action, first_button_text, first_button_id, second_button_text, second_button_id, NULL); } static void _gtk_widget_hide_on_delete(GtkWidget *w) { g_signal_connect(GTK_WIDGET(w), "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); } static inline gchar **make_strings(int count) { return (gchar **)malloc(sizeof(gchar *) * count); } static inline void destroy_strings(gchar **strings) { free(strings); } static inline gchar *get_string(gchar **strings, int n) { return strings[n]; } static inline void set_string(gchar **strings, int n, gchar *str) { strings[n] = str; } extern void goBuilderConnect(GtkBuilder *builder, GObject *object, gchar *signal_name, gchar *handler_name, GObject *connect_object, GConnectFlags flags, gpointer user_data); static inline void _gtk_builder_connect_signals_full(GtkBuilder *builder) { gtk_builder_connect_signals_full( builder, (GtkBuilderConnectFunc)(goBuilderConnect), NULL); } extern gboolean goTreeViewSearchEqualFunc(GtkTreeModel *model, gint column, gchar *key, GtkTreeIter *iter, gpointer data); static inline void _gtk_tree_view_set_search_equal_func(GtkTreeView *tree_view, gpointer user_data) { gtk_tree_view_set_search_equal_func( tree_view, (GtkTreeViewSearchEqualFunc)(goTreeViewSearchEqualFunc), user_data, (GDestroyNotify)(gotk3_callbackDelete)); } extern gboolean goTreeModelFilterVisibleFunc(GtkTreeModel *model, GtkTreeIter *iter, gpointer data); static inline void _gtk_tree_model_filter_set_visible_func(GtkTreeModelFilter *filter, gpointer user_data) { gtk_tree_model_filter_set_visible_func( filter, (GtkTreeModelFilterVisibleFunc)(goTreeModelFilterVisibleFunc), user_data, (GDestroyNotify)(gotk3_callbackDelete)); } static inline void _gtk_text_buffer_insert_with_tag_by_name( GtkTextBuffer *buffer, GtkTextIter *iter, const gchar *text, gint len, const gchar *first_tag_name) { gtk_text_buffer_insert_with_tags_by_name(buffer, iter, text, len, first_tag_name, NULL); } static inline void _gtk_text_buffer_insert_with_tag(GtkTextBuffer *buffer, GtkTextIter *iter, const gchar *text, gint len, GtkTextTag *tag) { gtk_text_buffer_insert_with_tags(buffer, iter, text, len, tag, NULL); } extern gint goTreeSortableSortFunc(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer data); static inline void _gtk_tree_sortable_set_sort_func(GtkTreeSortable *sortable, gint sort_column_id, gpointer user_data) { gtk_tree_sortable_set_sort_func( sortable, sort_column_id, (GtkTreeIterCompareFunc)(goTreeSortableSortFunc), user_data, NULL); } static inline void _gtk_tree_sortable_set_default_sort_func(GtkTreeSortable *sortable, gpointer user_data) { gtk_tree_sortable_set_default_sort_func( sortable, (GtkTreeIterCompareFunc)(goTreeSortableSortFunc), user_data, (GDestroyNotify)(gotk3_callbackDelete)); } static GtkWidget *_gtk_dialog_new_with_buttons(const gchar *title, GtkWindow *parent, GtkDialogFlags flags, const gchar *first_button_text) { GtkWidget *w; w = gtk_dialog_new_with_buttons(title, parent, flags, first_button_text, NULL); return (w); } extern gint goTreeModelForeachFunc(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data); static inline void _gtk_tree_model_foreach(GtkTreeModel *model, gpointer user_data) { gtk_tree_model_foreach( model, (GtkTreeModelForeachFunc)(goTreeModelForeachFunc), user_data); } extern void goTreeSelectionForeachFunc(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data); static inline void _gtk_tree_selection_selected_foreach(GtkTreeSelection *selection, gpointer user_data) { gtk_tree_selection_selected_foreach( selection, (GtkTreeSelectionForeachFunc)(goTreeSelectionForeachFunc), user_data); } extern gboolean goTreeSelectionFunc(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean selected, gpointer data); static inline void _gtk_tree_selection_set_select_function(GtkTreeSelection *selection, gpointer user_data) { gtk_tree_selection_set_select_function( selection, (GtkTreeSelectionFunc)(goTreeSelectionFunc), user_data, (GDestroyNotify)(gotk3_callbackDelete)); } gotk3-0.6.2/gtk/gtk_deprecated_since_3_10.go000066400000000000000000000323221431157473000205410ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // This file includes wrapers for symbols deprecated beginning with GTK 3.10, // and should only be included in a build targeted intended to target GTK // 3.8 or earlier. To target an earlier build build, use the build tag // gtk_MAJOR_MINOR. For example, to target GTK 3.8, run // 'go build -tags gtk_3_8'. // +build gtk_3_6 gtk_3_8 gtk_deprecated package gtk // #include // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) // ButtonNewFromStock is a wrapper around gtk_button_new_from_stock(). func ButtonNewFromStock(stock Stock) (*Button, error) { cstr := C.CString(string(stock)) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_button_new_from_stock((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapButton(glib.Take(unsafe.Pointer(c))), nil } // SetUseStock is a wrapper around gtk_button_set_use_stock(). func (v *Button) SetUseStock(useStock bool) { C.gtk_button_set_use_stock(v.native(), gbool(useStock)) } // GetUseStock is a wrapper around gtk_button_get_use_stock(). func (v *Button) GetUseStock() bool { c := C.gtk_button_get_use_stock(v.native()) return gobool(c) } // GetIconStock is a wrapper around gtk_entry_get_icon_stock(). func (v *Entry) GetIconStock(iconPos EntryIconPosition) (string, error) { c := C.gtk_entry_get_icon_stock(v.native(), C.GtkEntryIconPosition(iconPos)) if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // SetIconFromStock is a wrapper around gtk_entry_set_icon_from_stock(). func (v *Entry) SetIconFromStock(iconPos EntryIconPosition, stockID string) { cstr := C.CString(stockID) defer C.free(unsafe.Pointer(cstr)) C.gtk_entry_set_icon_from_stock(v.native(), C.GtkEntryIconPosition(iconPos), (*C.gchar)(cstr)) } /* * GtkImage */ // TODO: /* // gtk_image_get_icon_set(). func (v *Image) GetIconSet() { } */ // gtk_image_get_stock(). /* // gtk_image_new_from_icon_set(). func ImageNewFromIconSet() { } */ // ImageNewFromStock is a wrapper around gtk_image_new_from_stock(). func ImageNewFromStock(stock Stock, size IconSize) (*Image, error) { cstr := C.CString(string(stock)) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_image_new_from_stock((*C.gchar)(cstr), C.GtkIconSize(size)) if c == nil { return nil, nilPtrErr } return wrapImage(glib.Take(unsafe.Pointer(c))), nil } // SetFromStock is a wrapper around gtk_image_set_from_stock(). func (v *Image) SetFromStock(stock Stock, size IconSize) { cstr := C.CString(string(stock)) defer C.free(unsafe.Pointer(cstr)) C.gtk_image_set_from_stock(v.native(), (*C.gchar)(cstr), C.GtkIconSize(size)) } // TODO: /* // gtk_image_set_from_icon_set(). func (v *Image) SetFromIconSet() { } */ // StatusIconNewFromStock is a wrapper around gtk_status_icon_new_from_stock(). // Deprecated since 3.10, use StatusIconNewFromIconName (gtk_status_icon_new_from_icon_name) instead. func StatusIconNewFromStock(stockId string) (*StatusIcon, error) { cstr := C.CString(stockId) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_status_icon_new_from_file((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapStatusIcon(obj), nil } // SetFromStock is a wrapper around gtk_status_icon_set_from_stock() // Deprecated since 3.10, use SetFromIconName (gtk_status_icon_set_from_icon_name) instead. func (v *StatusIcon) SetFromStock(stockID string) { cstr := C.CString(stockID) defer C.free(unsafe.Pointer(cstr)) C.gtk_status_icon_set_from_stock(v.native(), (*C.gchar)(cstr)) } // GetStock is a wrapper around gtk_status_icon_get_stock() // Deprecated since 3.10, use GetIconName (gtk_status_icon_get_icon_name) instead func (v *StatusIcon) GetStock() string { c := C.gtk_status_icon_get_stock(v.native()) if c == nil { return "" } return C.GoString((*C.char)(c)) } // Stock is a special type that does not have an equivalent type in // GTK. It is the type used as a parameter anytime an identifier for // stock icons are needed. A Stock must be type converted to string when // function parameters may take a Stock, but when other string values are // valid as well. type Stock string const ( STOCK_ABOUT Stock = C.GTK_STOCK_ABOUT STOCK_ADD Stock = C.GTK_STOCK_ADD STOCK_APPLY Stock = C.GTK_STOCK_APPLY STOCK_BOLD Stock = C.GTK_STOCK_BOLD STOCK_CANCEL Stock = C.GTK_STOCK_CANCEL STOCK_CAPS_LOCK_WARNING Stock = C.GTK_STOCK_CAPS_LOCK_WARNING STOCK_CDROM Stock = C.GTK_STOCK_CDROM STOCK_CLEAR Stock = C.GTK_STOCK_CLEAR STOCK_CLOSE Stock = C.GTK_STOCK_CLOSE STOCK_COLOR_PICKER Stock = C.GTK_STOCK_COLOR_PICKER STOCK_CONNECT Stock = C.GTK_STOCK_CONNECT STOCK_CONVERT Stock = C.GTK_STOCK_CONVERT STOCK_COPY Stock = C.GTK_STOCK_COPY STOCK_CUT Stock = C.GTK_STOCK_CUT STOCK_DELETE Stock = C.GTK_STOCK_DELETE STOCK_DIALOG_AUTHENTICATION Stock = C.GTK_STOCK_DIALOG_AUTHENTICATION STOCK_DIALOG_INFO Stock = C.GTK_STOCK_DIALOG_INFO STOCK_DIALOG_WARNING Stock = C.GTK_STOCK_DIALOG_WARNING STOCK_DIALOG_ERROR Stock = C.GTK_STOCK_DIALOG_ERROR STOCK_DIALOG_QUESTION Stock = C.GTK_STOCK_DIALOG_QUESTION STOCK_DIRECTORY Stock = C.GTK_STOCK_DIRECTORY STOCK_DISCARD Stock = C.GTK_STOCK_DISCARD STOCK_DISCONNECT Stock = C.GTK_STOCK_DISCONNECT STOCK_DND Stock = C.GTK_STOCK_DND STOCK_DND_MULTIPLE Stock = C.GTK_STOCK_DND_MULTIPLE STOCK_EDIT Stock = C.GTK_STOCK_EDIT STOCK_EXECUTE Stock = C.GTK_STOCK_EXECUTE STOCK_FILE Stock = C.GTK_STOCK_FILE STOCK_FIND Stock = C.GTK_STOCK_FIND STOCK_FIND_AND_REPLACE Stock = C.GTK_STOCK_FIND_AND_REPLACE STOCK_FLOPPY Stock = C.GTK_STOCK_FLOPPY STOCK_FULLSCREEN Stock = C.GTK_STOCK_FULLSCREEN STOCK_GOTO_BOTTOM Stock = C.GTK_STOCK_GOTO_BOTTOM STOCK_GOTO_FIRST Stock = C.GTK_STOCK_GOTO_FIRST STOCK_GOTO_LAST Stock = C.GTK_STOCK_GOTO_LAST STOCK_GOTO_TOP Stock = C.GTK_STOCK_GOTO_TOP STOCK_GO_BACK Stock = C.GTK_STOCK_GO_BACK STOCK_GO_DOWN Stock = C.GTK_STOCK_GO_DOWN STOCK_GO_FORWARD Stock = C.GTK_STOCK_GO_FORWARD STOCK_GO_UP Stock = C.GTK_STOCK_GO_UP STOCK_HARDDISK Stock = C.GTK_STOCK_HARDDISK STOCK_HELP Stock = C.GTK_STOCK_HELP STOCK_HOME Stock = C.GTK_STOCK_HOME STOCK_INDEX Stock = C.GTK_STOCK_INDEX STOCK_INDENT Stock = C.GTK_STOCK_INDENT STOCK_INFO Stock = C.GTK_STOCK_INFO STOCK_ITALIC Stock = C.GTK_STOCK_ITALIC STOCK_JUMP_TO Stock = C.GTK_STOCK_JUMP_TO STOCK_JUSTIFY_CENTER Stock = C.GTK_STOCK_JUSTIFY_CENTER STOCK_JUSTIFY_FILL Stock = C.GTK_STOCK_JUSTIFY_FILL STOCK_JUSTIFY_LEFT Stock = C.GTK_STOCK_JUSTIFY_LEFT STOCK_JUSTIFY_RIGHT Stock = C.GTK_STOCK_JUSTIFY_RIGHT STOCK_LEAVE_FULLSCREEN Stock = C.GTK_STOCK_LEAVE_FULLSCREEN STOCK_MISSING_IMAGE Stock = C.GTK_STOCK_MISSING_IMAGE STOCK_MEDIA_FORWARD Stock = C.GTK_STOCK_MEDIA_FORWARD STOCK_MEDIA_NEXT Stock = C.GTK_STOCK_MEDIA_NEXT STOCK_MEDIA_PAUSE Stock = C.GTK_STOCK_MEDIA_PAUSE STOCK_MEDIA_PLAY Stock = C.GTK_STOCK_MEDIA_PLAY STOCK_MEDIA_PREVIOUS Stock = C.GTK_STOCK_MEDIA_PREVIOUS STOCK_MEDIA_RECORD Stock = C.GTK_STOCK_MEDIA_RECORD STOCK_MEDIA_REWIND Stock = C.GTK_STOCK_MEDIA_REWIND STOCK_MEDIA_STOP Stock = C.GTK_STOCK_MEDIA_STOP STOCK_NETWORK Stock = C.GTK_STOCK_NETWORK STOCK_NEW Stock = C.GTK_STOCK_NEW STOCK_NO Stock = C.GTK_STOCK_NO STOCK_OK Stock = C.GTK_STOCK_OK STOCK_OPEN Stock = C.GTK_STOCK_OPEN STOCK_ORIENTATION_PORTRAIT Stock = C.GTK_STOCK_ORIENTATION_PORTRAIT STOCK_ORIENTATION_LANDSCAPE Stock = C.GTK_STOCK_ORIENTATION_LANDSCAPE STOCK_ORIENTATION_REVERSE_LANDSCAPE Stock = C.GTK_STOCK_ORIENTATION_REVERSE_LANDSCAPE STOCK_ORIENTATION_REVERSE_PORTRAIT Stock = C.GTK_STOCK_ORIENTATION_REVERSE_PORTRAIT STOCK_PAGE_SETUP Stock = C.GTK_STOCK_PAGE_SETUP STOCK_PASTE Stock = C.GTK_STOCK_PASTE STOCK_PREFERENCES Stock = C.GTK_STOCK_PREFERENCES STOCK_PRINT Stock = C.GTK_STOCK_PRINT STOCK_PRINT_ERROR Stock = C.GTK_STOCK_PRINT_ERROR STOCK_PRINT_PAUSED Stock = C.GTK_STOCK_PRINT_PAUSED STOCK_PRINT_PREVIEW Stock = C.GTK_STOCK_PRINT_PREVIEW STOCK_PRINT_REPORT Stock = C.GTK_STOCK_PRINT_REPORT STOCK_PRINT_WARNING Stock = C.GTK_STOCK_PRINT_WARNING STOCK_PROPERTIES Stock = C.GTK_STOCK_PROPERTIES STOCK_QUIT Stock = C.GTK_STOCK_QUIT STOCK_REDO Stock = C.GTK_STOCK_REDO STOCK_REFRESH Stock = C.GTK_STOCK_REFRESH STOCK_REMOVE Stock = C.GTK_STOCK_REMOVE STOCK_REVERT_TO_SAVED Stock = C.GTK_STOCK_REVERT_TO_SAVED STOCK_SAVE Stock = C.GTK_STOCK_SAVE STOCK_SAVE_AS Stock = C.GTK_STOCK_SAVE_AS STOCK_SELECT_ALL Stock = C.GTK_STOCK_SELECT_ALL STOCK_SELECT_COLOR Stock = C.GTK_STOCK_SELECT_COLOR STOCK_SELECT_FONT Stock = C.GTK_STOCK_SELECT_FONT STOCK_SORT_ASCENDING Stock = C.GTK_STOCK_SORT_ASCENDING STOCK_SORT_DESCENDING Stock = C.GTK_STOCK_SORT_DESCENDING STOCK_SPELL_CHECK Stock = C.GTK_STOCK_SPELL_CHECK STOCK_STOP Stock = C.GTK_STOCK_STOP STOCK_STRIKETHROUGH Stock = C.GTK_STOCK_STRIKETHROUGH STOCK_UNDELETE Stock = C.GTK_STOCK_UNDELETE STOCK_UNDERLINE Stock = C.GTK_STOCK_UNDERLINE STOCK_UNDO Stock = C.GTK_STOCK_UNDO STOCK_UNINDENT Stock = C.GTK_STOCK_UNINDENT STOCK_YES Stock = C.GTK_STOCK_YES STOCK_ZOOM_100 Stock = C.GTK_STOCK_ZOOM_100 STOCK_ZOOM_FIT Stock = C.GTK_STOCK_ZOOM_FIT STOCK_ZOOM_IN Stock = C.GTK_STOCK_ZOOM_IN STOCK_ZOOM_OUT Stock = C.GTK_STOCK_ZOOM_OUT ) // ReshowWithInitialSize is a wrapper around // gtk_window_reshow_with_initial_size(). func (v *Window) ReshowWithInitialSize() { C.gtk_window_reshow_with_initial_size(v.native()) } /* * GtkWidget */ // TODO: // gtk_widget_render_icon_pixbuf(). // gtk_widget_pop_composite_child(). // gtk_widget_push_composite_child(). // gtk_widget_set_composite_name(). /* * GtkContainer */ // TODO: // gtk_container_resize_children(). /* * GtkImageMenuItem */ // TODO: // gtk_image_menu_item_set_image(). // gtk_image_menu_item_get_image(). // gtk_image_menu_item_new(). // gtk_image_menu_item_new_from_stock(). // gtk_image_menu_item_new_with_label(). // gtk_image_menu_item_new_with_mnemonic(). // gtk_image_menu_item_get_use_stock(). // gtk_image_menu_item_set_use_stock(). // gtk_image_menu_item_get_always_show_image(). // gtk_image_menu_item_set_always_show_image(). // gtk_image_menu_item_set_accel_group(). /* * GtkToolButton */ // TODO: // gtk_tool_button_new_from_stock(). // gtk_tool_button_set_stock_id(). // gtk_tool_button_get_stock_id(). /* * GtkDialog */ // TODO: /* // gtk_dialog_set_alternative_button_order(). func SetAlternativeButtonOrder(ids ...ResponseType) { } */ /* // gtk_alternative_dialog_button_order(). func (v *gdk.Screen) AlternativeDialogButtonOrder() bool { c := C.gtk_alternative_dialog_button_order(v.native()) return gobool(c) } */ // gtk_dialog_set_alternative_button_order_from_array gotk3-0.6.2/gtk/gtk_deprecated_since_3_12.go000066400000000000000000000054231431157473000205450ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // This file includes wrapers for symbols deprecated beginning with GTK 3.12, // and should only be included in a build targeted intended to target GTK // 3.10 or earlier. To target an earlier build build, use the build tag // gtk_MAJOR_MINOR. For example, to target GTK 3.8, run // 'go build -tags gtk_3_8'. // +build gtk_3_6 gtk_3_8 gtk_3_10 gtk_deprecated package gtk // #include import "C" /* * GtkDialog */ // GetActionArea() is a wrapper around gtk_dialog_get_action_area(). func (v *Dialog) GetActionArea() (IWidget, error) { c := C.gtk_dialog_get_action_area(v.native()) if c == nil { return nil, nilPtrErr } return castWidget(c) } /* * GtkMessageDialog */ // GetImage is a wrapper around gtk_message_dialog_get_image(). func (v *MessageDialog) GetImage() (IWidget, error) { c := C.gtk_message_dialog_get_image(v.native()) if c == nil { return nil, nilPtrErr } return castWidget(c) } // SetImage is a wrapper around gtk_message_dialog_set_image(). func (v *MessageDialog) SetImage(image IWidget) { C.gtk_message_dialog_set_image(v.native(), image.toWidget()) } /* * GtkWidget */ // GetMarginLeft is a wrapper around gtk_widget_get_margin_left(). func (v *Widget) GetMarginLeft() int { c := C.gtk_widget_get_margin_left(v.native()) return int(c) } // SetMarginLeft is a wrapper around gtk_widget_set_margin_left(). func (v *Widget) SetMarginLeft(margin int) { C.gtk_widget_set_margin_left(v.native(), C.gint(margin)) } // GetMarginRight is a wrapper around gtk_widget_get_margin_right(). func (v *Widget) GetMarginRight() int { c := C.gtk_widget_get_margin_right(v.native()) return int(c) } // SetMarginRight is a wrapper around gtk_widget_set_margin_right(). func (v *Widget) SetMarginRight(margin int) { C.gtk_widget_set_margin_right(v.native(), C.gint(margin)) } // TODO: // gtk_widget_get_root_window(). /* * GtkContainer */ // TODO: // gtk_container_get_resize_mode(). // gtk_container_set_resize_mode(). gotk3-0.6.2/gtk/gtk_deprecated_since_3_14.go000066400000000000000000000351241431157473000205500ustar00rootroot00000000000000// +build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_deprecated package gtk // #include // #include // #include "gtk_deprecated_since_3_14.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_alignment_get_type()), marshalAlignment}, {glib.Type(C.gtk_arrow_get_type()), marshalArrow}, {glib.Type(C.gtk_misc_get_type()), marshalMisc}, {glib.Type(C.gtk_status_icon_get_type()), marshalStatusIcon}, } glib.RegisterGValueMarshalers(tm) //Contribute to casting for k, v := range map[string]WrapFn{ "GtkAlignment": wrapAlignment, "GtkArrow": wrapArrow, "GtkMisc": wrapMisc, "GtkStatusIcon": wrapStatusIcon, } { WrapMap[k] = v } } /* * deprecated since version 3.14 and should not be used in newly-written code */ /* * GtkTreeView */ // TODO: // gtk_tree_view_set_rules_hint(). // gtk_tree_view_get_rules_hint(). /* * GtkWindow */ // SetHasResizeGrip is a wrapper around gtk_window_set_has_resize_grip(). func (v *Window) SetHasResizeGrip(setting bool) { C.gtk_window_set_has_resize_grip(v.native(), gbool(setting)) } // GetHasResizeGrip is a wrapper around gtk_window_get_has_resize_grip(). func (v *Window) GetHasResizeGrip() bool { c := C.gtk_window_get_has_resize_grip(v.native()) return gobool(c) } // ResizeGripIsVisible is a wrapper around gtk_window_resize_grip_is_visible(). func (v *Window) ResizeGripIsVisible() bool { c := C.gtk_window_resize_grip_is_visible(v.native()) return gobool(c) } // GetResizeGripArea is a wrapper around gtk_window_get_resize_grip_area(). func (v *Window) GetResizeGripArea() (*gdk.Rectangle, bool) { var cRect *C.GdkRectangle wasRetrieved := C.gtk_window_get_resize_grip_area(v.native(), cRect) rect := gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) return rect, gobool(wasRetrieved) } /* * GtkWidget */ // Reparent() is a wrapper around gtk_widget_reparent(). func (v *Widget) Reparent(newParent IWidget) { C.gtk_widget_reparent(v.native(), newParent.toWidget()) } // SetDoubleBuffered is a wrapper around gtk_widget_set_double_buffered(). func (v *Widget) SetDoubleBuffered(doubleBuffered bool) { C.gtk_widget_set_double_buffered(v.native(), gbool(doubleBuffered)) } // GetDoubleBuffered is a wrapper around gtk_widget_get_double_buffered(). func (v *Widget) GetDoubleBuffered() bool { c := C.gtk_widget_get_double_buffered(v.native()) return gobool(c) } // TODO: // gtk_widget_region_intersect(). // GetPadding is a wrapper around gtk_alignment_get_padding(). func (v *Alignment) GetPadding() (top, bottom, left, right uint) { var ctop, cbottom, cleft, cright C.guint C.gtk_alignment_get_padding(v.native(), &ctop, &cbottom, &cleft, &cright) return uint(ctop), uint(cbottom), uint(cleft), uint(cright) } // SetPadding is a wrapper around gtk_alignment_set_padding(). func (v *Alignment) SetPadding(top, bottom, left, right uint) { C.gtk_alignment_set_padding(v.native(), C.guint(top), C.guint(bottom), C.guint(left), C.guint(right)) } // AlignmentNew is a wrapper around gtk_alignment_new(). func AlignmentNew(xalign, yalign, xscale, yscale float32) (*Alignment, error) { c := C.gtk_alignment_new(C.gfloat(xalign), C.gfloat(yalign), C.gfloat(xscale), C.gfloat(yscale)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapAlignment(obj), nil } // Set is a wrapper around gtk_alignment_set(). func (v *Alignment) Set(xalign, yalign, xscale, yscale float32) { C.gtk_alignment_set(v.native(), C.gfloat(xalign), C.gfloat(yalign), C.gfloat(xscale), C.gfloat(yscale)) } /* * GtkArrow */ // Arrow is a representation of GTK's GtkArrow. type Arrow struct { Misc } // ArrowNew is a wrapper around gtk_arrow_new(). func ArrowNew(arrowType ArrowType, shadowType ShadowType) (*Arrow, error) { c := C.gtk_arrow_new(C.GtkArrowType(arrowType), C.GtkShadowType(shadowType)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapArrow(obj), nil } // Set is a wrapper around gtk_arrow_set(). func (v *Arrow) Set(arrowType ArrowType, shadowType ShadowType) { C.gtk_arrow_set(v.native(), C.GtkArrowType(arrowType), C.GtkShadowType(shadowType)) } // SetAlignment() is a wrapper around gtk_button_set_alignment(). func (v *Button) SetAlignment(xalign, yalign float32) { C.gtk_button_set_alignment(v.native(), (C.gfloat)(xalign), (C.gfloat)(yalign)) } // GetAlignment() is a wrapper around gtk_button_get_alignment(). func (v *Button) GetAlignment() (xalign, yalign float32) { var x, y C.gfloat C.gtk_button_get_alignment(v.native(), &x, &y) return float32(x), float32(y) } // SetReallocateRedraws is a wrapper around gtk_container_set_reallocate_redraws(). func (v *Container) SetReallocateRedraws(needsRedraws bool) { C.gtk_container_set_reallocate_redraws(v.native(), gbool(needsRedraws)) } // GetAlignment is a wrapper around gtk_misc_get_alignment(). func (v *Misc) GetAlignment() (xAlign, yAlign float32) { var x, y C.gfloat C.gtk_misc_get_alignment(v.native(), &x, &y) return float32(x), float32(y) } // SetAlignment is a wrapper around gtk_misc_set_alignment(). func (v *Misc) SetAlignment(xAlign, yAlign float32) { C.gtk_misc_set_alignment(v.native(), C.gfloat(xAlign), C.gfloat(yAlign)) } // GetPadding is a wrapper around gtk_misc_get_padding(). func (v *Misc) GetPadding() (xpad, ypad int) { var x, y C.gint C.gtk_misc_get_padding(v.native(), &x, &y) return int(x), int(y) } // SetPadding is a wrapper around gtk_misc_set_padding(). func (v *Misc) SetPadding(xPad, yPad int) { C.gtk_misc_set_padding(v.native(), C.gint(xPad), C.gint(yPad)) } /* * GtkArrow * deprecated since version 3.14 */ // native returns a pointer to the underlying GtkButton. func (v *Arrow) native() *C.GtkArrow { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkArrow(p) } func marshalArrow(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapArrow(obj), nil } func wrapArrow(obj *glib.Object) *Arrow { if obj == nil { return nil } return &Arrow{Misc{Widget{glib.InitiallyUnowned{obj}}}} } /* * GtkAlignment * deprecated since version 3.14 */ type Alignment struct { Bin } // native returns a pointer to the underlying GtkAlignment. func (v *Alignment) native() *C.GtkAlignment { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkAlignment(p) } func marshalAlignment(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapAlignment(obj), nil } func wrapAlignment(obj *glib.Object) *Alignment { if obj == nil { return nil } return &Alignment{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } /* * GtkStatusIcon * deprecated since version 3.14 */ // StatusIcon is a representation of GTK's GtkStatusIcon. // Deprecated since 3.14 in favor of notifications // (no replacement, see https://stackoverflow.com/questions/41917903/gtk-3-statusicon-replacement) type StatusIcon struct { *glib.Object } func marshalStatusIcon(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapStatusIcon(obj), nil } func wrapStatusIcon(obj *glib.Object) *StatusIcon { if obj == nil { return nil } return &StatusIcon{obj} } func (v *StatusIcon) native() *C.GtkStatusIcon { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkStatusIcon(p) } // TODO: GtkStatusIcon * gtk_status_icon_new_from_gicon (GIcon *icon); // TODO: void gtk_status_icon_set_from_gicon (GtkStatusIcon *status_icon, GIcon *icon); // TODO: GIcon * gtk_status_icon_get_gicon (GtkStatusIcon *status_icon); // TODO: void gtk_status_icon_set_screen (GtkStatusIcon *status_icon, GdkScreen *screen); // TODO: GdkScreen * gtk_status_icon_get_screen (GtkStatusIcon *status_icon); // TODO: GdkPixbuf * gtk_status_icon_get_pixbuf (GtkStatusIcon *status_icon); // TODO: void gtk_status_icon_position_menu (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data); // TODO: gboolean gtk_status_icon_get_geometry (GtkStatusIcon *status_icon, GdkScreen **screen, GdkRectangle *area, GtkOrientation *orientation); // StatusIconNew is a wrapper around gtk_status_icon_new() func StatusIconNew() (*StatusIcon, error) { c := C.gtk_status_icon_new() if c == nil { return nil, nilPtrErr } return wrapStatusIcon(glib.Take(unsafe.Pointer(c))), nil } // StatusIconNewFromFile is a wrapper around gtk_status_icon_new_from_file() func StatusIconNewFromFile(filename string) (*StatusIcon, error) { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_status_icon_new_from_file((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapStatusIcon(glib.Take(unsafe.Pointer(c))), nil } // StatusIconNewFromIconName is a wrapper around gtk_status_icon_new_from_icon_name() func StatusIconNewFromIconName(iconName string) (*StatusIcon, error) { cstr := C.CString(iconName) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_status_icon_new_from_icon_name((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return wrapStatusIcon(glib.Take(unsafe.Pointer(c))), nil } // StatusIconNewFromPixbuf is a wrapper around gtk_status_icon_new_from_pixbuf(). func StatusIconNewFromPixbuf(pixbuf *gdk.Pixbuf) (*StatusIcon, error) { c := C.gtk_status_icon_new_from_pixbuf(C.toGdkPixbuf(unsafe.Pointer(pixbuf.Native()))) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapStatusIcon(obj), nil } // SetFromFile is a wrapper around gtk_status_icon_set_from_file() func (v *StatusIcon) SetFromFile(filename string) { cstr := C.CString(filename) defer C.free(unsafe.Pointer(cstr)) C.gtk_status_icon_set_from_file(v.native(), (*C.gchar)(cstr)) } // SetFromIconName is a wrapper around gtk_status_icon_set_from_icon_name() func (v *StatusIcon) SetFromIconName(iconName string) { cstr := C.CString(iconName) defer C.free(unsafe.Pointer(cstr)) C.gtk_status_icon_set_from_icon_name(v.native(), (*C.gchar)(cstr)) } // SetFromPixbuf is a wrapper around gtk_status_icon_set_from_pixbuf() func (v *StatusIcon) SetFromPixbuf(pixbuf *gdk.Pixbuf) { C.gtk_status_icon_set_from_pixbuf(v.native(), C.toGdkPixbuf(unsafe.Pointer(pixbuf.Native()))) } // GetStorageType is a wrapper around gtk_status_icon_get_storage_type() func (v *StatusIcon) GetStorageType() ImageType { return (ImageType)(C.gtk_status_icon_get_storage_type(v.native())) } // SetTooltipText is a wrapper around gtk_status_icon_set_tooltip_text() func (v *StatusIcon) SetTooltipText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_status_icon_set_tooltip_text(v.native(), (*C.gchar)(cstr)) } // GetTooltipText is a wrapper around gtk_status_icon_get_tooltip_text() func (v *StatusIcon) GetTooltipText() string { c := C.gtk_status_icon_get_tooltip_text(v.native()) if c == nil { return "" } return C.GoString((*C.char)(c)) } // SetTooltipMarkup is a wrapper around gtk_status_icon_set_tooltip_markup() func (v *StatusIcon) SetTooltipMarkup(markup string) { cstr := C.CString(markup) defer C.free(unsafe.Pointer(cstr)) C.gtk_status_icon_set_tooltip_markup(v.native(), (*C.gchar)(cstr)) } // GetTooltipMarkup is a wrapper around gtk_status_icon_get_tooltip_markup() func (v *StatusIcon) GetTooltipMarkup() string { c := C.gtk_status_icon_get_tooltip_markup(v.native()) if c == nil { return "" } return C.GoString((*C.char)(c)) } // SetHasTooltip is a wrapper around gtk_status_icon_set_has_tooltip() func (v *StatusIcon) SetHasTooltip(hasTooltip bool) { C.gtk_status_icon_set_has_tooltip(v.native(), gbool(hasTooltip)) } // GetTitle is a wrapper around gtk_status_icon_get_title() func (v *StatusIcon) GetTitle() string { c := C.gtk_status_icon_get_title(v.native()) if c == nil { return "" } return C.GoString((*C.char)(c)) } // SetName is a wrapper around gtk_status_icon_set_name() func (v *StatusIcon) SetName(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_status_icon_set_name(v.native(), (*C.gchar)(cstr)) } // SetVisible is a wrapper around gtk_status_icon_set_visible() func (v *StatusIcon) SetVisible(visible bool) { C.gtk_status_icon_set_visible(v.native(), gbool(visible)) } // GetVisible is a wrapper around gtk_status_icon_get_visible() func (v *StatusIcon) GetVisible() bool { return gobool(C.gtk_status_icon_get_visible(v.native())) } // IsEmbedded is a wrapper around gtk_status_icon_is_embedded() func (v *StatusIcon) IsEmbedded() bool { return gobool(C.gtk_status_icon_is_embedded(v.native())) } // GetX11WindowID is a wrapper around gtk_status_icon_get_x11_window_id() func (v *StatusIcon) GetX11WindowID() uint32 { return uint32(C.gtk_status_icon_get_x11_window_id(v.native())) } // GetHasTooltip is a wrapper around gtk_status_icon_get_has_tooltip() func (v *StatusIcon) GetHasTooltip() bool { return gobool(C.gtk_status_icon_get_has_tooltip(v.native())) } // SetTitle is a wrapper around gtk_status_icon_set_title() func (v *StatusIcon) SetTitle(title string) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) C.gtk_status_icon_set_title(v.native(), (*C.gchar)(cstr)) } // GetIconName is a wrapper around gtk_status_icon_get_icon_name() func (v *StatusIcon) GetIconName() string { c := C.gtk_status_icon_get_icon_name(v.native()) if c == nil { return "" } return C.GoString((*C.char)(c)) } // GetSize is a wrapper around gtk_status_icon_get_size() func (v *StatusIcon) GetSize() int { return int(C.gtk_status_icon_get_size(v.native())) } // PopupAtStatusIcon() is a wrapper around gtk_menu_popup() specific to usage with GtkStatusIcon. // gomenu_popup() is defined in menu.go.h, this is a workaround to pass gtk_status_icon_position_menu as the GtkMenuPositionFunc. func (v *Menu) PopupAtStatusIcon(statusIcon *StatusIcon, button gdk.Button, activateTime uint32) { C.gotk_menu_popup_at_status_icon(v.native(), statusIcon.native(), C.guint(button), C.guint32(activateTime)) } /* * GtkMisc */ // Misc is a representation of GTK's GtkMisc. type Misc struct { Widget } // native returns a pointer to the underlying GtkMisc. func (v *Misc) native() *C.GtkMisc { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkMisc(p) } func marshalMisc(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapMisc(obj), nil } func wrapMisc(obj *glib.Object) *Misc { if obj == nil { return nil } return &Misc{Widget{glib.InitiallyUnowned{obj}}} } /* * End deprecated since version 3.14 */ gotk3-0.6.2/gtk/gtk_deprecated_since_3_14.go.h000066400000000000000000000017361431157473000210000ustar00rootroot00000000000000 /* * deprecated since version 3.14 */ // Wrapper for gtk_menu_popup to allow calling gtk_status_icon_position_menu as // callback from go code Used in func (v *Menu) PopupAtStatusIcon static void gotk_menu_popup_at_status_icon(GtkMenu *menu, GtkStatusIcon *status_icon, guint button, guint32 activate_time) { gtk_menu_popup(menu, NULL, NULL, gtk_status_icon_position_menu, status_icon, button, activate_time); } static GtkAlignment *toGtkAlignment(void *p) { return (GTK_ALIGNMENT(p)); } static GtkArrow *toGtkArrow(void *p) { return (GTK_ARROW(p)); } static GtkMisc *toGtkMisc(void *p) { return (GTK_MISC(p)); } static GtkStatusIcon *toGtkStatusIcon(void *p) { return (GTK_STATUS_ICON(p)); } static GdkPixbuf *toGdkPixbuf(void *p) { return (GDK_PIXBUF(p)); } /* * End deprecated since version 3.14 */ gotk3-0.6.2/gtk/gtk_deprecated_since_3_16.go000066400000000000000000000031011431157473000205400ustar00rootroot00000000000000//+build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14 gtk_deprecated package gtk // #include // #include // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" ) // OverrideColor is a wrapper around gtk_widget_override_color(). func (v *Widget) OverrideColor(state StateFlags, color *gdk.RGBA) { var cColor *C.GdkRGBA if color != nil { cColor = (*C.GdkRGBA)(unsafe.Pointer(color.Native())) } C.gtk_widget_override_color(v.native(), C.GtkStateFlags(state), cColor) } // OverrideBackgroundColor is a wrapper around gtk_widget_override_background_color(). func (v *Widget) OverrideBackgroundColor(state StateFlags, color *gdk.RGBA) { var cColor *C.GdkRGBA if color != nil { cColor = (*C.GdkRGBA)(unsafe.Pointer(color.Native())) } C.gtk_widget_override_background_color(v.native(), C.GtkStateFlags(state), cColor) } // SetColor is a convenience func to override the background color of the given button. func (v *Button) SetColor(color string) { rgba := C.GdkRGBA{} C.gdk_rgba_parse(&rgba, (*C.gchar)(C.CString(color))) C.gtk_widget_override_background_color(v.toWidget(), C.GTK_STATE_FLAG_NORMAL, &rgba) } // OverrideFont is a wrapper around gtk_widget_override_font(). func (v *Widget) OverrideFont(description string) { cstr := C.CString(description) defer C.free(unsafe.Pointer(cstr)) c := C.pango_font_description_from_string(cstr) C.gtk_widget_override_font(v.native(), c) } // TODO: // gtk_widget_override_symbolic_color(). // gtk_widget_override_cursor(). func (v *Label) SetFont(font string) { v.OverrideFont(font) } gotk3-0.6.2/gtk/gtk_deprecated_since_3_18.go000066400000000000000000000003471431157473000205530ustar00rootroot00000000000000//+build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14 gtk_3_16 gtk_deprecated package gtk /* * GtkPlacesSidebar */ // TODO: // gtk_places_sidebar_get_show_connect_to_server(). // gtk_places_sidebar_set_show_connect_to_server(). gotk3-0.6.2/gtk/gtk_deprecated_since_3_20.go000066400000000000000000000041211431157473000205360ustar00rootroot00000000000000//+build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14 gtk_3_16 gtk_3_18 gtk_deprecated package gtk // #include // #include import "C" import ( "unsafe" ) /* * GtkRange */ // TODO: // gtk_range_get_min_slider_size(). // gtk_range_set_min_slider_size(). /* * GtkToolbar */ // TODO: // GtkToolbarSpaceStyle /* * GtkFileChooserButton */ // GetFocusOnClick is a wrapper around gtk_file_chooser_button_get_focus_on_click(). func (v *FileChooserButton) GetFocusOnClick() bool { return gobool(C.gtk_file_chooser_button_get_focus_on_click(v.native())) } // SetFocusOnClick is a wrapper around gtk_file_chooser_button_set_focus_on_click(). func (v *FileChooserButton) SetFocusOnClick(grabFocus bool) { C.gtk_file_chooser_button_set_focus_on_click(v.native(), gbool(grabFocus)) } /* * GtkButton */ // GetFocusOnClick is a wrapper around gtk_button_get_focus_on_click(). func (v *Button) GetFocusOnClick() bool { c := C.gtk_button_get_focus_on_click(v.native()) return gobool(c) } // SetFocusOnClick is a wrapper around gtk_button_set_focus_on_click(). func (v *Button) SetFocusOnClick(focusOnClick bool) { C.gtk_button_set_focus_on_click(v.native(), gbool(focusOnClick)) } /* * GtkTextIter */ // BeginsTag is a wrapper around gtk_text_iter_begins_tag(). func (v *TextIter) BeginsTag(v1 *TextTag) bool { return gobool(C.gtk_text_iter_begins_tag(v.native(), v1.native())) } /* * GtkWindow */ // ParseGeometry is a wrapper around gtk_window_parse_geometry(). func (v *Window) ParseGeometry(geometry string) bool { cstr := C.CString(geometry) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_window_parse_geometry(v.native(), (*C.gchar)(cstr)) return gobool(c) } // ResizeToGeometry is a wrapper around gtk_window_resize_to_geometry(). func (v *Window) ResizeToGeometry(width, height int) { C.gtk_window_resize_to_geometry(v.native(), C.gint(width), C.gint(height)) } // SetDefaultGeometry is a wrapper around gtk_window_set_default_geometry(). func (v *Window) SetDefaultGeometry(width, height int) { C.gtk_window_set_default_geometry(v.native(), C.gint(width), C.gint(height)) } gotk3-0.6.2/gtk/gtk_deprecated_since_3_22.go000066400000000000000000000033521431157473000205450ustar00rootroot00000000000000//+build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14 gtk_3_16 gtk_3_18 gtk_3_20 gtk_deprecated package gtk // #include // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" ) /* * GtkWidget */ // TODO: // gtk_widget_send_expose(). // gtk_widget_is_composited(). // PopupAtMouse() is a wrapper for gtk_menu_popup(), without the option for a custom positioning function. func (v *Menu) PopupAtMouseCursor(parentMenuShell IMenu, parentMenuItem IMenuItem, button gdk.Button, activateTime uint32) { wshell := nullableWidget(parentMenuShell) witem := nullableWidget(parentMenuItem) C.gtk_menu_popup(v.native(), wshell, witem, nil, nil, C.guint(button), C.guint32(activateTime)) } func (v *SizeGroup) GetIgnoreHidden() bool { c := C.gtk_size_group_get_ignore_hidden(v.native()) return gobool(c) } // SetWMClass is a wrapper around gtk_window_set_wmclass(). func (v *Window) SetWMClass(name, class string) { cName := C.CString(name) defer C.free(unsafe.Pointer(cName)) cClass := C.CString(class) defer C.free(unsafe.Pointer(cClass)) C.gtk_window_set_wmclass(v.native(), (*C.gchar)(cName), (*C.gchar)(cClass)) } func (v *SizeGroup) SetIgnoreHidden(ignoreHidden bool) { C.gtk_size_group_set_ignore_hidden(v.native(), gbool(ignoreHidden)) } // GetFontName is a wrapper around gtk_font_button_get_font_name(). func (v *FontButton) GetFontName() string { c := C.gtk_font_button_get_font_name(v.native()) return goString(c) } // SetFontName is a wrapper around gtk_font_button_set_font_name(). func (v *FontButton) SetFontName(fontname string) bool { cstr := C.CString(fontname) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_font_button_set_font_name(v.native(), (*C.gchar)(cstr)) return gobool(c) } gotk3-0.6.2/gtk/gtk_deprecated_since_3_24.go000066400000000000000000000031671431157473000205530ustar00rootroot00000000000000//+build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14 gtk_3_16 gtk_3_18 gtk_3_20 gtk_3_22 gtk_deprecated package gtk // #include // #include import "C" import ( "fmt" "unsafe" "github.com/gotk3/gotk3/glib" ) // GetFocusChain is a wrapper around gtk_container_get_focus_chain(). func (v *Container) GetFocusChain() ([]IWidget, bool, error) { var cwlist *C.GList c := C.gtk_container_get_focus_chain(v.native(), &cwlist) if cwlist == nil { return nil, gobool(c), nil } var widgets []IWidget wlist := glib.WrapList(uintptr(unsafe.Pointer(cwlist))) for ; wlist.Data() != nil; wlist = wlist.Next() { w, ok := wlist.Data().(*Widget) if !ok { return nil, gobool(c), fmt.Errorf("element is not of type *Widget, got %T", w) } widget, err := castWidget(w.toWidget()) if err != nil { return nil, gobool(c), err } widgets = append(widgets, widget) } return widgets, gobool(c), nil } /* * GtkContainer */ // SetFocusChain is a wrapper around gtk_container_set_focus_chain(). func (v *Container) SetFocusChain(focusableWidgets []IWidget) { var list *glib.List for _, w := range focusableWidgets { data := uintptr(unsafe.Pointer(w.toWidget())) list = list.Append(data) } glist := (*C.GList)(unsafe.Pointer(list)) C.gtk_container_set_focus_chain(v.native(), glist) } // TODO: // gtk_container_unset_focus_chain // CssProviderGetDefault is a wrapper around gtk_css_provider_get_default(). func CssProviderGetDefault() (*CssProvider, error) { c := C.gtk_css_provider_get_default() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapCssProvider(obj), nil } gotk3-0.6.2/gtk/gtk_deprecated_since_3_8.go000066400000000000000000000033551431157473000204740ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // This file includes wrapers for symbols deprecated beginning with GTK 3.8, // and should only be included in a build targeted intended to target GTK // 3.6 or earlier. To target an earlier build build, use the build tag // gtk_MAJOR_MINOR. For example, to target GTK 3.6, run // 'go build -tags gtk_3_6'. // +build gtk_3_6 gtk_deprecated package gtk // #include // #include import "C" // SetOpacity is a wrapper around gtk_window_set_opacity() // Deprecated since 3.8, replaced by SetOpacity on Widget (gtk_widget_set_opacity) func (v *Window) SetOpacity(opacity float64) { C.gtk_window_set_opacity(v.native(), C.gdouble(opacity)) } // GetOpacity is a wrapper around gtk_window_get_opacity() // Deprecated since 3.8, replaced by GetOpacity on Widget (gtk_widget_get_opacity) func (v *Window) GetOpacity() float64 { c := C.gtk_window_get_opacity(v.native()) return float64(c) } gotk3-0.6.2/gtk/gtk_export.go000066400000000000000000000060151431157473000160570ustar00rootroot00000000000000package gtk /* #include */ import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/internal/callback" ) //export goBuilderConnect func goBuilderConnect( builder *C.GtkBuilder, object *C.GObject, signal_name *C.gchar, handler_name *C.gchar, connect_object *C.GObject, flags C.GConnectFlags, user_data C.gpointer) { builderSignals.Lock() signals, ok := builderSignals.m[builder] builderSignals.Unlock() if !ok { panic("no signal mapping defined for this GtkBuilder") } h := C.GoString((*C.char)(handler_name)) s := C.GoString((*C.char)(signal_name)) handler, ok := signals[h] if !ok { return } if object == nil { panic("unexpected nil object from builder") } //TODO: figure out a better way to get a glib.Object from a *C.GObject gobj := glib.Object{glib.ToGObject(unsafe.Pointer(object))} gobj.Connect(s, handler) } //export goTreeViewSearchEqualFunc func goTreeViewSearchEqualFunc(model *C.GtkTreeModel, column C.gint, key *C.gchar, iter *C.GtkTreeIter, data C.gpointer) C.gboolean { fn := callback.Get(uintptr(data)).(TreeViewSearchEqualFunc) return gbool(fn( wrapTreeModel(glib.Take(unsafe.Pointer(model))), int(column), C.GoString(key), &TreeIter{(C.GtkTreeIter)(*iter)}, )) } //export goTreeModelFilterVisibleFunc func goTreeModelFilterVisibleFunc(model *C.GtkTreeModel, iter *C.GtkTreeIter, data C.gpointer) C.gboolean { goIter := &TreeIter{(C.GtkTreeIter)(*iter)} fn := callback.Get(uintptr(data)).(TreeModelFilterVisibleFunc) return gbool(fn( wrapTreeModel(glib.Take(unsafe.Pointer(model))), goIter, )) } //export goTreeSortableSortFunc func goTreeSortableSortFunc(model *C.GtkTreeModel, a, b *C.GtkTreeIter, data C.gpointer) C.gint { fn := callback.Get(uintptr(data)).(TreeIterCompareFunc) return C.gint(fn( wrapTreeModel(glib.Take(unsafe.Pointer(model))), &TreeIter{(C.GtkTreeIter)(*a)}, &TreeIter{(C.GtkTreeIter)(*b)}, )) } //export goTreeModelForeachFunc func goTreeModelForeachFunc(model *C.GtkTreeModel, path *C.GtkTreePath, iter *C.GtkTreeIter, data C.gpointer) C.gboolean { fn := callback.Get(uintptr(data)).(TreeModelForeachFunc) return gbool(fn( wrapTreeModel(glib.Take(unsafe.Pointer(model))), &TreePath{(*C.GtkTreePath)(path)}, &TreeIter{(C.GtkTreeIter)(*iter)}, )) } //export goTreeSelectionForeachFunc func goTreeSelectionForeachFunc(model *C.GtkTreeModel, path *C.GtkTreePath, iter *C.GtkTreeIter, data C.gpointer) { fn := callback.Get(uintptr(data)).(TreeSelectionForeachFunc) fn( wrapTreeModel(glib.Take(unsafe.Pointer(model))), &TreePath{(*C.GtkTreePath)(path)}, &TreeIter{(C.GtkTreeIter)(*iter)}, ) } //export goTreeSelectionFunc func goTreeSelectionFunc(selection *C.GtkTreeSelection, model *C.GtkTreeModel, path *C.GtkTreePath, selected C.gboolean, data C.gpointer) C.gboolean { fn := callback.Get(uintptr(data)).(TreeSelectionFunc) return gbool(fn( wrapTreeSelection(glib.Take(unsafe.Pointer(selection))), wrapTreeModel(glib.Take(unsafe.Pointer(model))), &TreePath{(*C.GtkTreePath)(path)}, gobool(selected), )) } gotk3-0.6.2/gtk/gtk_export_since_3_10.go000066400000000000000000000020021431157473000177520ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8 package gtk // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/internal/callback" ) //export goListBoxFilterFuncs func goListBoxFilterFuncs(row *C.GtkListBoxRow, userData C.gpointer) C.gboolean { fn := callback.Get(uintptr(userData)).(ListBoxFilterFunc) return gbool(fn(wrapListBoxRow(glib.Take(unsafe.Pointer(row))))) } //export goListBoxHeaderFuncs func goListBoxHeaderFuncs(row *C.GtkListBoxRow, before *C.GtkListBoxRow, userData C.gpointer) { fn := callback.Get(uintptr(userData)).(ListBoxHeaderFunc) fn( wrapListBoxRow(glib.Take(unsafe.Pointer(row))), wrapListBoxRow(glib.Take(unsafe.Pointer(before))), ) } //export goListBoxSortFuncs func goListBoxSortFuncs(row1 *C.GtkListBoxRow, row2 *C.GtkListBoxRow, userData C.gpointer) C.gint { fn := callback.Get(uintptr(userData)).(ListBoxSortFunc) return C.gint(fn( wrapListBoxRow(glib.Take(unsafe.Pointer(row1))), wrapListBoxRow(glib.Take(unsafe.Pointer(row2))), )) } gotk3-0.6.2/gtk/gtk_export_since_3_14.go000066400000000000000000000010431431157473000177620ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12 package gtk // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/internal/callback" ) //export goListBoxForEachFuncs func goListBoxForEachFuncs(box *C.GtkListBox, row *C.GtkListBoxRow, userData C.gpointer) { fn := callback.Get(uintptr(userData)).(ListBoxForeachFunc) fn(wrapListBox(glib.Take(unsafe.Pointer(box))), wrapListBoxRow(glib.Take(unsafe.Pointer(row)))) } gotk3-0.6.2/gtk/gtk_export_since_3_16.go000066400000000000000000000006341431157473000177710ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14 package gtk // #include import "C" import "github.com/gotk3/gotk3/internal/callback" //export goListBoxCreateWidgetFuncs func goListBoxCreateWidgetFuncs(item, userData C.gpointer) { fn := callback.Get(uintptr(userData)).(ListBoxCreateWidgetFunc) fn(uintptr(item)) } gotk3-0.6.2/gtk/gtk_since_3_10.go000066400000000000000000000653121431157473000163660ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains accelerator related functions and structures // +build !gtk_3_6,!gtk_3_8 // not use this: go build -tags gtk_3_8'. Otherwise, if no build tags are used, GTK 3.10 package gtk // #include // #include // #include "gtk_since_3_10.go.h" import "C" import ( "errors" "unsafe" "github.com/gotk3/gotk3/cairo" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/internal/callback" "github.com/gotk3/gotk3/pango" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.gtk_revealer_transition_type_get_type()), marshalRevealerTransitionType}, {glib.Type(C.gtk_stack_transition_type_get_type()), marshalStackTransitionType}, // Objects/Interfaces {glib.Type(C.gtk_header_bar_get_type()), marshalHeaderBar}, {glib.Type(C.gtk_list_box_get_type()), marshalListBox}, {glib.Type(C.gtk_list_box_row_get_type()), marshalListBoxRow}, {glib.Type(C.gtk_revealer_get_type()), marshalRevealer}, {glib.Type(C.gtk_search_bar_get_type()), marshalSearchBar}, {glib.Type(C.gtk_stack_get_type()), marshalStack}, {glib.Type(C.gtk_stack_switcher_get_type()), marshalStackSwitcher}, } glib.RegisterGValueMarshalers(tm) //Contribute to casting for k, v := range map[string]WrapFn{ "GtkHeaderBar": wrapHeaderBar, "GtkListBox": wrapListBox, "GtkListBoxRow": wrapListBoxRow, "GtkRevealer": wrapRevealer, "GtkSearchBar": wrapSearchBar, "GtkStack": wrapStack, } { WrapMap[k] = v } } /* * Constants */ const ( ALIGN_BASELINE Align = C.GTK_ALIGN_BASELINE ) // ImageType const ( IMAGE_SURFACE ImageType = C.GTK_IMAGE_SURFACE ) // RevealerTransitionType is a representation of GTK's GtkRevealerTransitionType. type RevealerTransitionType int const ( REVEALER_TRANSITION_TYPE_NONE RevealerTransitionType = C.GTK_REVEALER_TRANSITION_TYPE_NONE REVEALER_TRANSITION_TYPE_CROSSFADE RevealerTransitionType = C.GTK_REVEALER_TRANSITION_TYPE_CROSSFADE REVEALER_TRANSITION_TYPE_SLIDE_RIGHT RevealerTransitionType = C.GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT REVEALER_TRANSITION_TYPE_SLIDE_LEFT RevealerTransitionType = C.GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT REVEALER_TRANSITION_TYPE_SLIDE_UP RevealerTransitionType = C.GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP REVEALER_TRANSITION_TYPE_SLIDE_DOWN RevealerTransitionType = C.GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN ) func marshalRevealerTransitionType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return RevealerTransitionType(c), nil } // StackTransitionType is a representation of GTK's GtkStackTransitionType. type StackTransitionType int const ( STACK_TRANSITION_TYPE_NONE StackTransitionType = C.GTK_STACK_TRANSITION_TYPE_NONE STACK_TRANSITION_TYPE_CROSSFADE StackTransitionType = C.GTK_STACK_TRANSITION_TYPE_CROSSFADE STACK_TRANSITION_TYPE_SLIDE_RIGHT StackTransitionType = C.GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT STACK_TRANSITION_TYPE_SLIDE_LEFT StackTransitionType = C.GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT STACK_TRANSITION_TYPE_SLIDE_UP StackTransitionType = C.GTK_STACK_TRANSITION_TYPE_SLIDE_UP STACK_TRANSITION_TYPE_SLIDE_DOWN StackTransitionType = C.GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT StackTransitionType = C.GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT STACK_TRANSITION_TYPE_SLIDE_UP_DOWN StackTransitionType = C.GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN ) func marshalStackTransitionType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return StackTransitionType(c), nil } /* * GtkWidget */ // TODO: // gtk_widget_get_composite_name(). /* * GtkImage */ // ImageNewFromSurface is a wrapper around gtk_image_new_from_surface(). func ImageNewFromSurface(surface *cairo.Surface) (*Image, error) { c := C.gtk_image_new_from_surface((*C.cairo_surface_t)(surface.GetCSurface())) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapImage(obj), nil } // SetFromSurface is a wrapper around gtk_image_set_from_surface(). func (v *Image) SetFromSurface(surface *cairo.Surface) { csurface := (*C.cairo_surface_t)(surface.GetCSurface()) C.gtk_image_set_from_surface(v.native(), csurface) } /* * GtkIconTheme */ // HasIcon is a wrapper around gtk_icon_theme_load_icon_for_scale(). func (v *IconTheme) LoadIconForScale(iconName string, size, scale int, flags IconLookupFlags) (*gdk.Pixbuf, error) { cstr := C.CString(iconName) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil c := C.gtk_icon_theme_load_icon_for_scale(v.Theme, (*C.gchar)(cstr), C.gint(size), C.gint(scale), C.GtkIconLookupFlags(flags), &err) if c == nil { defer C.g_error_free(err) return nil, errors.New(goString(err.message)) } return &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))}, nil } /* * GtkEntry */ // GetTabs is a wrapper around gtk_entry_get_tabs(). func (v *Entry) GetTabs() (*pango.TabArray, error) { c := C.gtk_entry_get_tabs(v.native()) if c == nil { return nil, nilPtrErr } return pango.WrapTabArray(uintptr(unsafe.Pointer(c))), nil } // SetTabs is a wrapper around gtk_entry_set_tabs(). func (v *Entry) SetTabs(tabs *pango.TabArray) { C.gtk_entry_set_tabs(v.native(), (*C.PangoTabArray)(unsafe.Pointer(tabs.Native()))) } /* * GtkButton */ // ButtonNewFromIconName is a wrapper around gtk_button_new_from_icon_name(). func ButtonNewFromIconName(iconName string, size IconSize) (*Button, error) { cstr := C.CString(iconName) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_button_new_from_icon_name((*C.gchar)(cstr), C.GtkIconSize(size)) if c == nil { return nil, nilPtrErr } return wrapButton(glib.Take(unsafe.Pointer(c))), nil } /* * GtkBox */ // TODO: // gtk_box_get_baseline_position(). // gtk_box_set_baseline_position(). /* * GtkGrid */ // RemoveRow is a wrapper around gtk_grid_remove_row(). func (v *Grid) RemoveRow(position int) { C.gtk_grid_remove_row(v.native(), C.gint(position)) } // RemoveColumn is a wrapper around gtk_grid_remove_column(). func (v *Grid) RemoveColumn(position int) { C.gtk_grid_remove_column(v.native(), C.gint(position)) } // TODO: // gtk_grid_get_baseline_row(). // gtk_grid_set_baseline_row(). // gtk_grid_get_row_baseline_position(). // gtk_grid_set_row_baseline_position(). /* * GtkHeaderBar */ // HeaderBar is a representation of GtkHeaderBar type HeaderBar struct { Container } // native returns a pointer to the underlying GtkHeaderBar. func (v *HeaderBar) native() *C.GtkHeaderBar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkHeaderBar(p) } func marshalHeaderBar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapHeaderBar(obj), nil } func wrapHeaderBar(obj *glib.Object) *HeaderBar { if obj == nil { return nil } return &HeaderBar{Container{Widget{glib.InitiallyUnowned{obj}}}} } // HeaderBarNew is a wrapper around gtk_header_bar_new(). func HeaderBarNew() (*HeaderBar, error) { c := C.gtk_header_bar_new() if c == nil { return nil, nilPtrErr } return wrapHeaderBar(glib.Take(unsafe.Pointer(c))), nil } // SetTitle is a wrapper around gtk_header_bar_set_title(). func (v *HeaderBar) SetTitle(title string) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) C.gtk_header_bar_set_title(v.native(), (*C.gchar)(cstr)) } // GetTitle is a wrapper around gtk_header_bar_get_title(). func (v *HeaderBar) GetTitle() string { cstr := C.gtk_header_bar_get_title(v.native()) return C.GoString((*C.char)(cstr)) } // SetSubtitle is a wrapper around gtk_header_bar_set_subtitle(). func (v *HeaderBar) SetSubtitle(subtitle string) { cstr := C.CString(subtitle) defer C.free(unsafe.Pointer(cstr)) C.gtk_header_bar_set_subtitle(v.native(), (*C.gchar)(cstr)) } // GetSubtitle is a wrapper around gtk_header_bar_get_subtitle(). func (v *HeaderBar) GetSubtitle() string { cstr := C.gtk_header_bar_get_subtitle(v.native()) return C.GoString((*C.char)(cstr)) } // SetCustomTitle is a wrapper around gtk_header_bar_set_custom_title(). func (v *HeaderBar) SetCustomTitle(titleWidget IWidget) { C.gtk_header_bar_set_custom_title(v.native(), titleWidget.toWidget()) } // GetCustomTitle is a wrapper around gtk_header_bar_get_custom_title(). func (v *HeaderBar) GetCustomTitle() (IWidget, error) { c := C.gtk_header_bar_get_custom_title(v.native()) if c == nil { return nil, nil } return castWidget(c) } // PackStart is a wrapper around gtk_header_bar_pack_start(). func (v *HeaderBar) PackStart(child IWidget) { C.gtk_header_bar_pack_start(v.native(), child.toWidget()) } // PackEnd is a wrapper around gtk_header_bar_pack_end(). func (v *HeaderBar) PackEnd(child IWidget) { C.gtk_header_bar_pack_end(v.native(), child.toWidget()) } // SetShowCloseButton is a wrapper around gtk_header_bar_set_show_close_button(). func (v *HeaderBar) SetShowCloseButton(setting bool) { C.gtk_header_bar_set_show_close_button(v.native(), gbool(setting)) } // GetShowCloseButton is a wrapper around gtk_header_bar_get_show_close_button(). func (v *HeaderBar) GetShowCloseButton() bool { c := C.gtk_header_bar_get_show_close_button(v.native()) return gobool(c) } /* * GtkLabel */ // GetLines is a wrapper around gtk_label_get_lines(). func (v *Label) GetLines() int { c := C.gtk_label_get_lines(v.native()) return int(c) } // SetLines is a wrapper around gtk_label_set_lines(). func (v *Label) SetLines(lines int) { C.gtk_label_set_lines(v.native(), C.gint(lines)) } /* * GtkListBox */ // ListBox is a representation of GTK's GtkListBox. type ListBox struct { Container } // native returns a pointer to the underlying GtkListBox. func (v *ListBox) native() *C.GtkListBox { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkListBox(p) } func marshalListBox(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapListBox(obj), nil } func wrapListBox(obj *glib.Object) *ListBox { if obj == nil { return nil } return &ListBox{Container{Widget{glib.InitiallyUnowned{obj}}}} } // ListBoxNew is a wrapper around gtk_list_box_new(). func ListBoxNew() (*ListBox, error) { c := C.gtk_list_box_new() if c == nil { return nil, nilPtrErr } return wrapListBox(glib.Take(unsafe.Pointer(c))), nil } // Prepend is a wrapper around gtk_list_box_prepend(). func (v *ListBox) Prepend(child IWidget) { C.gtk_list_box_prepend(v.native(), child.toWidget()) } // Insert is a wrapper around gtk_list_box_insert(). func (v *ListBox) Insert(child IWidget, position int) { C.gtk_list_box_insert(v.native(), child.toWidget(), C.gint(position)) } // SelectRow is a wrapper around gtk_list_box_select_row(). func (v *ListBox) SelectRow(row *ListBoxRow) { C.gtk_list_box_select_row(v.native(), row.native()) } // GetSelectedRow is a wrapper around gtk_list_box_get_selected_row(). func (v *ListBox) GetSelectedRow() *ListBoxRow { c := C.gtk_list_box_get_selected_row(v.native()) if c == nil { return nil } return wrapListBoxRow(glib.Take(unsafe.Pointer(c))) } // SetSelectionMode is a wrapper around gtk_list_box_set_selection_mode(). func (v *ListBox) SetSelectionMode(mode SelectionMode) { C.gtk_list_box_set_selection_mode(v.native(), C.GtkSelectionMode(mode)) } // GetSelectionMode is a wrapper around gtk_list_box_get_selection_mode() func (v *ListBox) GetSelectionMode() SelectionMode { c := C.gtk_list_box_get_selection_mode(v.native()) return SelectionMode(c) } // SetActivateOnSingleClick is a wrapper around gtk_list_box_set_activate_on_single_click(). func (v *ListBox) SetActivateOnSingleClick(single bool) { C.gtk_list_box_set_activate_on_single_click(v.native(), gbool(single)) } // GetActivateOnSingleClick is a wrapper around gtk_list_box_get_activate_on_single_click(). func (v *ListBox) GetActivateOnSingleClick() bool { c := C.gtk_list_box_get_activate_on_single_click(v.native()) return gobool(c) } // GetAdjustment is a wrapper around gtk_list_box_get_adjustment(). func (v *ListBox) GetAdjustment() *Adjustment { c := C.gtk_list_box_get_adjustment(v.native()) obj := glib.Take(unsafe.Pointer(c)) return &Adjustment{glib.InitiallyUnowned{obj}} } // SetAdjustment is a wrapper around gtk_list_box_set_adjustment(). func (v *ListBox) SetAdjustment(adjustment *Adjustment) { C.gtk_list_box_set_adjustment(v.native(), adjustment.native()) } // SetPlaceholder is a wrapper around gtk_list_box_set_placeholder(). func (v *ListBox) SetPlaceholder(placeholder IWidget) { C.gtk_list_box_set_placeholder(v.native(), placeholder.toWidget()) } // GetRowAtIndex is a wrapper around gtk_list_box_get_row_at_index(). func (v *ListBox) GetRowAtIndex(index int) *ListBoxRow { c := C.gtk_list_box_get_row_at_index(v.native(), C.gint(index)) if c == nil { return nil } return wrapListBoxRow(glib.Take(unsafe.Pointer(c))) } // GetRowAtY is a wrapper around gtk_list_box_get_row_at_y(). func (v *ListBox) GetRowAtY(y int) *ListBoxRow { c := C.gtk_list_box_get_row_at_y(v.native(), C.gint(y)) if c == nil { return nil } return wrapListBoxRow(glib.Take(unsafe.Pointer(c))) } // InvalidateFilter is a wrapper around gtk_list_box_invalidate_filter(). func (v *ListBox) InvalidateFilter() { C.gtk_list_box_invalidate_filter(v.native()) } // InvalidateHeaders is a wrapper around gtk_list_box_invalidate_headers(). func (v *ListBox) InvalidateHeaders() { C.gtk_list_box_invalidate_headers(v.native()) } // InvalidateSort is a wrapper around gtk_list_box_invalidate_sort(). func (v *ListBox) InvalidateSort() { C.gtk_list_box_invalidate_sort(v.native()) } // ListBoxFilterFunc is a representation of GtkListBoxFilterFunc type ListBoxFilterFunc func(row *ListBoxRow) bool // SetFilterFunc is a wrapper around gtk_list_box_set_filter_func func (v *ListBox) SetFilterFunc(fn ListBoxFilterFunc) { C._gtk_list_box_set_filter_func(v.native(), C.gpointer(callback.Assign(fn))) } // ListBoxHeaderFunc is a representation of GtkListBoxUpdateHeaderFunc type ListBoxHeaderFunc func(row *ListBoxRow, before *ListBoxRow) // SetHeaderFunc is a wrapper around gtk_list_box_set_header_func func (v *ListBox) SetHeaderFunc(fn ListBoxHeaderFunc) { C._gtk_list_box_set_header_func(v.native(), C.gpointer(callback.Assign(fn))) } // ListBoxSortFunc is a representation of GtkListBoxSortFunc type ListBoxSortFunc func(row1 *ListBoxRow, row2 *ListBoxRow) int // SetSortFunc is a wrapper around gtk_list_box_set_sort_func func (v *ListBox) SetSortFunc(fn ListBoxSortFunc) { C._gtk_list_box_set_sort_func(v.native(), C.gpointer(callback.Assign(fn))) } // DragHighlightRow is a wrapper around gtk_list_box_drag_highlight_row() func (v *ListBox) DragHighlightRow(row *ListBoxRow) { C.gtk_list_box_drag_highlight_row(v.native(), row.native()) } // DragUnhighlightRow is a wrapper around gtk_list_box_drag_unhighlight_row(). func (v *ListBox) DragUnhighlightRow() { C.gtk_list_box_drag_unhighlight_row(v.native()) } /* * GtkListBoxRow */ // ListBoxRow is a representation of GTK's GtkListBoxRow. type ListBoxRow struct { Bin } // native returns a pointer to the underlying GtkListBoxRow. func (v *ListBoxRow) native() *C.GtkListBoxRow { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkListBoxRow(p) } func marshalListBoxRow(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapListBoxRow(obj), nil } func wrapListBoxRow(obj *glib.Object) *ListBoxRow { if obj == nil { return nil } return &ListBoxRow{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // ListBoxRowNew is a wrapper around gtk_list_box_row_new(). func ListBoxRowNew() (*ListBoxRow, error) { c := C.gtk_list_box_row_new() if c == nil { return nil, nilPtrErr } return wrapListBoxRow(glib.Take(unsafe.Pointer(c))), nil } // Changed is a wrapper around gtk_list_box_row_changed(). func (v *ListBoxRow) Changed() { C.gtk_list_box_row_changed(v.native()) } // GetHeader is a wrapper around gtk_list_box_row_get_header(). func (v *ListBoxRow) GetHeader() (IWidget, error) { c := C.gtk_list_box_row_get_header(v.native()) if c == nil { return nil, nil } return castWidget(c) } // SetHeader is a wrapper around gtk_list_box_row_set_header(). func (v *ListBoxRow) SetHeader(header IWidget) { if header == nil { C.gtk_list_box_row_set_header(v.native(), nil) return } C.gtk_list_box_row_set_header(v.native(), header.toWidget()) } // GetIndex is a wrapper around gtk_list_box_row_get_index() func (v *ListBoxRow) GetIndex() int { c := C.gtk_list_box_row_get_index(v.native()) return int(c) } /* * GtkPlacesSidebar */ // TODO: // gtk_places_sidebar_new(). // gtk_places_sidebar_set_open_flags(). // gtk_places_sidebar_get_open_flags(). // gtk_places_sidebar_set_location(). // gtk_places_sidebar_get_location(). // gtk_places_sidebar_set_show_desktop(). // gtk_places_sidebar_get_show_desktop(). // gtk_places_sidebar_add_shortcut(). // gtk_places_sidebar_remove_shortcut(). // gtk_places_sidebar_list_shortcuts(). // gtk_places_sidebar_get_nth_bookmark(). // enum GtkPlacesOpenFlags /* * GtkRevealer */ // Revealer is a representation of GTK's GtkRevealer type Revealer struct { Bin } // native returns a pointer to the underlying GtkRevealer. func (v *Revealer) native() *C.GtkRevealer { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkRevealer(p) } func marshalRevealer(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapRevealer(obj), nil } func wrapRevealer(obj *glib.Object) *Revealer { if obj == nil { return nil } return &Revealer{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // RevealerNew is a wrapper around gtk_revealer_new() func RevealerNew() (*Revealer, error) { c := C.gtk_revealer_new() if c == nil { return nil, nilPtrErr } return wrapRevealer(glib.Take(unsafe.Pointer(c))), nil } // GetRevealChild is a wrapper around gtk_revealer_get_reveal_child(). func (v *Revealer) GetRevealChild() bool { c := C.gtk_revealer_get_reveal_child(v.native()) return gobool(c) } // SetRevealChild is a wrapper around gtk_revealer_set_reveal_child(). func (v *Revealer) SetRevealChild(revealChild bool) { C.gtk_revealer_set_reveal_child(v.native(), gbool(revealChild)) } // GetChildRevealed is a wrapper around gtk_revealer_get_child_revealed(). func (v *Revealer) GetChildRevealed() bool { c := C.gtk_revealer_get_child_revealed(v.native()) return gobool(c) } // GetTransitionDuration is a wrapper around gtk_revealer_get_transition_duration() func (v *Revealer) GetTransitionDuration() uint { c := C.gtk_revealer_get_transition_duration(v.native()) return uint(c) } // SetTransitionDuration is a wrapper around gtk_revealer_set_transition_duration(). func (v *Revealer) SetTransitionDuration(duration uint) { C.gtk_revealer_set_transition_duration(v.native(), C.guint(duration)) } // GetTransitionType is a wrapper around gtk_revealer_get_transition_type() func (v *Revealer) GetTransitionType() RevealerTransitionType { c := C.gtk_revealer_get_transition_type(v.native()) return RevealerTransitionType(c) } // SetTransitionType is a wrapper around gtk_revealer_set_transition_type() func (v *Revealer) SetTransitionType(transition RevealerTransitionType) { t := C.GtkRevealerTransitionType(transition) C.gtk_revealer_set_transition_type(v.native(), t) } /* * GtkSearchBar */ // SearchBar is a representation of GTK's GtkSearchBar. type SearchBar struct { Bin } // native returns a pointer to the underlying GtkSearchBar. func (v *SearchBar) native() *C.GtkSearchBar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSearchBar(p) } func marshalSearchBar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapSearchBar(obj), nil } func wrapSearchBar(obj *glib.Object) *SearchBar { if obj == nil { return nil } return &SearchBar{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // SearchBarNew is a wrapper around gtk_search_bar_new() func SearchBarNew() (*SearchBar, error) { c := C.gtk_search_bar_new() if c == nil { return nil, nilPtrErr } return wrapSearchBar(glib.Take(unsafe.Pointer(c))), nil } // ConnectEntry is a wrapper around gtk_search_bar_connect_entry(). func (v *SearchBar) ConnectEntry(entry IEntry) { C.gtk_search_bar_connect_entry(v.native(), entry.toEntry()) } // GetSearchMode is a wrapper around gtk_search_bar_get_search_mode(). func (v *SearchBar) GetSearchMode() bool { c := C.gtk_search_bar_get_search_mode(v.native()) return gobool(c) } // SetSearchMode is a wrapper around gtk_search_bar_set_search_mode(). func (v *SearchBar) SetSearchMode(searchMode bool) { C.gtk_search_bar_set_search_mode(v.native(), gbool(searchMode)) } // GetShowCloseButton is a wrapper arounb gtk_search_bar_get_show_close_button(). func (v *SearchBar) GetShowCloseButton() bool { c := C.gtk_search_bar_get_show_close_button(v.native()) return gobool(c) } // SetShowCloseButton is a wrapper around gtk_search_bar_set_show_close_button() func (v *SearchBar) SetShowCloseButton(visible bool) { C.gtk_search_bar_set_show_close_button(v.native(), gbool(visible)) } // HandleEvent is a wrapper around gtk_search_bar_handle_event() func (v *SearchBar) HandleEvent(event *gdk.Event) { e := (*C.GdkEvent)(unsafe.Pointer(event.Native())) C.gtk_search_bar_handle_event(v.native(), e) } /* * GtkStack */ // Stack is a representation of GTK's GtkStack. type Stack struct { Container } // native returns a pointer to the underlying GtkStack. func (v *Stack) native() *C.GtkStack { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkStack(p) } func marshalStack(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapStack(obj), nil } func wrapStack(obj *glib.Object) *Stack { if obj == nil { return nil } return &Stack{Container{Widget{glib.InitiallyUnowned{obj}}}} } // StackNew is a wrapper around gtk_stack_new(). func StackNew() (*Stack, error) { c := C.gtk_stack_new() if c == nil { return nil, nilPtrErr } return wrapStack(glib.Take(unsafe.Pointer(c))), nil } // AddNamed is a wrapper around gtk_stack_add_named(). func (v *Stack) AddNamed(child IWidget, name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_stack_add_named(v.native(), child.toWidget(), (*C.gchar)(cstr)) } // AddTitled is a wrapper around gtk_stack_add_titled(). func (v *Stack) AddTitled(child IWidget, name, title string) { cName := C.CString(name) defer C.free(unsafe.Pointer(cName)) cTitle := C.CString(title) defer C.free(unsafe.Pointer(cTitle)) C.gtk_stack_add_titled(v.native(), child.toWidget(), (*C.gchar)(cName), (*C.gchar)(cTitle)) } // SetVisibleChild is a wrapper around gtk_stack_set_visible_child(). func (v *Stack) SetVisibleChild(child IWidget) { C.gtk_stack_set_visible_child(v.native(), child.toWidget()) } // GetVisibleChild is a wrapper around gtk_stack_get_visible_child(). func (v *Stack) GetVisibleChild() (IWidget, error) { c := C.gtk_stack_get_visible_child(v.native()) if c == nil { return nil, nil } return castWidget(c) } // SetVisibleChildName is a wrapper around gtk_stack_set_visible_child_name(). func (v *Stack) SetVisibleChildName(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_stack_set_visible_child_name(v.native(), (*C.gchar)(cstr)) } // GetVisibleChildName is a wrapper around gtk_stack_get_visible_child_name(). func (v *Stack) GetVisibleChildName() string { c := C.gtk_stack_get_visible_child_name(v.native()) return C.GoString((*C.char)(c)) } // SetVisibleChildFull is a wrapper around gtk_stack_set_visible_child_full(). func (v *Stack) SetVisibleChildFull(name string, transaction StackTransitionType) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_stack_set_visible_child_full(v.native(), (*C.gchar)(cstr), C.GtkStackTransitionType(transaction)) } // SetHomogeneous is a wrapper around gtk_stack_set_homogeneous(). func (v *Stack) SetHomogeneous(homogeneous bool) { C.gtk_stack_set_homogeneous(v.native(), gbool(homogeneous)) } // GetHomogeneous is a wrapper around gtk_stack_get_homogeneous(). func (v *Stack) GetHomogeneous() bool { c := C.gtk_stack_get_homogeneous(v.native()) return gobool(c) } // SetTransitionDuration is a wrapper around gtk_stack_set_transition_duration(). func (v *Stack) SetTransitionDuration(duration uint) { C.gtk_stack_set_transition_duration(v.native(), C.guint(duration)) } // GetTransitionDuration is a wrapper around gtk_stack_get_transition_duration(). func (v *Stack) GetTransitionDuration() uint { c := C.gtk_stack_get_transition_duration(v.native()) return uint(c) } // SetTransitionType is a wrapper around gtk_stack_set_transition_type(). func (v *Stack) SetTransitionType(transition StackTransitionType) { C.gtk_stack_set_transition_type(v.native(), C.GtkStackTransitionType(transition)) } // GetTransitionType is a wrapper around gtk_stack_get_transition_type(). func (v *Stack) GetTransitionType() StackTransitionType { c := C.gtk_stack_get_transition_type(v.native()) return StackTransitionType(c) } /* * GtkBuilder */ // BuilderNewFromFile is a wrapper around gtk_builder_new_from_file(). func BuilderNewFromFile(filePath string) (*Builder, error) { cstr := C.CString(filePath) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_builder_new_from_file((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return &Builder{obj}, nil } // BuilderNewFromResource is a wrapper around gtk_builder_new_from_resource(). func BuilderNewFromResource(resourcePath string) (*Builder, error) { cstr := C.CString(resourcePath) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_builder_new_from_resource((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return &Builder{obj}, nil } // BuilderNewFromString is a wrapper around gtk_builder_new_from_string(). func BuilderNewFromString(resource string) (*Builder, error) { cstr := C.CString(resource) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_builder_new_from_string((*C.gchar)(cstr), C.gssize(len(resource))) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return &Builder{obj}, nil } // TODO: // gtk_builder_add_callback_symbol // gtk_builder_add_callback_symbols // gtk_builder_lookup_callback_symbol // gtk_builder_set_application // gtk_builder_get_application /* * GtkFileChooser */ // GetCurrentName is a wrapper around gtk_file_chooser_get_current_name(). func (v *FileChooser) GetCurrentName() string { c := C.gtk_file_chooser_get_current_name(v.native()) defer C.free(unsafe.Pointer(c)) return goString(c) } gotk3-0.6.2/gtk/gtk_since_3_10.go.h000066400000000000000000000052601431157473000166100ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include "gtk.go.h" // for gotk3_callbackDelete #include static GtkHeaderBar *toGtkHeaderBar(void *p) { return (GTK_HEADER_BAR(p)); } static GtkListBox *toGtkListBox(void *p) { return (GTK_LIST_BOX(p)); } static GtkListBoxRow *toGtkListBoxRow(void *p) { return (GTK_LIST_BOX_ROW(p)); } static GtkRevealer *toGtkRevealer(void *p) { return (GTK_REVEALER(p)); } static GtkSearchBar *toGtkSearchBar(void *p) { return (GTK_SEARCH_BAR(p)); } static GtkStack *toGtkStack(void *p) { return (GTK_STACK(p)); } static GtkStackSwitcher *toGtkStackSwitcher(void *p) { return (GTK_STACK_SWITCHER(p)); } extern gboolean goListBoxFilterFuncs(GtkListBoxRow *row, gpointer user_data); static inline void _gtk_list_box_set_filter_func(GtkListBox *box, gpointer user_data) { gtk_list_box_set_filter_func(box, (GtkListBoxFilterFunc)(goListBoxFilterFuncs), user_data, (GDestroyNotify)(gotk3_callbackDelete)); } extern void goListBoxHeaderFuncs(GtkListBoxRow *row, GtkListBoxRow *before, gpointer user_data); static inline void _gtk_list_box_set_header_func(GtkListBox *box, gpointer user_data) { gtk_list_box_set_header_func( box, (GtkListBoxUpdateHeaderFunc)(goListBoxHeaderFuncs), user_data, (GDestroyNotify)(gotk3_callbackDelete)); } extern gint goListBoxSortFuncs(GtkListBoxRow *row1, GtkListBoxRow *row2, gpointer user_data); static inline void _gtk_list_box_set_sort_func(GtkListBox *box, gpointer user_data) { gtk_list_box_set_sort_func(box, (GtkListBoxSortFunc)(goListBoxSortFuncs), user_data, (GDestroyNotify)(gotk3_callbackDelete)); } gotk3-0.6.2/gtk/gtk_since_3_12.go000066400000000000000000000410061431157473000163620ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // Wrapper for GtkPopover originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // +build !gtk_3_6,!gtk_3_8,!gtk_3_10 // not use this: go build -tags gtk_3_8'. Otherwise, if no build tags are used, GTK 3.10 package gtk // #include // #include // #include "gtk_since_3_12.go.h" import "C" import ( "errors" "runtime" "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) /* * Constants */ const ( DIALOG_USE_HEADER_BAR DialogFlags = C.GTK_DIALOG_USE_HEADER_BAR ) const ( STATE_FLAG_LINK StateFlags = C.GTK_STATE_FLAG_LINK STATE_FLAG_VISITED StateFlags = C.GTK_STATE_FLAG_VISITED ) const ( BUTTONBOX_EXPAND ButtonBoxStyle = C.GTK_BUTTONBOX_EXPAND ) func init() { tm := []glib.TypeMarshaler{ // Objects/Interfaces {glib.Type(C.gtk_flow_box_get_type()), marshalFlowBox}, {glib.Type(C.gtk_flow_box_child_get_type()), marshalFlowBoxChild}, {glib.Type(C.gtk_popover_get_type()), marshalPopover}, } glib.RegisterGValueMarshalers(tm) //Contribute to casting for k, v := range map[string]WrapFn{ "GtkFlowBox": wrapFlowBox, "GtkFlowBoxChild": wrapFlowBoxChild, "GtkPopover": wrapPopover, } { WrapMap[k] = v } } // GetLocaleDirection is a wrapper around gtk_get_locale_direction(). func GetLocaleDirection() TextDirection { c := C.gtk_get_locale_direction() return TextDirection(c) } /* * GtkStack */ const ( STACK_TRANSITION_TYPE_OVER_UP StackTransitionType = C.GTK_STACK_TRANSITION_TYPE_OVER_UP STACK_TRANSITION_TYPE_OVER_DOWN = C.GTK_STACK_TRANSITION_TYPE_OVER_DOWN STACK_TRANSITION_TYPE_OVER_LEFT = C.GTK_STACK_TRANSITION_TYPE_OVER_LEFT STACK_TRANSITION_TYPE_OVER_RIGHT = C.GTK_STACK_TRANSITION_TYPE_OVER_RIGHT STACK_TRANSITION_TYPE_UNDER_UP = C.GTK_STACK_TRANSITION_TYPE_UNDER_UP STACK_TRANSITION_TYPE_UNDER_DOWN = C.GTK_STACK_TRANSITION_TYPE_UNDER_DOWN STACK_TRANSITION_TYPE_UNDER_LEFT = C.GTK_STACK_TRANSITION_TYPE_UNDER_LEFT STACK_TRANSITION_TYPE_UNDER_RIGHT = C.GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT STACK_TRANSITION_TYPE_OVER_UP_DOWN = C.GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN ) /* * Dialog */ // GetHeaderBar is a wrapper around gtk_dialog_get_header_bar(). func (v *Dialog) GetHeaderBar() (IWidget, error) { c := C.gtk_dialog_get_header_bar(v.native()) if c == nil { return nil, nil } return castWidget(c) } /* * Entry */ // SetMaxWidthChars is a wrapper around gtk_entry_set_max_width_chars(). func (v *Entry) SetMaxWidthChars(nChars int) { C.gtk_entry_set_max_width_chars(v.native(), C.gint(nChars)) } // GetMaxWidthChars is a wrapper around gtk_entry_get_max_width_chars(). func (v *Entry) GetMaxWidthChars() int { c := C.gtk_entry_get_max_width_chars(v.native()) return int(c) } /* * HeaderBar */ // GetDecorationLayout is a wrapper around gtk_header_bar_get_decoration_layout(). func (v *HeaderBar) GetDecorationLayout() string { c := C.gtk_header_bar_get_decoration_layout(v.native()) return C.GoString((*C.char)(c)) } // SetDecorationLayout is a wrapper around gtk_header_bar_set_decoration_layout(). func (v *HeaderBar) SetDecorationLayout(layout string) { cstr := C.CString(layout) defer C.free(unsafe.Pointer(cstr)) C.gtk_header_bar_set_decoration_layout(v.native(), (*C.gchar)(cstr)) } // GetHasSubtitle is a wrapper around gtk_header_bar_get_has_subtitle(). func (v *HeaderBar) GetHasSubtitle() bool { c := C.gtk_header_bar_get_has_subtitle(v.native()) return gobool(c) } // SetHasSubtitle is a wrapper around gtk_header_bar_set_has_subtitle(). func (v *HeaderBar) SetHasSubtitle(setting bool) { C.gtk_header_bar_set_has_subtitle(v.native(), gbool(setting)) } /* * MenuButton */ // SetPopover is a wrapper around gtk_menu_button_set_popover(). func (v *MenuButton) SetPopover(popover *Popover) { C.gtk_menu_button_set_popover(v.native(), popover.toWidget()) } // GetPopover is a wrapper around gtk_menu_button_get_popover(). func (v *MenuButton) GetPopover() *Popover { c := C.gtk_menu_button_get_popover(v.native()) if c == nil { return nil } return wrapPopover(glib.Take(unsafe.Pointer(c))) } // GetUsePopover is a wrapper around gtk_menu_button_get_use_popover(). func (v *MenuButton) GetUsePopover() bool { c := C.gtk_menu_button_get_use_popover(v.native()) return gobool(c) } // SetUsePopover is a wrapper around gtk_menu_button_set_use_popover(). func (v *MenuButton) SetUsePopover(setting bool) { C.gtk_menu_button_set_use_popover(v.native(), gbool(setting)) } /* * FlowBox */ // FlowBox is a representation of GtkFlowBox type FlowBox struct { Container } func (fb *FlowBox) native() *C.GtkFlowBox { if fb == nil || fb.GObject == nil { return nil } p := unsafe.Pointer(fb.GObject) return C.toGtkFlowBox(p) } func marshalFlowBox(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFlowBox(obj), nil } func wrapFlowBox(obj *glib.Object) *FlowBox { if obj == nil { return nil } return &FlowBox{Container{Widget{glib.InitiallyUnowned{obj}}}} } // FlowBoxNew is a wrapper around gtk_flow_box_new() func FlowBoxNew() (*FlowBox, error) { c := C.gtk_flow_box_new() if c == nil { return nil, nilPtrErr } return wrapFlowBox(glib.Take(unsafe.Pointer(c))), nil } // Insert is a wrapper around gtk_flow_box_insert() func (fb *FlowBox) Insert(widget IWidget, position int) { C.gtk_flow_box_insert(fb.native(), widget.toWidget(), C.gint(position)) } // GetChildAtIndex is a wrapper around gtk_flow_box_get_child_at_index() func (fb *FlowBox) GetChildAtIndex(idx int) *FlowBoxChild { c := C.gtk_flow_box_get_child_at_index(fb.native(), C.gint(idx)) if c == nil { return nil } return wrapFlowBoxChild(glib.Take(unsafe.Pointer(c))) } // TODO 3.22.6 gtk_flow_box_get_child_at_pos() // SetHAdjustment is a wrapper around gtk_flow_box_set_hadjustment() func (fb *FlowBox) SetHAdjustment(adjustment *Adjustment) { C.gtk_flow_box_set_hadjustment(fb.native(), adjustment.native()) } // SetVAdjustment is a wrapper around gtk_flow_box_set_vadjustment() func (fb *FlowBox) SetVAdjustment(adjustment *Adjustment) { C.gtk_flow_box_set_vadjustment(fb.native(), adjustment.native()) } // SetHomogeneous is a wrapper around gtk_flow_box_set_homogeneous() func (fb *FlowBox) SetHomogeneous(homogeneous bool) { C.gtk_flow_box_set_homogeneous(fb.native(), gbool(homogeneous)) } // GetHomogeneous is a wrapper around gtk_flow_box_get_homogeneous() func (fb *FlowBox) GetHomogeneous() bool { c := C.gtk_flow_box_get_homogeneous(fb.native()) return gobool(c) } // SetRowSpacing is a wrapper around gtk_flow_box_set_row_spacing() func (fb *FlowBox) SetRowSpacing(spacing uint) { C.gtk_flow_box_set_row_spacing(fb.native(), C.guint(spacing)) } // GetRowSpacing is a wrapper around gtk_flow_box_get_row_spacing() func (fb *FlowBox) GetRowSpacing() uint { c := C.gtk_flow_box_get_row_spacing(fb.native()) return uint(c) } // SetColumnSpacing is a wrapper around gtk_flow_box_set_column_spacing() func (fb *FlowBox) SetColumnSpacing(spacing uint) { C.gtk_flow_box_set_column_spacing(fb.native(), C.guint(spacing)) } // GetColumnSpacing is a wrapper around gtk_flow_box_get_column_spacing() func (fb *FlowBox) GetColumnSpacing() uint { c := C.gtk_flow_box_get_column_spacing(fb.native()) return uint(c) } // SetMinChildrenPerLine is a wrapper around gtk_flow_box_set_min_children_per_line() func (fb *FlowBox) SetMinChildrenPerLine(n_children uint) { C.gtk_flow_box_set_min_children_per_line(fb.native(), C.guint(n_children)) } // GetMinChildrenPerLine is a wrapper around gtk_flow_box_get_min_children_per_line() func (fb *FlowBox) GetMinChildrenPerLine() uint { c := C.gtk_flow_box_get_min_children_per_line(fb.native()) return uint(c) } // SetMaxChildrenPerLine is a wrapper around gtk_flow_box_set_max_children_per_line() func (fb *FlowBox) SetMaxChildrenPerLine(n_children uint) { C.gtk_flow_box_set_max_children_per_line(fb.native(), C.guint(n_children)) } // GetMaxChildrenPerLine is a wrapper around gtk_flow_box_get_max_children_per_line() func (fb *FlowBox) GetMaxChildrenPerLine() uint { c := C.gtk_flow_box_get_max_children_per_line(fb.native()) return uint(c) } // SetActivateOnSingleClick is a wrapper around gtk_flow_box_set_activate_on_single_click() func (fb *FlowBox) SetActivateOnSingleClick(single bool) { C.gtk_flow_box_set_activate_on_single_click(fb.native(), gbool(single)) } // GetActivateOnSingleClick gtk_flow_box_get_activate_on_single_click() func (fb *FlowBox) GetActivateOnSingleClick() bool { c := C.gtk_flow_box_get_activate_on_single_click(fb.native()) return gobool(c) } // TODO: gtk_flow_box_selected_foreach() // GetSelectedChildren is a wrapper around gtk_flow_box_get_selected_children() func (fb *FlowBox) GetSelectedChildren() (rv []*FlowBoxChild) { c := C.gtk_flow_box_get_selected_children(fb.native()) if c == nil { return } list := glib.WrapList(uintptr(unsafe.Pointer(c))) for l := list; l != nil; l = l.Next() { o := wrapFlowBoxChild(glib.Take(l.Data().(unsafe.Pointer))) rv = append(rv, o) } // We got a transfer container, so we must free the list. list.Free() return } // SelectChild is a wrapper around gtk_flow_box_select_child() func (fb *FlowBox) SelectChild(child *FlowBoxChild) { C.gtk_flow_box_select_child(fb.native(), child.native()) } // UnselectChild is a wrapper around gtk_flow_box_unselect_child() func (fb *FlowBox) UnselectChild(child *FlowBoxChild) { C.gtk_flow_box_unselect_child(fb.native(), child.native()) } // SelectAll is a wrapper around gtk_flow_box_select_all() func (fb *FlowBox) SelectAll() { C.gtk_flow_box_select_all(fb.native()) } // UnselectAll is a wrapper around gtk_flow_box_unselect_all() func (fb *FlowBox) UnselectAll() { C.gtk_flow_box_unselect_all(fb.native()) } // SetSelectionMode is a wrapper around gtk_flow_box_set_selection_mode() func (fb *FlowBox) SetSelectionMode(mode SelectionMode) { C.gtk_flow_box_set_selection_mode(fb.native(), C.GtkSelectionMode(mode)) } // GetSelectionMode is a wrapper around gtk_flow_box_get_selection_mode() func (fb *FlowBox) GetSelectionMode() SelectionMode { c := C.gtk_flow_box_get_selection_mode(fb.native()) return SelectionMode(c) } // TODO gtk_flow_box_set_filter_func() // TODO gtk_flow_box_invalidate_filter() // TODO gtk_flow_box_set_sort_func() // TODO gtk_flow_box_invalidate_sort() // TODO 3.18 gtk_flow_box_bind_model() /* * FlowBoxChild */ // FlowBoxChild is a representation of GtkFlowBoxChild type FlowBoxChild struct { Bin } func (fbc *FlowBoxChild) native() *C.GtkFlowBoxChild { if fbc == nil || fbc.GObject == nil { return nil } p := unsafe.Pointer(fbc.GObject) return C.toGtkFlowBoxChild(p) } func marshalFlowBoxChild(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapFlowBoxChild(obj), nil } func wrapFlowBoxChild(obj *glib.Object) *FlowBoxChild { if obj == nil { return nil } return &FlowBoxChild{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // FlowBoxChildNew is a wrapper around gtk_flow_box_child_new() func FlowBoxChildNew() (*FlowBoxChild, error) { c := C.gtk_flow_box_child_new() if c == nil { return nil, nilPtrErr } return wrapFlowBoxChild(glib.Take(unsafe.Pointer(c))), nil } // GetIndex is a wrapper around gtk_flow_box_child_get_index() func (fbc *FlowBoxChild) GetIndex() int { c := C.gtk_flow_box_child_get_index(fbc.native()) return int(c) } // IsSelected is a wrapper around gtk_flow_box_child_is_selected() func (fbc *FlowBoxChild) IsSelected() bool { c := C.gtk_flow_box_child_is_selected(fbc.native()) return gobool(c) } // Changed is a wrapper around gtk_flow_box_child_changed() func (fbc *FlowBoxChild) Changed() { C.gtk_flow_box_child_changed(fbc.native()) } /* * GtkPlacesSidebar */ // TODO: // gtk_places_sidebar_get_local_only(). // gtk_places_sidebar_set_local_only(). /* * GtkPopover */ // Popover is a representation of GTK's GtkPopover. type Popover struct { Bin } func (v *Popover) native() *C.GtkPopover { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkPopover(p) } func marshalPopover(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapPopover(glib.Take(unsafe.Pointer(c))), nil } func wrapPopover(obj *glib.Object) *Popover { if obj == nil { return nil } return &Popover{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // PopoverNew is a wrapper around gtk_popover_new(). func PopoverNew(relative IWidget) (*Popover, error) { //Takes relative to widget var c *C.struct__GtkWidget if relative == nil { c = C.gtk_popover_new(nil) } else { c = C.gtk_popover_new(relative.toWidget()) } if c == nil { return nil, nilPtrErr } return wrapPopover(glib.Take(unsafe.Pointer(c))), nil } // PopoverNewFromModel is a wrapper around gtk_popover_new_from_model(). func PopoverNewFromModel(relative IWidget, model *glib.MenuModel) (*Popover, error) { //Takes relative to widget var c *C.struct__GtkWidget mptr := C.toGMenuModel(unsafe.Pointer(model.Native())) if relative == nil { c = C.gtk_popover_new_from_model(nil, mptr) } else { c = C.gtk_popover_new_from_model(relative.toWidget(), mptr) } if c == nil { return nil, nilPtrErr } return wrapPopover(glib.Take(unsafe.Pointer(c))), nil } // BindModel is a wrapper around gtk_popover_bind_model(). func (v *Popover) BindModel(menuModel *glib.MenuModel, actionNamespace string) { cstr := C.CString(actionNamespace) defer C.free(unsafe.Pointer(cstr)) C.gtk_popover_bind_model(v.native(), C.toGMenuModel(unsafe.Pointer(menuModel.Native())), (*C.gchar)(cstr)) } // SetRelativeTo is a wrapper around gtk_popover_set_relative_to(). func (v *Popover) SetRelativeTo(relative IWidget) { C.gtk_popover_set_relative_to(v.native(), relative.toWidget()) } // GetRelativeTo is a wrapper around gtk_popover_get_relative_to(). func (v *Popover) GetRelativeTo() (IWidget, error) { c := C.gtk_popover_get_relative_to(v.native()) if c == nil { return nil, nil } return castWidget(c) } // SetPointingTo is a wrapper around gtk_popover_set_pointing_to(). func (v *Popover) SetPointingTo(rect gdk.Rectangle) { C.gtk_popover_set_pointing_to(v.native(), nativeGdkRectangle(rect)) } // GetPointingTo is a wrapper around gtk_popover_get_pointing_to(). func (v *Popover) GetPointingTo() (*gdk.Rectangle, bool) { var cRect *C.GdkRectangle isSet := C.gtk_popover_get_pointing_to(v.native(), cRect) rect := gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) return rect, gobool(isSet) } // SetPosition is a wrapper around gtk_popover_set_position(). func (v *Popover) SetPosition(position PositionType) { C.gtk_popover_set_position(v.native(), C.GtkPositionType(position)) } // GetPosition is a wrapper around gtk_popover_get_position(). func (v *Popover) GetPosition() PositionType { c := C.gtk_popover_get_position(v.native()) return PositionType(c) } // SetModal is a wrapper around gtk_popover_set_modal(). func (v *Popover) SetModal(modal bool) { C.gtk_popover_set_modal(v.native(), gbool(modal)) } // GetModal is a wrapper around gtk_popover_get_modal(). func (v *Popover) GetModal() bool { return gobool(C.gtk_popover_get_modal(v.native())) } /* * TreePath */ // TreePathNewFromIndicesv is a wrapper around gtk_tree_path_new_from_indicesv(). func TreePathNewFromIndicesv(indices []int) (*TreePath, error) { if len(indices) == 0 { return nil, errors.New("no indice") } var cIndices []C.gint for i := 0; i < len(indices); i++ { cIndices = append(cIndices, C.gint(indices[i])) } var cIndicesPointer *C.gint = &cIndices[0] c := C.gtk_tree_path_new_from_indicesv(cIndicesPointer, C.gsize(len(indices))) if c == nil { return nil, nilPtrErr } t := &TreePath{c} runtime.SetFinalizer(t, func(l *TreePath) { glib.FinalizerStrategy(l.free) }) return t, nil } gotk3-0.6.2/gtk/gtk_since_3_12.go.h000066400000000000000000000022251431157473000166100ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ static GtkFlowBox *toGtkFlowBox(void *p) { return (GTK_FLOW_BOX(p)); } static GtkFlowBoxChild *toGtkFlowBoxChild(void *p) { return (GTK_FLOW_BOX_CHILD(p)); } static GMenuModel *toGMenuModel(void *p) { return (G_MENU_MODEL(p)); } static GtkPopover *toGtkPopover(void *p) { return (GTK_POPOVER(p)); } gotk3-0.6.2/gtk/gtk_since_3_14.go000066400000000000000000000067711431157473000163760ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12 package gtk // #include // #include // #include "gtk_since_3_14.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/internal/callback" "github.com/gotk3/gotk3/glib" ) /* * Constants */ const ( STATE_FLAG_CHECKED StateFlags = C.GTK_STATE_FLAG_CHECKED ) // IconLookupFlags is a representation of GTK's GtkIconLookupFlags. const ( ICON_LOOKUP_FORCE_REGULAR IconLookupFlags = C.GTK_ICON_LOOKUP_FORCE_REGULAR ICON_LOOKUP_FORCE_SYMBOLIC = C.GTK_ICON_LOOKUP_FORCE_SYMBOLIC ICON_LOOKUP_DIR_LTR = C.GTK_ICON_LOOKUP_DIR_LTR ICON_LOOKUP_DIR_RTL = C.GTK_ICON_LOOKUP_DIR_RTL ) /* * GtkStack */ const ( STACK_TRANSITION_TYPE_OVER_DOWN_UP StackTransitionType = C.GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT = C.GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT = C.GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT ) /* * GtkListBox */ // UnselectRow is a wrapper around gtk_list_box_unselect_row(). func (v *ListBox) UnselectRow(row *ListBoxRow) { C.gtk_list_box_unselect_row(v.native(), row.native()) } // SelectAll is a wrapper around gtk_list_box_select_all(). func (v *ListBox) SelectAll() { C.gtk_list_box_select_all(v.native()) } // UnselectAll is a wrapper around gtk_list_box_unselect_all(). func (v *ListBox) UnselectAll() { C.gtk_list_box_unselect_all(v.native()) } // ListBoxForeachFunc is a representation of GtkListBoxForeachFunc type ListBoxForeachFunc func(box *ListBox, row *ListBoxRow) int // SelectedForeach is a wrapper around gtk_list_box_selected_foreach(). func (v *ListBox) SelectedForeach(fn ListBoxForeachFunc) { id := callback.Assign(fn) defer callback.Delete(id) C._gtk_list_box_selected_foreach(v.native(), C.gpointer(id)) } // GetSelectedRows is a wrapper around gtk_list_box_get_selected_rows(). func (v *ListBox) GetSelectedRows() *glib.List { clist := C.gtk_list_box_get_selected_rows(v.native()) if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return wrapListBoxRow(glib.Take(ptr)) }) return glist } /* * GtkListBoxRow */ // IsSelected is a wrapper around gtk_list_box_row_is_selected(). func (v *ListBoxRow) IsSelected() bool { c := C.gtk_list_box_row_is_selected(v.native()) return gobool(c) } // SetActivatable is a wrapper around gtk_list_box_row_set_activatable(). func (v *ListBoxRow) SetActivatable(activatable bool) { C.gtk_list_box_row_set_activatable(v.native(), gbool(activatable)) } // GetActivatable is a wrapper around gtk_list_box_row_get_activatable(). func (v *ListBoxRow) GetActivatable() bool { c := C.gtk_list_box_row_get_activatable(v.native()) return gobool(c) } // SetSelectable is a wrapper around gtk_list_box_row_set_selectable(). func (v *ListBoxRow) SetSelectable(selectable bool) { C.gtk_list_box_row_set_selectable(v.native(), gbool(selectable)) } // GetSelectable is a wrapper around gtk_list_box_row_get_selectable(). func (v *ListBoxRow) GetSelectable() bool { c := C.gtk_list_box_row_get_selectable(v.native()) return gobool(c) } /* * GtkPlacesSidebar */ // TODO: // gtk_places_sidebar_get_show_enter_location(). // gtk_places_sidebar_set_show_enter_location(). /* * GtkSwitch */ // TODO: // gtk_switch_set_state(). // gtk_switch_get_state(). gotk3-0.6.2/gtk/gtk_since_3_14.go.h000066400000000000000000000006741431157473000166200ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project extern void goListBoxForEachFuncs(GtkListBox *box, GtkListBoxRow *row, gpointer user_data); static inline void _gtk_list_box_selected_foreach(GtkListBox *box, gpointer user_data) { gtk_list_box_selected_foreach( box, (GtkListBoxForeachFunc)(goListBoxForEachFuncs), user_data); } gotk3-0.6.2/gtk/gtk_since_3_16.go000066400000000000000000000223321431157473000163670ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14 // See: https://developer.gnome.org/gtk3/3.16/api-index-3-16.html package gtk // #include // #include "gtk_since_3_16.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) const ( POLICY_EXTERNAL PolicyType = C.GTK_POLICY_EXTERNAL ) func init() { tm := []glib.TypeMarshaler{ // Objects/Interfaces {glib.Type(C.gtk_button_role_get_type()), marshalButtonRole}, {glib.Type(C.gtk_popover_menu_get_type()), marshalPopoverMenu}, {glib.Type(C.gtk_model_button_get_type()), marshalModelButton}, {glib.Type(C.gtk_stack_sidebar_get_type()), marshalStackSidebar}, {glib.Type(C.gtk_text_extend_selection_get_type()), marshalTextExtendSelection}, } glib.RegisterGValueMarshalers(tm) //Contribute to casting for k, v := range map[string]WrapFn{ "GtkPopoverMenu": wrapPopoverMenu, "GtkModelButton": wrapModelButton, "GtkStackSidebar": wrapStackSidebar, } { WrapMap[k] = v } } /* * Constants */ // ButtonRole is a representation of GTK's GtkButtonRole. type ButtonRole int const ( BUTTON_ROLE_NORMAL ButtonRole = C.GTK_BUTTON_ROLE_NORMAL BUTTON_ROLE_CHECK ButtonRole = C.GTK_BUTTON_ROLE_CHECK BUTTON_ROLE_RADIO ButtonRole = C.GTK_BUTTON_ROLE_RADIO ) func marshalButtonRole(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return ButtonRole(c), nil } /* * TextView */ // TextExtendSelection is a representation of GTK's GtkTextExtendSelection. type TextExtendSelection int const ( TEXT_EXTEND_SELECTION_WORD TextExtendSelection = C.GTK_TEXT_EXTEND_SELECTION_WORD TEXT_EXTEND_SELECTION_LINE TextExtendSelection = C.GTK_TEXT_EXTEND_SELECTION_LINE ) func marshalTextExtendSelection(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return TextExtendSelection(c), nil } /* * GtkStack */ // SetHHomogeneous is a wrapper around gtk_stack_set_hhomogeneous(). func (v *Stack) SetHHomogeneous(hhomogeneous bool) { C.gtk_stack_set_hhomogeneous(v.native(), gbool(hhomogeneous)) } // GetHHomogeneous is a wrapper around gtk_stack_get_hhomogeneous(). func (v *Stack) GetHHomogeneous() bool { return gobool(C.gtk_stack_get_hhomogeneous(v.native())) } // SetVHomogeneous is a wrapper around gtk_stack_set_vhomogeneous(). func (v *Stack) SetVHomogeneous(vhomogeneous bool) { C.gtk_stack_set_vhomogeneous(v.native(), gbool(vhomogeneous)) } // GetVHomogeneous is a wrapper around gtk_stack_get_vhomogeneous(). func (v *Stack) GetVHomogeneous() bool { return gobool(C.gtk_stack_get_vhomogeneous(v.native())) } /* * GtkNotebook */ // DetachTab is a wrapper around gtk_notebook_detach_tab(). func (v *Notebook) DetachTab(child IWidget) { C.gtk_notebook_detach_tab(v.native(), child.toWidget()) } /* * GtkListBox */ // ListBoxCreateWidgetFunc is a representation of GtkListBoxCreateWidgetFunc. type ListBoxCreateWidgetFunc func(item interface{}) int /* * GtkScrolledWindow */ // SetOverlayScrolling is a wrapper around gtk_scrolled_window_set_overlay_scrolling(). func (v *ScrolledWindow) SetOverlayScrolling(scrolling bool) { C.gtk_scrolled_window_set_overlay_scrolling(v.native(), gbool(scrolling)) } // GetOverlayScrolling is a wrapper around gtk_scrolled_window_get_overlay_scrolling(). func (v *ScrolledWindow) GetOverlayScrolling() bool { return gobool(C.gtk_scrolled_window_get_overlay_scrolling(v.native())) } /* * GtkPaned */ // SetWideHandle is a wrapper around gtk_paned_set_wide_handle(). func (v *Paned) SetWideHandle(wide bool) { C.gtk_paned_set_wide_handle(v.native(), gbool(wide)) } // GetWideHandle is a wrapper around gtk_paned_get_wide_handle(). func (v *Paned) GetWideHandle() bool { return gobool(C.gtk_paned_get_wide_handle(v.native())) } /* * GtkLabel */ // GetXAlign is a wrapper around gtk_label_get_xalign(). func (v *Label) GetXAlign() float64 { c := C.gtk_label_get_xalign(v.native()) return float64(c) } // GetYAlign is a wrapper around gtk_label_get_yalign(). func (v *Label) GetYAlign() float64 { c := C.gtk_label_get_yalign(v.native()) return float64(c) } // SetXAlign is a wrapper around gtk_label_set_xalign(). func (v *Label) SetXAlign(n float64) { C.gtk_label_set_xalign(v.native(), C.gfloat(n)) } // SetYAlign is a wrapper around gtk_label_set_yalign(). func (v *Label) SetYAlign(n float64) { C.gtk_label_set_yalign(v.native(), C.gfloat(n)) } /* * GtkModelButton */ // ModelButton is a representation of GTK's GtkModelButton. type ModelButton struct { Button } func (v *ModelButton) native() *C.GtkModelButton { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkModelButton(p) } func marshalModelButton(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapModelButton(glib.Take(unsafe.Pointer(c))), nil } func wrapModelButton(obj *glib.Object) *ModelButton { if obj == nil { return nil } actionable := wrapActionable(obj) return &ModelButton{Button{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}, actionable}} } // ModelButtonNew is a wrapper around gtk_model_button_new func ModelButtonNew() (*ModelButton, error) { c := C.gtk_model_button_new() if c == nil { return nil, nilPtrErr } return wrapModelButton(glib.Take(unsafe.Pointer(c))), nil } /* * GtkPopoverMenu */ // PopoverMenu is a representation of GTK's GtkPopoverMenu. type PopoverMenu struct { Popover } func (v *PopoverMenu) native() *C.GtkPopoverMenu { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkPopoverMenu(p) } func marshalPopoverMenu(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapPopoverMenu(glib.Take(unsafe.Pointer(c))), nil } func wrapPopoverMenu(obj *glib.Object) *PopoverMenu { if obj == nil { return nil } return &PopoverMenu{Popover{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} } // PopoverMenuNew is a wrapper around gtk_popover_menu_new func PopoverMenuNew() (*PopoverMenu, error) { c := C.gtk_popover_menu_new() if c == nil { return nil, nilPtrErr } return wrapPopoverMenu(glib.Take(unsafe.Pointer(c))), nil } // OpenSubmenu is a wrapper around gtk_popover_menu_open_submenu func (v *PopoverMenu) OpenSubmenu(name string) { cstr1 := (*C.gchar)(C.CString(name)) defer C.free(unsafe.Pointer(cstr1)) C.gtk_popover_menu_open_submenu(v.native(), cstr1) } /* * GtkStackSidebar */ // StackSidebar is a representation of GTK's GtkStackSidebar. type StackSidebar struct { Bin } // native returns a pointer to the underlying GtkStack. func (v *StackSidebar) native() *C.GtkStackSidebar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkStackSidebar(p) } func marshalStackSidebar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapStackSidebar(obj), nil } func wrapStackSidebar(obj *glib.Object) *StackSidebar { if obj == nil { return nil } return &StackSidebar{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // StackSidebarNew is a wrapper around gtk_stack_sidebar_new(). func StackSidebarNew() (*StackSidebar, error) { c := C.gtk_stack_sidebar_new() if c == nil { return nil, nilPtrErr } return wrapStackSidebar(glib.Take(unsafe.Pointer(c))), nil } // SetStack is a wrapper around gtk_stack_sidebar_set_stack(). func (v *StackSidebar) SetStack(stack *Stack) { C.gtk_stack_sidebar_set_stack(v.native(), stack.native()) } // GetStack is a wrapper around gtk_stack_sidebar_get_stack(). func (v *StackSidebar) GetStack() *Stack { c := C.gtk_stack_sidebar_get_stack(v.native()) if c == nil { return nil } return wrapStack(glib.Take(unsafe.Pointer(c))) } /* * GtkEntry */ // GrabFocusWithoutSelecting is a wrapper for gtk_entry_grab_focus_without_selecting() func (v *Entry) GrabFocusWithoutSelecting() { C.gtk_entry_grab_focus_without_selecting(v.native()) } /* * GtkSearchEntry */ // HandleEvent is a wrapper around gtk_search_entry_handle_event(). func (v *SearchEntry) HandleEvent(event *gdk.Event) { e := (*C.GdkEvent)(unsafe.Pointer(event.Native())) C.gtk_search_entry_handle_event(v.native(), e) } /* * GtkTextBuffer */ // InsertMarkup is a wrapper around gtk_text_buffer_insert_markup() func (v *TextBuffer) InsertMarkup(start *TextIter, text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_text_buffer_insert_markup(v.native(), (*C.GtkTextIter)(start), (*C.gchar)(cstr), C.gint(len(text))) } /* * CssProvider */ // LoadFromResource is a wrapper around gtk_css_provider_load_from_resource(). // // See: https://developer.gnome.org/gtk3/stable/GtkCssProvider.html#gtk-css-provider-load-from-resource func (v *CssProvider) LoadFromResource(path string) { cpath := C.CString(path) defer C.free(unsafe.Pointer(cpath)) C.gtk_css_provider_load_from_resource(v.native(), (*C.gchar)(cpath)) } /* * GtkTextView */ // SetMonospace is a wrapper around gtk_text_view_set_monospace() func (v *TextView) SetMonospace(monospace bool) { C.gtk_text_view_set_monospace(v.native(), gbool(monospace)) } // GetMonospace is a wrapper around gtk_text_view_get_monospace() func (v *TextView) GetMonospace() bool { return gobool(C.gtk_text_view_get_monospace(v.native())) } gotk3-0.6.2/gtk/gtk_since_3_16.go.h000066400000000000000000000033151431157473000166150ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #pragma once #include "gtk.go.h" #include // for gotk3_callbackDelete static GListModel *toGListModel(void *p) { return (G_LIST_MODEL(p)); } static GtkModelButton *toGtkModelButton(void *mb) { return (GTK_MODEL_BUTTON(mb)); } static GtkPopoverMenu *toGtkPopoverMenu(void *p) { return (GTK_POPOVER_MENU(p)); } static GtkStackSidebar *toGtkStackSidebar(void *p) { return (GTK_STACK_SIDEBAR(p)); } static GtkGLArea *toGtkGLArea(void *p) { return (GTK_GL_AREA(p)); } extern void goListBoxCreateWidgetFuncs(gpointer item, gpointer user_data); static inline void _gtk_list_box_bind_model(GtkListBox *box, GListModel *model, gpointer user_data) { gtk_list_box_bind_model( box, model, (GtkListBoxCreateWidgetFunc)(goListBoxCreateWidgetFuncs), user_data, (GDestroyNotify)(gotk3_callbackDelete)); } gotk3-0.6.2/gtk/gtk_since_3_16_deprecated_since_3_20.go000066400000000000000000000013141431157473000224500ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project. // This file is normally only compiled for GTK 3.16 and 3.18. // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,gtk_deprecated gtk_3_16 gtk_3_18 package gtk // #include import "C" /* * GtkPopover */ // SetTransitionsEnabled is a wrapper gtk_popover_set_transitions_enabled(). func (v *Popover) SetTransitionsEnabled(transitionsEnabled bool) { C.gtk_popover_set_transitions_enabled(v.native(), gbool(transitionsEnabled)) } // GetTransitionsEnabled is a wrapper gtk_popover_get_transitions_enabled(). func (v *Popover) GetTransitionsEnabled() bool { return gobool(C.gtk_popover_get_transitions_enabled(v.native())) } gotk3-0.6.2/gtk/gtk_since_3_16_glib_2_44.go000066400000000000000000000013321431157473000201110ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // The code in this file is only for GTK+ version 3.16+, as well as Glib version 2.44+ // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!glib_2_40,!glib_2_42 package gtk // #include // #include "gtk_since_3_16.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/internal/callback" "github.com/gotk3/gotk3/glib" ) // BindModel is a wrapper around gtk_list_box_bind_model(). func (v *ListBox) BindModel(listModel *glib.ListModel, createWidgetFunc ListBoxCreateWidgetFunc) { C._gtk_list_box_bind_model( v.native(), C.toGListModel(unsafe.Pointer(listModel.Native())), C.gpointer(callback.Assign(createWidgetFunc)), ) } gotk3-0.6.2/gtk/gtk_since_3_18.go000066400000000000000000000055721431157473000164000ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16 // See: https://developer.gnome.org/gtk3/3.18/api-index-3-18.html // For gtk_overlay_reorder_overlay(): // See: https://git.gnome.org/browse/gtk+/tree/gtk/gtkoverlay.h?h=gtk-3-18 package gtk // #include import "C" /* * GtkStack */ // TODO: // gtk_stack_get_interpolate_size(). // gtk_stack_set_interpolate_size(). /* * GtkRadioMenuItem */ // JoinGroup is a wrapper around gtk_radio_menu_item_join_group(). func (v *RadioMenuItem) JoinGroup(group_source *RadioMenuItem) { C.gtk_radio_menu_item_join_group(v.native(), group_source.native()) } /* * GtkOverlay */ // ReorderOverlay() is a wrapper around gtk_overlay_reorder_overlay(). func (v *Overlay) ReorderOverlay(child IWidget, position int) { C.gtk_overlay_reorder_overlay(v.native(), child.toWidget(), C.int(position)) } // GetOverlayPassThrough() is a wrapper around gtk_overlay_get_overlay_pass_through(). func (v *Overlay) GetOverlayPassThrough(widget IWidget) bool { c := C.gtk_overlay_get_overlay_pass_through(v.native(), widget.toWidget()) return gobool(c) } // SetOverlayPassThrough() is a wrapper around gtk_overlay_set_overlay_pass_through(). func (v *Overlay) SetOverlayPassThrough(widget IWidget, passThrough bool) { C.gtk_overlay_set_overlay_pass_through(v.native(), widget.toWidget(), gbool(passThrough)) } /* * GtkPlacesSidebar */ // TODO: // gtk_places_sidebar_set_show_recent(). // gtk_places_sidebar_get_show_recent(). // gtk_places_sidebar_get_show_trash(). // gtk_places_sidebar_set_show_trash(). // gtk_places_sidebar_get_show_other_locations(). // gtk_places_sidebar_set_show_other_locations(). // gtk_places_sidebar_set_drop_targets_visible(). /* * GtkPopover */ // SetDefaultWidget is a wrapper around gtk_popover_set_default_widget(). func (p *Popover) SetDefaultWidget(widget IWidget) { C.gtk_popover_set_default_widget(p.native(), widget.toWidget()) } // GetDefaultWidget is a wrapper around gtk_popover_get_default_widget(). func (p *Popover) GetDefaultWidget() (IWidget, error) { w := C.gtk_popover_get_default_widget(p.native()) if w == nil { return nil, nil } return castWidget(w) } /* * GtkTextView */ // SetTopMargin is a wrapper around gtk_text_view_set_top_margin(). func (v *TextView) SetTopMargin(topMargin int) { C.gtk_text_view_set_top_margin(v.native(), C.gint(topMargin)) } // GetTopMargin is a wrapper around gtk_text_view_get_top_margin(). func (v *TextView) GetTopMargin() int { return int(C.gtk_text_view_get_top_margin(v.native())) } // SetBottomMargin is a wrapper around gtk_text_view_set_bottom_margin(). func (v *TextView) SetBottomMargin(bottomMargin int) { C.gtk_text_view_set_bottom_margin(v.native(), C.gint(bottomMargin)) } // GetBottomMargin is a wrapper around gtk_text_view_get_bottom_margin(). func (v *TextView) GetBottomMargin() int { return int(C.gtk_text_view_get_bottom_margin(v.native())) } gotk3-0.6.2/gtk/gtk_since_3_20.go000066400000000000000000000165201431157473000163640ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18 // See: https://developer.gnome.org/gtk3/3.20/api-index-3-20.html package gtk // #include // #include "gtk_since_3_20.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.gtk_popover_constraint_get_type()), marshalPopoverConstraint}, } glib.RegisterGValueMarshalers(tm) } /* * Constants */ // PopoverConstraint is a representation of GTK's GtkPopoverConstraint. type PopoverConstraint int const ( POPOVER_CONSTRAINT_NONE PopoverConstraint = C.GTK_POPOVER_CONSTRAINT_NONE POPOVER_CONSTRAINT_WINDOW PopoverConstraint = C.GTK_POPOVER_CONSTRAINT_WINDOW ) func marshalPopoverConstraint(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PopoverConstraint(c), nil } const ( STATE_FLAG_DROP_ACTIVE StateFlags = C.GTK_STATE_FLAG_DROP_ACTIVE ) /* * GtkNativeDialog */ // NativeDialog is a representation of GTK's GtkNativeDialog. type NativeDialog struct { glib.InitiallyUnowned } // native returns a pointer to the underlying GObject as a GtkNativeDialog. func (v *NativeDialog) native() *C.GtkNativeDialog { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkNativeDialog(p) } func wrapNativeDialog(obj *glib.Object) *NativeDialog { if obj == nil { return nil } return &NativeDialog{glib.InitiallyUnowned{obj}} } // Run() is a wrapper around gtk_native_dialog_run(). func (v *NativeDialog) Run() int { c := C.gtk_native_dialog_run(v.native()) return int(c) } // Destroy() is a wrapper around gtk_native_dialog_destroy(). func (v *NativeDialog) Destroy() { C.gtk_native_dialog_destroy(v.native()) } // SetModal is a wrapper around gtk_native_dialog_set_modal(). func (v *NativeDialog) SetModal(modal bool) { C.gtk_native_dialog_set_modal(v.native(), gbool(modal)) } // GetModal is a wrapper around gtk_native_dialog_get_modal(). func (v *NativeDialog) GetModal() bool { c := C.gtk_native_dialog_get_modal(v.native()) return gobool(c) } // SetTitle is a wrapper around gtk_native_dialog_set_title(). func (v *NativeDialog) SetTitle(title string) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) C.gtk_native_dialog_set_title(v.native(), (*C.char)(cstr)) } // GetTitle is a wrapper around gtk_native_dialog_get_title(). func (v *NativeDialog) GetTitle() (string, error) { return stringReturn((*C.gchar)(C.gtk_native_dialog_get_title(v.native()))) } // SetTransientFor is a wrapper around gtk_native_dialog_set_transient_for(). func (v *NativeDialog) SetTransientFor(parent IWindow) { var pw *C.GtkWindow = nil if parent != nil { pw = parent.toWindow() } C.gtk_native_dialog_set_transient_for(v.native(), pw) } // GetTransientFor is a wrapper around gtk_native_dialog_get_transient_for(). func (v *NativeDialog) GetTransientFor() (*Window, error) { c := C.gtk_native_dialog_get_transient_for(v.native()) if c == nil { return nil, nilPtrErr } return wrapWindow(glib.Take(unsafe.Pointer(c))), nil } // GetVisible() is a wrapper around gtk_native_dialog_get_visible(). func (v *NativeDialog) GetVisible() bool { c := C.gtk_native_dialog_get_visible(v.native()) return gobool(c) } // Show() is a wrapper around gtk_native_dialog_show(). func (v *NativeDialog) Show() { C.gtk_native_dialog_show(v.native()) } // Hide() is a wrapper around gtk_native_dialog_hide(). func (v *NativeDialog) Hide() { C.gtk_native_dialog_hide(v.native()) } /* * GtkFileChooserNative */ // FileChooserNativeDialog is a representation of GTK's GtkFileChooserNative. type FileChooserNativeDialog struct { NativeDialog // Interfaces FileChooser } // native returns a pointer to the underlying GObject as a GtkNativeDialog. func (v *FileChooserNativeDialog) native() *C.GtkFileChooserNative { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkFileChooserNative(p) } func wrapFileChooserNativeDialog(obj *glib.Object) *FileChooserNativeDialog { if obj == nil { return nil } fc := wrapFileChooser(obj) return &FileChooserNativeDialog{NativeDialog{glib.InitiallyUnowned{obj}}, *fc} } // FileChooserNativeDialogNew is a wrapper around gtk_file_chooser_native_new(). func FileChooserNativeDialogNew(title string, parent IWindow, action FileChooserAction, accept_label string, cancel_label string) (*FileChooserNativeDialog, error) { c_title := C.CString(title) defer C.free(unsafe.Pointer(c_title)) c_accept_label := C.CString(accept_label) defer C.free(unsafe.Pointer(c_accept_label)) c_cancel_label := C.CString(cancel_label) defer C.free(unsafe.Pointer(c_cancel_label)) var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } c := C.gtk_file_chooser_native_new( (*C.gchar)(c_title), w, C.GtkFileChooserAction(action), (*C.gchar)(c_accept_label), (*C.gchar)(c_cancel_label)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapFileChooserNativeDialog(obj), nil } /* * FileChooserNative */ func OpenFileChooserNative(title string, parent IWindow) *string { c_title := C.CString(title) var native *C.GtkFileChooserNative var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } native = C.gtk_file_chooser_native_new((*C.gchar)(c_title), w, C.GtkFileChooserAction(FILE_CHOOSER_ACTION_OPEN), (*C.gchar)(C.CString("_Open")), (*C.gchar)(C.CString("_Cancel"))) p := unsafe.Pointer(unsafe.Pointer(native)) dlg := C.toGtkNativeDialog(p) res := C.gtk_native_dialog_run(dlg) if res == C.GTK_RESPONSE_ACCEPT { c := C.gtk_file_chooser_get_filename(C.toGtkFileChooser(p)) s := goString(c) defer C.g_free((C.gpointer)(c)) return &s } return nil } // SetAcceptLabel is a wrapper around gtk_file_chooser_native_set_accept_label(). func (v *FileChooserNativeDialog) SetAcceptLabel(accept_label string) { cstr := C.CString(accept_label) defer C.free(unsafe.Pointer(cstr)) C.gtk_file_chooser_native_set_accept_label(v.native(), (*C.char)(cstr)) } // GetAcceptLabel is a wrapper around gtk_file_chooser_native_get_accept_label(). func (v *FileChooserNativeDialog) GetAcceptLabel() (string, error) { return stringReturn((*C.gchar)(C.gtk_file_chooser_native_get_accept_label(v.native()))) } // SetCancelLabel is a wrapper around gtk_file_chooser_native_set_cancel_label(). func (v *FileChooserNativeDialog) SetCancelLabel(cancel_label string) { cstr := C.CString(cancel_label) defer C.free(unsafe.Pointer(cstr)) C.gtk_file_chooser_native_set_cancel_label(v.native(), (*C.char)(cstr)) } // GetCancelLabel is a wrapper around gtk_file_chooser_native_get_cancel_label(). func (v *FileChooserNativeDialog) GetCancelLabel() (string, error) { return stringReturn((*C.gchar)(C.gtk_file_chooser_native_get_cancel_label(v.native()))) } /* * GtkTextView */ // TODO: // gtk_text_view_reset_cursor_blink(). /* * GtkExpander */ // TODO: // gtk_expander_set_spacing(). // gtk_expander_get_spacing(). /* * GtkPopover */ // SetConstrainTo is a wrapper gtk_popover_set_constrain_to(). func (v *Popover) SetConstrainTo(constrain PopoverConstraint) { C.gtk_popover_set_constrain_to(v.native(), C.GtkPopoverConstraint(constrain)) } // GetConstrainTo is a wrapper gtk_popover_get_constrain_to(). func (v *Popover) GetConstrainTo() PopoverConstraint { return PopoverConstraint(C.gtk_popover_get_constrain_to(v.native())) } gotk3-0.6.2/gtk/gtk_since_3_20.go.h000066400000000000000000000022371431157473000166120ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #pragma once #include static GtkFileChooser *toGtkFileChooser(void *p) { return (GTK_FILE_CHOOSER(p)); } static GtkFileChooserNative *toGtkFileChooserNative(void *p) { return (GTK_FILE_CHOOSER_NATIVE(p)); } static GtkNativeDialog *toGtkNativeDialog(void *p) { return (GTK_NATIVE_DIALOG(p)); } gotk3-0.6.2/gtk/gtk_since_3_22.go000066400000000000000000000103711431157473000163640ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18,!gtk_3_20 // See: https://developer.gnome.org/gtk3/3.22/api-index-3-22.html package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" ) // Popup is a wrapper around gtk_popover_popup(). func (v *Popover) Popup() { C.gtk_popover_popup(v.native()) } // Popdown is a wrapper around gtk_popover_popdown(). func (v *Popover) Popdown() { C.gtk_popover_popdown(v.native()) } /* * GtkFileChooser */ // AddChoice is a wrapper around gtk_file_chooser_add_choice(). func (v *FileChooser) AddChoice(id, label string, options, optionLabels []string) { cId := C.CString(id) defer C.free(unsafe.Pointer(cId)) cLabel := C.CString(label) defer C.free(unsafe.Pointer(cLabel)) if options == nil || optionLabels == nil { C.gtk_file_chooser_add_choice(v.native(), (*C.gchar)(cId), (*C.gchar)(cLabel), nil, nil) return } cOptions := C.make_strings(C.int(len(options) + 1)) for i, option := range options { cstr := C.CString(option) defer C.free(unsafe.Pointer(cstr)) C.set_string(cOptions, C.int(i), (*C.gchar)(cstr)) } C.set_string(cOptions, C.int(len(options)), nil) cOptionLabels := C.make_strings(C.int(len(optionLabels) + 1)) for i, optionLabel := range optionLabels { cstr := C.CString(optionLabel) defer C.free(unsafe.Pointer(cstr)) C.set_string(cOptionLabels, C.int(i), (*C.gchar)(cstr)) } C.set_string(cOptionLabels, C.int(len(optionLabels)), nil) C.gtk_file_chooser_add_choice(v.native(), (*C.gchar)(cId), (*C.gchar)(cLabel), cOptions, cOptionLabels) } // RemoveChoice is a wrapper around gtk_file_chooser_remove_choice(). func (v *FileChooser) RemoveChoice(id string) { cId := C.CString(id) defer C.free(unsafe.Pointer(cId)) C.gtk_file_chooser_remove_choice(v.native(), (*C.gchar)(cId)) } // SetChoice is a wrapper around gtk_file_chooser_set_choice(). func (v *FileChooser) SetChoice(id, option string) { cId := C.CString(id) defer C.free(unsafe.Pointer(cId)) cOption := C.CString(option) defer C.free(unsafe.Pointer(cOption)) C.gtk_file_chooser_set_choice(v.native(), (*C.gchar)(cId), (*C.gchar)(cOption)) } // GetChoice is a wrapper around gtk_file_chooser_get_choice(). func (v *FileChooser) GetChoice(id string) string { cId := C.CString(id) defer C.free(unsafe.Pointer(cId)) c := C.gtk_file_chooser_get_choice(v.native(), (*C.gchar)(cId)) return C.GoString(c) } /* * GtkScrolledWindow */ // GetMaxContentWidth is a wrapper around gtk_scrolled_window_get_max_content_width(). func (v *ScrolledWindow) GetMaxContentWidth() int { c := C.gtk_scrolled_window_get_max_content_width(v.native()) return int(c) } // SetMaxContentWidth is a wrapper around gtk_scrolled_window_set_max_content_width(). func (v *ScrolledWindow) SetMaxContentWidth(width int) { C.gtk_scrolled_window_set_max_content_width(v.native(), C.gint(width)) } // GetMaxContentHeight is a wrapper around gtk_scrolled_window_get_max_content_height(). func (v *ScrolledWindow) GetMaxContentHeight() int { c := C.gtk_scrolled_window_get_max_content_height(v.native()) return int(c) } // SetMaxContentHeight is a wrapper around gtk_scrolled_window_set_max_content_height(). func (v *ScrolledWindow) SetMaxContentHeight(width int) { C.gtk_scrolled_window_set_max_content_height(v.native(), C.gint(width)) } // GetPropagateNaturalWidth is a wrapper around gtk_scrolled_window_get_propagate_natural_width(). func (v *ScrolledWindow) GetPropagateNaturalWidth() bool { c := C.gtk_scrolled_window_get_propagate_natural_width(v.native()) return gobool(c) } // SetPropagateNaturalWidth is a wrapper around gtk_scrolled_window_set_propagate_natural_width(). func (v *ScrolledWindow) SetPropagateNaturalWidth(propagate bool) { C.gtk_scrolled_window_set_propagate_natural_width(v.native(), gbool(propagate)) } // GetPropagateNaturalHeight is a wrapper around gtk_scrolled_window_get_propagate_natural_height(). func (v *ScrolledWindow) GetPropagateNaturalHeight() bool { c := C.gtk_scrolled_window_get_propagate_natural_height(v.native()) return gobool(c) } // SetPropagateNaturalHeight is a wrapper around gtk_scrolled_window_set_propagate_natural_height(). func (v *ScrolledWindow) SetPropagateNaturalHeight(propagate bool) { C.gtk_scrolled_window_set_propagate_natural_height(v.native(), gbool(propagate)) } gotk3-0.6.2/gtk/gtk_since_3_24.go000066400000000000000000000003751431157473000163710ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18,!gtk_3_20,!gtk_3_22 package gtk // #include import "C" /* * GtkInputPurpose */ const ( INPUT_PURPOSE_TERMINAL InputPurpose = C.GTK_INPUT_PURPOSE_TERMINAL ) gotk3-0.6.2/gtk/gtk_since_3_8.go000066400000000000000000000025621431157473000163130ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // This file includes wrapers for symbols included since GTK 3.8, and // and should not be included in a build intended to target any older GTK // versions. To target an older build, such as 3.8, use // 'go build -tags gtk_3_8'. Otherwise, if no build tags are used, GTK 3.18 // is assumed and this file is built. // +build !gtk_3_6 package gtk // #include import "C" /* * Constants */ const ( STATE_FLAG_DIR_LTR StateFlags = C.GTK_STATE_FLAG_DIR_LTR STATE_FLAG_DIR_RTL StateFlags = C.GTK_STATE_FLAG_DIR_RTL ) gotk3-0.6.2/gtk/gtk_test.go000066400000000000000000000525731431157473000155270ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package gtk import ( "fmt" "log" "runtime" "testing" "time" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) func init() { Init(nil) } // TestConnectNotifySignal ensures that property notification signals (those // whose name begins with "notify::") are queried by the name "notify" (with the // "::" and the property name omitted). This is because the signal is "notify" // and the characters after the "::" are not recognized by the signal system. // // See // https://developer.gnome.org/gobject/stable/gobject-The-Base-Object-Type.html#GObject-notify // for background, and // https://developer.gnome.org/gobject/stable/gobject-Signals.html#g-signal-new // for the specification of valid signal names. func TestConnectNotifySignal(t *testing.T) { runtime.LockOSThread() // Create any GObject that has defined properties. spacing := 0 box, _ := BoxNew(ORIENTATION_HORIZONTAL, spacing) // Connect to a "notify::" signal to listen on property changes. box.Connect("notify::spacing", func() { MainQuit() }) glib.IdleAdd(func() bool { spacing++ box.SetSpacing(spacing) return true }) Main() } // TestBoolConvs tests the conversion between Go bools and gboolean // types. func TestBoolConvs(t *testing.T) { if err := testBoolConvs(); err != nil { t.Error(err) } } // TestBox tests creating and adding widgets to a Box func TestBox(t *testing.T) { vbox, err := BoxNew(ORIENTATION_VERTICAL, 0) if err != nil { t.Error("Unable to create box") } vbox.Set("homogeneous", true) if vbox.GetHomogeneous() != true { t.Error("Could not set or get Box homogeneous property") } vbox.SetHomogeneous(false) if vbox.GetHomogeneous() != false { t.Error("Could not set or get Box homogeneous property") } vbox.Set("spacing", 1) if vbox.GetSpacing() != 1 { t.Error("Could not set or get Box spacing") } vbox.SetSpacing(2) if vbox.GetSpacing() != 2 { t.Error("Could not set or get Box spacing") } // add a child to start and end start, err := LabelNew("Start") if err != nil { t.Error("Unable to create label") } end, err := LabelNew("End") if err != nil { t.Error("Unable to create label") } vbox.PackStart(start, true, true, 3) vbox.PackEnd(end, true, true, 3) } func TestTextBuffer_WhenSetText_ExpectGetTextReturnsSame(t *testing.T) { buffer, err := TextBufferNew(nil) if err != nil { t.Error("Unable to create text buffer") } expected := "Hello, World!" buffer.SetText(expected) start, end := buffer.GetBounds() actual, err := buffer.GetText(start, end, true) if err != nil { t.Error("Unable to get text from buffer") } if actual != expected { t.Errorf("Expected '%s'; Got '%s'", expected, actual) } } func testTextViewEditable(set bool) error { tv, err := TextViewNew() if err != nil { return err } exp := set tv.SetEditable(exp) act := tv.GetEditable() if exp != act { return fmt.Errorf("Expected GetEditable(): %v; Got: %v", exp, act) } return nil } func TestTextView_WhenSetEditableFalse_ExpectGetEditableReturnsFalse(t *testing.T) { if err := testTextViewEditable(false); err != nil { t.Error(err) } } func TestTextView_WhenSetEditableTrue_ExpectGetEditableReturnsTrue(t *testing.T) { if err := testTextViewEditable(true); err != nil { t.Error(err) } } func testTextViewWrapMode(set WrapMode) error { tv, err := TextViewNew() if err != nil { return err } exp := set tv.SetWrapMode(set) act := tv.GetWrapMode() if act != exp { return fmt.Errorf("Expected GetWrapMode(): %v; Got: %v", exp, act) } return nil } func TestTextView_WhenSetWrapModeNone_ExpectGetWrapModeReturnsNone(t *testing.T) { if err := testTextViewWrapMode(WRAP_NONE); err != nil { t.Error(err) } } func TestTextView_WhenSetWrapModeWord_ExpectGetWrapModeReturnsWord(t *testing.T) { if err := testTextViewWrapMode(WRAP_WORD); err != nil { t.Error(err) } } func testTextViewCursorVisible(set bool) error { tv, err := TextViewNew() if err != nil { return err } exp := set tv.SetCursorVisible(set) act := tv.GetCursorVisible() if act != exp { return fmt.Errorf("Expected GetCursorVisible(): %v; Got: %v", exp, act) } return nil } func TestTextView_WhenSetCursorVisibleFalse_ExpectGetCursorVisibleReturnsFalse(t *testing.T) { if err := testTextViewCursorVisible(false); err != nil { t.Error(err) } } func TestTextView_WhenSetCursorVisibleTrue_ExpectGetCursorVisibleReturnsTrue(t *testing.T) { if err := testTextViewCursorVisible(true); err != nil { t.Error(err) } } func testTextViewOverwrite(set bool) error { tv, err := TextViewNew() if err != nil { return err } exp := set tv.SetOverwrite(set) act := tv.GetOverwrite() if act != exp { return fmt.Errorf("Expected GetOverwrite(): %v; Got: %v", exp, act) } return nil } func TestTextView_WhenSetOverwriteFalse_ExpectGetOverwriteReturnsFalse(t *testing.T) { if err := testTextViewOverwrite(false); err != nil { t.Error(err) } } func TestTextView_WhenSetOverwriteTrue_ExpectGetOverwriteReturnsTrue(t *testing.T) { if err := testTextViewOverwrite(true); err != nil { t.Error(err) } } func testTextViewJustification(justify Justification) error { tv, err := TextViewNew() if err != nil { return err } exp := justify tv.SetJustification(justify) act := tv.GetJustification() if act != exp { return fmt.Errorf("Expected GetJustification(): %v; Got: %v", exp, act) } return nil } func TestTextView_WhenSetJustificationLeft_ExpectGetJustificationReturnsLeft(t *testing.T) { if err := testTextViewJustification(JUSTIFY_LEFT); err != nil { t.Error(err) } } func TestTextView_WhenSetJustificationRight_ExpectGetJustificationReturnsRight(t *testing.T) { if err := testTextViewJustification(JUSTIFY_RIGHT); err != nil { t.Error(err) } } func testTextViewAcceptsTab(set bool) error { tv, err := TextViewNew() if err != nil { return err } exp := set tv.SetAcceptsTab(set) if act := tv.GetAcceptsTab(); act != exp { return fmt.Errorf("Expected GetAcceptsTab(): %v; Got: %v", exp, act) } return nil } func TestTextView_WhenSetAcceptsTabFalse_ExpectGetAcceptsTabReturnsFalse(t *testing.T) { if err := testTextViewAcceptsTab(false); err != nil { t.Error(err) } } func TestTextView_WhenSetAcceptsTabTrue_ExpectGetAcceptsTabReturnsTrue(t *testing.T) { if err := testTextViewAcceptsTab(true); err != nil { t.Error(err) } } func testIntProperty(val int, set func(int), get func() int) error { set(val) if exp, act := val, get(); act != exp { return fmt.Errorf("Expected: %d; got: %d", exp, act) } return nil } func testTextViewPixelsAboveLines(px int) error { tv, err := TextViewNew() if err != nil { return err } return testIntProperty(px, (*tv).SetPixelsAboveLines, (*tv).GetPixelsAboveLines) } func TestTextView_WhenSetPixelsAboveLines10_ExpectGetPixelsAboveLinesReturns10(t *testing.T) { if err := testTextViewPixelsAboveLines(10); err != nil { t.Error(err) } } func TestTextView_WhenSetPixelsAboveLines11_ExpectGetPixelsAboveLinesReturns11(t *testing.T) { if err := testTextViewPixelsAboveLines(11); err != nil { t.Error(err) } } func testTextViewPixelsBelowLines(px int) error { tv, err := TextViewNew() if err != nil { return err } return testIntProperty(px, (*tv).SetPixelsBelowLines, (*tv).GetPixelsBelowLines) } func TestTextView_WhenSetPixelsBelowLines10_ExpectGetPixelsAboveLinesReturns10(t *testing.T) { if err := testTextViewPixelsBelowLines(10); err != nil { t.Error(err) } } func TestTextView_WhenSetPixelsBelowLines11_ExpectGetPixelsBelowLinesReturns11(t *testing.T) { if err := testTextViewPixelsBelowLines(11); err != nil { t.Error(err) } } func testTextViewPixelsInsideWrap(px int) error { tv, err := TextViewNew() if err != nil { return err } return testIntProperty(px, (*tv).SetPixelsInsideWrap, (*tv).GetPixelsInsideWrap) } func TestTextView_WhenSetPixelsInsideWrap10_ExpectGetPixelsInsideWrapReturns11(t *testing.T) { if err := testTextViewPixelsInsideWrap(10); err != nil { t.Error(err) } } func TestTextView_WhenSetPixelsInsideWrap11_ExpectGetPixelsInsideWrapReturns11(t *testing.T) { if err := testTextViewPixelsInsideWrap(11); err != nil { t.Error(err) } } func testTextViewLeftMargin(margin int) error { tv, err := TextViewNew() if err != nil { return err } return testIntProperty(margin, (*tv).SetLeftMargin, (*tv).GetLeftMargin) } func TestTextView_WhenSetLeftMargin11_ExpectGetLeftMarginReturns11(t *testing.T) { if err := testTextViewLeftMargin(11); err != nil { t.Error(err) } } func TestTextView_WhenSetLeftMargin10_ExpectGetLeftMarginReturns10(t *testing.T) { if err := testTextViewLeftMargin(10); err != nil { t.Error(err) } } func testTextViewRightMargin(margin int) error { tv, err := TextViewNew() if err != nil { return err } return testIntProperty(margin, (*tv).SetRightMargin, (*tv).GetRightMargin) } func TestTextView_WhenSetRightMargin10_ExpectGetRightMarginReturns10(t *testing.T) { if err := testTextViewRightMargin(10); err != nil { t.Error(err) } } func TestTextView_WhenSetRightMargin11_ExpectGetRightMarginReturns11(t *testing.T) { if err := testTextViewRightMargin(11); err != nil { t.Error(err) } } func testTextViewIndent(indent int) error { tv, err := TextViewNew() if err != nil { return err } return testIntProperty(indent, (*tv).SetIndent, (*tv).GetIndent) } func TestTextView_WhenSetIndent10_ExpectGetIndentReturns10(t *testing.T) { if err := testTextViewIndent(10); err != nil { t.Error(err) } } func TestTextView_WhenSetIndent11_ExpectGetIndentReturns11(t *testing.T) { if err := testTextViewIndent(11); err != nil { t.Error(err) } } func testTextViewInputHints(hint InputHints) error { tv, err := TextViewNew() if err != nil { return err } tv.SetInputHints(hint) if exp, act := hint, tv.GetInputHints(); act != exp { return fmt.Errorf("Expected %v; Got %v", exp, act) } return nil } func TestTextView_WhenSetInputHintsNone_ExpectGetInputHintsReturnsNone(t *testing.T) { if err := testTextViewInputHints(INPUT_HINT_NONE); err != nil { t.Error(err) } } func TestTextView_WhenSetInputHintsSpellCheck_ExpectGetInputHintsReturnsSpellCheck(t *testing.T) { if err := testTextViewInputHints(INPUT_HINT_SPELLCHECK); err != nil { t.Error(err) } } func testTextViewInputPurpose(purpose InputPurpose) error { tv, err := TextViewNew() if err != nil { return err } tv.SetInputPurpose(purpose) if exp, act := purpose, tv.GetInputPurpose(); act != exp { return fmt.Errorf("Expected %v; Got %v", exp, act) } return nil } func TestTextView_WhenSetInputPurposeURL_ExpectGetInputPurposeReturnsURL(t *testing.T) { if err := testTextViewInputPurpose(INPUT_PURPOSE_URL); err != nil { t.Error(err) } } func TestTextView_WhenSetInputPurposeALPHA_ExpectGetInputPurposeReturnsALPHA(t *testing.T) { if err := testTextViewInputPurpose(INPUT_PURPOSE_ALPHA); err != nil { t.Error(err) } } func testCellRendererToggleSetRadio(set bool) error { renderer, err := CellRendererToggleNew() if err != nil { return err } renderer.SetRadio(set) if exp, act := set, renderer.GetRadio(); act != exp { return fmt.Errorf("Expected GetRadio(): %v; Got: %v", exp, act) } return nil } func TestCellRendererToggle_WhenSetRadioFalse_ExpectGetRadioReturnsFalse(t *testing.T) { if err := testCellRendererToggleSetRadio(false); err != nil { t.Error(err) } } func TestCellRendererToggle_WhenSetRadioTrue_ExpectGetRadioReturnsTrue(t *testing.T) { if err := testCellRendererToggleSetRadio(true); err != nil { t.Error(err) } } func testCellRendererToggleSetActive(set bool) error { renderer, err := CellRendererToggleNew() if err != nil { return err } renderer.SetActive(set) if exp, act := set, renderer.GetActive(); act != exp { return fmt.Errorf("Expected GetActive(): %v; Got: %v", exp, act) } return nil } func TestCellRendererToggle_WhenSetActiveFalse_ExpectGetActiveReturnsFalse(t *testing.T) { if err := testCellRendererToggleSetActive(false); err != nil { t.Error(err) } } func TestCellRendererToggle_WhenSetActiveTrue_ExpectGetActiveReturnsTrue(t *testing.T) { if err := testCellRendererToggleSetActive(true); err != nil { t.Error(err) } } func testCellRendererToggleSetActivatable(set bool) error { renderer, err := CellRendererToggleNew() if err != nil { return err } renderer.SetActivatable(set) if exp, act := set, renderer.GetActivatable(); act != exp { return fmt.Errorf("Expected GetActivatable(): %v; Got: %v", exp, act) } return nil } func TestCellRendererToggle_WhenSetActivatableFalse_ExpectGetActivatableReturnsFalse(t *testing.T) { if err := testCellRendererToggleSetActivatable(false); err != nil { t.Error(err) } } func TestCellRendererToggle_WhenSetActivatableTrue_ExpectGetActivatableReturnsTrue(t *testing.T) { if err := testCellRendererToggleSetActivatable(true); err != nil { t.Error(err) } } func TestCellRendererAccel_AccelModeMarshaling(t *testing.T) { // CellRendererAccel has no getters/setters, everything is handled via properties, so marshaling has to work renderer, err := CellRendererAccelNew() if err != nil { t.Error(err) } err = renderer.SetProperty("accel-mode", CELL_RENDERER_ACCEL_MODE_OTHER) if err != nil { t.Error(err) } value, err := renderer.GetProperty("accel-mode") if err != nil { t.Error(err) } if CELL_RENDERER_ACCEL_MODE_OTHER != value { t.Errorf("Expected %v, got %v", CELL_RENDERER_ACCEL_MODE_OTHER, value) } } func TestCellRendererAccel_ModifierTypeMarshaling(t *testing.T) { // CellRendererAccel has no getters/setters, everything is handled via properties, so marshaling has to work renderer, err := CellRendererAccelNew() if err != nil { t.Error(err) } err = renderer.SetProperty("accel-mods", gdk.META_MASK) if err != nil { t.Error(err) } value, err := renderer.GetProperty("accel-mods") if err != nil { t.Error(err) } if gdk.META_MASK != value.(gdk.ModifierType) { t.Errorf("Expected %v, got %v", gdk.META_MASK, value.(gdk.ModifierType)) } } func setupListStore() *ListStore { ls, err := ListStoreNew(glib.TYPE_STRING) if err != nil { log.Fatal("Unexpected err:", err) } return ls } func getLastIter(ls *ListStore) (*TreeIter, bool) { iter, listIsntEmpty := ls.GetIterFirst() if !listIsntEmpty { return iter, listIsntEmpty } for { temp := *iter last := &temp if !ls.IterNext(iter) { return last, true } } panic("Shouldn't get here") } // TestListStoreRemoveLastInvalidIterator tests that when a ListStore stores // one item and it is removed, the iterator becomes invalid. func TestListStoreRemoveLastInvalidIterator(t *testing.T) { ls := setupListStore() iter := ls.Append() if iterValid := ls.Remove(iter); iterValid { t.Fatal("Remove() returned true (iter valid); expected false (iter invalid)") } } func TestListStoreInsertBefore(t *testing.T) { ls := setupListStore() // Given 1 iter is already in the liststore initialIter := ls.Append() // When another iter is inserted before it newIter := ls.InsertBefore(initialIter) // Expect the newly-inserted iter is first iter in list firstIter, listIsntEmpty := ls.GetIterFirst() if !listIsntEmpty { t.Fatal("Unexpected: liststore is empty") } if *firstIter != *newIter { t.Fatal("Expected the new iter added to front of list") } } // When 'sibling' parameter is nil, the new iter should be appended to the liststore func TestListStoreInsertBefore_WhenNilSibling(t *testing.T) { ls := setupListStore() // Given 2 iters in liststore ls.Append() ls.Append() // When 'sibling' parameter of InsertBefore() is nil... newIter := ls.InsertBefore(nil) // Then expect newly-inserted iter is the first iter in list lastIter, listIsntEmpty := getLastIter(ls) if !listIsntEmpty { t.Fatal("Unexpected: liststore is empty") } if *lastIter != *newIter { t.Fatal("Expected the new iter added to end of list") } } func TestListStoreInsertAfter(t *testing.T) { ls := setupListStore() // Given 1 iter in liststore sibling := ls.Append() // When InsertAfter(sibling) newIter := ls.InsertAfter(sibling) // Then expect newly-inserted iter is the last iter in list lastIter, listIsntEmpty := getLastIter(ls) if !listIsntEmpty { t.Fatal("Unexpected: liststore is empty") } if *lastIter != *newIter { t.Fatal("Expected the new iter added to end of list") } } // When 'sibling' parameter is nil, the new iter should be prepended to the liststore func TestListStoreInsertAfter_WhenNilSibling(t *testing.T) { ls := setupListStore() // Given 2 iters in liststore ls.Append() ls.Append() // When InsertAfter(nil) newIter := ls.InsertAfter(nil) // Then expect newly-inserted iter is the first iter in the list first, listIsntEmpty := ls.GetIterFirst() if !listIsntEmpty { t.Fatal("Unexpected: liststore is empty") } if *first != *newIter { t.Fatal("Expected the new iter was prepended to liststore") } } // Test storing and fetching a non-empty string value in a ListStore func TestListStoreGetValue_NonEmptyString(t *testing.T) { ls := setupListStore() // Add a string err := ls.InsertWithValues(nil, -1, []int{0}, []interface{}{"foo"}) if err != nil { t.Fatal("Failed to insert row", err) } // Fetch the first iter first, listIsntEmpty := ls.GetIterFirst() if !listIsntEmpty { t.Fatal("Unexpected: liststore is empty") } // Obtain a value v, err := ls.GetValue(first, 0) if err != nil { t.Fatal("Failed GetValue()", err) } s, err := v.GetString() if err != nil { t.Fatal("Failed GetString()", err) } if s != "foo" { t.Errorf("Expected 'foo'; Got %v", s) } } // Test storing and fetching an empty string value in a ListStore func TestListStoreGetValue_EmptyString(t *testing.T) { ls := setupListStore() // Add a string err := ls.InsertWithValues(nil, -1, []int{0}, []interface{}{""}) if err != nil { t.Fatal("Failed to insert row", err) } // Fetch the first iter first, listIsntEmpty := ls.GetIterFirst() if !listIsntEmpty { t.Fatal("Unexpected: liststore is empty") } // Obtain a value v, err := ls.GetValue(first, 0) if err != nil { t.Fatal("Failed GetValue()", err) } s, err := v.GetString() if err != nil { t.Fatal("Failed GetString()", err) } if s != "" { t.Errorf("Expected an empty string; Got %v", s) } } // Test storing and fetching a missing string value in a ListStore func TestListStoreGetValue_MissingString(t *testing.T) { ls := setupListStore() // Add a string err := ls.InsertWithValues(nil, -1, nil, nil) if err != nil { t.Fatal("Failed to insert row", err) } // Fetch the first iter first, listIsntEmpty := ls.GetIterFirst() if !listIsntEmpty { t.Fatal("Unexpected: liststore is empty") } // Obtain a value v, err := ls.GetValue(first, 0) if err != nil { t.Fatal("Failed GetValue()", err) } _, err = v.GetString() if err == nil { t.Fatal("Unexpected success: error expected from GetString()", err) } } func TestBuilder(t *testing.T) { builder, err := BuilderNew() if err != nil { t.Error("Unable to create builder") } str := ` 10 20 gtk-ok TRUE ` err = builder.AddFromString(str) if err != nil { t.Error("Unable to add from string") } widget, err := builder.GetObject("ok_button") if err != nil { t.Error("Unable to get widget from string") } button, ok := widget.(*Button) if !ok { t.Error("Unable to cast to gtk.Button") } l, err := button.GetLabel() if err != nil { t.Error("Unable to get button label") } if l != "gtk-ok" { t.Errorf("Label has the wrong value: %q", l) } done := make(chan bool) builder.ConnectSignals(map[string]interface{}{ "ok_button_clicked": func() { done <- true }, }) go button.Emit("clicked") select { case <-done: case <-time.After(1 * time.Second): t.Error("Failed to call callback") } } func TestTextTagEvent(t *testing.T) { textTag, err := TextTagNew("mytexttag") if err != nil { t.Error("could not create text tag") } evk := gdk.EventKeyNew() var iter TextIter ok := textTag.Event(textTag.Object, evk.Event, &iter) if ok { t.Error("event should not have been handled") } textTag.Connect("event", func() bool { return true }) ok = textTag.Event(textTag.Object, evk.Event, &iter) if !ok { t.Error("event should have been handled") } } gotk3-0.6.2/gtk/icon_view.go000066400000000000000000000346201431157473000156560ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) /* * GtkIconView */ // IconView is a representation of GTK's GtkIconView. type IconView struct { Container } // native returns a pointer to the underlying GtkIconView. func (v *IconView) native() *C.GtkIconView { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkIconView(p) } func marshalIconView(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapIconView(obj), nil } func wrapIconView(obj *glib.Object) *IconView { if obj == nil { return nil } return &IconView{Container{Widget{glib.InitiallyUnowned{obj}}}} } // IconViewNew is a wrapper around gtk_icon_view_new(). func IconViewNew() (*IconView, error) { c := C.gtk_icon_view_new() if c == nil { return nil, nilPtrErr } return wrapIconView(glib.Take(unsafe.Pointer(c))), nil } // TODO: // gtk_icon_view_new_with_area(). // IconViewNewWithModel is a wrapper around gtk_icon_view_new_with_model(). func IconViewNewWithModel(model ITreeModel) (*IconView, error) { c := C.gtk_icon_view_new_with_model(model.toTreeModel()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapIconView(obj), nil } // SetModel is a wrapper around gtk_icon_view_set_model(). func (v *IconView) SetModel(model ITreeModel) { var mptr *C.GtkTreeModel if model != nil { mptr = model.toTreeModel() } C.gtk_icon_view_set_model(v.native(), mptr) } // GetModel is a wrapper around gtk_icon_view_get_model(). func (v *IconView) GetModel() (ITreeModel, error) { c := C.gtk_icon_view_get_model(v.native()) if c == nil { return nil, nilPtrErr } return castTreeModel(c) } // SetTextColumn is a wrapper around gtk_icon_view_set_text_column(). func (v *IconView) SetTextColumn(column int) { C.gtk_icon_view_set_text_column(v.native(), C.gint(column)) } // GetTextColumn is a wrapper around gtk_icon_view_get_text_column(). func (v *IconView) GetTextColumn() int { return int(C.gtk_icon_view_get_text_column(v.native())) } // SetMarkupColumn is a wrapper around gtk_icon_view_set_markup_column(). func (v *IconView) SetMarkupColumn(column int) { C.gtk_icon_view_set_markup_column(v.native(), C.gint(column)) } // GetMarkupColumn is a wrapper around gtk_icon_view_get_markup_column(). func (v *IconView) GetMarkupColumn() int { return int(C.gtk_icon_view_get_markup_column(v.native())) } // SetPixbufColumn is a wrapper around gtk_icon_view_set_pixbuf_column(). func (v *IconView) SetPixbufColumn(column int) { C.gtk_icon_view_set_pixbuf_column(v.native(), C.gint(column)) } // GetPixbufColumn is a wrapper around gtk_icon_view_get_pixbuf_column(). func (v *IconView) GetPixbufColumn() int { return int(C.gtk_icon_view_get_pixbuf_column(v.native())) } // GetPathAtPos is a wrapper around gtk_icon_view_get_path_at_pos(). func (v *IconView) GetPathAtPos(x, y int) *TreePath { var ( cpath *C.GtkTreePath path *TreePath ) cpath = C.gtk_icon_view_get_path_at_pos(v.native(), C.gint(x), C.gint(y)) if cpath != nil { path = &TreePath{cpath} runtime.SetFinalizer(path, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } return path } // GetItemAtPos is a wrapper around gtk_icon_view_get_item_at_pos(). func (v *IconView) GetItemAtPos(x, y int) (*TreePath, *CellRenderer) { var ( cpath *C.GtkTreePath ccell *C.GtkCellRenderer path *TreePath cell *CellRenderer ) C.gtk_icon_view_get_item_at_pos(v.native(), C.gint(x), C.gint(y), &cpath, &ccell) if cpath != nil { path = &TreePath{cpath} runtime.SetFinalizer(path, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } if ccell != nil { cell = wrapCellRenderer(glib.Take(unsafe.Pointer(ccell))) } return path, cell } // ConvertWidgetToBinWindowCoords is a wrapper around gtk_icon_view_convert_widget_to_bin_window_coords(). func (v *IconView) ConvertWidgetToBinWindowCoords(x, y int) (int, int) { var bx, by C.gint C.gtk_icon_view_convert_widget_to_bin_window_coords(v.native(), C.gint(x), C.gint(y), &bx, &by) return int(bx), int(by) } // SetCursor is a wrapper around gtk_icon_view_set_cursor(). func (v *IconView) SetCursor(path *TreePath, cell *CellRenderer, startEditing bool) { C.gtk_icon_view_set_cursor(v.native(), path.native(), cell.native(), gbool(startEditing)) } // GetCursor is a wrapper around gtk_icon_view_get_cursor(). func (v *IconView) GetCursor() (*TreePath, *CellRenderer) { var ( cpath *C.GtkTreePath ccell *C.GtkCellRenderer path *TreePath cell *CellRenderer ) C.gtk_icon_view_get_cursor(v.native(), &cpath, &ccell) if cpath != nil { path = &TreePath{cpath} runtime.SetFinalizer(path, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } if ccell != nil { cell = wrapCellRenderer(glib.Take(unsafe.Pointer(ccell))) } return path, cell } // TODO: // gtk_icon_view_selected_foreach(). // func (v *IconView) SelectedForeach() {} // SetSelectionMode is a wrapper around gtk_icon_view_set_selection_mode(). func (v *IconView) SetSelectionMode(mode SelectionMode) { C.gtk_icon_view_set_selection_mode(v.native(), C.GtkSelectionMode(mode)) } // GetSelectionMode is a wrapper around gtk_icon_view_get_selection_mode(). func (v *IconView) GetSelectionMode() SelectionMode { return SelectionMode(C.gtk_icon_view_get_selection_mode(v.native())) } // SetItemOrientation is a wrapper around gtk_icon_view_set_item_orientation(). func (v *IconView) SetItemOrientation(orientation Orientation) { C.gtk_icon_view_set_item_orientation(v.native(), C.GtkOrientation(orientation)) } // GetItemOrientation is a wrapper around gtk_icon_view_get_item_orientation(). func (v *IconView) GetItemOrientation() Orientation { return Orientation(C.gtk_icon_view_get_item_orientation(v.native())) } // SetColumns is a wrapper around gtk_icon_view_set_columns(). func (v *IconView) SetColumns(columns int) { C.gtk_icon_view_set_columns(v.native(), C.gint(columns)) } // GetColumns is a wrapper around gtk_icon_view_get_columns(). func (v *IconView) GetColumns() int { return int(C.gtk_icon_view_get_columns(v.native())) } // SetItemWidth is a wrapper around gtk_icon_view_set_item_width(). func (v *IconView) SetItemWidth(width int) { C.gtk_icon_view_set_item_width(v.native(), C.gint(width)) } // GetItemWidth is a wrapper around gtk_icon_view_get_item_width(). func (v *IconView) GetItemWidth() int { return int(C.gtk_icon_view_get_item_width(v.native())) } // SetSpacing is a wrapper around gtk_icon_view_set_spacing(). func (v *IconView) SetSpacing(spacing int) { C.gtk_icon_view_set_spacing(v.native(), C.gint(spacing)) } // GetSpacing is a wrapper around gtk_icon_view_get_spacing(). func (v *IconView) GetSpacing() int { return int(C.gtk_icon_view_get_spacing(v.native())) } // SetRowSpacing is a wrapper around gtk_icon_view_set_row_spacing(). func (v *IconView) SetRowSpacing(rowSpacing int) { C.gtk_icon_view_set_row_spacing(v.native(), C.gint(rowSpacing)) } // GetRowSpacing is a wrapper around gtk_icon_view_get_row_spacing(). func (v *IconView) GetRowSpacing() int { return int(C.gtk_icon_view_get_row_spacing(v.native())) } // SetColumnSpacing is a wrapper around gtk_icon_view_set_column_spacing(). func (v *IconView) SetColumnSpacing(columnSpacing int) { C.gtk_icon_view_set_column_spacing(v.native(), C.gint(columnSpacing)) } // GetColumnSpacing is a wrapper around gtk_icon_view_get_column_spacing(). func (v *IconView) GetColumnSpacing() int { return int(C.gtk_icon_view_get_column_spacing(v.native())) } // SetMargin is a wrapper around gtk_icon_view_set_margin(). func (v *IconView) SetMargin(margin int) { C.gtk_icon_view_set_margin(v.native(), C.gint(margin)) } // GetMargin is a wrapper around gtk_icon_view_get_margin(). func (v *IconView) GetMargin() int { return int(C.gtk_icon_view_get_margin(v.native())) } // SetItemPadding is a wrapper around gtk_icon_view_set_item_padding(). func (v *IconView) SetItemPadding(itemPadding int) { C.gtk_icon_view_set_item_padding(v.native(), C.gint(itemPadding)) } // GetItemPadding is a wrapper around gtk_icon_view_get_item_padding(). func (v *IconView) GetItemPadding() int { return int(C.gtk_icon_view_get_item_padding(v.native())) } // SetActivateOnSingleClick is a wrapper around gtk_icon_view_set_activate_on_single_click(). func (v *IconView) SetActivateOnSingleClick(single bool) { C.gtk_icon_view_set_activate_on_single_click(v.native(), gbool(single)) } // GetActivateOnSingleClick is a wrapper around gtk_icon_view_get_activate_on_single_click(). func (v *IconView) GetActivateOnSingleClick() bool { return gobool(C.gtk_icon_view_get_activate_on_single_click(v.native())) } // GetCellRect is a wrapper around gtk_icon_view_get_cell_rect(). func (v *IconView) GetCellRect(path *TreePath, cell *CellRenderer) *gdk.Rectangle { var crect C.GdkRectangle C.gtk_icon_view_get_cell_rect(v.native(), path.native(), cell.native(), &crect) return gdk.WrapRectangle(uintptr(unsafe.Pointer(&crect))) } // SelectPath is a wrapper around gtk_icon_view_select_path(). func (v *IconView) SelectPath(path *TreePath) { C.gtk_icon_view_select_path(v.native(), path.native()) } // UnselectPath is a wrapper around gtk_icon_view_unselect_path(). func (v *IconView) UnselectPath(path *TreePath) { C.gtk_icon_view_unselect_path(v.native(), path.native()) } // PathIsSelected is a wrapper around gtk_icon_view_path_is_selected(). func (v *IconView) PathIsSelected(path *TreePath) bool { return gobool(C.gtk_icon_view_path_is_selected(v.native(), path.native())) } // GetSelectedItems is a wrapper around gtk_icon_view_get_selected_items(). func (v *IconView) GetSelectedItems() *glib.List { clist := C.gtk_icon_view_get_selected_items(v.native()) if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return &TreePath{(*C.GtkTreePath)(ptr)} }) runtime.SetFinalizer(glist, func(glist *glib.List) { glib.FinalizerStrategy(func() { glist.FreeFull(func(item interface{}) { path := item.(*TreePath) C.gtk_tree_path_free(path.GtkTreePath) }) }) }) return glist } // SelectAll is a wrapper around gtk_icon_view_select_all(). func (v *IconView) SelectAll() { C.gtk_icon_view_select_all(v.native()) } // UnselectAll is a wrapper around gtk_icon_view_unselect_all(). func (v *IconView) UnselectAll() { C.gtk_icon_view_unselect_all(v.native()) } // ItemActivated is a wrapper around gtk_icon_view_item_activated(). func (v *IconView) ItemActivated(path *TreePath) { C.gtk_icon_view_item_activated(v.native(), path.native()) } // ScrollToPath is a wrapper around gtk_icon_view_scroll_to_path(). func (v *IconView) ScrollToPath(path *TreePath, useAlign bool, rowAlign, colAlign float64) { C.gtk_icon_view_scroll_to_path(v.native(), path.native(), gbool(useAlign), C.gfloat(rowAlign), C.gfloat(colAlign)) } // GetVisibleRange is a wrapper around gtk_icon_view_get_visible_range(). func (v *IconView) GetVisibleRange() (*TreePath, *TreePath) { var ( cpathStart, cpathEnd *C.GtkTreePath pathStart, pathEnd *TreePath ) C.gtk_icon_view_get_visible_range(v.native(), &cpathStart, &cpathEnd) if cpathStart != nil { pathStart = &TreePath{cpathStart} runtime.SetFinalizer(pathStart, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } if cpathEnd != nil { pathEnd = &TreePath{cpathEnd} runtime.SetFinalizer(pathEnd, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } return pathStart, pathEnd } // SetTooltipItem is a wrapper around gtk_icon_view_set_tooltip_item(). func (v *IconView) SetTooltipItem(tooltip *Tooltip, path *TreePath) { C.gtk_icon_view_set_tooltip_item(v.native(), tooltip.native(), path.native()) } // SetTooltipCell is a wrapper around gtk_icon_view_set_tooltip_cell(). func (v *IconView) SetTooltipCell(tooltip *Tooltip, path *TreePath, cell *CellRenderer) { C.gtk_icon_view_set_tooltip_cell(v.native(), tooltip.native(), path.native(), cell.native()) } // GetTooltipContext is a wrapper around gtk_icon_view_get_tooltip_context(). func (v *IconView) GetTooltipContext(x, y int, keyboardTip bool) (*TreeModel, *TreePath, *TreeIter) { var ( cmodel *C.GtkTreeModel cpath *C.GtkTreePath citer *C.GtkTreeIter model *TreeModel path *TreePath iter *TreeIter ) px := C.gint(x) py := C.gint(y) if !gobool(C.gtk_icon_view_get_tooltip_context(v.native(), &px, &py, gbool(keyboardTip), &cmodel, &cpath, citer, )) { return nil, nil, nil } if cmodel != nil { model = wrapTreeModel(glib.Take(unsafe.Pointer(cmodel))) } if cpath != nil { path = &TreePath{cpath} runtime.SetFinalizer(path, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } if citer != nil { iter = &TreeIter{*citer} runtime.SetFinalizer(iter, func(v *TreeIter) { glib.FinalizerStrategy(v.free) }) } return model, path, iter } // SetTooltipColumn is a wrapper around gtk_icon_view_set_tooltip_column(). func (v *IconView) SetTooltipColumn(column int) { C.gtk_icon_view_set_tooltip_column(v.native(), C.gint(column)) } // GetTooltipColumn is a wrapper around gtk_icon_view_get_tooltip_column(). func (v *IconView) GetTooltipColumn() int { return int(C.gtk_icon_view_get_tooltip_column(v.native())) } // GetItemRow is a wrapper around gtk_icon_view_get_item_row(). func (v *IconView) GetItemRow(path *TreePath) int { return int(C.gtk_icon_view_get_item_row(v.native(), path.native())) } // TODO: // gtk_icon_view_get_item_column(). // gtk_icon_view_enable_model_drag_source(). // func (v *IconView) EnableModelDragSource() {} // gtk_icon_view_enable_model_drag_dest(). // func (v *IconView) EnableModelDragDest() {} // gtk_icon_view_unset_model_drag_source(). // func (v *IconView) UnsetModelDragSource() {} // gtk_icon_view_unset_model_drag_dest(). // func (v *IconView) UnsetModelDragDest() {} // SetReorderable is a wrapper around gtk_icon_view_set_reorderable(). func (v *IconView) SetReorderable(reorderable bool) { C.gtk_icon_view_set_reorderable(v.native(), gbool(reorderable)) } // GetReorderable is a wrapper around gtk_icon_view_get_reorderable(). func (v *IconView) GetReorderable() bool { return gobool(C.gtk_icon_view_get_reorderable(v.native())) } // TODO: // gtk_icon_view_set_drag_dest_item(). // func (v *IconView) SetDragDestItem() {} // gtk_icon_view_get_drag_dest_item(). // func (v *IconView) GetDragDestItem() {} // gtk_icon_view_get_dest_item_at_pos(). // func (v *IconView) GetDestItemAtPos() {} // gtk_icon_view_create_drag_icon(). // func (v *IconView) CreateDragIcon() {} gotk3-0.6.2/gtk/info_bar.go000066400000000000000000000067551431157473000154630ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_info_bar_get_type()), marshalInfoBar}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkInfoBar"] = wrapInfoBar } type InfoBar struct { Box } func (v *InfoBar) native() *C.GtkInfoBar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkInfoBar(p) } func marshalInfoBar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapInfoBar(glib.Take(unsafe.Pointer(c))), nil } func wrapInfoBar(obj *glib.Object) *InfoBar { if obj == nil { return nil } return &InfoBar{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // InfoBarNew is a wrapper around gtk_info_bar_new(). func InfoBarNew() (*InfoBar, error) { c := C.gtk_info_bar_new() if c == nil { return nil, nilPtrErr } return wrapInfoBar(glib.Take(unsafe.Pointer(c))), nil } // TODO: // gtk_info_bar_new_with_buttons(). // AddActionWidget is a wrapper around gtk_info_bar_add_action_widget(). func (v *InfoBar) AddActionWidget(w IWidget, responseId ResponseType) { C.gtk_info_bar_add_action_widget(v.native(), w.toWidget(), C.gint(responseId)) } // AddButton is a wrapper around gtk_info_bar_add_button(). func (v *InfoBar) AddButton(buttonText string, responseId ResponseType) { cstr := C.CString(buttonText) defer C.free(unsafe.Pointer(cstr)) C.gtk_info_bar_add_button(v.native(), (*C.gchar)(cstr), C.gint(responseId)) } // TODO: // gtk_info_bar_add_buttons(). // SetResponseSensitive is a wrapper around gtk_info_bar_set_response_sensitive(). func (v *InfoBar) SetResponseSensitive(responseId ResponseType, setting bool) { C.gtk_info_bar_set_response_sensitive(v.native(), C.gint(responseId), gbool(setting)) } // SetDefaultResponse is a wrapper around gtk_info_bar_set_default_response(). func (v *InfoBar) SetDefaultResponse(responseId ResponseType) { C.gtk_info_bar_set_default_response(v.native(), C.gint(responseId)) } // TODO: // gtk_info_bar_response(). // SetMessageType is a wrapper around gtk_info_bar_set_message_type(). func (v *InfoBar) SetMessageType(messageType MessageType) { C.gtk_info_bar_set_message_type(v.native(), C.GtkMessageType(messageType)) } // GetMessageType is a wrapper around gtk_info_bar_get_message_type(). func (v *InfoBar) GetMessageType() MessageType { messageType := C.gtk_info_bar_get_message_type(v.native()) return MessageType(messageType) } // GetActionArea is a wrapper around gtk_info_bar_get_action_area(). func (v *InfoBar) GetActionArea() (IWidget, error) { c := C.gtk_info_bar_get_action_area(v.native()) if c == nil { return nil, nilPtrErr } return castWidget(c) } // GetContentArea is a wrapper around gtk_info_bar_get_content_area(). func (v *InfoBar) GetContentArea() (*Box, error) { c := C.gtk_info_bar_get_content_area(v.native()) if c == nil { return nil, nilPtrErr } return wrapBox(glib.Take(unsafe.Pointer(c))), nil } // GetShowCloseButton is a wrapper around gtk_info_bar_get_show_close_button(). func (v *InfoBar) GetShowCloseButton() bool { b := C.gtk_info_bar_get_show_close_button(v.native()) return gobool(b) } // SetShowCloseButton is a wrapper around gtk_info_bar_set_show_close_button(). func (v *InfoBar) SetShowCloseButton(setting bool) { C.gtk_info_bar_set_show_close_button(v.native(), gbool(setting)) } // TODO: for GTK+ 3.22.29 // gtk_info_bar_get_revealed(). // gtk_info_bar_set_revealed(). gotk3-0.6.2/gtk/label.go000066400000000000000000000216501431157473000147520ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains style related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/pango" "github.com/gotk3/gotk3/glib" ) /* * GtkLabel */ // Label is a representation of GTK's GtkLabel. type Label struct { Widget } // native returns a pointer to the underlying GtkLabel. func (v *Label) native() *C.GtkLabel { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkLabel(p) } func marshalLabel(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapLabel(obj), nil } func wrapLabel(obj *glib.Object) *Label { if obj == nil { return nil } return &Label{Widget{glib.InitiallyUnowned{obj}}} } // WidgetToLabel is a convience func that casts the given *Widget into a *Label. func WidgetToLabel(widget *Widget) (*Label, error) { obj := glib.Take(unsafe.Pointer(widget.GObject)) return wrapLabel(obj), nil } // LabelNew is a wrapper around gtk_label_new(). func LabelNew(str string) (*Label, error) { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_label_new((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapLabel(obj), nil } // SetText is a wrapper around gtk_label_set_text(). func (v *Label) SetText(str string) { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) C.gtk_label_set_text(v.native(), (*C.gchar)(cstr)) } // TODO: // gtk_label_set_text_with_mnemonic(). // SetAttributes is a wrapper around "gtk_label_set_attributes". func (v *Label) SetAttributes(attributes *pango.AttrList) { C.gtk_label_set_attributes(v.native(), (*C.PangoAttrList)(unsafe.Pointer(attributes.Native()))) } // GetAttributes is a wrapper around "gtk_label_get_attributes". func (v *Label) GetAttributes() (*pango.AttrList, error) { ptr := C.gtk_label_get_attributes(v.native()) if ptr == nil { return nil, nilPtrErr } return pango.WrapAttrList(unsafe.Pointer(ptr)), nil } // SetMarkup is a wrapper around gtk_label_set_markup(). func (v *Label) SetMarkup(str string) { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) C.gtk_label_set_markup(v.native(), (*C.gchar)(cstr)) } // SetMarkupWithMnemonic is a wrapper around // gtk_label_set_markup_with_mnemonic(). func (v *Label) SetMarkupWithMnemonic(str string) { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) C.gtk_label_set_markup_with_mnemonic(v.native(), (*C.gchar)(cstr)) } // SetPattern is a wrapper around gtk_label_set_pattern(). func (v *Label) SetPattern(patern string) { cstr := C.CString(patern) defer C.free(unsafe.Pointer(cstr)) C.gtk_label_set_pattern(v.native(), (*C.gchar)(cstr)) } // SetJustify is a wrapper around gtk_label_set_justify(). func (v *Label) SetJustify(jtype Justification) { C.gtk_label_set_justify(v.native(), C.GtkJustification(jtype)) } // SetEllipsize is a wrapper around gtk_label_set_ellipsize(). func (v *Label) SetEllipsize(mode pango.EllipsizeMode) { C.gtk_label_set_ellipsize(v.native(), C.PangoEllipsizeMode(mode)) } // GetWidthChars is a wrapper around gtk_label_get_width_chars(). func (v *Label) GetWidthChars() int { c := C.gtk_label_get_width_chars(v.native()) return int(c) } // SetWidthChars is a wrapper around gtk_label_set_width_chars(). func (v *Label) SetWidthChars(nChars int) { C.gtk_label_set_width_chars(v.native(), C.gint(nChars)) } // GetMaxWidthChars is a wrapper around gtk_label_get_max_width_chars(). func (v *Label) GetMaxWidthChars() int { c := C.gtk_label_get_max_width_chars(v.native()) return int(c) } // SetMaxWidthChars is a wrapper around gtk_label_set_max_width_chars(). func (v *Label) SetMaxWidthChars(nChars int) { C.gtk_label_set_max_width_chars(v.native(), C.gint(nChars)) } // GetLineWrap is a wrapper around gtk_label_get_line_wrap(). func (v *Label) GetLineWrap() bool { c := C.gtk_label_get_line_wrap(v.native()) return gobool(c) } // SetLineWrap is a wrapper around gtk_label_set_line_wrap(). func (v *Label) SetLineWrap(wrap bool) { C.gtk_label_set_line_wrap(v.native(), gbool(wrap)) } // SetLineWrapMode is a wrapper around gtk_label_set_line_wrap_mode(). func (v *Label) SetLineWrapMode(wrapMode pango.WrapMode) { C.gtk_label_set_line_wrap_mode(v.native(), C.PangoWrapMode(wrapMode)) } // TODO: // gtk_label_get_line_wrap_mode(). // gtk_label_get_layout_offsets(). // gtk_label_get_layout(). // gtk_label_get_mnemonic_widget(). // GetSelectable is a wrapper around gtk_label_get_selectable(). func (v *Label) GetSelectable() bool { c := C.gtk_label_get_selectable(v.native()) return gobool(c) } // GetText is a wrapper around gtk_label_get_text(). func (v *Label) GetText() (string, error) { c := C.gtk_label_get_text(v.native()) if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // GetJustify is a wrapper around gtk_label_get_justify(). func (v *Label) GetJustify() Justification { c := C.gtk_label_get_justify(v.native()) return Justification(c) } // GetEllipsize is a wrapper around gtk_label_get_ellipsize(). func (v *Label) GetEllipsize() pango.EllipsizeMode { c := C.gtk_label_get_ellipsize(v.native()) return pango.EllipsizeMode(c) } // GetCurrentUri is a wrapper around gtk_label_get_current_uri(). func (v *Label) GetCurrentUri() string { c := C.gtk_label_get_current_uri(v.native()) return C.GoString((*C.char)(c)) } // GetTrackVisitedLinks is a wrapper around gtk_label_get_track_visited_links(). func (v *Label) GetTrackVisitedLinks() bool { c := C.gtk_label_get_track_visited_links(v.native()) return gobool(c) } // SetTrackVisitedLinks is a wrapper around gtk_label_set_track_visited_links(). func (v *Label) SetTrackVisitedLinks(trackLinks bool) { C.gtk_label_set_track_visited_links(v.native(), gbool(trackLinks)) } // GetAngle is a wrapper around gtk_label_get_angle(). func (v *Label) GetAngle() float64 { c := C.gtk_label_get_angle(v.native()) return float64(c) } // SetAngle is a wrapper around gtk_label_set_angle(). func (v *Label) SetAngle(angle float64) { C.gtk_label_set_angle(v.native(), C.gdouble(angle)) } // GetSelectionBounds is a wrapper around gtk_label_get_selection_bounds(). func (v *Label) GetSelectionBounds() (start, end int, nonEmpty bool) { var cstart, cend C.gint c := C.gtk_label_get_selection_bounds(v.native(), &cstart, &cend) return int(cstart), int(cend), gobool(c) } // GetSingleLineMode is a wrapper around gtk_label_get_single_line_mode(). func (v *Label) GetSingleLineMode() bool { c := C.gtk_label_get_single_line_mode(v.native()) return gobool(c) } // SetSingleLineMode is a wrapper around gtk_label_set_single_line_mode(). func (v *Label) SetSingleLineMode(mode bool) { C.gtk_label_set_single_line_mode(v.native(), gbool(mode)) } // GetUseMarkup is a wrapper around gtk_label_get_use_markup(). func (v *Label) GetUseMarkup() bool { c := C.gtk_label_get_use_markup(v.native()) return gobool(c) } // SetUseMarkup is a wrapper around gtk_label_set_use_markup(). func (v *Label) SetUseMarkup(use bool) { C.gtk_label_set_use_markup(v.native(), gbool(use)) } // GetUseUnderline is a wrapper around gtk_label_get_use_underline(). func (v *Label) GetUseUnderline() bool { c := C.gtk_label_get_use_underline(v.native()) return gobool(c) } // SetUseUnderline is a wrapper around gtk_label_set_use_underline(). func (v *Label) SetUseUnderline(use bool) { C.gtk_label_set_use_underline(v.native(), gbool(use)) } // LabelNewWithMnemonic is a wrapper around gtk_label_new_with_mnemonic(). func LabelNewWithMnemonic(str string) (*Label, error) { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_label_new_with_mnemonic((*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapLabel(obj), nil } // SelectRegion is a wrapper around gtk_label_select_region(). func (v *Label) SelectRegion(startOffset, endOffset int) { C.gtk_label_select_region(v.native(), C.gint(startOffset), C.gint(endOffset)) } // SetSelectable is a wrapper around gtk_label_set_selectable(). func (v *Label) SetSelectable(setting bool) { C.gtk_label_set_selectable(v.native(), gbool(setting)) } // SetLabel is a wrapper around gtk_label_set_label(). func (v *Label) SetLabel(str string) { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) C.gtk_label_set_label(v.native(), (*C.gchar)(cstr)) } // GetLabel is a wrapper around gtk_label_get_label(). func (v *Label) GetLabel() string { c := C.gtk_label_get_label(v.native()) if c == nil { return "" } return C.GoString((*C.char)(c)) } // GetMnemonicKeyval is a wrapper around gtk_label_get_mnemonic_keyval(). func (v *Label) GetMnemonicKeyval() uint { return uint(C.gtk_label_get_mnemonic_keyval(v.native())) } // SetMnemonicWidget is a wrapper around gtk_label_set_mnemonic_widget(). func (v *Label) SetMnemonicWidget(widget IWidget) { C.gtk_label_set_mnemonic_widget(v.native(), widget.toWidget()) } gotk3-0.6.2/gtk/level_bar.go000066400000000000000000000104501431157473000156220ustar00rootroot00000000000000// Supports building with gtk 3.6+ package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_level_bar_mode_get_type()), marshalLevelBarMode}, {glib.Type(C.gtk_level_bar_get_type()), marshalLevelBar}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkLevelBar"] = wrapLevelBar } // LevelBarMode is a representation of GTK's GtkLevelBarMode. type LevelBarMode int const ( LEVEL_BAR_MODE_CONTINUOUS LevelBarMode = C.GTK_LEVEL_BAR_MODE_CONTINUOUS LEVEL_BAR_MODE_DISCRETE LevelBarMode = C.GTK_LEVEL_BAR_MODE_DISCRETE ) // stock offset macro values of GtkLevelBar const ( LEVEL_BAR_OFFSET_LOW string = C.GTK_LEVEL_BAR_OFFSET_LOW LEVEL_BAR_OFFSET_HIGH string = C.GTK_LEVEL_BAR_OFFSET_HIGH ) func marshalLevelBarMode(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return LevelBarMode(c), nil } /* * GtkLevelBar */ type LevelBar struct { Widget } // native returns a pointer to the underlying GtkLevelBar. func (v *LevelBar) native() *C.GtkLevelBar { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkLevelBar(p) } func marshalLevelBar(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapLevelBar(obj), nil } func wrapLevelBar(obj *glib.Object) *LevelBar { if obj == nil { return nil } return &LevelBar{Widget{glib.InitiallyUnowned{obj}}} } // LevelBarNew is a wrapper around gtk_level_bar_new(). func LevelBarNew() (*LevelBar, error) { c := C.gtk_level_bar_new() if c == nil { return nil, nilPtrErr } return wrapLevelBar(glib.Take(unsafe.Pointer(c))), nil } // LevelBarNewForInterval is a wrapper around gtk_level_bar_new_for_interval(). func LevelBarNewForInterval(min_value, max_value float64) (*LevelBar, error) { c := C.gtk_level_bar_new_for_interval(C.gdouble(min_value), C.gdouble(max_value)) if c == nil { return nil, nilPtrErr } return wrapLevelBar(glib.Take(unsafe.Pointer(c))), nil } // SetMode is a wrapper around gtk_level_bar_set_mode(). func (v *LevelBar) SetMode(m LevelBarMode) { C.gtk_level_bar_set_mode(v.native(), C.GtkLevelBarMode(m)) } // GetMode is a wrapper around gtk_level_bar_get_mode(). func (v *LevelBar) GetMode() LevelBarMode { return LevelBarMode(C.gtk_level_bar_get_mode(v.native())) } // SetValue is a wrapper around gtk_level_bar_set_value(). func (v *LevelBar) SetValue(value float64) { C.gtk_level_bar_set_value(v.native(), C.gdouble(value)) } // GetValue is a wrapper around gtk_level_bar_get_value(). func (v *LevelBar) GetValue() float64 { c := C.gtk_level_bar_get_value(v.native()) return float64(c) } // SetMinValue is a wrapper around gtk_level_bar_set_min_value(). func (v *LevelBar) SetMinValue(value float64) { C.gtk_level_bar_set_min_value(v.native(), C.gdouble(value)) } // GetMinValue is a wrapper around gtk_level_bar_get_min_value(). func (v *LevelBar) GetMinValue() float64 { c := C.gtk_level_bar_get_min_value(v.native()) return float64(c) } // SetMaxValue is a wrapper around gtk_level_bar_set_max_value(). func (v *LevelBar) SetMaxValue(value float64) { C.gtk_level_bar_set_max_value(v.native(), C.gdouble(value)) } // GetMaxValue is a wrapper around gtk_level_bar_get_max_value(). func (v *LevelBar) GetMaxValue() float64 { c := C.gtk_level_bar_get_max_value(v.native()) return float64(c) } // AddOffsetValue is a wrapper around gtk_level_bar_add_offset_value(). func (v *LevelBar) AddOffsetValue(name string, value float64) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_level_bar_add_offset_value(v.native(), (*C.gchar)(cstr), C.gdouble(value)) } // RemoveOffsetValue is a wrapper around gtk_level_bar_remove_offset_value(). func (v *LevelBar) RemoveOffsetValue(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_level_bar_remove_offset_value(v.native(), (*C.gchar)(cstr)) } // GetOffsetValue is a wrapper around gtk_level_bar_get_offset_value(). func (v *LevelBar) GetOffsetValue(name string) (float64, bool) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) var value C.gdouble c := C.gtk_level_bar_get_offset_value(v.native(), (*C.gchar)(cstr), &value) return float64(value), gobool(c) } gotk3-0.6.2/gtk/level_bar_since_3_20.go000066400000000000000000000003621431157473000175270ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18 package gtk // #include // #include "gtk.go.h" import "C" /* * Constants */ const ( LEVEL_BAR_OFFSET_FULL string = C.GTK_LEVEL_BAR_OFFSET_FULL ) gotk3-0.6.2/gtk/level_bar_since_3_8.go000066400000000000000000000006731431157473000174620ustar00rootroot00000000000000// +build !gtk_3_6 package gtk // #include // #include "gtk.go.h" import "C" // SetInverted() is a wrapper around gtk_level_bar_set_inverted(). func (v *LevelBar) SetInverted(inverted bool) { C.gtk_level_bar_set_inverted(v.native(), gbool(inverted)) } // GetInverted() is a wrapper around gtk_level_bar_get_inverted(). func (v *LevelBar) GetInverted() bool { c := C.gtk_level_bar_get_inverted(v.native()) return gobool(c) } gotk3-0.6.2/gtk/menu.go000066400000000000000000000102231431157473000146310ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains accelerator related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) /* * GtkMenu */ // Menu is a representation of GTK's GtkMenu. type Menu struct { MenuShell } // IMenu is an interface type implemented by all structs embedding // a Menu. It is meant to be used as an argument type for wrapper // functions that wrap around a C GTK function taking a // GtkMenu. type IMenu interface { toMenu() *C.GtkMenu toWidget() *C.GtkWidget } // native() returns a pointer to the underlying GtkMenu. func (v *Menu) native() *C.GtkMenu { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkMenu(p) } func (v *Menu) toMenu() *C.GtkMenu { if v == nil { return nil } return v.native() } func marshalMenu(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapMenu(obj), nil } func wrapMenu(obj *glib.Object) *Menu { if obj == nil { return nil } return &Menu{MenuShell{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // MenuNew() is a wrapper around gtk_menu_new(). func MenuNew() (*Menu, error) { c := C.gtk_menu_new() if c == nil { return nil, nilPtrErr } return wrapMenu(glib.Take(unsafe.Pointer(c))), nil } // GtkMenuNewFromModel is a wrapper around gtk_menu_new_from_model(). func GtkMenuNewFromModel(model *glib.MenuModel) (*Menu, error) { c := C.gtk_menu_new_from_model(C.toGMenuModel(unsafe.Pointer(model.Native()))) if c == nil { return nil, nilPtrErr } return wrapMenu(glib.Take(unsafe.Pointer(c))), nil } // SetScreen is a wrapper around gtk_menu_set_screen(). func (v *Menu) SetScreen(screen *gdk.Screen) { C.gtk_menu_set_screen(v.native(), (*C.GdkScreen)(unsafe.Pointer(screen.Native()))) } // Attach is a wrapper around gtk_menu_attach(). func (v *Menu) Attach(child IWidget, l, r, t, b uint) { C.gtk_menu_attach( v.native(), child.toWidget(), C.guint(l), C.guint(r), C.guint(t), C.guint(b)) } // SetMonitor() is a wrapper around gtk_menu_set_monitor(). func (v *Menu) SetMonitor(monitor_num int) { C.gtk_menu_set_monitor(v.native(), C.gint(monitor_num)) } // GetMonitor() is a wrapper around gtk_menu_get_monitor(). func (v *Menu) GetMonitor() int { return int(C.gtk_menu_get_monitor(v.native())) } // ReorderChild() is a wrapper around gtk_menu_reorder_child(). func (v *Menu) ReorderChild(child IWidget, position int) { C.gtk_menu_reorder_child(v.native(), child.toWidget(), C.gint(position)) } // SetReserveToggleSize() is a wrapper around gtk_menu_set_reserve_toggle_size(). func (v *Menu) SetReserveToggleSize(reserve bool) { C.gtk_menu_set_reserve_toggle_size(v.native(), gbool(reserve)) } // GetReserveToggleSize() is a wrapper around gtk_menu_get_reserve_toggle_size(). func (v *Menu) GetReserveToggleSize() bool { return gobool(C.gtk_menu_get_reserve_toggle_size(v.native())) } // Popdown() is a wrapper around gtk_menu_popdown(). func (v *Menu) Popdown() { C.gtk_menu_popdown(v.native()) } // TODO /* gtk_menu_reposition () require 'GtkMenuPositionFunc' (according to its position function.) */ // GetActive() is a wrapper around gtk_menu_get_active(). func (v *Menu) GetActive() (*Menu, error) { c := C.gtk_menu_get_active(v.native()) if c == nil { return nil, nilPtrErr } return wrapMenu(glib.Take(unsafe.Pointer(c))), nil } // SetActive() is a wrapper around gtk_menu_set_active(). func (v *Menu) SetActive(index uint) { C.gtk_menu_set_active(v.native(), C.guint(index)) } // TODO /* void gtk_menu_attach_to_widget (GtkMenu *menu, GtkWidget *attach_widget, GtkMenuDetachFunc detacher); void gtk_menu_detach (GtkMenu *menu); */ // GetAttachWidget() is a wrapper around gtk_menu_get_attach_widget(). func (v *Menu) GetAttachWidget() (IWidget, error) { c := C.gtk_menu_get_attach_widget(v.native()) if c == nil { return nil, nilPtrErr } return castWidget(c) } // TODO /* GList * gtk_menu_get_for_attach_widget (GtkWidget *widget); */ gotk3-0.6.2/gtk/menu_before_3_22.go000066400000000000000000000007061431157473000167050ustar00rootroot00000000000000// +build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14 gtk_3_16 gtk_3_18 gtk_3_20 package gtk // #include // #include import "C" import "github.com/gotk3/gotk3/gdk" // PopupAtPointer() is a wrapper for gtk_menu_popup_at_pointer(), on older versions it uses PopupAtMouseCursor func (v *Menu) PopupAtPointer(_ *gdk.Event) { C.gtk_menu_popup(v.native(), nil, nil, nil, nil, C.guint(0), C.gtk_get_current_event_time()) } gotk3-0.6.2/gtk/menu_shell.go000066400000000000000000000105431431157473000160250ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains accelerator related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_menu_direction_type_get_type()), marshalMenuDirectionType}, } glib.RegisterGValueMarshalers(tm) } // MenuDirectionType is a representation of GTK's GtkMenuDirectionType. type MenuDirectionType int const ( MENU_DIR_PARENT MenuDirectionType = C.GTK_MENU_DIR_PARENT MENU_DIR_CHILD MenuDirectionType = C.GTK_MENU_DIR_CHILD MENU_DIR_NEXT MenuDirectionType = C.GTK_MENU_DIR_NEXT MENU_DIR_PREV MenuDirectionType = C.GTK_MENU_DIR_PREV ) func marshalMenuDirectionType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return MenuDirectionType(c), nil } /* * GtkMenuShell */ // MenuShell is a representation of GTK's GtkMenuShell. type MenuShell struct { Container } // native returns a pointer to the underlying GtkMenuShell. func (v *MenuShell) native() *C.GtkMenuShell { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkMenuShell(p) } func marshalMenuShell(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapMenuShell(obj), nil } func wrapMenuShell(obj *glib.Object) *MenuShell { if obj == nil { return nil } return &MenuShell{Container{Widget{glib.InitiallyUnowned{obj}}}} } // Append is a wrapper around gtk_menu_shell_append(). func (v *MenuShell) Append(child IMenuItem) { C.gtk_menu_shell_append(v.native(), child.toWidget()) } // Prepend is a wrapper around gtk_menu_shell_prepend(). func (v *MenuShell) Prepend(child IMenuItem) { C.gtk_menu_shell_prepend(v.native(), child.toWidget()) } // Insert is a wrapper around gtk_menu_shell_insert(). func (v *MenuShell) Insert(child IMenuItem, position int) { C.gtk_menu_shell_insert(v.native(), child.toWidget(), C.gint(position)) } // Deactivate is a wrapper around gtk_menu_shell_deactivate(). func (v *MenuShell) Deactivate() { C.gtk_menu_shell_deactivate(v.native()) } // SelectItem is a wrapper around gtk_menu_shell_select_item(). func (v *MenuShell) SelectItem(child IMenuItem) { C.gtk_menu_shell_select_item(v.native(), child.toWidget()) } // SelectFirst is a wrapper around gtk_menu_shell_select_first(). func (v *MenuShell) SelectFirst(searchSensitive bool) { C.gtk_menu_shell_select_first(v.native(), gbool(searchSensitive)) } // Deselect is a wrapper around gtk_menu_shell_deselect(). func (v *MenuShell) Deselect() { C.gtk_menu_shell_deselect(v.native()) } // ActivateItem is a wrapper around gtk_menu_shell_activate_item(). func (v *MenuShell) ActivateItem(child IMenuItem, forceDeactivate bool) { C.gtk_menu_shell_activate_item(v.native(), child.toWidget(), gbool(forceDeactivate)) } // Cancel is a wrapper around gtk_menu_shell_cancel(). func (v *MenuShell) Cancel() { C.gtk_menu_shell_cancel(v.native()) } // SetTakeFocus is a wrapper around gtk_menu_shell_set_take_focus(). func (v *MenuShell) SetTakeFocus(takeFocus bool) { C.gtk_menu_shell_set_take_focus(v.native(), gbool(takeFocus)) } // GetTakeFocus is a wrapper around gtk_menu_shell_get_take_focus(). func (v *MenuShell) GetTakeFocus() bool { return gobool(C.gtk_menu_shell_get_take_focus(v.native())) } // GetSelectedItem is a wrapper around gtk_menu_shell_get_selected_item(). func (v *MenuShell) GetSelectedItem() (IMenuItem, error) { c := C.gtk_menu_shell_get_selected_item(v.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapMenuItem(obj), nil } // GetParentShell is a wrapper around gtk_menu_shell_get_parent_shell(). func (v *MenuShell) GetParentShell() (*MenuShell, error) { c := C.gtk_menu_shell_get_parent_shell(v.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapMenuShell(obj), nil } // BindModel is a wrapper around gtk_menu_shell_bind_model(). func (v *MenuShell) BindModel(model *glib.MenuModel, action_namespace string, with_separators bool) { cstr := C.CString(action_namespace) defer C.free(unsafe.Pointer(cstr)) C.gtk_menu_shell_bind_model( v.native(), (*C.GMenuModel)(unsafe.Pointer(model.Native())), cstr, gbool(with_separators)) } gotk3-0.6.2/gtk/menu_since_3_22.go000066400000000000000000000030131431157473000165360ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18,!gtk_3_20 package gtk // #include // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" ) // PopupAtRect is a wrapper around gtk_menu_popup_at_rect(). func (v *Menu) PopupAtRect(rect_window *gdk.Window, rect *gdk.Rectangle, rect_anchor, menu_anchor gdk.Gravity, trigger_event *gdk.Event) { C.gtk_menu_popup_at_rect( v.native(), (*C.GdkWindow)(unsafe.Pointer(rect_window.Native())), (*C.GdkRectangle)(unsafe.Pointer(&rect.GdkRectangle)), C.GdkGravity(rect_anchor), C.GdkGravity(menu_anchor), (*C.GdkEvent)(unsafe.Pointer(trigger_event.Native()))) } // PopupAtWidget() is a wrapper for gtk_menu_popup_at_widget() func (v *Menu) PopupAtWidget(widget IWidget, widgetAnchor gdk.Gravity, menuAnchor gdk.Gravity, triggerEvent *gdk.Event) { e := (*C.GdkEvent)(unsafe.Pointer(triggerEvent.Native())) C.gtk_menu_popup_at_widget(v.native(), widget.toWidget(), C.GdkGravity(widgetAnchor), C.GdkGravity(menuAnchor), e) } // PopupAtPointer() is a wrapper for gtk_menu_popup_at_pointer(), on older versions it uses PopupAtMouseCursor func (v *Menu) PopupAtPointer(triggerEvent *gdk.Event) { e := (*C.GdkEvent)(unsafe.Pointer(triggerEvent.Native())) C.gtk_menu_popup_at_pointer(v.native(), e) } // PlaceOnMonitor() is a wrapper around gtk_menu_place_on_monitor(). func (v *Menu) PlaceOnMonitor(monitor *gdk.Monitor) { C.gtk_menu_place_on_monitor( v.native(), (*C.GdkMonitor)(unsafe.Pointer(monitor.Native()))) } gotk3-0.6.2/gtk/print.go000066400000000000000000001555721431157473000150420ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" // #include "print.go.h" import "C" import ( "errors" "runtime" "unsafe" "github.com/gotk3/gotk3/cairo" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/internal/callback" "github.com/gotk3/gotk3/pango" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.gtk_page_orientation_get_type()), marshalPageOrientation}, {glib.Type(C.gtk_print_error_get_type()), marshalPrintError}, {glib.Type(C.gtk_print_operation_action_get_type()), marshalPrintOperationAction}, {glib.Type(C.gtk_print_operation_result_get_type()), marshalPrintOperationResult}, {glib.Type(C.gtk_print_status_get_type()), marshalPrintStatus}, {glib.Type(C.gtk_unit_get_type()), marshalUnit}, // Objects/Interfaces {glib.Type(C.gtk_number_up_layout_get_type()), marshalNumberUpLayout}, {glib.Type(C.gtk_page_orientation_get_type()), marshalPageOrientation}, {glib.Type(C.gtk_page_set_get_type()), marshalPageSet}, {glib.Type(C.gtk_page_setup_get_type()), marshalPageSetup}, {glib.Type(C.gtk_print_context_get_type()), marshalPrintContext}, {glib.Type(C.gtk_print_duplex_get_type()), marshalPrintDuplex}, {glib.Type(C.gtk_print_operation_get_type()), marshalPrintOperation}, {glib.Type(C.gtk_print_operation_preview_get_type()), marshalPrintOperationPreview}, {glib.Type(C.gtk_print_pages_get_type()), marshalPrintPages}, {glib.Type(C.gtk_print_quality_get_type()), marshalPrintQuality}, {glib.Type(C.gtk_print_settings_get_type()), marshalPrintSettings}, // Boxed {glib.Type(C.gtk_paper_size_get_type()), marshalPaperSize}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkPageSetup"] = wrapPageSetup WrapMap["GtkPrintContext"] = wrapPrintContext WrapMap["GtkPrintOperation"] = wrapPrintOperation WrapMap["GtkPrintOperationPreview"] = wrapPrintOperationPreview WrapMap["GtkPrintSettings"] = wrapPrintSettings } /* * Constants */ // NumberUpLayout is a representation of GTK's GtkNumberUpLayout. type NumberUpLayout int const ( NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM NumberUpLayout = C.GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP NumberUpLayout = C.GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM NumberUpLayout = C.GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP NumberUpLayout = C.GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT NumberUpLayout = C.GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT NumberUpLayout = C.GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT NumberUpLayout = C.GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT NumberUpLayout = C.GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT ) func marshalNumberUpLayout(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return NumberUpLayout(c), nil } // PageOrientation is a representation of GTK's GtkPageOrientation. type PageOrientation int const ( PAGE_ORIENTATION_PORTRAIT PageOrientation = C.GTK_PAGE_ORIENTATION_PORTRAIT PAGE_ORIENTATION_LANDSCAPE PageOrientation = C.GTK_PAGE_ORIENTATION_LANDSCAPE PAGE_ORIENTATION_REVERSE_PORTRAIT PageOrientation = C.GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT PAGE_ORIENTATION_REVERSE_LANDSCAPE PageOrientation = C.GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE ) func marshalPageOrientation(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PageOrientation(c), nil } // PrintDuplex is a representation of GTK's GtkPrintDuplex. type PrintDuplex int const ( PRINT_DUPLEX_SIMPLEX PrintDuplex = C.GTK_PRINT_DUPLEX_SIMPLEX PRINT_DUPLEX_HORIZONTAL PrintDuplex = C.GTK_PRINT_DUPLEX_HORIZONTAL PRINT_DUPLEX_VERTICAL PrintDuplex = C.GTK_PRINT_DUPLEX_VERTICAL ) func marshalPrintDuplex(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PrintDuplex(c), nil } // PrintPages is a representation of GTK's GtkPrintPages. type PrintPages int const ( PRINT_PAGES_ALL PrintPages = C.GTK_PRINT_PAGES_ALL PRINT_PAGES_CURRENT PrintPages = C.GTK_PRINT_PAGES_CURRENT PRINT_PAGES_RANGES PrintPages = C.GTK_PRINT_PAGES_RANGES PRINT_PAGES_SELECTION PrintPages = C.GTK_PRINT_PAGES_SELECTION ) func marshalPrintPages(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PrintPages(c), nil } // PageSet is a representation of GTK's GtkPageSet. type PageSet int const ( PAGE_SET_ALL PageSet = C.GTK_PAGE_SET_ALL PAGE_SET_EVEN PageSet = C.GTK_PAGE_SET_EVEN PAGE_SET_ODD PageSet = C.GTK_PAGE_SET_ODD ) func marshalPageSet(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PageSet(c), nil } // PrintOperationAction is a representation of GTK's GtkPrintError. type PrintError int const ( PRINT_ERROR_GENERAL PrintError = C.GTK_PRINT_ERROR_GENERAL PRINT_ERROR_INTERNAL_ERROR PrintError = C.GTK_PRINT_ERROR_INTERNAL_ERROR PRINT_ERROR_NOMEM PrintError = C.GTK_PRINT_ERROR_NOMEM PRINT_ERROR_INVALID_FILE PrintError = C.GTK_PRINT_ERROR_INVALID_FILE ) func marshalPrintError(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PrintError(c), nil } // PrintOperationAction is a representation of GTK's GtkPrintOperationAction. type PrintOperationAction int const ( PRINT_OPERATION_ACTION_PRINT_DIALOG PrintOperationAction = C.GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG PRINT_OPERATION_ACTION_PRINT PrintOperationAction = C.GTK_PRINT_OPERATION_ACTION_PRINT PRINT_OPERATION_ACTION_PREVIEW PrintOperationAction = C.GTK_PRINT_OPERATION_ACTION_PREVIEW PRINT_OPERATION_ACTION_EXPORT PrintOperationAction = C.GTK_PRINT_OPERATION_ACTION_EXPORT ) func marshalPrintOperationAction(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PrintOperationAction(c), nil } // PrintOperationResult is a representation of GTK's GtkPrintOperationResult. type PrintOperationResult int const ( PRINT_OPERATION_RESULT_ERROR PrintOperationResult = C.GTK_PRINT_OPERATION_RESULT_ERROR PRINT_OPERATION_RESULT_APPLY PrintOperationResult = C.GTK_PRINT_OPERATION_RESULT_APPLY PRINT_OPERATION_RESULT_CANCEL PrintOperationResult = C.GTK_PRINT_OPERATION_RESULT_CANCEL PRINT_OPERATION_RESULT_IN_PROGRESS PrintOperationResult = C.GTK_PRINT_OPERATION_RESULT_IN_PROGRESS ) func marshalPrintOperationResult(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PrintOperationResult(c), nil } // PrintStatus is a representation of GTK's GtkPrintStatus. type PrintStatus int const ( PRINT_STATUS_INITIAL PrintStatus = C.GTK_PRINT_STATUS_INITIAL PRINT_STATUS_PREPARING PrintStatus = C.GTK_PRINT_STATUS_PREPARING PRINT_STATUS_GENERATING_DATA PrintStatus = C.GTK_PRINT_STATUS_GENERATING_DATA PRINT_STATUS_SENDING_DATA PrintStatus = C.GTK_PRINT_STATUS_SENDING_DATA PRINT_STATUS_PENDING PrintStatus = C.GTK_PRINT_STATUS_PENDING PRINT_STATUS_PENDING_ISSUE PrintStatus = C.GTK_PRINT_STATUS_PENDING_ISSUE PRINT_STATUS_PRINTING PrintStatus = C.GTK_PRINT_STATUS_PRINTING PRINT_STATUS_FINISHED PrintStatus = C.GTK_PRINT_STATUS_FINISHED PRINT_STATUS_FINISHED_ABORTED PrintStatus = C.GTK_PRINT_STATUS_FINISHED_ABORTED ) func marshalPrintStatus(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PrintStatus(c), nil } // PrintQuality is a representation of GTK's GtkPrintQuality. type PrintQuality int const ( PRINT_QUALITY_LOW PrintQuality = C.GTK_PRINT_QUALITY_LOW PRINT_QUALITY_NORMAL PrintQuality = C.GTK_PRINT_QUALITY_NORMAL PRINT_QUALITY_HIGH PrintQuality = C.GTK_PRINT_QUALITY_HIGH PRINT_QUALITY_DRAFT PrintQuality = C.GTK_PRINT_QUALITY_DRAFT ) func marshalPrintQuality(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return PrintQuality(c), nil } // Unit is a representation of GTK's GtkUnit. type Unit int const ( GTK_UNIT_NONE Unit = C.GTK_UNIT_NONE GTK_UNIT_POINTS Unit = C.GTK_UNIT_POINTS GTK_UNIT_INCH Unit = C.GTK_UNIT_INCH GTK_UNIT_MM Unit = C.GTK_UNIT_MM ) func marshalUnit(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Unit(c), nil } /* * GtkPageSetup */ type PageSetup struct { *glib.Object } func (ps *PageSetup) native() *C.GtkPageSetup { if ps == nil || ps.GObject == nil { return nil } p := unsafe.Pointer(ps.GObject) return C.toGtkPageSetup(p) } func marshalPageSetup(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapPageSetup(obj), nil } func wrapPageSetup(obj *glib.Object) *PageSetup { if obj == nil { return nil } return &PageSetup{obj} } // PageSetupNew() is a wrapper around gtk_page_setup_new(). func PageSetupNew() (*PageSetup, error) { c := C.gtk_page_setup_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapPageSetup(obj), nil } // Copy() is a wrapper around gtk_page_setup_copy(). func (ps *PageSetup) Copy() (*PageSetup, error) { c := C.gtk_page_setup_copy(ps.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapPageSetup(obj), nil } // GetOrientation() is a wrapper around gtk_page_setup_get_orientation(). func (ps *PageSetup) GetOrientation() PageOrientation { c := C.gtk_page_setup_get_orientation(ps.native()) return PageOrientation(c) } // SetOrientation() is a wrapper around gtk_page_setup_set_orientation(). func (ps *PageSetup) SetOrientation(orientation PageOrientation) { C.gtk_page_setup_set_orientation(ps.native(), C.GtkPageOrientation(orientation)) } // GetPaperSize() is a wrapper around gtk_page_setup_get_paper_size(). func (ps *PageSetup) GetPaperSize() *PaperSize { c := C.gtk_page_setup_get_paper_size(ps.native()) p := &PaperSize{c} runtime.SetFinalizer(p, func(v *PaperSize) { glib.FinalizerStrategy(v.free) }) return p } // SetPaperSize() is a wrapper around gtk_page_setup_set_paper_size(). func (ps *PageSetup) SetPaperSize(size *PaperSize) { C.gtk_page_setup_set_paper_size(ps.native(), size.native()) } // GetTopMargin() is a wrapper around gtk_page_setup_get_top_margin(). func (ps *PageSetup) GetTopMargin(unit Unit) float64 { c := C.gtk_page_setup_get_top_margin(ps.native(), C.GtkUnit(unit)) return float64(c) } // SetTopMargin() is a wrapper around gtk_page_setup_set_top_margin(). func (ps *PageSetup) SetTopMargin(margin float64, unit Unit) { C.gtk_page_setup_set_top_margin(ps.native(), C.gdouble(margin), C.GtkUnit(unit)) } // GetBottomMargin() is a wrapper around gtk_page_setup_get_bottom_margin(). func (ps *PageSetup) GetBottomMargin(unit Unit) float64 { c := C.gtk_page_setup_get_bottom_margin(ps.native(), C.GtkUnit(unit)) return float64(c) } // SetBottomMargin() is a wrapper around gtk_page_setup_set_bottom_margin(). func (ps *PageSetup) SetBottomMargin(margin float64, unit Unit) { C.gtk_page_setup_set_bottom_margin(ps.native(), C.gdouble(margin), C.GtkUnit(unit)) } // GetLeftMargin() is a wrapper around gtk_page_setup_get_left_margin(). func (ps *PageSetup) GetLeftMargin(unit Unit) float64 { c := C.gtk_page_setup_get_left_margin(ps.native(), C.GtkUnit(unit)) return float64(c) } // SetLeftMargin() is a wrapper around gtk_page_setup_set_left_margin(). func (ps *PageSetup) SetLeftMargin(margin float64, unit Unit) { C.gtk_page_setup_set_left_margin(ps.native(), C.gdouble(margin), C.GtkUnit(unit)) } // GetRightMargin() is a wrapper around gtk_page_setup_get_right_margin(). func (ps *PageSetup) GetRightMargin(unit Unit) float64 { c := C.gtk_page_setup_get_right_margin(ps.native(), C.GtkUnit(unit)) return float64(c) } // SetRightMargin() is a wrapper around gtk_page_setup_set_right_margin(). func (ps *PageSetup) SetRightMargin(margin float64, unit Unit) { C.gtk_page_setup_set_right_margin(ps.native(), C.gdouble(margin), C.GtkUnit(unit)) } // SetPaperSizeAndDefaultMargins() is a wrapper around gtk_page_setup_set_paper_size_and_default_margins(). func (ps *PageSetup) SetPaperSizeAndDefaultMargins(size *PaperSize) { C.gtk_page_setup_set_paper_size_and_default_margins(ps.native(), size.native()) } // GetPaperWidth() is a wrapper around gtk_page_setup_get_paper_width(). func (ps *PageSetup) GetPaperWidth(unit Unit) float64 { c := C.gtk_page_setup_get_paper_width(ps.native(), C.GtkUnit(unit)) return float64(c) } // GetPaperHeight() is a wrapper around gtk_page_setup_get_paper_height(). func (ps *PageSetup) GetPaperHeight(unit Unit) float64 { c := C.gtk_page_setup_get_paper_height(ps.native(), C.GtkUnit(unit)) return float64(c) } // GetPageWidth() is a wrapper around gtk_page_setup_get_page_width(). func (ps *PageSetup) GetPageWidth(unit Unit) float64 { c := C.gtk_page_setup_get_page_width(ps.native(), C.GtkUnit(unit)) return float64(c) } // GetPageHeight() is a wrapper around gtk_page_setup_get_page_height(). func (ps *PageSetup) GetPageHeight(unit Unit) float64 { c := C.gtk_page_setup_get_page_height(ps.native(), C.GtkUnit(unit)) return float64(c) } // PageSetupNewFromFile() is a wrapper around gtk_page_setup_new_from_file(). func PageSetupNewFromFile(fileName string) (*PageSetup, error) { cstr := C.CString(fileName) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil c := C.gtk_page_setup_new_from_file((*C.gchar)(cstr), &err) if c == nil { defer C.g_error_free(err) return nil, errors.New(C.GoString((*C.char)(err.message))) } obj := glib.Take(unsafe.Pointer(c)) return &PageSetup{obj}, nil } // PageSetupNewFromKeyFile() is a wrapper around gtk_page_setup_new_from_key_file(). // PageSetupLoadFile() is a wrapper around gtk_page_setup_load_file(). func (ps *PageSetup) PageSetupLoadFile(name string) error { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil res := C.gtk_page_setup_load_file(ps.native(), cstr, &err) if !gobool(res) { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // PageSetupLoadKeyFile() is a wrapper around gtk_page_setup_load_key_file(). // PageSetupToFile() is a wrapper around gtk_page_setup_to_file(). func (ps *PageSetup) PageSetupToFile(name string) error { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil res := C.gtk_page_setup_to_file(ps.native(), cstr, &err) if !gobool(res) { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // PageSetupToKeyFile() is a wrapper around gtk_page_setup_to_key_file(). /* * GtkPaperSize */ // PaperSize is a representation of GTK's GtkPaperSize type PaperSize struct { GtkPaperSize *C.GtkPaperSize } // native returns a pointer to the underlying GtkPaperSize. func (ps *PaperSize) native() *C.GtkPaperSize { if ps == nil { return nil } return ps.GtkPaperSize } func marshalPaperSize(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return &PaperSize{(*C.GtkPaperSize)(unsafe.Pointer(c))}, nil } const ( UNIT_PIXEL int = C.GTK_UNIT_PIXEL PAPER_NAME_A3 string = C.GTK_PAPER_NAME_A3 PAPER_NAME_A4 string = C.GTK_PAPER_NAME_A4 PAPER_NAME_A5 string = C.GTK_PAPER_NAME_A5 PAPER_NAME_B5 string = C.GTK_PAPER_NAME_B5 PAPER_NAME_LETTER string = C.GTK_PAPER_NAME_LETTER PAPER_NAME_EXECUTIVE string = C.GTK_PAPER_NAME_EXECUTIVE PAPER_NAME_LEGAL string = C.GTK_PAPER_NAME_LEGAL ) // PaperSizeNew() is a wrapper around gtk_paper_size_new(). func PaperSizeNew(name string) (*PaperSize, error) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) var gName *C.gchar if name == "" { gName = nil } else { gName = (*C.gchar)(cstr) } c := C.gtk_paper_size_new(gName) if c == nil { return nil, nilPtrErr } t := &PaperSize{c} runtime.SetFinalizer(t, func(v *PaperSize) { glib.FinalizerStrategy(v.free) }) return t, nil } // PaperSizeNewFromPPD() is a wrapper around gtk_paper_size_new_from_ppd(). func PaperSizeNewFromPPD(name, displayName string, width, height float64) (*PaperSize, error) { cName := C.CString(name) defer C.free(unsafe.Pointer(cName)) cDisplayName := C.CString(displayName) defer C.free(unsafe.Pointer(cDisplayName)) c := C.gtk_paper_size_new_from_ppd((*C.gchar)(cName), (*C.gchar)(cDisplayName), C.gdouble(width), C.gdouble(height)) if c == nil { return nil, nilPtrErr } t := &PaperSize{c} runtime.SetFinalizer(t, func(v *PaperSize) { glib.FinalizerStrategy(v.free) }) return t, nil } // PaperSizeNewCustom() is a wrapper around gtk_paper_size_new_custom(). func PaperSizeNewCustom(name, displayName string, width, height float64, unit Unit) (*PaperSize, error) { cName := C.CString(name) defer C.free(unsafe.Pointer(cName)) cDisplayName := C.CString(displayName) defer C.free(unsafe.Pointer(cDisplayName)) c := C.gtk_paper_size_new_custom((*C.gchar)(cName), (*C.gchar)(cDisplayName), C.gdouble(width), C.gdouble(height), C.GtkUnit(unit)) if c == nil { return nil, nilPtrErr } t := &PaperSize{c} runtime.SetFinalizer(t, func(v *PaperSize) { glib.FinalizerStrategy(v.free) }) return t, nil } // Copy() is a wrapper around gtk_paper_size_copy(). func (ps *PaperSize) Copy() (*PaperSize, error) { c := C.gtk_paper_size_copy(ps.native()) if c == nil { return nil, nilPtrErr } t := &PaperSize{c} runtime.SetFinalizer(t, func(v *PaperSize) { glib.FinalizerStrategy(v.free) }) return t, nil } // free() is a wrapper around gtk_paper_size_free(). func (ps *PaperSize) free() { C.gtk_paper_size_free(ps.native()) } // IsEqual() is a wrapper around gtk_paper_size_is_equal(). func (ps *PaperSize) IsEqual(other *PaperSize) bool { c := C.gtk_paper_size_is_equal(ps.native(), other.native()) return gobool(c) } // PaperSizeGetPaperSizes() is a wrapper around gtk_paper_size_get_paper_sizes(). func PaperSizeGetPaperSizes(includeCustom bool) *glib.List { clist := C.gtk_paper_size_get_paper_sizes(gbool(includeCustom)) if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return &PaperSize{(*C.GtkPaperSize)(ptr)} }) runtime.SetFinalizer(glist, func(glist *glib.List) { glib.FinalizerStrategy(func() { glist.FreeFull(func(item interface{}) { ps := item.(*PaperSize) C.gtk_paper_size_free(ps.GtkPaperSize) }) }) }) return glist } // GetName() is a wrapper around gtk_paper_size_get_name(). func (ps *PaperSize) GetName() string { c := C.gtk_paper_size_get_name(ps.native()) return C.GoString((*C.char)(c)) } // GetDisplayName() is a wrapper around gtk_paper_size_get_display_name(). func (ps *PaperSize) GetDisplayName() string { c := C.gtk_paper_size_get_display_name(ps.native()) return C.GoString((*C.char)(c)) } // GetPPDName() is a wrapper around gtk_paper_size_get_ppd_name(). func (ps *PaperSize) GetPPDName() (string, error) { c := C.gtk_paper_size_get_ppd_name(ps.native()) if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // GetWidth() is a wrapper around gtk_paper_size_get_width(). func (ps *PaperSize) GetWidth(unit Unit) float64 { c := C.gtk_paper_size_get_width(ps.native(), C.GtkUnit(unit)) return float64(c) } // GetHeight() is a wrapper around gtk_paper_size_get_height(). func (ps *PaperSize) GetHeight(unit Unit) float64 { c := C.gtk_paper_size_get_width(ps.native(), C.GtkUnit(unit)) return float64(c) } // IsCustom() is a wrapper around gtk_paper_size_is_custom(). func (ps *PaperSize) IsCustom() bool { c := C.gtk_paper_size_is_custom(ps.native()) return gobool(c) } // SetSize() is a wrapper around gtk_paper_size_set_size(). func (ps *PaperSize) SetSize(width, height float64, unit Unit) { C.gtk_paper_size_set_size(ps.native(), C.gdouble(width), C.gdouble(height), C.GtkUnit(unit)) } // GetDefaultTopMargin() is a wrapper around gtk_paper_size_get_default_top_margin(). func (ps *PaperSize) GetDefaultTopMargin(unit Unit) float64 { c := C.gtk_paper_size_get_default_top_margin(ps.native(), C.GtkUnit(unit)) return float64(c) } // GetDefaultBottomMargin() is a wrapper around gtk_paper_size_get_default_bottom_margin(). func (ps *PaperSize) GetDefaultBottomMargin(unit Unit) float64 { c := C.gtk_paper_size_get_default_bottom_margin(ps.native(), C.GtkUnit(unit)) return float64(c) } // GetDefaultLeftMargin() is a wrapper around gtk_paper_size_get_default_left_margin(). func (ps *PaperSize) GetDefaultLeftMargin(unit Unit) float64 { c := C.gtk_paper_size_get_default_left_margin(ps.native(), C.GtkUnit(unit)) return float64(c) } // GetDefaultRightMargin() is a wrapper around gtk_paper_size_get_default_right_margin(). func (ps *PaperSize) GetDefaultRightMargin(unit Unit) float64 { c := C.gtk_paper_size_get_default_right_margin(ps.native(), C.GtkUnit(unit)) return float64(c) } // PaperSizeGetDefault() is a wrapper around gtk_paper_size_get_default(). func PaperSizeGetDefaultRightMargin(unit Unit) string { c := C.gtk_paper_size_get_default() return C.GoString((*C.char)(c)) } // PaperSizeNewFromKeyFile() is a wrapper around gtk_paper_size_new_from_key_file(). // PaperSizeToKeyFile() is a wrapper around gtk_paper_size_to_key_file(). /* * GtkPrintContext */ // PrintContext is a representation of GTK's GtkPrintContext. type PrintContext struct { *glib.Object } // native() returns a pointer to the underlying GtkPrintContext. func (pc *PrintContext) native() *C.GtkPrintContext { if pc == nil || pc.GObject == nil { return nil } p := unsafe.Pointer(pc.GObject) return C.toGtkPrintContext(p) } func marshalPrintContext(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapPrintContext(obj), nil } func wrapPrintContext(obj *glib.Object) *PrintContext { if obj == nil { return nil } return &PrintContext{obj} } // GetCairoContext() is a wrapper around gtk_print_context_get_cairo_context(). func (pc *PrintContext) GetCairoContext() *cairo.Context { c := C.gtk_print_context_get_cairo_context(pc.native()) return cairo.WrapContext(uintptr(unsafe.Pointer(c))) } // SetCairoContext() is a wrapper around gtk_print_context_set_cairo_context(). func (pc *PrintContext) SetCairoContext(cr *cairo.Context, dpiX, dpiY float64) { C.gtk_print_context_set_cairo_context(pc.native(), (*C.cairo_t)(unsafe.Pointer(cr.Native())), C.double(dpiX), C.double(dpiY)) } // GetPageSetup() is a wrapper around gtk_print_context_get_page_setup(). func (pc *PrintContext) GetPageSetup() *PageSetup { c := C.gtk_print_context_get_page_setup(pc.native()) obj := glib.Take(unsafe.Pointer(c)) return wrapPageSetup(obj) } // GetWidth() is a wrapper around gtk_print_context_get_width(). func (pc *PrintContext) GetWidth() float64 { c := C.gtk_print_context_get_width(pc.native()) return float64(c) } // GetHeight() is a wrapper around gtk_print_context_get_height(). func (pc *PrintContext) GetHeight() float64 { c := C.gtk_print_context_get_height(pc.native()) return float64(c) } // GetDpiX() is a wrapper around gtk_print_context_get_dpi_x(). func (pc *PrintContext) GetDpiX() float64 { c := C.gtk_print_context_get_dpi_x(pc.native()) return float64(c) } // GetDpiY() is a wrapper around gtk_print_context_get_dpi_y(). func (pc *PrintContext) GetDpiY() float64 { c := C.gtk_print_context_get_dpi_y(pc.native()) return float64(c) } // GetPangoFontMap() is a wrapper around gtk_print_context_get_pango_fontmap(). func (pc *PrintContext) GetPangoFontMap() *pango.FontMap { c := C.gtk_print_context_get_pango_fontmap(pc.native()) return pango.WrapFontMap(uintptr(unsafe.Pointer(c))) } // CreatePangoContext() is a wrapper around gtk_print_context_create_pango_context(). func (pc *PrintContext) CreatePangoContext() *pango.Context { c := C.gtk_print_context_create_pango_context(pc.native()) return pango.WrapContext(uintptr(unsafe.Pointer(c))) } // CreatePangoLayout() is a wrapper around gtk_print_context_create_pango_layout(). func (pc *PrintContext) CreatePangoLayout() *pango.Layout { c := C.gtk_print_context_create_pango_layout(pc.native()) return pango.WrapLayout(uintptr(unsafe.Pointer(c))) } // GetHardMargins() is a wrapper around gtk_print_context_get_hard_margins(). func (pc *PrintContext) GetHardMargins() (float64, float64, float64, float64, error) { var top, bottom, left, right C.gdouble c := C.gtk_print_context_get_hard_margins(pc.native(), &top, &bottom, &left, &right) if gobool(c) == false { return 0.0, 0.0, 0.0, 0.0, errors.New("unable to retrieve hard margins") } return float64(top), float64(bottom), float64(left), float64(right), nil } /* * GtkPrintOperation */ type PrintOperation struct { *glib.Object // Interfaces PrintOperationPreview } func (po *PrintOperation) native() *C.GtkPrintOperation { if po == nil || po.GObject == nil { return nil } p := unsafe.Pointer(po.GObject) return C.toGtkPrintOperation(p) } func (v *PrintOperation) toPrintOperationPreview() *C.GtkPrintOperationPreview { if v == nil { return nil } return C.toGtkPrintOperationPreview(unsafe.Pointer(v.GObject)) } func marshalPrintOperation(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapPrintOperation(obj), nil } func wrapPrintOperation(obj *glib.Object) *PrintOperation { if obj == nil { return nil } pop := wrapPrintOperationPreview(obj) return &PrintOperation{obj, *pop} } // PrintOperationNew() is a wrapper around gtk_print_operation_new(). func PrintOperationNew() (*PrintOperation, error) { c := C.gtk_print_operation_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapPrintOperation(obj), nil } // SetAllowAsync() is a wrapper around gtk_print_operation_set_allow_async(). func (po *PrintOperation) PrintOperationSetAllowAsync(allowSync bool) { C.gtk_print_operation_set_allow_async(po.native(), gbool(allowSync)) } // GetError() is a wrapper around gtk_print_operation_get_error(). func (po *PrintOperation) PrintOperationGetError() error { var err *C.GError = nil C.gtk_print_operation_get_error(po.native(), &err) defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } // SetDefaultPageSetup() is a wrapper around gtk_print_operation_set_default_page_setup(). func (po *PrintOperation) SetDefaultPageSetup(ps *PageSetup) { C.gtk_print_operation_set_default_page_setup(po.native(), ps.native()) } // GetDefaultPageSetup() is a wrapper around gtk_print_operation_get_default_page_setup(). func (po *PrintOperation) GetDefaultPageSetup() (*PageSetup, error) { c := C.gtk_print_operation_get_default_page_setup(po.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapPageSetup(obj), nil } // SetPrintSettings() is a wrapper around gtk_print_operation_set_print_settings(). func (po *PrintOperation) SetPrintSettings(ps *PrintSettings) { C.gtk_print_operation_set_print_settings(po.native(), ps.native()) } // GetPrintSettings() is a wrapper around gtk_print_operation_get_print_settings(). func (po *PrintOperation) GetPrintSettings(ps *PageSetup) (*PrintSettings, error) { c := C.gtk_print_operation_get_print_settings(po.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapPrintSettings(obj), nil } // SetJobName() is a wrapper around gtk_print_operation_set_job_name(). func (po *PrintOperation) SetJobName(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_operation_set_job_name(po.native(), (*C.gchar)(cstr)) } // SetNPages() is a wrapper around gtk_print_operation_set_n_pages(). func (po *PrintOperation) SetNPages(pages int) { C.gtk_print_operation_set_n_pages(po.native(), C.gint(pages)) } // GetNPagesToPrint() is a wrapper around gtk_print_operation_get_n_pages_to_print(). func (po *PrintOperation) GetNPagesToPrint() int { c := C.gtk_print_operation_get_n_pages_to_print(po.native()) return int(c) } // SetCurrentPage() is a wrapper around gtk_print_operation_set_current_page(). func (po *PrintOperation) SetCurrentPage(page int) { C.gtk_print_operation_set_current_page(po.native(), C.gint(page)) } // SetUseFullPage() is a wrapper around gtk_print_operation_set_use_full_page(). func (po *PrintOperation) SetUseFullPage(full bool) { C.gtk_print_operation_set_use_full_page(po.native(), gbool(full)) } // SetUnit() is a wrapper around gtk_print_operation_set_unit(). func (po *PrintOperation) SetUnit(unit Unit) { C.gtk_print_operation_set_unit(po.native(), C.GtkUnit(unit)) } // SetExportFilename() is a wrapper around gtk_print_operation_set_export_filename(). func (po *PrintOperation) SetExportFilename(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_operation_set_export_filename(po.native(), (*C.gchar)(cstr)) } // SetShowProgress() is a wrapper around gtk_print_operation_set_show_progress(). func (po *PrintOperation) SetShowProgress(show bool) { C.gtk_print_operation_set_show_progress(po.native(), gbool(show)) } // SetTrackPrintStatus() is a wrapper around gtk_print_operation_set_track_print_status(). func (po *PrintOperation) SetTrackPrintStatus(progress bool) { C.gtk_print_operation_set_track_print_status(po.native(), gbool(progress)) } // SetCustomTabLabel() is a wrapper around gtk_print_operation_set_custom_tab_label(). func (po *PrintOperation) SetCustomTabLabel(label string) { cstr := C.CString(label) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_operation_set_custom_tab_label(po.native(), (*C.gchar)(cstr)) } // Run() is a wrapper around gtk_print_operation_run(). func (po *PrintOperation) Run(action PrintOperationAction, parent IWindow) (PrintOperationResult, error) { var err *C.GError = nil var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } c := C.gtk_print_operation_run(po.native(), C.GtkPrintOperationAction(action), w, &err) res := PrintOperationResult(c) if res == PRINT_OPERATION_RESULT_ERROR { defer C.g_error_free(err) return res, errors.New(C.GoString((*C.char)(err.message))) } return res, nil } // Cancel() is a wrapper around gtk_print_operation_cancel(). func (po *PrintOperation) Cancel() { C.gtk_print_operation_cancel(po.native()) } // DrawPageFinish() is a wrapper around gtk_print_operation_draw_page_finish(). func (po *PrintOperation) DrawPageFinish() { C.gtk_print_operation_draw_page_finish(po.native()) } // SetDeferDrawing() is a wrapper around gtk_print_operation_set_defer_drawing(). func (po *PrintOperation) SetDeferDrawing() { C.gtk_print_operation_set_defer_drawing(po.native()) } // GetStatus() is a wrapper around gtk_print_operation_get_status(). func (po *PrintOperation) GetStatus() PrintStatus { c := C.gtk_print_operation_get_status(po.native()) return PrintStatus(c) } // GetStatusString() is a wrapper around gtk_print_operation_get_status_string(). func (po *PrintOperation) GetStatusString() string { c := C.gtk_print_operation_get_status_string(po.native()) return C.GoString((*C.char)(c)) } // IsFinished() is a wrapper around gtk_print_operation_is_finished(). func (po *PrintOperation) IsFinished() bool { c := C.gtk_print_operation_is_finished(po.native()) return gobool(c) } // SetSupportSelection() is a wrapper around gtk_print_operation_set_support_selection(). func (po *PrintOperation) SetSupportSelection(selection bool) { C.gtk_print_operation_set_support_selection(po.native(), gbool(selection)) } // GetSupportSelection() is a wrapper around gtk_print_operation_get_support_selection(). func (po *PrintOperation) GetSupportSelection() bool { c := C.gtk_print_operation_get_support_selection(po.native()) return gobool(c) } // SetHasSelection() is a wrapper around gtk_print_operation_set_has_selection(). func (po *PrintOperation) SetHasSelection(selection bool) { C.gtk_print_operation_set_has_selection(po.native(), gbool(selection)) } // GetHasSelection() is a wrapper around gtk_print_operation_get_has_selection(). func (po *PrintOperation) GetHasSelection() bool { c := C.gtk_print_operation_get_has_selection(po.native()) return gobool(c) } // SetEmbedPageSetup() is a wrapper around gtk_print_operation_set_embed_page_setup(). func (po *PrintOperation) SetEmbedPageSetup(embed bool) { C.gtk_print_operation_set_embed_page_setup(po.native(), gbool(embed)) } // GetEmbedPageSetup() is a wrapper around gtk_print_operation_get_embed_page_setup(). func (po *PrintOperation) GetEmbedPageSetup() bool { c := C.gtk_print_operation_get_embed_page_setup(po.native()) return gobool(c) } // PrintRunPageSetupDialog() is a wrapper around gtk_print_run_page_setup_dialog(). func PrintRunPageSetupDialog(parent IWindow, pageSetup *PageSetup, settings *PrintSettings) *PageSetup { var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } c := C.gtk_print_run_page_setup_dialog(w, pageSetup.native(), settings.native()) obj := glib.Take(unsafe.Pointer(c)) return wrapPageSetup(obj) } type PageSetupDoneCallback func(setup *PageSetup) // PrintRunPageSetupDialogAsync() is a wrapper around gtk_print_run_page_setup_dialog_async(). func PrintRunPageSetupDialogAsync(parent IWindow, setup *PageSetup, settings *PrintSettings, cb PageSetupDoneCallback) { var w *C.GtkWindow = nil if parent != nil { w = parent.toWindow() } C._gtk_print_run_page_setup_dialog_async(w, setup.native(), settings.native(), C.gpointer(callback.Assign(cb))) } /* * GtkPrintOperationPreview */ // PrintOperationPreview is a representation of GTK's GtkPrintOperationPreview GInterface. type PrintOperationPreview struct { *glib.Object } // IPrintOperationPreview is an interface type implemented by all structs // embedding a PrintOperationPreview. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkPrintOperationPreview. type IPrintOperationPreview interface { toPrintOperationPreview() *C.GtkPrintOperationPreview } // native() returns a pointer to the underlying GObject as a GtkPrintOperationPreview. func (v *PrintOperationPreview) native() *C.GtkPrintOperationPreview { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkPrintOperationPreview(p) } func marshalPrintOperationPreview(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapPrintOperationPreview(obj), nil } func wrapPrintOperationPreview(obj *glib.Object) *PrintOperationPreview { if obj == nil { return nil } return &PrintOperationPreview{obj} } func (v *PrintOperationPreview) toPrintOperationPreview() *C.GtkPrintOperationPreview { if v == nil { return nil } return v.native() } // RenderPage()() is a wrapper around gtk_print_operation_preview_render_page(). func (pop *PrintOperationPreview) RenderPage(page int) { C.gtk_print_operation_preview_render_page(pop.native(), C.gint(page)) } // EndPreview()() is a wrapper around gtk_print_operation_preview_end_preview(). func (pop *PrintOperationPreview) EndPreview() { C.gtk_print_operation_preview_end_preview(pop.native()) } // IsSelected()() is a wrapper around gtk_print_operation_preview_is_selected(). func (pop *PrintOperationPreview) IsSelected(page int) bool { c := C.gtk_print_operation_preview_is_selected(pop.native(), C.gint(page)) return gobool(c) } /* * GtkPrintSettings */ type PrintSettings struct { *glib.Object } func (ps *PrintSettings) native() *C.GtkPrintSettings { if ps == nil || ps.GObject == nil { return nil } p := unsafe.Pointer(ps.GObject) return C.toGtkPrintSettings(p) } func marshalPrintSettings(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapPrintSettings(glib.Take(unsafe.Pointer(c))), nil } func wrapPrintSettings(obj *glib.Object) *PrintSettings { if obj == nil { return nil } return &PrintSettings{obj} } const ( PRINT_SETTINGS_PRINTER string = C.GTK_PRINT_SETTINGS_PRINTER PRINT_SETTINGS_ORIENTATION string = C.GTK_PRINT_SETTINGS_ORIENTATION PRINT_SETTINGS_PAPER_FORMAT string = C.GTK_PRINT_SETTINGS_PAPER_FORMAT PRINT_SETTINGS_PAPER_WIDTH string = C.GTK_PRINT_SETTINGS_PAPER_WIDTH PRINT_SETTINGS_PAPER_HEIGHT string = C.GTK_PRINT_SETTINGS_PAPER_HEIGHT PRINT_SETTINGS_USE_COLOR string = C.GTK_PRINT_SETTINGS_USE_COLOR PRINT_SETTINGS_COLLATE string = C.GTK_PRINT_SETTINGS_COLLATE PRINT_SETTINGS_REVERSE string = C.GTK_PRINT_SETTINGS_REVERSE PRINT_SETTINGS_DUPLEX string = C.GTK_PRINT_SETTINGS_DUPLEX PRINT_SETTINGS_QUALITY string = C.GTK_PRINT_SETTINGS_QUALITY PRINT_SETTINGS_N_COPIES string = C.GTK_PRINT_SETTINGS_N_COPIES PRINT_SETTINGS_NUMBER_UP string = C.GTK_PRINT_SETTINGS_NUMBER_UP PRINT_SETTINGS_NUMBER_UP_LAYOUT string = C.GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT PRINT_SETTINGS_RESOLUTION string = C.GTK_PRINT_SETTINGS_RESOLUTION PRINT_SETTINGS_RESOLUTION_X string = C.GTK_PRINT_SETTINGS_RESOLUTION_X PRINT_SETTINGS_RESOLUTION_Y string = C.GTK_PRINT_SETTINGS_RESOLUTION_Y PRINT_SETTINGS_PRINTER_LPI string = C.GTK_PRINT_SETTINGS_PRINTER_LPI PRINT_SETTINGS_SCALE string = C.GTK_PRINT_SETTINGS_SCALE PRINT_SETTINGS_PRINT_PAGES string = C.GTK_PRINT_SETTINGS_PRINT_PAGES PRINT_SETTINGS_PAGE_RANGES string = C.GTK_PRINT_SETTINGS_PAGE_RANGES PRINT_SETTINGS_PAGE_SET string = C.GTK_PRINT_SETTINGS_PAGE_SET PRINT_SETTINGS_DEFAULT_SOURCE string = C.GTK_PRINT_SETTINGS_DEFAULT_SOURCE PRINT_SETTINGS_MEDIA_TYPE string = C.GTK_PRINT_SETTINGS_MEDIA_TYPE PRINT_SETTINGS_DITHER string = C.GTK_PRINT_SETTINGS_DITHER PRINT_SETTINGS_FINISHINGS string = C.GTK_PRINT_SETTINGS_FINISHINGS PRINT_SETTINGS_OUTPUT_BIN string = C.GTK_PRINT_SETTINGS_OUTPUT_BIN PRINT_SETTINGS_OUTPUT_DIR string = C.GTK_PRINT_SETTINGS_OUTPUT_DIR PRINT_SETTINGS_OUTPUT_BASENAME string = C.GTK_PRINT_SETTINGS_OUTPUT_BASENAME PRINT_SETTINGS_OUTPUT_FILE_FORMAT string = C.GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT PRINT_SETTINGS_OUTPUT_URI string = C.GTK_PRINT_SETTINGS_OUTPUT_URI PRINT_SETTINGS_WIN32_DRIVER_EXTRA string = C.GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA PRINT_SETTINGS_WIN32_DRIVER_VERSION string = C.GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION ) // PrintSettingsNew() is a wrapper around gtk_print_settings_new(). func PrintSettingsNew() (*PrintSettings, error) { c := C.gtk_print_settings_new() if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapPrintSettings(obj), nil } // Copy() is a wrapper around gtk_print_settings_copy(). func (ps *PrintSettings) Copy() (*PrintSettings, error) { c := C.gtk_print_settings_copy(ps.native()) if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapPrintSettings(obj), nil } // HasKey() is a wrapper around gtk_print_settings_has_key(). func (ps *PrintSettings) HasKey(key string) bool { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_print_settings_has_key(ps.native(), (*C.gchar)(cstr)) return gobool(c) } // Get() is a wrapper around gtk_print_settings_get(). func (ps *PrintSettings) Get(key string) string { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_print_settings_get(ps.native(), (*C.gchar)(cstr)) return C.GoString((*C.char)(c)) } // Set() is a wrapper around gtk_print_settings_set(). // TODO: Since value can't be nil, we can't unset values here. func (ps *PrintSettings) Set(key, value string) { cKey := C.CString(key) defer C.free(unsafe.Pointer(cKey)) cValue := C.CString(value) defer C.free(unsafe.Pointer(cValue)) C.gtk_print_settings_set(ps.native(), (*C.gchar)(cKey), (*C.gchar)(cValue)) } // Unset() is a wrapper around gtk_print_settings_unset(). func (ps *PrintSettings) Unset(key string) { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_unset(ps.native(), (*C.gchar)(cstr)) } type PrintSettingsCallback func(key, value string) // Foreach() is a wrapper around gtk_print_settings_foreach(). func (ps *PrintSettings) ForEach(cb PrintSettingsCallback) { // Clean up callback immediately as we only need it for the duration of this Foreach call id := callback.Assign(cb) defer callback.Delete(id) C._gtk_print_settings_foreach(ps.native(), C.gpointer(id)) } // GetBool() is a wrapper around gtk_print_settings_get_bool(). func (ps *PrintSettings) GetBool(key string) bool { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_print_settings_get_bool(ps.native(), (*C.gchar)(cstr)) return gobool(c) } // SetBool() is a wrapper around gtk_print_settings_set_bool(). func (ps *PrintSettings) SetBool(key string, value bool) { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_set_bool(ps.native(), (*C.gchar)(cstr), gbool(value)) } // GetDouble() is a wrapper around gtk_print_settings_get_double(). func (ps *PrintSettings) GetDouble(key string) float64 { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_print_settings_get_double(ps.native(), (*C.gchar)(cstr)) return float64(c) } // GetDoubleWithDefault() is a wrapper around gtk_print_settings_get_double_with_default(). func (ps *PrintSettings) GetDoubleWithDefault(key string, def float64) float64 { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_print_settings_get_double_with_default(ps.native(), (*C.gchar)(cstr), C.gdouble(def)) return float64(c) } // SetDouble() is a wrapper around gtk_print_settings_set_double(). func (ps *PrintSettings) SetDouble(key string, value float64) { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_set_double(ps.native(), (*C.gchar)(cstr), C.gdouble(value)) } // GetLength() is a wrapper around gtk_print_settings_get_length(). func (ps *PrintSettings) GetLength(key string, unit Unit) float64 { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_print_settings_get_length(ps.native(), (*C.gchar)(cstr), C.GtkUnit(unit)) return float64(c) } // SetLength() is a wrapper around gtk_print_settings_set_length(). func (ps *PrintSettings) SetLength(key string, value float64, unit Unit) { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_set_length(ps.native(), (*C.gchar)(cstr), C.gdouble(value), C.GtkUnit(unit)) } // GetInt() is a wrapper around gtk_print_settings_get_int(). func (ps *PrintSettings) GetInt(key string) int { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_print_settings_get_int(ps.native(), (*C.gchar)(cstr)) return int(c) } // GetIntWithDefault() is a wrapper around gtk_print_settings_get_int_with_default(). func (ps *PrintSettings) GetIntWithDefault(key string, def int) int { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_print_settings_get_int_with_default(ps.native(), (*C.gchar)(cstr), C.gint(def)) return int(c) } // SetInt() is a wrapper around gtk_print_settings_set_int(). func (ps *PrintSettings) SetInt(key string, value int) { cstr := C.CString(key) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_set_int(ps.native(), (*C.gchar)(cstr), C.gint(value)) } // GetPrinter() is a wrapper around gtk_print_settings_get_printer(). func (ps *PrintSettings) GetPrinter() string { c := C.gtk_print_settings_get_printer(ps.native()) return C.GoString((*C.char)(c)) } // SetPrinter() is a wrapper around gtk_print_settings_set_printer(). func (ps *PrintSettings) SetPrinter(printer string) { cstr := C.CString(printer) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_set_printer(ps.native(), (*C.gchar)(cstr)) } // GetOrientation() is a wrapper around gtk_print_settings_get_orientation(). func (ps *PrintSettings) GetOrientation() PageOrientation { c := C.gtk_print_settings_get_orientation(ps.native()) return PageOrientation(c) } // SetOrientation() is a wrapper around gtk_print_settings_set_orientation(). func (ps *PrintSettings) SetOrientation(orientation PageOrientation) { C.gtk_print_settings_set_orientation(ps.native(), C.GtkPageOrientation(orientation)) } // GetPaperSize() is a wrapper around gtk_print_settings_get_paper_size(). func (ps *PrintSettings) GetPaperSize() (*PaperSize, error) { c := C.gtk_print_settings_get_paper_size(ps.native()) if c == nil { return nil, nilPtrErr } p := &PaperSize{c} runtime.SetFinalizer(p, func(v *PaperSize) { glib.FinalizerStrategy(v.free) }) return p, nil } // SetPaperSize() is a wrapper around gtk_print_settings_set_paper_size(). func (ps *PrintSettings) SetPaperSize(size *PaperSize) { C.gtk_print_settings_set_paper_size(ps.native(), size.native()) } // GetPaperWidth() is a wrapper around gtk_print_settings_get_paper_width(). func (ps *PrintSettings) GetPaperWidth(unit Unit) float64 { c := C.gtk_print_settings_get_paper_width(ps.native(), C.GtkUnit(unit)) return float64(c) } // SetPaperWidth() is a wrapper around gtk_print_settings_set_paper_width(). func (ps *PrintSettings) SetPaperWidth(width float64, unit Unit) { C.gtk_print_settings_set_paper_width(ps.native(), C.gdouble(width), C.GtkUnit(unit)) } // GetPaperHeight() is a wrapper around gtk_print_settings_get_paper_height(). func (ps *PrintSettings) GetPaperHeight(unit Unit) float64 { c := C.gtk_print_settings_get_paper_height(ps.native(), C.GtkUnit(unit)) return float64(c) } // SetPaperHeight() is a wrapper around gtk_print_settings_set_paper_height(). func (ps *PrintSettings) SetPaperHeight(width float64, unit Unit) { C.gtk_print_settings_set_paper_height(ps.native(), C.gdouble(width), C.GtkUnit(unit)) } // GetUseColor() is a wrapper around gtk_print_settings_get_use_color(). func (ps *PrintSettings) GetUseColor() bool { c := C.gtk_print_settings_get_use_color(ps.native()) return gobool(c) } // SetUseColor() is a wrapper around gtk_print_settings_set_use_color(). func (ps *PrintSettings) SetUseColor(color bool) { C.gtk_print_settings_set_use_color(ps.native(), gbool(color)) } // GetCollate() is a wrapper around gtk_print_settings_get_collate(). func (ps *PrintSettings) GetCollate() bool { c := C.gtk_print_settings_get_collate(ps.native()) return gobool(c) } // SetCollate() is a wrapper around gtk_print_settings_set_collate(). func (ps *PrintSettings) SetCollate(collate bool) { C.gtk_print_settings_set_collate(ps.native(), gbool(collate)) } // GetReverse() is a wrapper around gtk_print_settings_get_reverse(). func (ps *PrintSettings) GetReverse() bool { c := C.gtk_print_settings_get_reverse(ps.native()) return gobool(c) } // SetReverse() is a wrapper around gtk_print_settings_set_reverse(). func (ps *PrintSettings) SetReverse(reverse bool) { C.gtk_print_settings_set_reverse(ps.native(), gbool(reverse)) } // GetDuplex() is a wrapper around gtk_print_settings_get_duplex(). func (ps *PrintSettings) GetDuplex() PrintDuplex { c := C.gtk_print_settings_get_duplex(ps.native()) return PrintDuplex(c) } // SetDuplex() is a wrapper around gtk_print_settings_set_duplex(). func (ps *PrintSettings) SetDuplex(duplex PrintDuplex) { C.gtk_print_settings_set_duplex(ps.native(), C.GtkPrintDuplex(duplex)) } // GetQuality() is a wrapper around gtk_print_settings_get_quality(). func (ps *PrintSettings) GetQuality() PrintQuality { c := C.gtk_print_settings_get_quality(ps.native()) return PrintQuality(c) } // SetQuality() is a wrapper around gtk_print_settings_set_quality(). func (ps *PrintSettings) SetQuality(quality PrintQuality) { C.gtk_print_settings_set_quality(ps.native(), C.GtkPrintQuality(quality)) } // GetNCopies() is a wrapper around gtk_print_settings_get_n_copies(). func (ps *PrintSettings) GetNCopies() int { c := C.gtk_print_settings_get_n_copies(ps.native()) return int(c) } // SetNCopies() is a wrapper around gtk_print_settings_set_n_copies(). func (ps *PrintSettings) SetNCopies(copies int) { C.gtk_print_settings_set_n_copies(ps.native(), C.gint(copies)) } // GetNmberUp() is a wrapper around gtk_print_settings_get_number_up(). func (ps *PrintSettings) GetNmberUp() int { c := C.gtk_print_settings_get_number_up(ps.native()) return int(c) } // SetNumberUp() is a wrapper around gtk_print_settings_set_number_up(). func (ps *PrintSettings) SetNumberUp(numberUp int) { C.gtk_print_settings_set_number_up(ps.native(), C.gint(numberUp)) } // GetNumberUpLayout() is a wrapper around gtk_print_settings_get_number_up_layout(). func (ps *PrintSettings) GetNumberUpLayout() NumberUpLayout { c := C.gtk_print_settings_get_number_up_layout(ps.native()) return NumberUpLayout(c) } // SetNumberUpLayout() is a wrapper around gtk_print_settings_set_number_up_layout(). func (ps *PrintSettings) SetNumberUpLayout(numberUpLayout NumberUpLayout) { C.gtk_print_settings_set_number_up_layout(ps.native(), C.GtkNumberUpLayout(numberUpLayout)) } // GetResolution() is a wrapper around gtk_print_settings_get_resolution(). func (ps *PrintSettings) GetResolution() int { c := C.gtk_print_settings_get_resolution(ps.native()) return int(c) } // SetResolution() is a wrapper around gtk_print_settings_set_resolution(). func (ps *PrintSettings) SetResolution(resolution int) { C.gtk_print_settings_set_resolution(ps.native(), C.gint(resolution)) } // SetResolutionXY() is a wrapper around gtk_print_settings_set_resolution_xy(). func (ps *PrintSettings) SetResolutionXY(resolutionX, resolutionY int) { C.gtk_print_settings_set_resolution_xy(ps.native(), C.gint(resolutionX), C.gint(resolutionY)) } // GetResolutionX() is a wrapper around gtk_print_settings_get_resolution_x(). func (ps *PrintSettings) GetResolutionX() int { c := C.gtk_print_settings_get_resolution_x(ps.native()) return int(c) } // GetResolutionY() is a wrapper around gtk_print_settings_get_resolution_y(). func (ps *PrintSettings) GetResolutionY() int { c := C.gtk_print_settings_get_resolution_y(ps.native()) return int(c) } // GetPrinterLpi() is a wrapper around gtk_print_settings_get_printer_lpi(). func (ps *PrintSettings) GetPrinterLpi() float64 { c := C.gtk_print_settings_get_printer_lpi(ps.native()) return float64(c) } // SetPrinterLpi() is a wrapper around gtk_print_settings_set_printer_lpi(). func (ps *PrintSettings) SetPrinterLpi(lpi float64) { C.gtk_print_settings_set_printer_lpi(ps.native(), C.gdouble(lpi)) } // GetScale() is a wrapper around gtk_print_settings_get_scale(). func (ps *PrintSettings) GetScale() float64 { c := C.gtk_print_settings_get_scale(ps.native()) return float64(c) } // SetScale() is a wrapper around gtk_print_settings_set_scale(). func (ps *PrintSettings) SetScale(scale float64) { C.gtk_print_settings_set_scale(ps.native(), C.gdouble(scale)) } // GetPrintPages() is a wrapper around gtk_print_settings_get_print_pages(). func (ps *PrintSettings) GetPrintPages() PrintPages { c := C.gtk_print_settings_get_print_pages(ps.native()) return PrintPages(c) } // SetPrintPages() is a wrapper around gtk_print_settings_set_print_pages(). func (ps *PrintSettings) SetPrintPages(pages PrintPages) { C.gtk_print_settings_set_print_pages(ps.native(), C.GtkPrintPages(pages)) } // GetPageSet() is a wrapper around gtk_print_settings_get_page_set(). func (ps *PrintSettings) GetPageSet(pages PrintPages) PageSet { c := C.gtk_print_settings_get_page_set(ps.native()) return PageSet(c) } // SetPageSet() is a wrapper around gtk_print_settings_set_page_set(). func (ps *PrintSettings) SetPageSet(pageSet PageSet) { C.gtk_print_settings_set_page_set(ps.native(), C.GtkPageSet(pageSet)) } // GetDefaultSource() is a wrapper around gtk_print_settings_get_default_source(). func (ps *PrintSettings) GetDefaultSource() string { c := C.gtk_print_settings_get_default_source(ps.native()) return C.GoString((*C.char)(c)) } // SetSefaultSource() is a wrapper around gtk_print_settings_set_default_source(). func (ps *PrintSettings) SetSefaultSource(defaultSource string) { cstr := C.CString(defaultSource) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_set_default_source(ps.native(), (*C.gchar)(cstr)) } // GetMediaType() is a wrapper around gtk_print_settings_get_media_type(). func (ps *PrintSettings) GetMediaType() string { c := C.gtk_print_settings_get_media_type(ps.native()) return C.GoString((*C.char)(c)) } // SetMediaType() is a wrapper around gtk_print_settings_set_media_type(). func (ps *PrintSettings) SetMediaType(mediaType string) { cstr := C.CString(mediaType) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_set_media_type(ps.native(), (*C.gchar)(cstr)) } // GetDither() is a wrapper around gtk_print_settings_get_dither(). func (ps *PrintSettings) GetDither() string { c := C.gtk_print_settings_get_dither(ps.native()) return C.GoString((*C.char)(c)) } // SetDither() is a wrapper around gtk_print_settings_set_dither(). func (ps *PrintSettings) SetDither(dither string) { cstr := C.CString(dither) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_set_dither(ps.native(), (*C.gchar)(cstr)) } // GetFinishings() is a wrapper around gtk_print_settings_get_finishings(). func (ps *PrintSettings) GetFinishings() string { c := C.gtk_print_settings_get_finishings(ps.native()) return C.GoString((*C.char)(c)) } // SetFinishings() is a wrapper around gtk_print_settings_set_finishings(). func (ps *PrintSettings) SetFinishings(dither string) { cstr := C.CString(dither) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_set_finishings(ps.native(), (*C.gchar)(cstr)) } // GetOutputBin() is a wrapper around gtk_print_settings_get_output_bin(). func (ps *PrintSettings) GetOutputBin() string { c := C.gtk_print_settings_get_output_bin(ps.native()) return C.GoString((*C.char)(c)) } // SetOutputBin() is a wrapper around gtk_print_settings_set_output_bin(). func (ps *PrintSettings) SetOutputBin(bin string) { cstr := C.CString(bin) defer C.free(unsafe.Pointer(cstr)) C.gtk_print_settings_set_output_bin(ps.native(), (*C.gchar)(cstr)) } // PrintSettingsNewFromFile() is a wrapper around gtk_print_settings_new_from_file(). func PrintSettingsNewFromFile(name string) (*PrintSettings, error) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil c := C.gtk_print_settings_new_from_file((*C.gchar)(cstr), &err) if c == nil { defer C.g_error_free(err) return nil, errors.New(C.GoString((*C.char)(err.message))) } obj := glib.Take(unsafe.Pointer(c)) return wrapPrintSettings(obj), nil } // PrintSettingsNewFromKeyFile() is a wrapper around gtk_print_settings_new_from_key_file(). // LoadFile() is a wrapper around gtk_print_settings_load_file(). func (ps *PrintSettings) LoadFile(name string) error { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil c := C.gtk_print_settings_load_file(ps.native(), (*C.gchar)(cstr), &err) if gobool(c) == false { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // LoadKeyFile() is a wrapper around gtk_print_settings_load_key_file(). // ToFile() is a wrapper around gtk_print_settings_to_file(). func (ps *PrintSettings) ToFile(name string) error { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil c := C.gtk_print_settings_to_file(ps.native(), (*C.gchar)(cstr), &err) if gobool(c) == false { return errors.New(C.GoString((*C.char)(err.message))) } return nil } // ToKeyFile() is a wrapper around gtk_print_settings_to_key_file(). gotk3-0.6.2/gtk/print.go.h000066400000000000000000000014601431157473000152520ustar00rootroot00000000000000#pragma once #include #include #include extern void goPrintSettings(gchar *key, gchar *value, gpointer user_data); static inline void _gtk_print_settings_foreach(GtkPrintSettings *ps, gpointer user_data) { gtk_print_settings_foreach(ps, (GtkPrintSettingsFunc)(goPrintSettings), user_data); } extern void goPageSetupDone(GtkPageSetup *setup, gpointer data); static inline void _gtk_print_run_page_setup_dialog_async(GtkWindow *parent, GtkPageSetup *setup, GtkPrintSettings *settings, gpointer data) { gtk_print_run_page_setup_dialog_async( parent, setup, settings, (GtkPageSetupDoneFunc)(goPageSetupDone), data); } gotk3-0.6.2/gtk/print_export.go000066400000000000000000000012141431157473000164220ustar00rootroot00000000000000package gtk // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/internal/callback" ) //export goPageSetupDone func goPageSetupDone(setup *C.GtkPageSetup, data C.gpointer) { // This callback is only used once, so we can clean up immediately fn := callback.GetAndDelete(uintptr(data)).(PageSetupDoneCallback) fn(wrapPageSetup(glib.Take(unsafe.Pointer(setup)))) } //export goPrintSettings func goPrintSettings(key *C.gchar, value *C.gchar, userData C.gpointer) { fn := callback.Get(uintptr(userData)).(PrintSettingsCallback) fn(C.GoString((*C.char)(key)), C.GoString((*C.char)(value))) } gotk3-0.6.2/gtk/print_since_3_16.go000066400000000000000000000015701431157473000167370ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14 // See: https://developer.gnome.org/gtk3/3.16/api-index-3-16.html package gtk // #include // #include "gtk.go.h" import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) // PaperSizeNewFromIpp is a wrapper around gtk_paper_size_new_from_ipp(). func PaperSizeNewFromIPP(name string, width, height float64) (*PaperSize, error) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_paper_size_new_from_ipp((*C.gchar)(cstr), C.gdouble(width), C.gdouble(height)) if c == nil { return nil, nilPtrErr } t := &PaperSize{c} runtime.SetFinalizer(t, func(v *PaperSize) { glib.FinalizerStrategy(v.free) }) return t, nil } // IsIPP() is a wrapper around gtk_paper_size_is_ipp(). func (ps *PaperSize) IsIPP() bool { c := C.gtk_paper_size_is_ipp(ps.native()) return gobool(c) } gotk3-0.6.2/gtk/print_test.go000066400000000000000000000021671431157473000160700ustar00rootroot00000000000000package gtk import ( "testing" ) func init() { Init(nil) } // TestPageSetup tests creating and manipulating PageSetup func TestPageSetup(t *testing.T) { _, err := PageSetupNew() if err != nil { t.Error(err) } } // TestPaperSize tests creating and manipulating PaperSize func TestPaperSize(t *testing.T) { _, err := PaperSizeNew(PAPER_NAME_A4) if err != nil { t.Error(err) } } // TestPrintContext tests creating and manipulating PrintContext // TestPrintOperation tests creating and manipulating PrintOperation func TestPrintOperation(t *testing.T) { _, err := PrintOperationNew() if err != nil { t.Error(err) } } // TestPrintOperationPreview tests creating and manipulating PrintOperationPreview // TestPrintSettings tests creating and manipulating PrintSettings func TestPrintSettings(t *testing.T) { settings, err := PrintSettingsNew() if err != nil { t.Error(err) } settings.Set("Key1", "String1") settings.SetBool("Key2", true) settings.Set("Key3", "String2") settings.SetInt("Key4", 2) settings.ForEach(func(key, value string) { }) } // TestPrintContext tests creating and manipulating PrintContext gotk3-0.6.2/gtk/settings.go000066400000000000000000000020151431157473000155250ustar00rootroot00000000000000package gtk // #include // #include "settings.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_settings_get_type()), marshalSettings}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkSettings"] = wrapSettings } //GtkSettings type Settings struct { *glib.Object } func (v *Settings) native() *C.GtkSettings { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSettings(p) } func marshalSettings(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) return wrapSettings(glib.Take(unsafe.Pointer(c))), nil } func wrapSettings(obj *glib.Object) *Settings { if obj == nil { return nil } return &Settings{obj} } //Get the global non window specific settings func SettingsGetDefault() (*Settings, error) { c := C.gtk_settings_get_default() if c == nil { return nil, nilPtrErr } return wrapSettings(glib.Take(unsafe.Pointer(c))), nil } gotk3-0.6.2/gtk/settings.go.h000066400000000000000000000001111431157473000157460ustar00rootroot00000000000000static GtkSettings *toGtkSettings(void *p) { return (GTK_SETTINGS(p)); } gotk3-0.6.2/gtk/shortcutswindow_since_3_20.go000066400000000000000000000074061431157473000210700ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18 package gtk // #include // #include "gtk.go.h" // #include "shortcutswindow_since_3_20.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_shortcuts_window_get_type()), marshalShortcutsWindow}, {glib.Type(C.gtk_shortcuts_section_get_type()), marshalShortcutsSection}, {glib.Type(C.gtk_shortcuts_group_get_type()), marshalShortcutsGroup}, {glib.Type(C.gtk_shortcuts_shortcut_get_type()), marshalShortcutsShortcut}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkShortcutsWindow"] = wrapShortcutsWindow WrapMap["GtkShortcutsSection"] = wrapShortcutsSection WrapMap["GtkShortcutsGroup"] = wrapShortcutsGroup WrapMap["GtkShortcutsShortcut"] = wrapShortcutsShortcut } /* * GtkShortcutsWindow */ // ShortcutsWindow is a representation of GTK's GtkShortcutsWindow. type ShortcutsWindow struct { Window } func (v *ShortcutsWindow) native() *C.GtkShortcutsWindow { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkShortcutsWindow(p) } func marshalShortcutsWindow(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapShortcutsWindow(obj), nil } func wrapShortcutsWindow(obj *glib.Object) *ShortcutsWindow { if obj == nil { return nil } return &ShortcutsWindow{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} } /* * GtkShortcutsSection */ // ShortcutsSection is a representation of GTK's GtkShortcutsSection. type ShortcutsSection struct { Box } // native returns a pointer to the underlying GtkShortcutsSection. func (v *ShortcutsSection) native() *C.GtkShortcutsSection { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkShortcutsSection(p) } func marshalShortcutsSection(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapShortcutsSection(obj), nil } func wrapShortcutsSection(obj *glib.Object) *ShortcutsSection { if obj == nil { return nil } return &ShortcutsSection{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}} } /* * GtkShortcutsGroup */ // ShortcutsGroup is a representation of GTK's GtkShortcutsGroup. type ShortcutsGroup struct { Box } // native returns a pointer to the underlying GtkShortcutsGroup. func (v *ShortcutsGroup) native() *C.GtkShortcutsGroup { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkShortcutsGroup(p) } func marshalShortcutsGroup(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapShortcutsGroup(obj), nil } func wrapShortcutsGroup(obj *glib.Object) *ShortcutsGroup { if obj == nil { return nil } return &ShortcutsGroup{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}} } /* * GtkShortcutsShortcut */ // ShortcutsShortcut is a representation of GTK's GtkShortcutsShortcut. type ShortcutsShortcut struct { Box } // native returns a pointer to the underlying GtkShortcutsShortcut. func (v *ShortcutsShortcut) native() *C.GtkShortcutsShortcut { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkShortcutsShortcut(p) } func marshalShortcutsShortcut(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapShortcutsShortcut(obj), nil } func wrapShortcutsShortcut(obj *glib.Object) *ShortcutsShortcut { if obj == nil { return nil } return &ShortcutsShortcut{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}} } gotk3-0.6.2/gtk/shortcutswindow_since_3_20.go.h000066400000000000000000000023611431157473000213110ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ static GtkShortcutsWindow *toGtkShortcutsWindow(void *p) { return (GTK_SHORTCUTS_WINDOW(p)); } static GtkShortcutsSection *toGtkShortcutsSection(void *p) { return (GTK_SHORTCUTS_SECTION(p)); } static GtkShortcutsGroup *toGtkShortcutsGroup(void *p) { return (GTK_SHORTCUTS_GROUP(p)); } static GtkShortcutsShortcut *toGtkShortcutsShortcut(void *p) { return (GTK_SHORTCUTS_SHORTCUT(p)); }gotk3-0.6.2/gtk/socket_plug.go000066400000000000000000000143131431157473000162100ustar00rootroot00000000000000// +build linux package gtk // #include // #include // #include // #include // #include "socket_plug.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_socket_get_type()), marshalSocket}, {glib.Type(C.gtk_plug_get_type()), marshalPlug}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkSocket"] = wrapSocket WrapMap["GtkPlug"] = wrapPlug } /* * GtkSocket */ // Socket is a representation of GTK's GtkSocket type Socket struct { Container } // native returns a pointer to the underlying GtkSocket func (v *Socket) native() *C.GtkSocket { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkSocket(p) } func marshalSocket(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapSocket(obj), nil } func wrapSocket(obj *glib.Object) *Socket { if obj == nil { return nil } return &Socket{Container{Widget{glib.InitiallyUnowned{obj}}}} } // SocketNew is a wrapper around gtk_socket_new(). // Create a new empty GtkSocket. func SocketNew() (*Socket, error) { c := C.gtk_socket_new() if c == nil { return nil, nilPtrErr } return wrapSocket(glib.Take(unsafe.Pointer(c))), nil } // AddId is a wrapper around gtk_socket_add_id(). // Adds an XEMBED client, such as a GtkPlug, to the GtkSocket. The client may be in the same process or in a different // process. // To embed a GtkPlug in a GtkSocket, you can either create the GtkPlug with gtk_plug_new (0), call gtk_plug_get_id() // to get the window ID of the plug, and then pass that to the gtk_socket_add_id(), or you can call gtk_socket_get_id() // to get the window ID for the socket, and call gtk_plug_new() passing in that ID. // The GtkSocket must have already be added into a toplevel window before you can make this call. func (v *Socket) AddId(window uint) { C.gtk_socket_add_id(v.native(), C.Window(window)) } // GetId is a wrapper around gtk_socket_get_id(). // Gets the window ID of a GtkSocket widget, which can then be used to create a client embedded inside the socket, // for instance with gtk_plug_new(). // The GtkSocket must have already be added into a toplevel window before you can make this call. func (v *Socket) GetId() uint { c := C.gtk_socket_get_id(v.native()) return uint(c) } // GetPlugWindow is a wrapper around gtk_socket_get_plug_window(). // Retrieves the window of the plug. Use this to check if the plug has been created inside of the socket. func (v *Socket) GetPlugWindow() (*Window, error) { c := C.gtk_socket_get_plug_window(v.native()) if c == nil { return nil, nilPtrErr } return wrapWindow(glib.Take(unsafe.Pointer(c))), nil } /* * GtkSocket */ // Plug is a representation of GTK's GtkPlug type Plug struct { Window } // native returns a pointer to the underlying GtkSocket func (v *Plug) native() *C.GtkPlug { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkPlug(p) } // native returns a C pointer to the underlying GdkDisplay. func native(v *gdk.Display) *C.GdkDisplay { // I'd love to not have to copy native() from gdk/gdk.go, but it appears you can't just // pass C structs from package to package if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGdkDisplay(p) } func marshalPlug(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapPlug(obj), nil } func wrapPlug(obj *glib.Object) *Plug { if obj == nil { return nil } return &Plug{Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}}} } // PlugNew is a wrapper around gtk_plug_new(). // Creates a new plug widget inside the GtkSocket identified by socket_id. // If socket_id is 0, the plug is left “unplugged” and can later be plugged into a GtkSocket by gtk_socket_add_id(). func PlugNew(socketId uint) (*Plug, error) { c := C.gtk_plug_new(C.Window(socketId)) if c == nil { return nil, nilPtrErr } return wrapPlug(glib.Take(unsafe.Pointer(c))), nil } // PlugNewForDisplay is a wrapper around gtk_plug_new_for_display(). // Creates a new plug widget inside the GtkSocket identified by socket_id. // If socket_id is 0, the plug is left “unplugged” and can later be plugged into a GtkSocket by gtk_socket_add_id(). func PlugNewForDisplay(display *gdk.Display, socketId uint) (*Plug, error) { c := C.gtk_plug_new_for_display(native(display), C.Window(socketId)) if c == nil { return nil, nilPtrErr } return wrapPlug(glib.Take(unsafe.Pointer(c))), nil } // Construct is a wrapper around gtk_plug_construct(). // Finish the initialization of plug for a given GtkSocket identified by socket_id. // This function will generally only be used by classes deriving from GtkPlug. func (v *Plug) Construct(socketId uint) { C.gtk_plug_construct(v.native(), C.Window(socketId)) } // ConstructForDisplay is a wrapper around gtk_plug_construct_for_display(). // Finish the initialization of plug for a given GtkSocket identified by socket_id which is currently // displayed on display. // This function will generally only be used by classes deriving from GtkPlug. func (v *Plug) ConstructForDisplay(display *gdk.Display, socketId uint) { C.gtk_plug_construct_for_display(v.native(), native(display), C.Window(socketId)) } // GetId is a wrapper around gtk_plug_get_id(). // Gets the window ID of a GtkPlug widget, which can then be used to embed this window inside another window, // for instance with gtk_socket_add_id(). func (v *Plug) GetId() uint { c := C.gtk_plug_get_id(v.native()) return uint(c) } // GetEmbedded is a wrapper around gtk_plug_get_embedded(). // Determines whether the plug is embedded in a socket. func (v *Plug) GetEmbedded() bool { c := C.gtk_plug_get_embedded(v.native()) return gobool(c) } // GetSocketWindow is a wrapper around gtk_plug_get_socket_window(). // Retrieves the socket the plug is embedded in. func (v *Plug) GetSocketWindow() (*Window, error) { c := C.gtk_plug_get_socket_window(v.native()) if c == nil { return nil, nilPtrErr } return wrapWindow(glib.Take(unsafe.Pointer(c))), nil } gotk3-0.6.2/gtk/socket_plug.go.h000066400000000000000000000003111431157473000164270ustar00rootroot00000000000000 static GtkSocket *toGtkSocket(void *p) { return (GTK_SOCKET(p)); } static GtkPlug *toGtkPlug(void *p) { return (GTK_PLUG(p)); } static GdkDisplay *toGdkDisplay(void *p) { return (GDK_DISPLAY(p)); } gotk3-0.6.2/gtk/stack_since_3_12.go000066400000000000000000000016271431157473000167070ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains accelerator related functions and structures // +build !gtk_3_6,!gtk_3_8,!gtk_3_10 // not use this: go build -tags gtk_3_8'. Otherwise, if no build tags are used, GTK 3.10 package gtk // #include // #include // #include "gtk_since_3_10.go.h" import "C" import ( "unsafe" ) // GetChildByName is a wrapper around gtk_stack_get_child_by_name(). func (v *Stack) GetChildByName(name string) (IWidget, error) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_stack_get_child_by_name(v.native(), (*C.gchar)(cstr)) if c == nil { return nil, nilPtrErr } return castWidget(c) } // GetTransitionRunning is a wrapper around gtk_stack_get_transition_running(). func (v *Stack) GetTransitionRunning() bool { c := C.gtk_stack_get_transition_running(v.native()) return gobool(c) } gotk3-0.6.2/gtk/stackswitcher_since_3_10.go000066400000000000000000000036501431157473000204540ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains accelerator related functions and structures // +build !gtk_3_6,!gtk_3_8 // not use this: go build -tags gtk_3_8'. Otherwise, if no build tags are used, GTK 3.10 package gtk // #include // #include // #include "gtk_since_3_10.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { //Contribute to casting for k, v := range map[string]WrapFn{ "GtkStackSwitcher": wrapStackSwitcher, } { WrapMap[k] = v } } /* * GtkStackSwitcher */ // StackSwitcher is a representation of GTK's GtkStackSwitcher type StackSwitcher struct { Box } // native returns a pointer to the underlying GtkStackSwitcher. func (v *StackSwitcher) native() *C.GtkStackSwitcher { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkStackSwitcher(p) } func marshalStackSwitcher(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapStackSwitcher(obj), nil } func wrapStackSwitcher(obj *glib.Object) *StackSwitcher { if obj == nil { return nil } return &StackSwitcher{Box{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // StackSwitcherNew is a wrapper around gtk_stack_switcher_new(). func StackSwitcherNew() (*StackSwitcher, error) { c := C.gtk_stack_switcher_new() if c == nil { return nil, nilPtrErr } return wrapStackSwitcher(glib.Take(unsafe.Pointer(c))), nil } // SetStack is a wrapper around gtk_stack_switcher_set_stack(). func (v *StackSwitcher) SetStack(stack *Stack) { C.gtk_stack_switcher_set_stack(v.native(), stack.native()) } // GetStack is a wrapper around gtk_stack_switcher_get_stack(). func (v *StackSwitcher) GetStack() *Stack { c := C.gtk_stack_switcher_get_stack(v.native()) if c == nil { return nil } return wrapStack(glib.Take(unsafe.Pointer(c))) } gotk3-0.6.2/gtk/style.go000066400000000000000000000210151431157473000150260ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains style related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/cairo" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) type StyleProviderPriority int const ( STYLE_PROVIDER_PRIORITY_FALLBACK StyleProviderPriority = C.GTK_STYLE_PROVIDER_PRIORITY_FALLBACK STYLE_PROVIDER_PRIORITY_THEME = C.GTK_STYLE_PROVIDER_PRIORITY_THEME STYLE_PROVIDER_PRIORITY_SETTINGS = C.GTK_STYLE_PROVIDER_PRIORITY_SETTINGS STYLE_PROVIDER_PRIORITY_APPLICATION = C.GTK_STYLE_PROVIDER_PRIORITY_APPLICATION STYLE_PROVIDER_PRIORITY_USER = C.GTK_STYLE_PROVIDER_PRIORITY_USER ) // RenderBackground is a wrapper around gtk_render_background(). func RenderBackground(context *StyleContext, cr *cairo.Context, x, y, w, h float64) { C.gtk_render_background( context.native(), (*C.cairo_t)(unsafe.Pointer(cr.Native())), C.gdouble(x), C.gdouble(y), C.gdouble(w), C.gdouble(h), ) } /* * GtkStyleContext */ // StyleContext is a representation of GTK's GtkStyleContext. type StyleContext struct { *glib.Object } // native returns a pointer to the underlying GtkStyleContext. func (v *StyleContext) native() *C.GtkStyleContext { if v == nil || v.Object == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkStyleContext(p) } func wrapStyleContext(obj *glib.Object) *StyleContext { if obj == nil { return nil } return &StyleContext{obj} } func (v *StyleContext) AddClass(class_name string) { cstr := C.CString(class_name) defer C.free(unsafe.Pointer(cstr)) C.gtk_style_context_add_class(v.native(), (*C.gchar)(cstr)) } func (v *StyleContext) RemoveClass(class_name string) { cstr := C.CString(class_name) defer C.free(unsafe.Pointer(cstr)) C.gtk_style_context_remove_class(v.native(), (*C.gchar)(cstr)) } func fromNativeStyleContext(c *C.GtkStyleContext) (*StyleContext, error) { if c == nil { return nil, nilPtrErr } obj := glib.Take(unsafe.Pointer(c)) return wrapStyleContext(obj), nil } // GetStyleContext is a wrapper around gtk_widget_get_style_context(). func (v *Widget) GetStyleContext() (*StyleContext, error) { return fromNativeStyleContext(C.gtk_widget_get_style_context(v.native())) } // GetParent is a wrapper around gtk_style_context_get_parent(). func (v *StyleContext) GetParent() (*StyleContext, error) { return fromNativeStyleContext(C.gtk_style_context_get_parent(v.native())) } // GetProperty is a wrapper around gtk_style_context_get_property(). func (v *StyleContext) GetProperty(property string, state StateFlags) (interface{}, error) { cstr := (*C.gchar)(C.CString(property)) defer C.free(unsafe.Pointer(cstr)) var gval C.GValue C.gtk_style_context_get_property(v.native(), cstr, C.GtkStateFlags(state), &gval) val := glib.ValueFromNative(unsafe.Pointer(&gval)) return val.GoValue() } // GetStyleProperty is a wrapper around gtk_style_context_get_style_property(). func (v *StyleContext) GetStyleProperty(property string) (interface{}, error) { cstr := (*C.gchar)(C.CString(property)) defer C.free(unsafe.Pointer(cstr)) var gval C.GValue C.gtk_style_context_get_style_property(v.native(), cstr, &gval) val := glib.ValueFromNative(unsafe.Pointer(&gval)) return val.GoValue() } // GetScreen is a wrapper around gtk_style_context_get_screen(). func (v *StyleContext) GetScreen() (*gdk.Screen, error) { c := C.gtk_style_context_get_screen(v.native()) if c == nil { return nil, nilPtrErr } d := &gdk.Screen{glib.Take(unsafe.Pointer(c))} return d, nil } // GetState is a wrapper around gtk_style_context_get_state(). func (v *StyleContext) GetState() StateFlags { return StateFlags(C.gtk_style_context_get_state(v.native())) } // GetColor is a wrapper around gtk_style_context_get_color(). func (v *StyleContext) GetColor(state StateFlags) *gdk.RGBA { gdkColor := gdk.NewRGBA() C.gtk_style_context_get_color(v.native(), C.GtkStateFlags(state), (*C.GdkRGBA)(unsafe.Pointer(gdkColor.Native()))) return gdkColor } // LookupColor is a wrapper around gtk_style_context_lookup_color(). func (v *StyleContext) LookupColor(colorName string) (*gdk.RGBA, bool) { cstr := (*C.gchar)(C.CString(colorName)) defer C.free(unsafe.Pointer(cstr)) gdkColor := gdk.NewRGBA() ret := C.gtk_style_context_lookup_color(v.native(), cstr, (*C.GdkRGBA)(unsafe.Pointer(gdkColor.Native()))) return gdkColor, gobool(ret) } // StyleContextResetWidgets is a wrapper around gtk_style_context_reset_widgets(). func StyleContextResetWidgets(v *gdk.Screen) { C.gtk_style_context_reset_widgets((*C.GdkScreen)(unsafe.Pointer(v.Native()))) } // Restore is a wrapper around gtk_style_context_restore(). func (v *StyleContext) Restore() { C.gtk_style_context_restore(v.native()) } // Save is a wrapper around gtk_style_context_save(). func (v *StyleContext) Save() { C.gtk_style_context_save(v.native()) } // SetParent is a wrapper around gtk_style_context_set_parent(). func (v *StyleContext) SetParent(p *StyleContext) { C.gtk_style_context_set_parent(v.native(), p.native()) } // HasClass is a wrapper around gtk_style_context_has_class(). func (v *StyleContext) HasClass(className string) bool { cstr := C.CString(className) defer C.free(unsafe.Pointer(cstr)) return gobool(C.gtk_style_context_has_class(v.native(), (*C.gchar)(cstr))) } // SetScreen is a wrapper around gtk_style_context_set_screen(). func (v *StyleContext) SetScreen(s *gdk.Screen) { C.gtk_style_context_set_screen(v.native(), (*C.GdkScreen)(unsafe.Pointer(s.Native()))) } // SetState is a wrapper around gtk_style_context_set_state(). func (v *StyleContext) SetState(state StateFlags) { C.gtk_style_context_set_state(v.native(), C.GtkStateFlags(state)) } type IStyleProvider interface { toStyleProvider() *C.GtkStyleProvider } // AddProvider is a wrapper around gtk_style_context_add_provider(). func (v *StyleContext) AddProvider(provider IStyleProvider, prio uint) { C.gtk_style_context_add_provider(v.native(), provider.toStyleProvider(), C.guint(prio)) } // AddProviderForScreen is a wrapper around gtk_style_context_add_provider_for_screen(). func AddProviderForScreen(s *gdk.Screen, provider IStyleProvider, prio uint) { C.gtk_style_context_add_provider_for_screen((*C.GdkScreen)(unsafe.Pointer(s.Native())), provider.toStyleProvider(), C.guint(prio)) } // RemoveProvider is a wrapper around gtk_style_context_remove_provider(). func (v *StyleContext) RemoveProvider(provider IStyleProvider) { C.gtk_style_context_remove_provider(v.native(), provider.toStyleProvider()) } // RemoveProviderForScreen is a wrapper around gtk_style_context_remove_provider_for_screen(). func RemoveProviderForScreen(s *gdk.Screen, provider IStyleProvider) { C.gtk_style_context_remove_provider_for_screen((*C.GdkScreen)(unsafe.Pointer(s.Native())), provider.toStyleProvider()) } // GtkStyleContext * gtk_style_context_new () // void gtk_style_context_get () // GtkTextDirection gtk_style_context_get_direction () // GtkJunctionSides gtk_style_context_get_junction_sides () // const GtkWidgetPath * gtk_style_context_get_path () // GdkFrameClock * gtk_style_context_get_frame_clock () // void gtk_style_context_get_style () // void gtk_style_context_get_style_valist () // void gtk_style_context_get_valist () // GtkCssSection * gtk_style_context_get_section () // void gtk_style_context_get_background_color () // void gtk_style_context_get_border_color () // void gtk_style_context_get_border () // void gtk_style_context_get_padding () // void gtk_style_context_get_margin () // const PangoFontDescription * gtk_style_context_get_font () // void gtk_style_context_invalidate () // gboolean gtk_style_context_state_is_running () // GtkIconSet * gtk_style_context_lookup_icon_set () // void gtk_style_context_cancel_animations () // void gtk_style_context_scroll_animations () // void gtk_style_context_notify_state_change () // void gtk_style_context_pop_animatable_region () // void gtk_style_context_push_animatable_region () // void gtk_style_context_set_background () // void gtk_style_context_set_direction () // void gtk_style_context_set_junction_sides () // void gtk_style_context_set_path () // void gtk_style_context_add_region () // void gtk_style_context_remove_region () // gboolean gtk_style_context_has_region () // GList * gtk_style_context_list_regions () // void gtk_style_context_set_frame_clock () // void gtk_style_context_set_scale () // gint gtk_style_context_get_scale () // GList * gtk_style_context_list_classes () gotk3-0.6.2/gtk/testing.go000066400000000000000000000137351431157473000153550ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import ( "errors" "os" "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) // TestFindLabel is a wrapper around gtk_test_find_label(). // This function will search widget and all its descendants for a GtkLabel widget with a text string matching label_pattern. // The labelPattern may contain asterisks “*” and question marks “?” as placeholders, g_pattern_match() is used for the matching. func TestFindLabel(widget IWidget, labelPattern string) (IWidget, error) { cstr := C.CString(labelPattern) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_test_find_label(widget.toWidget(), (*C.gchar)(cstr)) if c == nil { return nil, errors.New("no label with pattern '" + labelPattern + "' found") } obj, err := castWidget(c) if err != nil { return nil, err } return obj, nil } // TestFindSibling is a wrapper around gtk_test_find_sibling(). // This function will search siblings of base_widget and siblings of its ancestors for all widgets matching widgetType. // Of the matching widgets, the one that is geometrically closest to base_widget will be returned. func TestFindSibling(baseWidget IWidget, widgetType glib.Type) (IWidget, error) { c := C.gtk_test_find_sibling(baseWidget.toWidget(), C.GType(widgetType)) if c == nil { return nil, errors.New("no widget of type '" + widgetType.Name() + "' found") } obj, err := castWidget(c) if err != nil { return nil, err } return obj, nil } // TestFindWidget is a wrapper around gtk_test_find_widget(). // This function will search the descendants of widget for a widget of type widget_type that has a label matching labelPattern next to it. // This is most useful for automated GUI testing, e.g. to find the “OK” button in a dialog and synthesize clicks on it. // However see TestFindLabel(), TestFindSibling() and TestWidgetClick() (and their GTK documentation) // for possible caveats involving the search of such widgets and synthesizing widget events. func TestFindWidget(widget IWidget, labelPattern string, widgetType glib.Type) (IWidget, error) { cstr := C.CString(labelPattern) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_test_find_widget(widget.toWidget(), (*C.gchar)(cstr), C.GType(widgetType)) if c == nil { return nil, errors.New("no widget with label pattern '" + labelPattern + "' and type '" + widgetType.Name() + "' found") } obj, err := castWidget(c) if err != nil { return nil, err } return obj, nil } /* TestInit is a wrapper around gtk_test_init(). This function is used to initialize a GTK+ test program. It will in turn call g_test_init() and gtk_init() to properly initialize the testing framework and graphical toolkit. It’ll also set the program’s locale to “C” and prevent loading of rc files and Gtk+ modules. This is done to make tets program environments as deterministic as possible. Like gtk_init() and g_test_init(), any known arguments will be processed and stripped from argc and argv. */ func TestInit(args *[]string) { if args != nil { argc := C.int(len(*args)) argv := C.make_strings(argc) defer C.destroy_strings(argv) for i, arg := range *args { cstr := C.CString(arg) C.set_string(argv, C.int(i), (*C.gchar)(cstr)) } C._gtk_test_init((*C.int)(unsafe.Pointer(&argc)), (***C.char)(unsafe.Pointer(&argv))) unhandled := make([]string, argc) for i := 0; i < int(argc); i++ { cstr := C.get_string(argv, C.int(i)) unhandled[i] = goString(cstr) C.free(unsafe.Pointer(cstr)) } *args = unhandled } else { // gtk_test_init does not take nil, we have to use an empty argument list // (only containing the first arg, which is the executable name) argc := C.int(1) argv := C.make_strings(argc) defer C.destroy_strings(argv) // Add first argument cstr := C.CString(os.Args[0]) C.set_string(argv, C.int(0), (*C.gchar)(cstr)) C._gtk_test_init((*C.int)(unsafe.Pointer(&argc)), (***C.char)(unsafe.Pointer(&argv))) } } // TestListAllTypes is a wrapper around gtk_test_list_all_types(). // Return the type ids that have been registered after calling TestRegisterAllTypes(). func TestListAllTypes() []glib.Type { var types *C.GType var clen C.guint types = C.gtk_test_list_all_types(&clen) defer C.free(unsafe.Pointer(types)) length := uint(clen) typeReturn := make([]glib.Type, length) for i := uint(0); i < length; i++ { current := (*C.GType)(pointerAtOffset(unsafe.Pointer(types), unsafe.Sizeof(*types), i)) typeReturn[i] = glib.Type(*current) } return typeReturn } // pointerAtOffset adjusts `arrayPointer` (pointer to the first element of a C array) // to point at the offset `i`, // to be able to read the value there without having to go through cgo. func pointerAtOffset(arrayPointer unsafe.Pointer, elementSize uintptr, offset uint) unsafe.Pointer { return unsafe.Pointer(uintptr(arrayPointer) + elementSize*uintptr(offset)) } // TestRegisterAllTypes is a wrapper around gtk_test_register_all_types(). // Force registration of all core Gtk+ and Gdk object types. // This allowes to refer to any of those object types via g_type_from_name() after calling this function. func TestRegisterAllTypes() { C.gtk_test_register_all_types() } // TestWidgetSendKey is a wrapper around gtk_test_widget_send_key() // // This function will generate keyboard press and release events // in the middle of the first GdkWindow found that belongs to widget. // For windowless widgets like GtkButton (which returns FALSE from gtk_widget_get_has_window()), // this will often be an input-only event window. // For other widgets, this is usually widget->window. // // widget: Widget to generate a key press and release on. // keyval: A Gdk keyboard value. // modifiers: Keyboard modifiers the event is setup with. // // returns: whether all actions neccessary for the key event simulation were carried out successfully. func TestWidgetSendKey(widget IWidget, keyval uint, modifiers gdk.ModifierType) bool { return gobool(C.gtk_test_widget_send_key(widget.toWidget(), C.guint(keyval), C.GdkModifierType(modifiers))) } gotk3-0.6.2/gtk/testing_deprecated_since_3_20.go000066400000000000000000000035351431157473000214360ustar00rootroot00000000000000//+build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14 gtk_3_16 gtk_3_18 gtk_deprecated package gtk // #include import "C" import ( "github.com/gotk3/gotk3/gdk" ) /* GtkWidget * gtk_test_create_simple_window (const gchar *window_title, const gchar *dialog_text); GtkWidget * gtk_test_create_widget (GType widget_type, const gchar *first_property_name, ...); GtkWidget * gtk_test_display_button_window (const gchar *window_title, const gchar *dialog_text, ...); double gtk_test_slider_get_value (GtkWidget *widget); void gtk_test_slider_set_perc (GtkWidget *widget, double percentage); gboolean gtk_test_spin_button_click (GtkSpinButton *spinner, guint button, gboolean upwards); gchar * gtk_test_text_get (GtkWidget *widget); void gtk_test_text_set (GtkWidget *widget, const gchar *string); */ // TestWidgetClick is a wrapper around gtk_test_widget_click() // Deprecated since 3.20 // // This function will generate a button click (button press and button release event) // in the middle of the first GdkWindow found that belongs to widget. // For windowless widgets like GtkButton (which returns FALSE from gtk_widget_get_has_window()), // this will often be an input-only event window. // For other widgets, this is usually widget->window. // // widget: Widget to generate a button click on. // button: Number of the pointer button for the event, usually 1, 2 or 3. // modifiers: Keyboard modifiers the event is setup with. // // returns: whether all actions neccessary for the button click simulation were carried out successfully. func TestWidgetClick(widget IWidget, button gdk.Button, modifiers gdk.ModifierType) bool { return gobool(C.gtk_test_widget_click(widget.toWidget(), C.guint(button), C.GdkModifierType(modifiers))) } gotk3-0.6.2/gtk/testing_since_3_10.go000066400000000000000000000011051431157473000172440ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8 package gtk // #include import "C" // TestWidgetWaitForDraw is a wrapper around gtk_test_widget_wait_for_draw(). // Enters the main loop and waits for widget to be “drawn”. In this context that means it waits for the frame clock of widget to have run a full styling, layout and drawing cycle. // This function is intended to be used for syncing with actions that depend on widget relayouting or on interaction with the display server. func TestWidgetWaitForDraw(widget IWidget) { C.gtk_test_widget_wait_for_draw(widget.toWidget()) } gotk3-0.6.2/gtk/testing_test.go000066400000000000000000000056451431157473000164150ustar00rootroot00000000000000package gtk import ( "reflect" "testing" "unsafe" "github.com/gotk3/gotk3/glib" ) func TestTestRegisterAllTypes(t *testing.T) { TestRegisterAllTypes() types := TestListAllTypes() if len(types) == 0 { t.Error("Expected at least one type to be registered") } } func TestPointerAtOffset(t *testing.T) { // Simulate a C array by using a pointer to the first element intArray := []int{4, 8, 2, 5, 9} arrayPointer := unsafe.Pointer(&intArray[0]) elementSize := unsafe.Sizeof(intArray[0]) for i, val := range intArray { intAtOffset := (*int)(pointerAtOffset(arrayPointer, elementSize, uint(i))) if val != *intAtOffset { t.Errorf("Expected %d at offset %d, got %d", val, i, *intAtOffset) } } } func TestTestFindLabel(t *testing.T) { // Build a dummy widget box, _ := BoxNew(ORIENTATION_HORIZONTAL, 0) label1, _ := LabelNew("First") label2, _ := LabelNew("Second") box.PackStart(label1, true, true, 0) box.PackStart(label2, true, true, 0) // Find a label in the box with text matching Fir* found, err := TestFindLabel(box, "Fir*") if err != nil { t.Error("Unexpected error:", err.Error()) } // Should return the label1 if found == nil { t.Error("Return value is nil") } foundAsLabel, ok := found.(*Label) if !ok { t.Error("Did not return a label. Received type:", reflect.TypeOf(found)) } text, _ := foundAsLabel.GetText() if text != "First" { t.Error("Expected: First, Got:", text) } } func TestTestFindSibling(t *testing.T) { // Build a dummy widget box, _ := BoxNew(ORIENTATION_HORIZONTAL, 0) label1, _ := LabelNew("First") label2, _ := LabelNew("Second") box.PackStart(label1, true, true, 0) box.PackStart(label2, true, true, 0) // Finx a sibling to label1, of type label found, err := TestFindSibling(label1, glib.TypeFromName("GtkLabel")) if err != nil { t.Error("Unexpected error:", err.Error()) } // Should return the label2 if found == nil { t.Error("Return value is nil") } foundAsLabel, ok := found.(*Label) if !ok { t.Error("Did not return a label. Received type:", reflect.TypeOf(found)) } text, _ := foundAsLabel.GetText() if text != "Second" { t.Error("Expected: First, Got:", text) } } func TestTestFindWidget(t *testing.T) { // Build a dummy widget box, _ := BoxNew(ORIENTATION_HORIZONTAL, 0) button1, _ := ButtonNewWithLabel("First") button2, _ := ButtonNewWithLabel("Second") box.PackStart(button1, true, true, 0) box.PackStart(button2, true, true, 0) // Find a label in the box with text matching Fir* found, err := TestFindWidget(box, "Sec*", glib.TypeFromName("GtkButton")) if err != nil { t.Error("Unexpected error:", err.Error()) } // Should return the button2 if found == nil { t.Error("Return value is nil") } foundAsButton, ok := found.(*Button) if !ok { t.Error("Did not return a button. Received type:", reflect.TypeOf(found)) } text, _ := foundAsButton.GetLabel() if text != "Second" { t.Error("Expected: Second, Got:", text) } } gotk3-0.6.2/gtk/text_child_anchor.go000066400000000000000000000037011431157473000173510ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package gtk // #include // #include "text_child_anchor.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Objects/Interfaces {glib.Type(C.gtk_text_child_anchor_get_type()), marshalTextChildAnchor}, } glib.RegisterGValueMarshalers(tm) } /* * GtkTextChildAnchor */ // TextChildAnchor is a representation of GTK's GtkTextChildAnchor type TextChildAnchor struct { glib.InitiallyUnowned } // native returns a pointer to the underlying GtkTextChildAnchor. func (v *TextChildAnchor) native() *C.GtkTextChildAnchor { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTextChildAnchor(p) } func marshalTextChildAnchor(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTextChildAnchor(obj), nil } func wrapTextChildAnchor(obj *glib.Object) *TextChildAnchor { if obj == nil { return nil } return &TextChildAnchor{glib.InitiallyUnowned{obj}} } // TextChildAnchorNew is a wrapper around gtk_text_child_anchor_new () func TextChildAnchorNew() (*TextChildAnchor, error) { c := C.gtk_text_child_anchor_new() if c == nil { return nil, nilPtrErr } return wrapTextChildAnchor(glib.Take(unsafe.Pointer(c))), nil } // GetWidgets is a wrapper around gtk_text_child_anchor_get_widgets (). func (v *TextChildAnchor) GetWidgets() *glib.List { clist := C.gtk_text_child_anchor_get_widgets(v.native()) if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return wrapWidget(glib.Take(ptr)) }) return glist } // GetDeleted is a wrapper around gtk_text_child_anchor_get_deleted(). func (v *TextChildAnchor) GetDeleted() bool { return gobool(C.gtk_text_child_anchor_get_deleted(v.native())) } gotk3-0.6.2/gtk/text_child_anchor.go.h000066400000000000000000000017071431157473000176030ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ static GtkTextChildAnchor * toGtkTextChildAnchor(void *p) { return (GTK_TEXT_CHILD_ANCHOR(p)); } gotk3-0.6.2/gtk/text_iter.go000066400000000000000000000357641431157473000157150ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) /* * GtkTextIter */ // TextIter is a representation of GTK's GtkTextIter type TextIter C.GtkTextIter // native returns a pointer to the underlying GtkTextIter. func (v *TextIter) native() *C.GtkTextIter { if v == nil { return nil } return (*C.GtkTextIter)(v) } func marshalTextIter(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) return (*TextIter)(unsafe.Pointer(c)), nil } // GetBuffer is a wrapper around gtk_text_iter_get_buffer(). func (v *TextIter) GetBuffer() *TextBuffer { c := C.gtk_text_iter_get_buffer(v.native()) if c == nil { return nil } return wrapTextBuffer(glib.Take(unsafe.Pointer(c))) } // GetOffset is a wrapper around gtk_text_iter_get_offset(). func (v *TextIter) GetOffset() int { return int(C.gtk_text_iter_get_offset(v.native())) } // GetLine is a wrapper around gtk_text_iter_get_line(). func (v *TextIter) GetLine() int { return int(C.gtk_text_iter_get_line(v.native())) } // GetLineOffset is a wrapper around gtk_text_iter_get_line_offset(). func (v *TextIter) GetLineOffset() int { return int(C.gtk_text_iter_get_line_offset(v.native())) } // GetLineIndex is a wrapper around gtk_text_iter_get_line_index(). func (v *TextIter) GetLineIndex() int { return int(C.gtk_text_iter_get_line_index(v.native())) } // GetVisibleLineOffset is a wrapper around gtk_text_iter_get_visible_line_offset(). func (v *TextIter) GetVisibleLineOffset() int { return int(C.gtk_text_iter_get_visible_line_offset(v.native())) } // GetVisibleLineIndex is a wrapper around gtk_text_iter_get_visible_line_index(). func (v *TextIter) GetVisibleLineIndex() int { return int(C.gtk_text_iter_get_visible_line_index(v.native())) } // GetChar is a wrapper around gtk_text_iter_get_char(). func (v *TextIter) GetChar() rune { return rune(C.gtk_text_iter_get_char(v.native())) } // GetSlice is a wrapper around gtk_text_iter_get_slice(). func (v *TextIter) GetSlice(end *TextIter) string { c := C.gtk_text_iter_get_slice(v.native(), end.native()) return C.GoString((*C.char)(c)) } // GetText is a wrapper around gtk_text_iter_get_text(). func (v *TextIter) GetText(end *TextIter) string { c := C.gtk_text_iter_get_text(v.native(), end.native()) return C.GoString((*C.char)(c)) } // GetVisibleSlice is a wrapper around gtk_text_iter_get_visible_slice(). func (v *TextIter) GetVisibleSlice(end *TextIter) string { c := C.gtk_text_iter_get_visible_slice(v.native(), end.native()) return C.GoString((*C.char)(c)) } // GetVisibleText is a wrapper around gtk_text_iter_get_visible_text(). func (v *TextIter) GetVisibleText(end *TextIter) string { c := C.gtk_text_iter_get_visible_text(v.native(), end.native()) return C.GoString((*C.char)(c)) } // EndsTag is a wrapper around gtk_text_iter_ends_tag(). func (v *TextIter) EndsTag(v1 *TextTag) bool { return gobool(C.gtk_text_iter_ends_tag(v.native(), v1.native())) } // TogglesTag is a wrapper around gtk_text_iter_toggles_tag(). func (v *TextIter) TogglesTag(v1 *TextTag) bool { return gobool(C.gtk_text_iter_toggles_tag(v.native(), v1.native())) } // HasTag is a wrapper around gtk_text_iter_has_tag(). func (v *TextIter) HasTag(v1 *TextTag) bool { return gobool(C.gtk_text_iter_has_tag(v.native(), v1.native())) } // Editable is a wrapper around gtk_text_iter_editable(). func (v *TextIter) Editable(v1 bool) bool { return gobool(C.gtk_text_iter_editable(v.native(), gbool(v1))) } // CanInsert is a wrapper around gtk_text_iter_can_insert(). func (v *TextIter) CanInsert(v1 bool) bool { return gobool(C.gtk_text_iter_can_insert(v.native(), gbool(v1))) } // StartsWord is a wrapper around gtk_text_iter_starts_word(). func (v *TextIter) StartsWord() bool { return gobool(C.gtk_text_iter_starts_word(v.native())) } // EndsWord is a wrapper around gtk_text_iter_ends_word(). func (v *TextIter) EndsWord() bool { return gobool(C.gtk_text_iter_ends_word(v.native())) } // InsideWord is a wrapper around gtk_text_iter_inside_word(). func (v *TextIter) InsideWord() bool { return gobool(C.gtk_text_iter_inside_word(v.native())) } // StartsLine is a wrapper around gtk_text_iter_starts_line(). func (v *TextIter) StartsLine() bool { return gobool(C.gtk_text_iter_starts_line(v.native())) } // EndsLine is a wrapper around gtk_text_iter_ends_line(). func (v *TextIter) EndsLine() bool { return gobool(C.gtk_text_iter_ends_line(v.native())) } // StartsSentence is a wrapper around gtk_text_iter_starts_sentence(). func (v *TextIter) StartsSentence() bool { return gobool(C.gtk_text_iter_starts_sentence(v.native())) } // EndsSentence is a wrapper around gtk_text_iter_ends_sentence(). func (v *TextIter) EndsSentence() bool { return gobool(C.gtk_text_iter_ends_sentence(v.native())) } // InsideSentence is a wrapper around gtk_text_iter_inside_sentence(). func (v *TextIter) InsideSentence() bool { return gobool(C.gtk_text_iter_inside_sentence(v.native())) } // IsCursorPosition is a wrapper around gtk_text_iter_is_cursor_position(). func (v *TextIter) IsCursorPosition() bool { return gobool(C.gtk_text_iter_is_cursor_position(v.native())) } // GetCharsInLine is a wrapper around gtk_text_iter_get_chars_in_line(). func (v *TextIter) GetCharsInLine() int { return int(C.gtk_text_iter_get_chars_in_line(v.native())) } // GetBytesInLine is a wrapper around gtk_text_iter_get_bytes_in_line(). func (v *TextIter) GetBytesInLine() int { return int(C.gtk_text_iter_get_bytes_in_line(v.native())) } // IsEnd is a wrapper around gtk_text_iter_is_end(). func (v *TextIter) IsEnd() bool { return gobool(C.gtk_text_iter_is_end(v.native())) } // IsStart is a wrapper around gtk_text_iter_is_start(). func (v *TextIter) IsStart() bool { return gobool(C.gtk_text_iter_is_start(v.native())) } // ForwardChar is a wrapper around gtk_text_iter_forward_char(). func (v *TextIter) ForwardChar() bool { return gobool(C.gtk_text_iter_forward_char(v.native())) } // BackwardChar is a wrapper around gtk_text_iter_backward_char(). func (v *TextIter) BackwardChar() bool { return gobool(C.gtk_text_iter_backward_char(v.native())) } // ForwardChars is a wrapper around gtk_text_iter_forward_chars(). func (v *TextIter) ForwardChars(v1 int) bool { return gobool(C.gtk_text_iter_forward_chars(v.native(), C.gint(v1))) } // BackwardChars is a wrapper around gtk_text_iter_backward_chars(). func (v *TextIter) BackwardChars(v1 int) bool { return gobool(C.gtk_text_iter_backward_chars(v.native(), C.gint(v1))) } // ForwardLine is a wrapper around gtk_text_iter_forward_line(). func (v *TextIter) ForwardLine() bool { return gobool(C.gtk_text_iter_forward_line(v.native())) } // BackwardLine is a wrapper around gtk_text_iter_backward_line(). func (v *TextIter) BackwardLine() bool { return gobool(C.gtk_text_iter_backward_line(v.native())) } // ForwardLines is a wrapper around gtk_text_iter_forward_lines(). func (v *TextIter) ForwardLines(v1 int) bool { return gobool(C.gtk_text_iter_forward_lines(v.native(), C.gint(v1))) } // BackwardLines is a wrapper around gtk_text_iter_backward_lines(). func (v *TextIter) BackwardLines(v1 int) bool { return gobool(C.gtk_text_iter_backward_lines(v.native(), C.gint(v1))) } // ForwardWordEnds is a wrapper around gtk_text_iter_forward_word_ends(). func (v *TextIter) ForwardWordEnds(v1 int) bool { return gobool(C.gtk_text_iter_forward_word_ends(v.native(), C.gint(v1))) } // ForwardWordEnd is a wrapper around gtk_text_iter_forward_word_end(). func (v *TextIter) ForwardWordEnd() bool { return gobool(C.gtk_text_iter_forward_word_end(v.native())) } // ForwardCursorPosition is a wrapper around gtk_text_iter_forward_cursor_position(). func (v *TextIter) ForwardCursorPosition() bool { return gobool(C.gtk_text_iter_forward_cursor_position(v.native())) } // BackwardCursorPosition is a wrapper around gtk_text_iter_backward_cursor_position(). func (v *TextIter) BackwardCursorPosition() bool { return gobool(C.gtk_text_iter_backward_cursor_position(v.native())) } // ForwardCursorPositions is a wrapper around gtk_text_iter_forward_cursor_positions(). func (v *TextIter) ForwardCursorPositions(v1 int) bool { return gobool(C.gtk_text_iter_forward_cursor_positions(v.native(), C.gint(v1))) } // BackwardCursorPositions is a wrapper around gtk_text_iter_backward_cursor_positions(). func (v *TextIter) BackwardCursorPositions(v1 int) bool { return gobool(C.gtk_text_iter_backward_cursor_positions(v.native(), C.gint(v1))) } // ForwardSentenceEnds is a wrapper around gtk_text_iter_forward_sentence_ends(). func (v *TextIter) ForwardSentenceEnds(v1 int) bool { return gobool(C.gtk_text_iter_forward_sentence_ends(v.native(), C.gint(v1))) } // ForwardSentenceEnd is a wrapper around gtk_text_iter_forward_sentence_end(). func (v *TextIter) ForwardSentenceEnd() bool { return gobool(C.gtk_text_iter_forward_sentence_end(v.native())) } // ForwardVisibleWordEnds is a wrapper around gtk_text_iter_forward_word_ends(). func (v *TextIter) ForwardVisibleWordEnds(v1 int) bool { return gobool(C.gtk_text_iter_forward_word_ends(v.native(), C.gint(v1))) } // ForwardVisibleWordEnd is a wrapper around gtk_text_iter_forward_visible_word_end(). func (v *TextIter) ForwardVisibleWordEnd() bool { return gobool(C.gtk_text_iter_forward_visible_word_end(v.native())) } // ForwardVisibleCursorPosition is a wrapper around gtk_text_iter_forward_visible_cursor_position(). func (v *TextIter) ForwardVisibleCursorPosition() bool { return gobool(C.gtk_text_iter_forward_visible_cursor_position(v.native())) } // BackwardVisibleCursorPosition is a wrapper around gtk_text_iter_backward_visible_cursor_position(). func (v *TextIter) BackwardVisibleCursorPosition() bool { return gobool(C.gtk_text_iter_backward_visible_cursor_position(v.native())) } // ForwardVisibleCursorPositions is a wrapper around gtk_text_iter_forward_visible_cursor_positions(). func (v *TextIter) ForwardVisibleCursorPositions(v1 int) bool { return gobool(C.gtk_text_iter_forward_visible_cursor_positions(v.native(), C.gint(v1))) } // BackwardVisibleCursorPositions is a wrapper around gtk_text_iter_backward_visible_cursor_positions(). func (v *TextIter) BackwardVisibleCursorPositions(v1 int) bool { return gobool(C.gtk_text_iter_backward_visible_cursor_positions(v.native(), C.gint(v1))) } // ForwardVisibleLine is a wrapper around gtk_text_iter_forward_visible_line(). func (v *TextIter) ForwardVisibleLine() bool { return gobool(C.gtk_text_iter_forward_visible_line(v.native())) } // BackwardVisibleLine is a wrapper around gtk_text_iter_backward_visible_line(). func (v *TextIter) BackwardVisibleLine() bool { return gobool(C.gtk_text_iter_backward_visible_line(v.native())) } // ForwardVisibleLines is a wrapper around gtk_text_iter_forward_visible_lines(). func (v *TextIter) ForwardVisibleLines(v1 int) bool { return gobool(C.gtk_text_iter_forward_visible_lines(v.native(), C.gint(v1))) } // BackwardVisibleLines is a wrapper around gtk_text_iter_backward_visible_lines(). func (v *TextIter) BackwardVisibleLines(v1 int) bool { return gobool(C.gtk_text_iter_backward_visible_lines(v.native(), C.gint(v1))) } // SetOffset is a wrapper around gtk_text_iter_set_offset(). func (v *TextIter) SetOffset(v1 int) { C.gtk_text_iter_set_offset(v.native(), C.gint(v1)) } // SetLine is a wrapper around gtk_text_iter_set_line(). func (v *TextIter) SetLine(v1 int) { C.gtk_text_iter_set_line(v.native(), C.gint(v1)) } // SetLineOffset is a wrapper around gtk_text_iter_set_line_offset(). func (v *TextIter) SetLineOffset(v1 int) { C.gtk_text_iter_set_line_offset(v.native(), C.gint(v1)) } // SetLineIndex is a wrapper around gtk_text_iter_set_line_index(). func (v *TextIter) SetLineIndex(v1 int) { C.gtk_text_iter_set_line_index(v.native(), C.gint(v1)) } // SetVisibleLineOffset is a wrapper around gtk_text_iter_set_visible_line_offset(). func (v *TextIter) SetVisibleLineOffset(v1 int) { C.gtk_text_iter_set_visible_line_offset(v.native(), C.gint(v1)) } // SetVisibleLineIndex is a wrapper around gtk_text_iter_set_visible_line_index(). func (v *TextIter) SetVisibleLineIndex(v1 int) { C.gtk_text_iter_set_visible_line_index(v.native(), C.gint(v1)) } // ForwardToEnd is a wrapper around gtk_text_iter_forward_to_end(). func (v *TextIter) ForwardToEnd() { C.gtk_text_iter_forward_to_end(v.native()) } // ForwardToLineEnd is a wrapper around gtk_text_iter_forward_to_line_end(). func (v *TextIter) ForwardToLineEnd() bool { return gobool(C.gtk_text_iter_forward_to_line_end(v.native())) } // ForwardToTagToggle is a wrapper around gtk_text_iter_forward_to_tag_toggle(). func (v *TextIter) ForwardToTagToggle(v1 *TextTag) bool { return gobool(C.gtk_text_iter_forward_to_tag_toggle(v.native(), v1.native())) } // BackwardToTagToggle is a wrapper around gtk_text_iter_backward_to_tag_toggle(). func (v *TextIter) BackwardToTagToggle(v1 *TextTag) bool { return gobool(C.gtk_text_iter_backward_to_tag_toggle(v.native(), v1.native())) } // Equal is a wrapper around gtk_text_iter_equal(). func (v *TextIter) Equal(v1 *TextIter) bool { return gobool(C.gtk_text_iter_equal(v.native(), v1.native())) } // Compare is a wrapper around gtk_text_iter_compare(). func (v *TextIter) Compare(v1 *TextIter) int { return int(C.gtk_text_iter_compare(v.native(), v1.native())) } // InRange is a wrapper around gtk_text_iter_in_range(). func (v *TextIter) InRange(v1 *TextIter, v2 *TextIter) bool { return gobool(C.gtk_text_iter_in_range(v.native(), v1.native(), v2.native())) } // ForwardSearch is a wrapper around gtk_text_iter_forward_search(). func (v *TextIter) ForwardSearch(text string, flags TextSearchFlags, limit *TextIter) (matchStart, matchEnd *TextIter, ok bool) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) matchStart, matchEnd = new(TextIter), new(TextIter) cbool := C.gtk_text_iter_forward_search(v.native(), (*C.gchar)(cstr), (C.GtkTextSearchFlags)(flags), (*C.GtkTextIter)(matchStart), (*C.GtkTextIter)(matchEnd), (*C.GtkTextIter)(limit)) return matchStart, matchEnd, gobool(cbool) } // BackwardSearch is a wrapper around gtk_text_iter_backward_search(). func (v *TextIter) BackwardSearch(text string, flags TextSearchFlags, limit *TextIter) (matchStart, matchEnd *TextIter, ok bool) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) matchStart, matchEnd = new(TextIter), new(TextIter) cbool := C.gtk_text_iter_backward_search(v.native(), (*C.gchar)(cstr), (C.GtkTextSearchFlags)(flags), (*C.GtkTextIter)(matchStart), (*C.GtkTextIter)(matchEnd), (*C.GtkTextIter)(limit)) return matchStart, matchEnd, gobool(cbool) } // void gtk_text_iter_order () // gboolean (*GtkTextCharPredicate) () // gboolean gtk_text_iter_forward_find_char () // gboolean gtk_text_iter_backward_find_char () // gboolean gtk_text_iter_get_attributes () // GtkTextIter * gtk_text_iter_copy () // void gtk_text_iter_assign () // void gtk_text_iter_free () // GdkPixbuf * gtk_text_iter_get_pixbuf () // GSList * gtk_text_iter_get_marks () // GSList * gtk_text_iter_get_toggled_tags () // GtkTextChildAnchor * gtk_text_iter_get_child_anchor () // GSList * gtk_text_iter_get_tags () // PangoLanguage * gtk_text_iter_get_language () gotk3-0.6.2/gtk/text_mark.go000066400000000000000000000045211431157473000156670ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { WrapMap["GtkTextMark"] = wrapTextMark } /* * GtkTextMark */ // TextMark is a representation of GTK's GtkTextMark. // A position in the buffer preserved across buffer modifications type TextMark struct { *glib.Object } // native returns a pointer to the underlying GtkTextMark. func (v *TextMark) native() *C.GtkTextMark { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTextMark(p) } func marshalTextMark(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTextMark(obj), nil } func wrapTextMark(obj *glib.Object) *TextMark { if obj == nil { return nil } return &TextMark{obj} } // TextMarkNew is a wrapper around gtk_text_mark_new(). func TextMarkNew(name string, leftGravity bool) (*TextMark, error) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) c := C.gtk_text_mark_new((*C.gchar)(cstr), gbool(leftGravity)) if c == nil { return nil, nilPtrErr } return wrapTextMark(glib.Take(unsafe.Pointer(c))), nil } // SetVisible is a wrapper around gtk_text_mark_set_visible(). func (v *TextMark) SetVisible(setting bool) { C.gtk_text_mark_set_visible(v.native(), gbool(setting)) } // GetVisible is a wrapper around gtk_text_mark_get_visible(). func (v *TextMark) GetVisible() bool { return gobool(C.gtk_text_mark_get_visible(v.native())) } // GetDeleted is a wrapper around gtk_text_mark_get_deleted(). func (v *TextMark) GetDeleted() bool { return gobool(C.gtk_text_mark_get_deleted(v.native())) } // GetName is a wrapper around gtk_text_mark_get_name(). func (v *TextMark) GetName() string { return goString(C.gtk_text_mark_get_name(v.native())) } // GetBuffer is a wrapper around gtk_text_mark_get_buffer(). func (v *TextMark) GetBuffer() (*TextBuffer, error) { c := C.gtk_text_mark_get_buffer(v.native()) if c == nil { return nil, nilPtrErr } return wrapTextBuffer(glib.Take(unsafe.Pointer(c))), nil } // GetLeftGravity is a wrapper around gtk_text_mark_get_left_gravity(). func (v *TextMark) GetLeftGravity() bool { return gobool(C.gtk_text_mark_get_left_gravity(v.native())) } gotk3-0.6.2/gtk/text_view.go000066400000000000000000000401121431157473000157030ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package gtk // #include // #include "gtk.go.h" import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/pango" ) func init() { tm := []glib.TypeMarshaler{ {glib.Type(C.gtk_text_window_type_get_type()), marshalTextWindowType}, } glib.RegisterGValueMarshalers(tm) } // TextWindowType is a representation of GTK's GtkTextWindowType. type TextWindowType int const ( TEXT_WINDOW_PRIVATE TextWindowType = C.GTK_TEXT_WINDOW_PRIVATE TEXT_WINDOW_WIDGET TextWindowType = C.GTK_TEXT_WINDOW_WIDGET TEXT_WINDOW_TEXT TextWindowType = C.GTK_TEXT_WINDOW_TEXT TEXT_WINDOW_LEFT TextWindowType = C.GTK_TEXT_WINDOW_LEFT TEXT_WINDOW_RIGHT TextWindowType = C.GTK_TEXT_WINDOW_RIGHT TEXT_WINDOW_TOP TextWindowType = C.GTK_TEXT_WINDOW_TOP TEXT_WINDOW_BOTTOM TextWindowType = C.GTK_TEXT_WINDOW_BOTTOM ) func marshalTextWindowType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return TextWindowType(c), nil } /* * GtkTextView */ // TextView is a representation of GTK's GtkTextView type TextView struct { Container } // native returns a pointer to the underlying GtkTextView. func (v *TextView) native() *C.GtkTextView { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTextView(p) } func marshalTextView(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTextView(obj), nil } func wrapTextView(obj *glib.Object) *TextView { if obj == nil { return nil } return &TextView{Container{Widget{glib.InitiallyUnowned{obj}}}} } // TextViewNew is a wrapper around gtk_text_view_new(). func TextViewNew() (*TextView, error) { c := C.gtk_text_view_new() if c == nil { return nil, nilPtrErr } return wrapTextView(glib.Take(unsafe.Pointer(c))), nil } // TextViewNewWithBuffer is a wrapper around gtk_text_view_new_with_buffer(). func TextViewNewWithBuffer(buf *TextBuffer) (*TextView, error) { cbuf := buf.native() c := C.gtk_text_view_new_with_buffer(cbuf) return wrapTextView(glib.Take(unsafe.Pointer(c))), nil } // GetBuffer is a wrapper around gtk_text_view_get_buffer(). func (v *TextView) GetBuffer() (*TextBuffer, error) { c := C.gtk_text_view_get_buffer(v.native()) if c == nil { return nil, nilPtrErr } return wrapTextBuffer(glib.Take(unsafe.Pointer(c))), nil } // SetBuffer is a wrapper around gtk_text_view_set_buffer(). func (v *TextView) SetBuffer(buffer *TextBuffer) { C.gtk_text_view_set_buffer(v.native(), buffer.native()) } // SetEditable is a wrapper around gtk_text_view_set_editable(). func (v *TextView) SetEditable(editable bool) { C.gtk_text_view_set_editable(v.native(), gbool(editable)) } // GetEditable is a wrapper around gtk_text_view_get_editable(). func (v *TextView) GetEditable() bool { c := C.gtk_text_view_get_editable(v.native()) return gobool(c) } // SetWrapMode is a wrapper around gtk_text_view_set_wrap_mode(). func (v *TextView) SetWrapMode(wrapMode WrapMode) { C.gtk_text_view_set_wrap_mode(v.native(), C.GtkWrapMode(wrapMode)) } // GetWrapMode is a wrapper around gtk_text_view_get_wrap_mode(). func (v *TextView) GetWrapMode() WrapMode { return WrapMode(C.gtk_text_view_get_wrap_mode(v.native())) } // SetCursorVisible is a wrapper around gtk_text_view_set_cursor_visible(). func (v *TextView) SetCursorVisible(visible bool) { C.gtk_text_view_set_cursor_visible(v.native(), gbool(visible)) } // GetCursorVisible is a wrapper around gtk_text_view_get_cursor_visible(). func (v *TextView) GetCursorVisible() bool { c := C.gtk_text_view_get_cursor_visible(v.native()) return gobool(c) } // SetOverwrite is a wrapper around gtk_text_view_set_overwrite(). func (v *TextView) SetOverwrite(overwrite bool) { C.gtk_text_view_set_overwrite(v.native(), gbool(overwrite)) } // GetOverwrite is a wrapper around gtk_text_view_get_overwrite(). func (v *TextView) GetOverwrite() bool { c := C.gtk_text_view_get_overwrite(v.native()) return gobool(c) } // SetJustification is a wrapper around gtk_text_view_set_justification(). func (v *TextView) SetJustification(justify Justification) { C.gtk_text_view_set_justification(v.native(), C.GtkJustification(justify)) } // GetJustification is a wrapper around gtk_text_view_get_justification(). func (v *TextView) GetJustification() Justification { c := C.gtk_text_view_get_justification(v.native()) return Justification(c) } // SetAcceptsTab is a wrapper around gtk_text_view_set_accepts_tab(). func (v *TextView) SetAcceptsTab(acceptsTab bool) { C.gtk_text_view_set_accepts_tab(v.native(), gbool(acceptsTab)) } // GetAcceptsTab is a wrapper around gtk_text_view_get_accepts_tab(). func (v *TextView) GetAcceptsTab() bool { c := C.gtk_text_view_get_accepts_tab(v.native()) return gobool(c) } // SetPixelsAboveLines is a wrapper around gtk_text_view_set_pixels_above_lines(). func (v *TextView) SetPixelsAboveLines(px int) { C.gtk_text_view_set_pixels_above_lines(v.native(), C.gint(px)) } // GetPixelsAboveLines is a wrapper around gtk_text_view_get_pixels_above_lines(). func (v *TextView) GetPixelsAboveLines() int { c := C.gtk_text_view_get_pixels_above_lines(v.native()) return int(c) } // SetPixelsBelowLines is a wrapper around gtk_text_view_set_pixels_below_lines(). func (v *TextView) SetPixelsBelowLines(px int) { C.gtk_text_view_set_pixels_below_lines(v.native(), C.gint(px)) } // GetPixelsBelowLines is a wrapper around gtk_text_view_get_pixels_below_lines(). func (v *TextView) GetPixelsBelowLines() int { c := C.gtk_text_view_get_pixels_below_lines(v.native()) return int(c) } // SetPixelsInsideWrap is a wrapper around gtk_text_view_set_pixels_inside_wrap(). func (v *TextView) SetPixelsInsideWrap(px int) { C.gtk_text_view_set_pixels_inside_wrap(v.native(), C.gint(px)) } // GetPixelsInsideWrap is a wrapper around gtk_text_view_get_pixels_inside_wrap(). func (v *TextView) GetPixelsInsideWrap() int { c := C.gtk_text_view_get_pixels_inside_wrap(v.native()) return int(c) } // SetLeftMargin is a wrapper around gtk_text_view_set_left_margin(). func (v *TextView) SetLeftMargin(margin int) { C.gtk_text_view_set_left_margin(v.native(), C.gint(margin)) } // GetLeftMargin is a wrapper around gtk_text_view_get_left_margin(). func (v *TextView) GetLeftMargin() int { c := C.gtk_text_view_get_left_margin(v.native()) return int(c) } // SetRightMargin is a wrapper around gtk_text_view_set_right_margin(). func (v *TextView) SetRightMargin(margin int) { C.gtk_text_view_set_right_margin(v.native(), C.gint(margin)) } // GetRightMargin is a wrapper around gtk_text_view_get_right_margin(). func (v *TextView) GetRightMargin() int { c := C.gtk_text_view_get_right_margin(v.native()) return int(c) } // SetIndent is a wrapper around gtk_text_view_set_indent(). func (v *TextView) SetIndent(indent int) { C.gtk_text_view_set_indent(v.native(), C.gint(indent)) } // GetIndent is a wrapper around gtk_text_view_get_indent(). func (v *TextView) GetIndent() int { c := C.gtk_text_view_get_indent(v.native()) return int(c) } // SetTabs is a wrapper around gtk_text_view_set_tabs(). func (v *TextView) SetTabs(tabs *pango.TabArray) { C.gtk_text_view_set_tabs(v.native(), (*C.PangoTabArray)(unsafe.Pointer(tabs.Native()))) } // GetTabs is a wrapper around gtk_text_view_get_tabs(). func (v *TextView) GetTabs() (*pango.TabArray, error) { c := C.gtk_text_view_get_tabs(v.native()) if c == nil { return nil, nilPtrErr } ta := pango.WrapTabArray(uintptr(unsafe.Pointer(c))) runtime.SetFinalizer(ta, func(v *pango.TabArray) { glib.FinalizerStrategy(v.Free) }) return ta, nil } // SetInputHints is a wrapper around gtk_text_view_set_input_hints(). func (v *TextView) SetInputHints(hints InputHints) { C.gtk_text_view_set_input_hints(v.native(), C.GtkInputHints(hints)) } // GetInputHints is a wrapper around gtk_text_view_get_input_hints(). func (v *TextView) GetInputHints() InputHints { c := C.gtk_text_view_get_input_hints(v.native()) return InputHints(c) } // SetInputPurpose is a wrapper around gtk_text_view_set_input_purpose(). func (v *TextView) SetInputPurpose(purpose InputPurpose) { C.gtk_text_view_set_input_purpose(v.native(), C.GtkInputPurpose(purpose)) } // GetInputPurpose is a wrapper around gtk_text_view_get_input_purpose(). func (v *TextView) GetInputPurpose() InputPurpose { c := C.gtk_text_view_get_input_purpose(v.native()) return InputPurpose(c) } // ScrollToMark is a wrapper around gtk_text_view_scroll_to_mark(). func (v *TextView) ScrollToMark(mark *TextMark, within_margin float64, use_align bool, xalign, yalign float64) { C.gtk_text_view_scroll_to_mark(v.native(), mark.native(), C.gdouble(within_margin), gbool(use_align), C.gdouble(xalign), C.gdouble(yalign)) } // ScrollToIter is a wrapper around gtk_text_view_scroll_to_iter(). func (v *TextView) ScrollToIter(iter *TextIter, within_margin float64, use_align bool, xalign, yalign float64) bool { return gobool(C.gtk_text_view_scroll_to_iter(v.native(), iter.native(), C.gdouble(within_margin), gbool(use_align), C.gdouble(xalign), C.gdouble(yalign))) } // ScrollMarkOnscreen is a wrapper around gtk_text_view_scroll_mark_onscreen(). func (v *TextView) ScrollMarkOnscreen(mark *TextMark) { C.gtk_text_view_scroll_mark_onscreen(v.native(), mark.native()) } // MoveMarkOnscreen is a wrapper around gtk_text_view_move_mark_onscreen(). func (v *TextView) MoveMarkOnscreen(mark *TextMark) bool { return gobool(C.gtk_text_view_move_mark_onscreen(v.native(), mark.native())) } // PlaceCursorOnscreen is a wrapper around gtk_text_view_place_cursor_onscreen(). func (v *TextView) PlaceCursorOnscreen() bool { return gobool(C.gtk_text_view_place_cursor_onscreen(v.native())) } // GetVisibleRect is a wrapper around gtk_text_view_get_visible_rect(). func (v *TextView) GetVisibleRect() *gdk.Rectangle { var rect C.GdkRectangle C.gtk_text_view_get_visible_rect(v.native(), &rect) return gdk.WrapRectangle(uintptr(unsafe.Pointer(&rect))) } // GetIterLocation is a wrapper around gtk_text_view_get_iter_location(). func (v *TextView) GetIterLocation(iter *TextIter) *gdk.Rectangle { var rect C.GdkRectangle C.gtk_text_view_get_iter_location(v.native(), iter.native(), &rect) return gdk.WrapRectangle(uintptr(unsafe.Pointer(&rect))) } // GetCursorLocations is a wrapper around gtk_text_view_get_cursor_locations(). func (v *TextView) GetCursorLocations(iter *TextIter) (strong, weak *gdk.Rectangle) { var strongRect, weakRect C.GdkRectangle C.gtk_text_view_get_cursor_locations(v.native(), iter.native(), &strongRect, &weakRect) return gdk.WrapRectangle(uintptr(unsafe.Pointer(&strongRect))), gdk.WrapRectangle(uintptr(unsafe.Pointer(&weakRect))) } // GetLineAtY is a wrapper around gtk_text_view_get_line_at_y(). func (v *TextView) GetLineAtY(y int) (*TextIter, int) { var iter TextIter var line_top C.gint iiter := (C.GtkTextIter)(iter) C.gtk_text_view_get_line_at_y(v.native(), &iiter, C.gint(y), &line_top) return &iter, int(line_top) } // GetLineYrange is a wrapper around gtk_text_view_get_line_yrange(). func (v *TextView) GetLineYrange(iter *TextIter) (y, height int) { var yx, heightx C.gint C.gtk_text_view_get_line_yrange(v.native(), iter.native(), &yx, &heightx) return int(yx), int(heightx) } // GetIterAtLocation is a wrapper around gtk_text_view_get_iter_at_location(). func (v *TextView) GetIterAtLocation(x, y int) *TextIter { var iter C.GtkTextIter C.gtk_text_view_get_iter_at_location(v.native(), &iter, C.gint(x), C.gint(y)) return (*TextIter)(&iter) } // GetIterAtPosition is a wrapper around gtk_text_view_get_iter_at_position(). func (v *TextView) GetIterAtPosition(x, y int) (*TextIter, int) { var iter C.GtkTextIter var trailing C.gint C.gtk_text_view_get_iter_at_position(v.native(), &iter, &trailing, C.gint(x), C.gint(y)) return (*TextIter)(&iter), int(trailing) } // BufferToWindowCoords is a wrapper around gtk_text_view_buffer_to_window_coords(). func (v *TextView) BufferToWindowCoords(win TextWindowType, buffer_x, buffer_y int) (window_x, window_y int) { var wx, wy C.gint C.gtk_text_view_buffer_to_window_coords(v.native(), C.GtkTextWindowType(win), C.gint(buffer_x), C.gint(buffer_y), &wx, &wy) return int(wx), int(wy) } // WindowToBufferCoords is a wrapper around gtk_text_view_window_to_buffer_coords(). func (v *TextView) WindowToBufferCoords(win TextWindowType, window_x, window_y int) (buffer_x, buffer_y int) { var bx, by C.gint C.gtk_text_view_window_to_buffer_coords(v.native(), C.GtkTextWindowType(win), C.gint(window_x), C.gint(window_y), &bx, &by) return int(bx), int(by) } // GetWindow is a wrapper around gtk_text_view_get_window(). func (v *TextView) GetWindow(win TextWindowType) *gdk.Window { c := C.gtk_text_view_get_window(v.native(), C.GtkTextWindowType(win)) if c == nil { return nil } return &gdk.Window{glib.Take(unsafe.Pointer(c))} } // GetWindowType is a wrapper around gtk_text_view_get_window_type(). func (v *TextView) GetWindowType(w *gdk.Window) TextWindowType { return TextWindowType(C.gtk_text_view_get_window_type(v.native(), (*C.GdkWindow)(unsafe.Pointer(w.Native())))) } // SetBorderWindowSize is a wrapper around gtk_text_view_set_border_window_size(). func (v *TextView) SetBorderWindowSize(tp TextWindowType, size int) { C.gtk_text_view_set_border_window_size(v.native(), C.GtkTextWindowType(tp), C.gint(size)) } // GetBorderWindowSize is a wrapper around gtk_text_view_get_border_window_size(). func (v *TextView) GetBorderWindowSize(tp TextWindowType) int { return int(C.gtk_text_view_get_border_window_size(v.native(), C.GtkTextWindowType(tp))) } // ForwardDisplayLine is a wrapper around gtk_text_view_forward_display_line(). func (v *TextView) ForwardDisplayLine(iter *TextIter) bool { return gobool(C.gtk_text_view_forward_display_line(v.native(), iter.native())) } // BackwardDisplayLine is a wrapper around gtk_text_view_backward_display_line(). func (v *TextView) BackwardDisplayLine(iter *TextIter) bool { return gobool(C.gtk_text_view_backward_display_line(v.native(), iter.native())) } // ForwardDisplayLineEnd is a wrapper around gtk_text_view_forward_display_line_end(). func (v *TextView) ForwardDisplayLineEnd(iter *TextIter) bool { return gobool(C.gtk_text_view_forward_display_line_end(v.native(), iter.native())) } // BackwardDisplayLineStart is a wrapper around gtk_text_view_backward_display_line_start(). func (v *TextView) BackwardDisplayLineStart(iter *TextIter) bool { return gobool(C.gtk_text_view_backward_display_line_start(v.native(), iter.native())) } // StartsDisplayLine is a wrapper around gtk_text_view_starts_display_line(). func (v *TextView) StartsDisplayLine(iter *TextIter) bool { return gobool(C.gtk_text_view_starts_display_line(v.native(), iter.native())) } // MoveVisually is a wrapper around gtk_text_view_move_visually(). func (v *TextView) MoveVisually(iter *TextIter, count int) bool { return gobool(C.gtk_text_view_move_visually(v.native(), iter.native(), C.gint(count))) } // AddChildInWindow is a wrapper around gtk_text_view_add_child_in_window(). func (v *TextView) AddChildInWindow(child IWidget, tp TextWindowType, xpos, ypos int) { C.gtk_text_view_add_child_in_window(v.native(), child.toWidget(), C.GtkTextWindowType(tp), C.gint(xpos), C.gint(ypos)) } // MoveChild is a wrapper around gtk_text_view_move_child(). func (v *TextView) MoveChild(child IWidget, xpos, ypos int) { C.gtk_text_view_move_child(v.native(), child.toWidget(), C.gint(xpos), C.gint(ypos)) } // ImContextFilterKeypress is a wrapper around gtk_text_view_im_context_filter_keypress(). func (v *TextView) ImContextFilterKeypress(event *gdk.EventKey) bool { return gobool(C.gtk_text_view_im_context_filter_keypress(v.native(), (*C.GdkEventKey)(unsafe.Pointer(event.Native())))) } // ResetImContext is a wrapper around gtk_text_view_reset_im_context(). func (v *TextView) ResetImContext() { C.gtk_text_view_reset_im_context(v.native()) } // AddChildAtAnchor is a wrapper around gtk_text_view_add_child_at_anchor(). func (v *TextView) AddChildAtAnchor(child IWidget, anchor *TextChildAnchor) { C.gtk_text_view_add_child_at_anchor(v.native(), child.toWidget(), anchor.native()) } // TODO: // GtkTextAttributes * gtk_text_view_get_default_attributes () -- GtkTextAttributes // GtkTextViewLayer gotk3-0.6.2/gtk/toolshell.go000066400000000000000000000005751431157473000157030ustar00rootroot00000000000000package gtk // TODO: // GtkToolShellIface // gtk_tool_shell_get_ellipsize_mode(). // gtk_tool_shell_get_icon_size(). // gtk_tool_shell_get_orientation(). // gtk_tool_shell_get_relief_style(). // gtk_tool_shell_get_style(). // gtk_tool_shell_get_text_alignment(). // gtk_tool_shell_get_text_orientation(). // gtk_tool_shell_rebuild_menu(). // gtk_tool_shell_get_text_size_group(). gotk3-0.6.2/gtk/tooltip.go000066400000000000000000000040171431157473000153630ustar00rootroot00000000000000package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) /* * GtkTooltip */ type Tooltip struct { Widget } // native returns a pointer to the underlying GtkIconView. func (t *Tooltip) native() *C.GtkTooltip { if t == nil || t.GObject == nil { return nil } p := unsafe.Pointer(t.GObject) return C.toGtkTooltip(p) } func marshalTooltip(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTooltip(obj), nil } func wrapTooltip(obj *glib.Object) *Tooltip { if obj == nil { return nil } return &Tooltip{Widget{glib.InitiallyUnowned{obj}}} } // SetMarkup is a wrapper around gtk_tooltip_set_markup(). func (t *Tooltip) SetMarkup(str string) { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) C.gtk_tooltip_set_markup(t.native(), (*C.gchar)(cstr)) } // SetText is a wrapper around gtk_tooltip_set_text(). func (t *Tooltip) SetText(str string) { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) C.gtk_tooltip_set_text(t.native(), (*C.gchar)(cstr)) } // SetIcon is a wrapper around gtk_tooltip_set_icon(). func (t *Tooltip) SetIcon(pixbuf *gdk.Pixbuf) { C.gtk_tooltip_set_icon(t.native(), (*C.GdkPixbuf)(unsafe.Pointer(pixbuf.Native()))) } // SetIconFromIconName is a wrapper around gtk_tooltip_set_icon_from_icon_name(). func (t *Tooltip) SetIconFromIconName(iconName string, size IconSize) { cstr := C.CString(iconName) defer C.free(unsafe.Pointer(cstr)) C.gtk_tooltip_set_icon_from_icon_name(t.native(), (*C.gchar)(cstr), C.GtkIconSize(size)) } // func (t *Tooltip) SetIconFromGIcon() { } // SetCustom is a wrapper around gtk_tooltip_set_custom(). func (t *Tooltip) SetCustom(w *Widget) { C.gtk_tooltip_set_custom(t.native(), w.native()) } // SetTipArea is a wrapper around gtk_tooltip_set_tip_area(). func (t *Tooltip) SetTipArea(rect gdk.Rectangle) { C.gtk_tooltip_set_tip_area(t.native(), nativeGdkRectangle(rect)) } gotk3-0.6.2/gtk/tree_view.go000066400000000000000000000541001431157473000156600ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains accelerator related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "runtime" "strings" "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/internal/callback" ) /* * GtkTreeView */ // TreeView is a representation of GTK's GtkTreeView. type TreeView struct { Container } // native returns a pointer to the underlying GtkTreeView. func (v *TreeView) native() *C.GtkTreeView { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTreeView(p) } func marshalTreeView(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTreeView(obj), nil } func wrapTreeView(obj *glib.Object) *TreeView { if obj == nil { return nil } return &TreeView{Container{Widget{glib.InitiallyUnowned{obj}}}} } func setupTreeView(c unsafe.Pointer) (*TreeView, error) { if c == nil { return nil, nilPtrErr } return wrapTreeView(glib.Take(c)), nil } // TreeViewNew is a wrapper around gtk_tree_view_new(). func TreeViewNew() (*TreeView, error) { return setupTreeView(unsafe.Pointer(C.gtk_tree_view_new())) } // TreeViewNewWithModel is a wrapper around gtk_tree_view_new_with_model(). func TreeViewNewWithModel(model ITreeModel) (*TreeView, error) { return setupTreeView(unsafe.Pointer(C.gtk_tree_view_new_with_model(model.toTreeModel()))) } // GetModel is a wrapper around gtk_tree_view_get_model(). func (v *TreeView) GetModel() (ITreeModel, error) { c := C.gtk_tree_view_get_model(v.native()) if c == nil { return nil, nilPtrErr } return castTreeModel(c) } // SetModel is a wrapper around gtk_tree_view_set_model(). func (v *TreeView) SetModel(model ITreeModel) { var mptr *C.GtkTreeModel if model != nil { mptr = model.toTreeModel() } C.gtk_tree_view_set_model(v.native(), mptr) } // GetSelection is a wrapper around gtk_tree_view_get_selection(). func (v *TreeView) GetSelection() (*TreeSelection, error) { c := C.gtk_tree_view_get_selection(v.native()) if c == nil { return nil, nilPtrErr } return wrapTreeSelection(glib.Take(unsafe.Pointer(c))), nil } // AppendColumn is a wrapper around gtk_tree_view_append_column(). func (v *TreeView) AppendColumn(column *TreeViewColumn) int { c := C.gtk_tree_view_append_column(v.native(), column.native()) return int(c) } // GetPathAtPos is a wrapper around gtk_tree_view_get_path_at_pos(). func (v *TreeView) GetPathAtPos(x, y int) (*TreePath, *TreeViewColumn, int, int, bool) { var ( cpath *C.GtkTreePath ccol *C.GtkTreeViewColumn ccellX, ccellY *C.gint cellX, cellY int ) path := new(TreePath) column := new(TreeViewColumn) cbool := C.gtk_tree_view_get_path_at_pos( v.native(), (C.gint)(x), (C.gint)(y), &cpath, &ccol, ccellX, ccellY) if cpath != nil { path = &TreePath{cpath} runtime.SetFinalizer(path, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } if ccol != nil { column = wrapTreeViewColumn(glib.Take(unsafe.Pointer(ccol))) } if ccellX != nil { cellX = int(*((*C.gint)(unsafe.Pointer(ccellX)))) } if ccellY != nil { cellY = int(*((*C.gint)(unsafe.Pointer(ccellY)))) } return path, column, cellX, cellY, gobool(cbool) } // GetCellArea is a wrapper around gtk_tree_view_get_cell_area(). func (v *TreeView) GetCellArea(path *TreePath, column *TreeViewColumn) *gdk.Rectangle { ctp := path.native() pctvcol := column.native() var rect C.GdkRectangle C.gtk_tree_view_get_cell_area(v.native(), ctp, pctvcol, &rect) return gdk.WrapRectangle(uintptr(unsafe.Pointer(&rect))) } // GetLevelIndentation is a wrapper around gtk_tree_view_get_level_indentation(). func (v *TreeView) GetLevelIndentation() int { return int(C.gtk_tree_view_get_level_indentation(v.native())) } // GetShowExpanders is a wrapper around gtk_tree_view_get_show_expanders(). func (v *TreeView) GetShowExpanders() bool { return gobool(C.gtk_tree_view_get_show_expanders(v.native())) } // SetLevelIndentation is a wrapper around gtk_tree_view_set_level_indentation(). func (v *TreeView) SetLevelIndentation(indent int) { C.gtk_tree_view_set_level_indentation(v.native(), C.gint(indent)) } // SetShowExpanders is a wrapper around gtk_tree_view_set_show_expanders(). func (v *TreeView) SetShowExpanders(show bool) { C.gtk_tree_view_set_show_expanders(v.native(), gbool(show)) } // GetHeadersVisible is a wrapper around gtk_tree_view_get_headers_visible(). func (v *TreeView) GetHeadersVisible() bool { return gobool(C.gtk_tree_view_get_headers_visible(v.native())) } // SetHeadersVisible is a wrapper around gtk_tree_view_set_headers_visible(). func (v *TreeView) SetHeadersVisible(show bool) { C.gtk_tree_view_set_headers_visible(v.native(), gbool(show)) } // ColumnsAutosize is a wrapper around gtk_tree_view_columns_autosize(). func (v *TreeView) ColumnsAutosize() { C.gtk_tree_view_columns_autosize(v.native()) } // GetHeadersClickable is a wrapper around gtk_tree_view_get_headers_clickable(). func (v *TreeView) GetHeadersClickable() bool { return gobool(C.gtk_tree_view_get_headers_clickable(v.native())) } // SetHeadersClickable is a wrapper around gtk_tree_view_set_headers_clickable(). func (v *TreeView) SetHeadersClickable(show bool) { C.gtk_tree_view_set_headers_clickable(v.native(), gbool(show)) } // GetActivateOnSingleClick is a wrapper around gtk_tree_view_get_activate_on_single_click(). func (v *TreeView) GetActivateOnSingleClick() bool { return gobool(C.gtk_tree_view_get_activate_on_single_click(v.native())) } // SetActivateOnSingleClick is a wrapper around gtk_tree_view_set_activate_on_single_click(). func (v *TreeView) SetActivateOnSingleClick(show bool) { C.gtk_tree_view_set_activate_on_single_click(v.native(), gbool(show)) } // RemoveColumn is a wrapper around gtk_tree_view_remove_column(). func (v *TreeView) RemoveColumn(column *TreeViewColumn) int { return int(C.gtk_tree_view_remove_column(v.native(), column.native())) } // InsertColumn is a wrapper around gtk_tree_view_insert_column(). func (v *TreeView) InsertColumn(column *TreeViewColumn, pos int) int { return int(C.gtk_tree_view_insert_column(v.native(), column.native(), C.gint(pos))) } // GetNColumns is a wrapper around gtk_tree_view_get_n_columns(). func (v *TreeView) GetNColumns() uint { return uint(C.gtk_tree_view_get_n_columns(v.native())) } // GetColumn is a wrapper around gtk_tree_view_get_column(). func (v *TreeView) GetColumn(n int) *TreeViewColumn { c := C.gtk_tree_view_get_column(v.native(), C.gint(n)) if c == nil { return nil } return wrapTreeViewColumn(glib.Take(unsafe.Pointer(c))) } // GetColumns is a wrapper around gtk_tree_view_get_columns(). func (v *TreeView) GetColumns() *glib.List { clist := C.gtk_tree_view_get_columns(v.native()) if clist == nil { return nil } list := glib.WrapList(uintptr(unsafe.Pointer(clist))) list.DataWrapper(func(ptr unsafe.Pointer) interface{} { return wrapTreeViewColumn(glib.Take(unsafe.Pointer(ptr))) }) runtime.SetFinalizer(list, func(glist *glib.List) { glib.FinalizerStrategy(glist.Free) }) return list } // MoveColumnAfter is a wrapper around gtk_tree_view_move_column_after(). func (v *TreeView) MoveColumnAfter(column *TreeViewColumn, baseColumn *TreeViewColumn) { C.gtk_tree_view_move_column_after(v.native(), column.native(), baseColumn.native()) } // SetExpanderColumn is a wrapper around gtk_tree_view_set_expander_column(). func (v *TreeView) SetExpanderColumn(column *TreeViewColumn) { C.gtk_tree_view_set_expander_column(v.native(), column.native()) } // GetExpanderColumn is a wrapper around gtk_tree_view_get_expander_column(). func (v *TreeView) GetExpanderColumn() *TreeViewColumn { c := C.gtk_tree_view_get_expander_column(v.native()) if c == nil { return nil } return wrapTreeViewColumn(glib.Take(unsafe.Pointer(c))) } // ScrollToPoint is a wrapper around gtk_tree_view_scroll_to_point(). func (v *TreeView) ScrollToPoint(treeX, treeY int) { C.gtk_tree_view_scroll_to_point(v.native(), C.gint(treeX), C.gint(treeY)) } // SetCursor is a wrapper around gtk_tree_view_set_cursor(). func (v *TreeView) SetCursor(path *TreePath, focusColumn *TreeViewColumn, startEditing bool) { C.gtk_tree_view_set_cursor(v.native(), path.native(), focusColumn.native(), gbool(startEditing)) } // SetCursorOnCell is a wrapper around gtk_tree_view_set_cursor_on_cell(). func (v *TreeView) SetCursorOnCell(path *TreePath, focusColumn *TreeViewColumn, focusCell *CellRenderer, startEditing bool) { C.gtk_tree_view_set_cursor_on_cell(v.native(), path.native(), focusColumn.native(), focusCell.native(), gbool(startEditing)) } // GetCursor is a wrapper around gtk_tree_view_get_cursor(). func (v *TreeView) GetCursor() (p *TreePath, c *TreeViewColumn) { var path *C.GtkTreePath var col *C.GtkTreeViewColumn C.gtk_tree_view_get_cursor(v.native(), &path, &col) if path != nil { p = &TreePath{path} runtime.SetFinalizer(p, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } if col != nil { c = wrapTreeViewColumn(glib.Take(unsafe.Pointer(col))) } return } // RowActivated is a wrapper around gtk_tree_view_row_activated(). func (v *TreeView) RowActivated(path *TreePath, column *TreeViewColumn) { C.gtk_tree_view_row_activated(v.native(), path.native(), column.native()) } // ExpandAll is a wrapper around gtk_tree_view_expand_all(). func (v *TreeView) ExpandAll() { C.gtk_tree_view_expand_all(v.native()) } // CollapseAll is a wrapper around gtk_tree_view_collapse_all(). func (v *TreeView) CollapseAll() { C.gtk_tree_view_collapse_all(v.native()) } // ExpandToPath is a wrapper around gtk_tree_view_expand_to_path(). func (v *TreeView) ExpandToPath(path *TreePath) { C.gtk_tree_view_expand_to_path(v.native(), path.native()) } // ExpandRow is a wrapper around gtk_tree_view_expand_row(). func (v *TreeView) ExpandRow(path *TreePath, openAll bool) bool { return gobool(C.gtk_tree_view_expand_row(v.native(), path.native(), gbool(openAll))) } // CollapseRow is a wrapper around gtk_tree_view_collapse_row(). func (v *TreeView) CollapseRow(path *TreePath) bool { return gobool(C.gtk_tree_view_collapse_row(v.native(), path.native())) } // RowExpanded is a wrapper around gtk_tree_view_row_expanded(). func (v *TreeView) RowExpanded(path *TreePath) bool { return gobool(C.gtk_tree_view_row_expanded(v.native(), path.native())) } // SetReorderable is a wrapper around gtk_tree_view_set_reorderable(). func (v *TreeView) SetReorderable(b bool) { C.gtk_tree_view_set_reorderable(v.native(), gbool(b)) } // GetReorderable is a wrapper around gtk_tree_view_get_reorderable(). func (v *TreeView) GetReorderable() bool { return gobool(C.gtk_tree_view_get_reorderable(v.native())) } // GetBinWindow is a wrapper around gtk_tree_view_get_bin_window(). func (v *TreeView) GetBinWindow() *gdk.Window { c := C.gtk_tree_view_get_bin_window(v.native()) if c == nil { return nil } w := &gdk.Window{glib.Take(unsafe.Pointer(c))} return w } // ConvertWidgetToBinWindowCoords is a rapper around gtk_tree_view_convert_widget_to_bin_window_coords(). func (v *TreeView) ConvertWidgetToBinWindowCoords(wx, wy int, bx, by *int) { C.gtk_tree_view_convert_widget_to_bin_window_coords( v.native(), (C.gint)(wx), (C.gint)(wy), (*C.gint)(unsafe.Pointer(bx)), (*C.gint)(unsafe.Pointer(by))) } // ConvertBinWindowToWidgetCoords is a rapper around gtk_tree_view_convert_bin_window_to_widget_coords(). func (v *TreeView) ConvertBinWindowToWidgetCoords(bx, by int, wx, wy *int) { C.gtk_tree_view_convert_bin_window_to_widget_coords(v.native(), (C.gint)(bx), (C.gint)(by), (*C.gint)(unsafe.Pointer(wx)), (*C.gint)(unsafe.Pointer(wy))) } // ConvertBinWindowToTreeCoords is a wrapper around gtk_tree_view_convert_bin_window_to_tree_coords(). func (v *TreeView) ConvertBinWindowToTreeCoords(bx, by int, tx, ty *int) { C.gtk_tree_view_convert_bin_window_to_tree_coords(v.native(), (C.gint)(bx), (C.gint)(by), (*C.gint)(unsafe.Pointer(tx)), (*C.gint)(unsafe.Pointer(ty))) } // SetEnableSearch is a wrapper around gtk_tree_view_set_enable_search(). func (v *TreeView) SetEnableSearch(b bool) { C.gtk_tree_view_set_enable_search(v.native(), gbool(b)) } // GetEnableSearch is a wrapper around gtk_tree_view_get_enable_search(). func (v *TreeView) GetEnableSearch() bool { return gobool(C.gtk_tree_view_get_enable_search(v.native())) } // SetSearchColumn is a wrapper around gtk_tree_view_set_search_column(). func (v *TreeView) SetSearchColumn(c int) { C.gtk_tree_view_set_search_column(v.native(), C.gint(c)) } // GetSearchColumn is a wrapper around gtk_tree_view_get_search_column(). func (v *TreeView) GetSearchColumn() int { return int(C.gtk_tree_view_get_search_column(v.native())) } // GetSearchEntry is a wrapper around gtk_tree_view_get_search_entry(). func (v *TreeView) GetSearchEntry() *Entry { c := C.gtk_tree_view_get_search_entry(v.native()) if c == nil { return nil } return wrapEntry(glib.Take(unsafe.Pointer(c))) } // SetSearchEntry is a wrapper around gtk_tree_view_set_search_entry(). func (v *TreeView) SetSearchEntry(e *Entry) { C.gtk_tree_view_set_search_entry(v.native(), e.native()) } // TreeViewSearchEqualFunc is the callback type for TreeView's // SetSearchEqualFunc. It is worth noting that the returned boolean should be // false if the row matches. type TreeViewSearchEqualFunc func(model *TreeModel, column int, key string, iter *TreeIter) (notMatch bool) // SetSearchEqualFunc is a wrapper around gtk_tree_view_set_search_equal_func(). func (v *TreeView) SetSearchEqualFunc(f TreeViewSearchEqualFunc) { C._gtk_tree_view_set_search_equal_func(v.native(), C.gpointer(callback.Assign(f))) } // SetSearchEqualSubstringMatch calls SetSearchEqualFunc with a strings.Contains // adapter. func (v *TreeView) SetSearchEqualSubstringMatch() { v.SetSearchEqualFunc(func(model *TreeModel, column int, key string, iter *TreeIter) bool { return !strings.Contains(model.GetStringFromIter(iter), key) }) } // SetFixedHeightMode is a wrapper around gtk_tree_view_set_fixed_height_mode(). func (v *TreeView) SetFixedHeightMode(b bool) { C.gtk_tree_view_set_fixed_height_mode(v.native(), gbool(b)) } // GetFixedHeightMode is a wrapper around gtk_tree_view_get_fixed_height_mode(). func (v *TreeView) GetFixedHeightMode() bool { return gobool(C.gtk_tree_view_get_fixed_height_mode(v.native())) } // SetHoverSelection is a wrapper around gtk_tree_view_set_hover_selection(). func (v *TreeView) SetHoverSelection(b bool) { C.gtk_tree_view_set_hover_selection(v.native(), gbool(b)) } // GetHoverSelection is a wrapper around gtk_tree_view_get_hover_selection(). func (v *TreeView) GetHoverSelection() bool { return gobool(C.gtk_tree_view_get_hover_selection(v.native())) } // SetHoverExpand is a wrapper around gtk_tree_view_set_hover_expand(). func (v *TreeView) SetHoverExpand(b bool) { C.gtk_tree_view_set_hover_expand(v.native(), gbool(b)) } // GetHoverExpand is a wrapper around gtk_tree_view_get_hover_expand(). func (v *TreeView) GetHoverExpand() bool { return gobool(C.gtk_tree_view_get_hover_expand(v.native())) } // SetRubberBanding is a wrapper around gtk_tree_view_set_rubber_banding(). func (v *TreeView) SetRubberBanding(b bool) { C.gtk_tree_view_set_rubber_banding(v.native(), gbool(b)) } // GetRubberBanding is a wrapper around gtk_tree_view_get_rubber_banding(). func (v *TreeView) GetRubberBanding() bool { return gobool(C.gtk_tree_view_get_rubber_banding(v.native())) } // IsRubberBandingActive is a wrapper around gtk_tree_view_is_rubber_banding_active(). func (v *TreeView) IsRubberBandingActive() bool { return gobool(C.gtk_tree_view_is_rubber_banding_active(v.native())) } // SetEnableTreeLines is a wrapper around gtk_tree_view_set_enable_tree_lines(). func (v *TreeView) SetEnableTreeLines(b bool) { C.gtk_tree_view_set_enable_tree_lines(v.native(), gbool(b)) } // GetEnableTreeLines is a wrapper around gtk_tree_view_get_enable_tree_lines(). func (v *TreeView) GetEnableTreeLines() bool { return gobool(C.gtk_tree_view_get_enable_tree_lines(v.native())) } // GetTooltipColumn is a wrapper around gtk_tree_view_get_tooltip_column(). func (v *TreeView) GetTooltipColumn() int { return int(C.gtk_tree_view_get_tooltip_column(v.native())) } // SetTooltipColumn is a wrapper around gtk_tree_view_set_tooltip_column(). func (v *TreeView) SetTooltipColumn(c int) { C.gtk_tree_view_set_tooltip_column(v.native(), C.gint(c)) } // SetGridLines is a wrapper around gtk_tree_view_set_grid_lines(). func (v *TreeView) SetGridLines(gridLines TreeViewGridLines) { C.gtk_tree_view_set_grid_lines(v.native(), C.GtkTreeViewGridLines(gridLines)) } // GetGridLines is a wrapper around gtk_tree_view_get_grid_lines(). func (v *TreeView) GetGridLines() TreeViewGridLines { return TreeViewGridLines(C.gtk_tree_view_get_grid_lines(v.native())) } // IsBlankAtPos is a wrapper around gtk_tree_view_is_blank_at_pos(). func (v *TreeView) IsBlankAtPos(x, y int) (*TreePath, *TreeViewColumn, int, int, bool) { var ( cpath *C.GtkTreePath ccol *C.GtkTreeViewColumn ccellX, ccellY *C.gint cellX, cellY int ) path := new(TreePath) column := new(TreeViewColumn) cbool := C.gtk_tree_view_is_blank_at_pos( v.native(), (C.gint)(x), (C.gint)(y), &cpath, &ccol, ccellX, ccellY) if cpath != nil { path = &TreePath{cpath} runtime.SetFinalizer(path, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } if ccol != nil { column = wrapTreeViewColumn(glib.Take(unsafe.Pointer(ccol))) } if ccellX != nil { cellX = int(*((*C.gint)(unsafe.Pointer(ccellX)))) } if ccellY != nil { cellY = int(*((*C.gint)(unsafe.Pointer(ccellY)))) } return path, column, cellX, cellY, gobool(cbool) } // ScrollToCell() is a wrapper around gtk_tree_view_scroll_to_cell(). func (v *TreeView) ScrollToCell(path *TreePath, column *TreeViewColumn, align bool, xAlign, yAlign float32) { C.gtk_tree_view_scroll_to_cell(v.native(), path.native(), column.native(), gbool(align), C.gfloat(xAlign), C.gfloat(yAlign)) } // SetTooltipCell() is a wrapper around gtk_tree_view_set_tooltip_cell(). func (v *TreeView) SetTooltipCell(tooltip *Tooltip, path *TreePath, column *TreeViewColumn, cell *CellRenderer) { C.gtk_tree_view_set_tooltip_cell(v.native(), tooltip.native(), path.native(), column.native(), cell.native()) } // SetTooltipRow() is a wrapper around gtk_tree_view_set_tooltip_row(). func (v *TreeView) SetTooltipRow(tooltip *Tooltip, path *TreePath) { C.gtk_tree_view_set_tooltip_row(v.native(), tooltip.native(), path.native()) } // TreeViewDropPosition describes GtkTreeViewDropPosition. type TreeViewDropPosition int const ( TREE_VIEW_DROP_BEFORE TreeViewDropPosition = C.GTK_TREE_VIEW_DROP_BEFORE TREE_VIEW_DROP_AFTER TreeViewDropPosition = C.GTK_TREE_VIEW_DROP_AFTER TREE_VIEW_DROP_INTO_OR_BEFORE TreeViewDropPosition = C.GTK_TREE_VIEW_DROP_INTO_OR_BEFORE TREE_VIEW_DROP_INTO_OR_AFTER TreeViewDropPosition = C.GTK_TREE_VIEW_DROP_INTO_OR_AFTER ) // TODO: // GtkTreeViewDropPosition // gboolean gtk_tree_view_get_tooltip_context () // void (*GtkTreeDestroyCountFunc) () // gboolean (*GtkTreeViewRowSeparatorFunc) () // GtkTreeViewRowSeparatorFunc gtk_tree_view_get_row_separator_func () // void gtk_tree_view_set_row_separator_func () // void (*GtkTreeViewSearchPositionFunc) () // GtkTreeViewSearchPositionFunc gtk_tree_view_get_search_position_func () // void gtk_tree_view_set_search_position_func () // GtkTreeViewSearchEqualFunc gtk_tree_view_get_search_equal_func () // void gtk_tree_view_map_expanded_rows () // gint gtk_tree_view_insert_column_with_attributes () // gint gtk_tree_view_insert_column_with_data_func () // void gtk_tree_view_set_column_drag_function () // void gtk_tree_view_get_background_area () // void gtk_tree_view_get_visible_rect () // gboolean gtk_tree_view_get_visible_range () // void gtk_tree_view_convert_tree_to_bin_window_coords () // void gtk_tree_view_convert_tree_to_widget_coords () // void gtk_tree_view_convert_widget_to_tree_coords () // cairo_surface_t * gtk_tree_view_create_row_drag_icon () // EnableModelDragDest is a wrapper around gtk_tree_view_enable_model_drag_dest(). func (v *TreeView) EnableModelDragDest(targets []TargetEntry, actions gdk.DragAction) { C.gtk_tree_view_enable_model_drag_dest(v.native(), (*C.GtkTargetEntry)(&targets[0]), C.gint(len(targets)), C.GdkDragAction(actions)) } // EnableModelDragSource is a wrapper around gtk_tree_view_enable_model_drag_source(). func (v *TreeView) EnableModelDragSource(startButtonMask gdk.ModifierType, targets []TargetEntry, actions gdk.DragAction) { C.gtk_tree_view_enable_model_drag_source(v.native(), C.GdkModifierType(startButtonMask), (*C.GtkTargetEntry)(&targets[0]), C.gint(len(targets)), C.GdkDragAction(actions)) } // UnsetRowsDragSource is a wrapper around gtk_tree_view_unset_rows_drag_source(). func (v *TreeView) UnsetRowsDragSource() { C.gtk_tree_view_unset_rows_drag_source(v.native()) } // UnsetRowsDragDest is a wrapper around gtk_tree_view_unset_rows_drag_dest(). func (v *TreeView) UnsetRowsDragDest() { C.gtk_tree_view_unset_rows_drag_dest(v.native()) } // SetDragDestRow is a wrapper around gtk_tree_view_set_drag_dest_row(). func (v *TreeView) SetDragDestRow(path *TreePath, pos TreeViewDropPosition) { C.gtk_tree_view_set_drag_dest_row(v.native(), path.native(), C.GtkTreeViewDropPosition(pos)) } // GetDragDestRow is a wrapper around gtk_tree_view_get_drag_dest_row(). func (v *TreeView) GetDragDestRow() (path *TreePath, pos TreeViewDropPosition) { var ( cpath *C.GtkTreePath cpos C.GtkTreeViewDropPosition ) C.gtk_tree_view_get_drag_dest_row(v.native(), &cpath, &cpos) pos = TreeViewDropPosition(cpos) if cpath != nil { path = &TreePath{cpath} runtime.SetFinalizer(path, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } return } // GetDestRowAtPos is a wrapper around gtk_tree_view_get_dest_row_at_pos(). func (v *TreeView) GetDestRowAtPos(dragX, dragY int) (path *TreePath, pos TreeViewDropPosition, ok bool) { var ( cpath *C.GtkTreePath cpos C.GtkTreeViewDropPosition ) cbool := C.gtk_tree_view_get_dest_row_at_pos(v.native(), C.gint(dragX), C.gint(dragY), &cpath, &cpos) ok = gobool(cbool) pos = TreeViewDropPosition(cpos) if cpath != nil { path = &TreePath{cpath} runtime.SetFinalizer(path, func(v *TreePath) { glib.FinalizerStrategy(v.free) }) } return } gotk3-0.6.2/gtk/tree_view_column.go000066400000000000000000000261461431157473000172460ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains accelerator related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) /* * GtkTreeViewColumn */ // TreeViewColumns is a representation of GTK's GtkTreeViewColumn. type TreeViewColumn struct { glib.InitiallyUnowned } // native returns a pointer to the underlying GtkTreeViewColumn. func (v *TreeViewColumn) native() *C.GtkTreeViewColumn { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkTreeViewColumn(p) } func marshalTreeViewColumn(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapTreeViewColumn(obj), nil } func wrapTreeViewColumn(obj *glib.Object) *TreeViewColumn { if obj == nil { return nil } return &TreeViewColumn{glib.InitiallyUnowned{obj}} } // TreeViewColumnNew() is a wrapper around gtk_tree_view_column_new(). func TreeViewColumnNew() (*TreeViewColumn, error) { c := C.gtk_tree_view_column_new() if c == nil { return nil, nilPtrErr } return wrapTreeViewColumn(glib.Take(unsafe.Pointer(c))), nil } // TreeViewColumnNewWithArea is a wrapper around gtk_tree_view_column_new_with_area(). func TreeViewColumnNewWithArea(area ICellArea) (*TreeViewColumn, error) { c := C.gtk_tree_view_column_new_with_area(area.toCellArea()) if c == nil { return nil, nilPtrErr } return wrapTreeViewColumn(glib.Take(unsafe.Pointer(c))), nil } // TreeViewColumnNewWithAttribute() is a wrapper around // gtk_tree_view_column_new_with_attributes() that only sets one // attribute for one column. func TreeViewColumnNewWithAttribute(title string, renderer ICellRenderer, attribute string, column int) (*TreeViewColumn, error) { t_cstr := C.CString(title) defer C.free(unsafe.Pointer(t_cstr)) a_cstr := C.CString(attribute) defer C.free(unsafe.Pointer(a_cstr)) c := C._gtk_tree_view_column_new_with_attributes_one((*C.gchar)(t_cstr), renderer.toCellRenderer(), (*C.gchar)(a_cstr), C.gint(column)) if c == nil { return nil, nilPtrErr } return wrapTreeViewColumn(glib.Take(unsafe.Pointer(c))), nil } // AddAttribute() is a wrapper around gtk_tree_view_column_add_attribute(). func (v *TreeViewColumn) AddAttribute(renderer ICellRenderer, attribute string, column int) { cstr := C.CString(attribute) defer C.free(unsafe.Pointer(cstr)) C.gtk_tree_view_column_add_attribute(v.native(), renderer.toCellRenderer(), (*C.gchar)(cstr), C.gint(column)) } // SetExpand() is a wrapper around gtk_tree_view_column_set_expand(). func (v *TreeViewColumn) SetExpand(expand bool) { C.gtk_tree_view_column_set_expand(v.native(), gbool(expand)) } // GetExpand() is a wrapper around gtk_tree_view_column_get_expand(). func (v *TreeViewColumn) GetExpand() bool { c := C.gtk_tree_view_column_get_expand(v.native()) return gobool(c) } // SetMinWidth() is a wrapper around gtk_tree_view_column_set_min_width(). func (v *TreeViewColumn) SetMinWidth(minWidth int) { C.gtk_tree_view_column_set_min_width(v.native(), C.gint(minWidth)) } // GetMinWidth() is a wrapper around gtk_tree_view_column_get_min_width(). func (v *TreeViewColumn) GetMinWidth() int { c := C.gtk_tree_view_column_get_min_width(v.native()) return int(c) } // PackStart() is a wrapper around gtk_tree_view_column_pack_start(). func (v *TreeViewColumn) PackStart(cell ICellRenderer, expand bool) { C.gtk_tree_view_column_pack_start(v.native(), cell.toCellRenderer(), gbool(expand)) } // PackEnd() is a wrapper around gtk_tree_view_column_pack_end(). func (v *TreeViewColumn) PackEnd(cell ICellRenderer, expand bool) { C.gtk_tree_view_column_pack_end(v.native(), cell.toCellRenderer(), gbool(expand)) } // Clear() is a wrapper around gtk_tree_view_column_clear(). func (v *TreeViewColumn) Clear() { C.gtk_tree_view_column_clear(v.native()) } // ClearAttributes() is a wrapper around gtk_tree_view_column_clear_attributes(). func (v *TreeViewColumn) ClearAttributes(cell *CellRenderer) { C.gtk_tree_view_column_clear_attributes(v.native(), cell.native()) } // SetSpacing() is a wrapper around gtk_tree_view_column_set_spacing(). func (v *TreeViewColumn) SetSpacing(spacing int) { C.gtk_tree_view_column_set_spacing(v.native(), C.gint(spacing)) } // GetSpacing() is a wrapper around gtk_tree_view_column_get_spacing(). func (v *TreeViewColumn) GetSpacing() int { return int(C.gtk_tree_view_column_get_spacing(v.native())) } // SetVisible() is a wrapper around gtk_tree_view_column_set_visible(). func (v *TreeViewColumn) SetVisible(visible bool) { C.gtk_tree_view_column_set_visible(v.native(), gbool(visible)) } // GetVisible() is a wrapper around gtk_tree_view_column_get_visible(). func (v *TreeViewColumn) GetVisible() bool { return gobool(C.gtk_tree_view_column_get_visible(v.native())) } // SetResizable() is a wrapper around gtk_tree_view_column_set_resizable(). func (v *TreeViewColumn) SetResizable(resizable bool) { C.gtk_tree_view_column_set_resizable(v.native(), gbool(resizable)) } // GetResizable() is a wrapper around gtk_tree_view_column_get_resizable(). func (v *TreeViewColumn) GetResizable() bool { return gobool(C.gtk_tree_view_column_get_resizable(v.native())) } // GetWidth() is a wrapper around gtk_tree_view_column_get_width(). func (v *TreeViewColumn) GetWidth() int { return int(C.gtk_tree_view_column_get_width(v.native())) } // SetFixedWidth() is a wrapper around gtk_tree_view_column_set_fixed_width(). func (v *TreeViewColumn) SetFixedWidth(w int) { C.gtk_tree_view_column_set_fixed_width(v.native(), C.gint(w)) } // GetFixedWidth() is a wrapper around gtk_tree_view_column_get_fixed_width(). func (v *TreeViewColumn) GetFixedWidth() int { return int(C.gtk_tree_view_column_get_fixed_width(v.native())) } // SetMaxWidth() is a wrapper around gtk_tree_view_column_set_max_width(). func (v *TreeViewColumn) SetMaxWidth(w int) { C.gtk_tree_view_column_set_max_width(v.native(), C.gint(w)) } // GetMaxWidth() is a wrapper around gtk_tree_view_column_get_max_width(). func (v *TreeViewColumn) GetMaxWidth() int { return int(C.gtk_tree_view_column_get_max_width(v.native())) } // Clicked() is a wrapper around gtk_tree_view_column_clicked(). func (v *TreeViewColumn) Clicked() { C.gtk_tree_view_column_clicked(v.native()) } // SetTitle() is a wrapper around gtk_tree_view_column_set_title(). func (v *TreeViewColumn) SetTitle(t string) { cstr := (*C.gchar)(C.CString(t)) defer C.free(unsafe.Pointer(cstr)) C.gtk_tree_view_column_set_title(v.native(), cstr) } // GetTitle() is a wrapper around gtk_tree_view_column_get_title(). func (v *TreeViewColumn) GetTitle() string { return C.GoString((*C.char)(C.gtk_tree_view_column_get_title(v.native()))) } // SetClickable() is a wrapper around gtk_tree_view_column_set_clickable(). func (v *TreeViewColumn) SetClickable(clickable bool) { C.gtk_tree_view_column_set_clickable(v.native(), gbool(clickable)) } // GetClickable() is a wrapper around gtk_tree_view_column_get_clickable(). func (v *TreeViewColumn) GetClickable() bool { return gobool(C.gtk_tree_view_column_get_clickable(v.native())) } // SetReorderable() is a wrapper around gtk_tree_view_column_set_reorderable(). func (v *TreeViewColumn) SetReorderable(reorderable bool) { C.gtk_tree_view_column_set_reorderable(v.native(), gbool(reorderable)) } // GetReorderable() is a wrapper around gtk_tree_view_column_get_reorderable(). func (v *TreeViewColumn) GetReorderable() bool { return gobool(C.gtk_tree_view_column_get_reorderable(v.native())) } // SetSortIndicator() is a wrapper around gtk_tree_view_column_set_sort_indicator(). func (v *TreeViewColumn) SetSortIndicator(reorderable bool) { C.gtk_tree_view_column_set_sort_indicator(v.native(), gbool(reorderable)) } // GetSortIndicator() is a wrapper around gtk_tree_view_column_get_sort_indicator(). func (v *TreeViewColumn) GetSortIndicator() bool { return gobool(C.gtk_tree_view_column_get_sort_indicator(v.native())) } // SetSortColumnID() is a wrapper around gtk_tree_view_column_set_sort_column_id(). func (v *TreeViewColumn) SetSortColumnID(w int) { C.gtk_tree_view_column_set_sort_column_id(v.native(), C.gint(w)) } // GetSortColumnID() is a wrapper around gtk_tree_view_column_get_sort_column_id(). func (v *TreeViewColumn) GetSortColumnID() int { return int(C.gtk_tree_view_column_get_sort_column_id(v.native())) } // CellIsVisible() is a wrapper around gtk_tree_view_column_cell_is_visible(). func (v *TreeViewColumn) CellIsVisible() bool { return gobool(C.gtk_tree_view_column_cell_is_visible(v.native())) } // FocusCell() is a wrapper around gtk_tree_view_column_focus_cell(). func (v *TreeViewColumn) FocusCell(cell *CellRenderer) { C.gtk_tree_view_column_focus_cell(v.native(), cell.native()) } // QueueResize() is a wrapper around gtk_tree_view_column_queue_resize(). func (v *TreeViewColumn) QueueResize() { C.gtk_tree_view_column_queue_resize(v.native()) } // GetXOffset() is a wrapper around gtk_tree_view_column_get_x_offset(). func (v *TreeViewColumn) GetXOffset() int { return int(C.gtk_tree_view_column_get_x_offset(v.native())) } // void gtk_tree_view_column_set_attributes () // void gtk_tree_view_column_set_cell_data_func () type TreeViewColumnSizing int const ( TREE_VIEW_COLUMN_GROW_ONLY TreeViewColumnSizing = C.GTK_TREE_VIEW_COLUMN_GROW_ONLY TREE_VIEW_COLUMN_AUTOSIZE = C.GTK_TREE_VIEW_COLUMN_AUTOSIZE TREE_VIEW_COLUMN_FIXED = C.GTK_TREE_VIEW_COLUMN_FIXED ) // void gtk_tree_view_column_set_sizing () func (v *TreeViewColumn) SetSizing(sizing TreeViewColumnSizing) { C.gtk_tree_view_column_set_sizing(v.native(), C.GtkTreeViewColumnSizing(sizing)) } // GtkTreeViewColumnSizing gtk_tree_view_column_get_sizing () func (v *TreeViewColumn) GetSizing() TreeViewColumnSizing { return TreeViewColumnSizing(C.gtk_tree_view_column_get_sizing(v.native())) } // SetWidget() is a wrapper around gtk_tree_view_column_set_widget(). func (v *TreeViewColumn) SetWidget(widget IWidget) { C.gtk_tree_view_column_set_widget(v.native(), widget.toWidget()) } // GetButton() is a wrapper around gtk_tree_view_column_get_button(). func (v *TreeViewColumn) GetButton() (IWidget, error) { widget := C.gtk_tree_view_column_get_button(v.native()) if widget == nil { return nil, nilPtrErr } return castWidget(widget) } // GetWidget() is a wrapper around gtk_tree_view_column_get_widget(). func (v *TreeViewColumn) GetWidget() (IWidget, error) { widget := C.gtk_tree_view_column_get_widget(v.native()) if widget == nil { return nil, nil } return castWidget(widget) } // void gtk_tree_view_column_set_alignment () // gfloat gtk_tree_view_column_get_alignment () // void gtk_tree_view_column_set_sort_order () func (v *TreeViewColumn) SetSortOrder(order SortType) { C.gtk_tree_view_column_set_sort_order(v.native(), C.GtkSortType(order)) } // GtkSortType gtk_tree_view_column_get_sort_order () func (v *TreeViewColumn) GetSortOrder() SortType { return SortType(C.gtk_tree_view_column_get_sort_order(v.native())) } // void gtk_tree_view_column_cell_set_cell_data () // void gtk_tree_view_column_cell_get_size () // gboolean gtk_tree_view_column_cell_get_position () // GtkWidget * gtk_tree_view_column_get_tree_view () gotk3-0.6.2/gtk/version.go000066400000000000000000000010231431157473000153500ustar00rootroot00000000000000package gtk // #include import "C" import "errors" func CheckVersion(major, minor, micro uint) error { errChar := C.gtk_check_version(C.guint(major), C.guint(minor), C.guint(micro)) if errChar == nil { return nil } return errors.New(C.GoString((*C.char)(errChar))) } func GetMajorVersion() uint { v := C.gtk_get_major_version() return uint(v) } func GetMinorVersion() uint { v := C.gtk_get_minor_version() return uint(v) } func GetMicroVersion() uint { v := C.gtk_get_micro_version() return uint(v) } gotk3-0.6.2/gtk/version_test.go000066400000000000000000000007251431157473000164170ustar00rootroot00000000000000package gtk import "testing" func TestCheckVersion(t *testing.T) { err := CheckVersion(GetMajorVersion(), GetMinorVersion(), GetMicroVersion()) if err != nil { t.Error(err) } err = CheckVersion(GetMajorVersion(), GetMinorVersion(), GetMicroVersion()-1) if err != nil { t.Error(err) } err = CheckVersion(GetMajorVersion(), GetMinorVersion(), GetMicroVersion()+1) if err == nil { t.Error("Expected to fail when an more recent version is expected") } } gotk3-0.6.2/gtk/widget.go000066400000000000000000000670071431157473000151640ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // This file contains accelerator related functions and structures package gtk // #include // #include "gtk.go.h" import "C" import ( "errors" "runtime" "unsafe" "github.com/gotk3/gotk3/cairo" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) /* * GtkWidget */ func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.gtk_size_request_mode_get_type()), marshalSizeRequestMode}, // Boxed {glib.Type(C.gtk_requisition_get_type()), marshalRequisition}, } glib.RegisterGValueMarshalers(tm) WrapMap["GtkRequisition"] = wrapRequisition } // SizeRequestMode is a representation of GTK's GtkSizeRequestMode. type SizeRequestMode int const ( SIZE_REQUEST_HEIGHT_FOR_WIDTH SizeRequestMode = C.GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH SIZE_REQUEST_WIDTH_FOR_HEIGHT SizeRequestMode = C.GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT SIZE_REQUEST_CONSTANT_SIZE SizeRequestMode = C.GTK_SIZE_REQUEST_CONSTANT_SIZE ) func marshalSizeRequestMode(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return SizeRequestMode(c), nil } // Widget is a representation of GTK's GtkWidget. type Widget struct { glib.InitiallyUnowned } // IWidget is an interface type implemented by all structs // embedding a Widget. It is meant to be used as an argument type // for wrapper functions that wrap around a C GTK function taking a // GtkWidget. type IWidget interface { toWidget() *C.GtkWidget ToWidget() *Widget Set(string, interface{}) error } type IWidgetable interface { toWidget() *C.GtkWidget } func nullableWidget(v IWidgetable) *C.GtkWidget { if v == nil { return nil } return v.toWidget() } // native returns a pointer to the underlying GtkWidget. func (v *Widget) native() *C.GtkWidget { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkWidget(p) } func (v *Widget) toWidget() *C.GtkWidget { if v == nil { return nil } return v.native() } // ToWidget is a helper getter, e.g.: it returns *gtk.Label as a *gtk.Widget. // In other cases, where you have a gtk.IWidget, use the type assertion. func (v *Widget) ToWidget() *Widget { return v } // Cast changes the widget to an object of interface type IWidget. // This is only useful if you don't already have an object of type IWidget at hand (see example below). // This func is similar to gtk.Builder.GetObject(): // The returned value needs to be type-asserted, before it can be used. // // Example: // // you know that the parent is an object of type *gtk.ApplicationWindow, // // or you want to check just in case // parentWindow, _ := myWindow.GetTransientFor() // intermediate, _ := parentWindow.Cast() // appWindow, typeAssertSuccessful := intermediate.(*gtk.ApplicationWindow) func (v *Widget) Cast() (IWidget, error) { return castWidget(v.native()) } func marshalWidget(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapWidget(obj), nil } func wrapWidget(obj *glib.Object) *Widget { if obj == nil { return nil } return &Widget{glib.InitiallyUnowned{obj}} } // TODO: // GtkCallback(). // gtk_widget_new(). // Destroy is a wrapper around gtk_widget_destroy(). func (v *Widget) Destroy() { C.gtk_widget_destroy(v.native()) } // HideOnDelete is a wrapper around gtk_widget_hide_on_delete(). // Calling this func adds gtk_widget_hide_on_delete to the widget's "delete-event" signal. func (v *Widget) HideOnDelete() { C._gtk_widget_hide_on_delete(v.native()) } // TODO: // gtk_widget_set_direction(). // gtk_widget_get_direction(). // gtk_widget_set_default_direction(). // gtk_widget_get_default_direction(). // gtk_widget_input_shape_combine_region(). // gtk_widget_create_pango_context(). // gtk_widget_create_pango_context(). // gtk_widget_get_pango_context(). // gtk_widget_create_pango_layout(). // QueueDrawArea is a wrapper aroung gtk_widget_queue_draw_area(). func (v *Widget) QueueDrawArea(x, y, w, h int) { C.gtk_widget_queue_draw_area(v.native(), C.gint(x), C.gint(y), C.gint(w), C.gint(h)) } // QueueDrawRegion is a wrapper aroung gtk_widget_queue_draw_region(). func (v *Widget) QueueDrawRegion(region *cairo.Region) { C.gtk_widget_queue_draw_region(v.native(), (*C.cairo_region_t)(unsafe.Pointer(region.Native()))) } // TODO: // gtk_widget_set_redraw_on_allocate(). // gtk_widget_mnemonic_activate(). // gtk_widget_class_install_style_property(). // gtk_widget_class_install_style_property_parser(). // gtk_widget_class_find_style_property(). // gtk_widget_class_list_style_properties(). // gtk_widget_send_focus_change(). // gtk_widget_style_get(). // gtk_widget_style_get_property(). // gtk_widget_style_get_valist(). // gtk_widget_class_set_accessible_type(). // gtk_widget_get_accessible(). // gtk_widget_child_focus(). // gtk_widget_child_notify(). // gtk_widget_get_child_visible(). // gtk_widget_get_settings(). // gtk_widget_get_clipboard(). // GetDisplay is a wrapper around gtk_widget_get_display(). func (v *Widget) GetDisplay() (*gdk.Display, error) { c := C.gtk_widget_get_display(v.native()) if c == nil { return nil, nilPtrErr } s := &gdk.Display{glib.Take(unsafe.Pointer(c))} return s, nil } // GetScreen is a wrapper around gtk_widget_get_screen(). func (v *Widget) GetScreen() (*gdk.Screen, error) { c := C.gtk_widget_get_screen(v.native()) if c == nil { return nil, nilPtrErr } s := &gdk.Screen{glib.Take(unsafe.Pointer(c))} return s, nil } // TODO: // gtk_widget_has_screen(). // gtk_widget_get_size_request(). // gtk_widget_set_child_visible(). // gtk_widget_list_mnemonic_labels(). // gtk_widget_add_mnemonic_label(). // gtk_widget_remove_mnemonic_label(). // gtk_widget_error_bell(). // gtk_widget_keynav_failed(). // gtk_widget_get_tooltip_window(). // gtk_widget_get_has_tooltip(). // gtk_widget_set_has_tooltip(). // gtk_widget_trigger_tooltip_query(). // gtk_cairo_should_draw_window(). // gtk_cairo_transform_to_window(). // DragDestSet is a wrapper around gtk_drag_dest_set(). func (v *Widget) DragDestSet(flags DestDefaults, targets []TargetEntry, actions gdk.DragAction) { C.gtk_drag_dest_set(v.native(), C.GtkDestDefaults(flags), (*C.GtkTargetEntry)(&targets[0]), C.gint(len(targets)), C.GdkDragAction(actions)) } // DragSourceSet is a wrapper around gtk_drag_source_set(). func (v *Widget) DragSourceSet(startButtonMask gdk.ModifierType, targets []TargetEntry, actions gdk.DragAction) { C.gtk_drag_source_set(v.native(), C.GdkModifierType(startButtonMask), (*C.GtkTargetEntry)(&targets[0]), C.gint(len(targets)), C.GdkDragAction(actions)) } // ResetStyle is a wrapper around gtk_widget_reset_style(). func (v *Widget) ResetStyle() { C.gtk_widget_reset_style(v.native()) } // InDestruction is a wrapper around gtk_widget_in_destruction(). func (v *Widget) InDestruction() bool { return gobool(C.gtk_widget_in_destruction(v.native())) } // TODO(jrick) this may require some rethinking /* // Destroyed is a wrapper around gtk_widget_destroyed(). func (v *Widget) Destroyed(widgetPointer **Widget) { } */ // Unparent is a wrapper around gtk_widget_unparent(). func (v *Widget) Unparent() { C.gtk_widget_unparent(v.native()) } // Show is a wrapper around gtk_widget_show(). func (v *Widget) Show() { C.gtk_widget_show(v.native()) } // Hide is a wrapper around gtk_widget_hide(). func (v *Widget) Hide() { C.gtk_widget_hide(v.native()) } // GetCanFocus is a wrapper around gtk_widget_get_can_focus(). func (v *Widget) GetCanFocus() bool { c := C.gtk_widget_get_can_focus(v.native()) return gobool(c) } // SetCanFocus is a wrapper around gtk_widget_set_can_focus(). func (v *Widget) SetCanFocus(canFocus bool) { C.gtk_widget_set_can_focus(v.native(), gbool(canFocus)) } // GetCanDefault is a wrapper around gtk_widget_get_can_default(). func (v *Widget) GetCanDefault() bool { c := C.gtk_widget_get_can_default(v.native()) return gobool(c) } // SetCanDefault is a wrapper around gtk_widget_set_can_default(). func (v *Widget) SetCanDefault(canDefault bool) { C.gtk_widget_set_can_default(v.native(), gbool(canDefault)) } // SetMapped is a wrapper around gtk_widget_set_mapped(). func (v *Widget) SetMapped(mapped bool) { C.gtk_widget_set_mapped(v.native(), gbool(mapped)) } // GetMapped is a wrapper around gtk_widget_get_mapped(). func (v *Widget) GetMapped() bool { c := C.gtk_widget_get_mapped(v.native()) return gobool(c) } // TODO: // gtk_widget_device_is_shadowed(). // gtk_widget_get_modifier_mask(). // InsertActionGroup is a wrapper around gtk_widget_insert_action_group(). func (v *Widget) InsertActionGroup(name string, group glib.IActionGroup) { C.gtk_widget_insert_action_group(v.native(), (*C.gchar)(C.CString(name)), C.toGActionGroup(unsafe.Pointer(group.Native()))) } // TODO: // gtk_widget_get_path(). // GetPreferredHeight is a wrapper around gtk_widget_get_preferred_height(). func (v *Widget) GetPreferredHeight() (int, int) { var minimum, natural C.gint C.gtk_widget_get_preferred_height(v.native(), &minimum, &natural) return int(minimum), int(natural) } // GetPreferredWidth is a wrapper around gtk_widget_get_preferred_width(). func (v *Widget) GetPreferredWidth() (int, int) { var minimum, natural C.gint C.gtk_widget_get_preferred_width(v.native(), &minimum, &natural) return int(minimum), int(natural) } // GetPreferredHeightForWidth is a wrapper around gtk_widget_get_preferred_height_for_width(). func (v *Widget) GetPreferredHeightForWidth(width int) (int, int) { var minimum, natural C.gint C.gtk_widget_get_preferred_height_for_width( v.native(), C.gint(width), &minimum, &natural) return int(minimum), int(natural) } // GetPreferredWidthForHeight is a wrapper around gtk_widget_get_preferred_width_for_height(). func (v *Widget) GetPreferredWidthForHeight(height int) (int, int) { var minimum, natural C.gint C.gtk_widget_get_preferred_width_for_height( v.native(), C.gint(height), &minimum, &natural) return int(minimum), int(natural) } // GetRequestMode is a wrapper around gtk_widget_get_request_mode(). func (v *Widget) GetRequestMode() SizeRequestMode { return SizeRequestMode(C.gtk_widget_get_request_mode(v.native())) } // GetPreferredSize is a wrapper around gtk_widget_get_preferred_size(). func (v *Widget) GetPreferredSize() (*Requisition, *Requisition) { minimum_size := new(C.GtkRequisition) natural_size := new(C.GtkRequisition) C.gtk_widget_get_preferred_size(v.native(), minimum_size, natural_size) minR, err := requisitionFromNative(minimum_size) if err != nil { minR = nil } natR, err := requisitionFromNative(natural_size) if err != nil { natR = nil } return minR, natR } // TODO: /* gint gtk_distribute_natural_allocation (gint extra_space, guint n_requested_sizes, GtkRequestedSize *sizes); */ // GetHAlign is a wrapper around gtk_widget_get_halign(). func (v *Widget) GetHAlign() Align { c := C.gtk_widget_get_halign(v.native()) return Align(c) } // SetHAlign is a wrapper around gtk_widget_set_halign(). func (v *Widget) SetHAlign(align Align) { C.gtk_widget_set_halign(v.native(), C.GtkAlign(align)) } // GetVAlign is a wrapper around gtk_widget_get_valign(). func (v *Widget) GetVAlign() Align { c := C.gtk_widget_get_valign(v.native()) return Align(c) } // SetVAlign is a wrapper around gtk_widget_set_valign(). func (v *Widget) SetVAlign(align Align) { C.gtk_widget_set_valign(v.native(), C.GtkAlign(align)) } // GetMarginTop is a wrapper around gtk_widget_get_margin_top(). func (v *Widget) GetMarginTop() int { c := C.gtk_widget_get_margin_top(v.native()) return int(c) } // SetMarginTop is a wrapper around gtk_widget_set_margin_top(). func (v *Widget) SetMarginTop(margin int) { C.gtk_widget_set_margin_top(v.native(), C.gint(margin)) } // GetMarginBottom is a wrapper around gtk_widget_get_margin_bottom(). func (v *Widget) GetMarginBottom() int { c := C.gtk_widget_get_margin_bottom(v.native()) return int(c) } // SetMarginBottom is a wrapper around gtk_widget_set_margin_bottom(). func (v *Widget) SetMarginBottom(margin int) { C.gtk_widget_set_margin_bottom(v.native(), C.gint(margin)) } // GetHExpand is a wrapper around gtk_widget_get_hexpand(). func (v *Widget) GetHExpand() bool { c := C.gtk_widget_get_hexpand(v.native()) return gobool(c) } // SetHExpand is a wrapper around gtk_widget_set_hexpand(). func (v *Widget) SetHExpand(expand bool) { C.gtk_widget_set_hexpand(v.native(), gbool(expand)) } // TODO: // gtk_widget_get_hexpand_set(). // gtk_widget_set_hexpand_set(). // GetVExpand is a wrapper around gtk_widget_get_vexpand(). func (v *Widget) GetVExpand() bool { c := C.gtk_widget_get_vexpand(v.native()) return gobool(c) } // SetVExpand is a wrapper around gtk_widget_set_vexpand(). func (v *Widget) SetVExpand(expand bool) { C.gtk_widget_set_vexpand(v.native(), gbool(expand)) } // TODO: // gtk_widget_get_vexpand_set(). // gtk_widget_set_vexpand_set(). // gtk_widget_queue_compute_expand(). // gtk_widget_compute_expand(). // GetRealized is a wrapper around gtk_widget_get_realized(). func (v *Widget) GetRealized() bool { c := C.gtk_widget_get_realized(v.native()) return gobool(c) } // SetRealized is a wrapper around gtk_widget_set_realized(). func (v *Widget) SetRealized(realized bool) { C.gtk_widget_set_realized(v.native(), gbool(realized)) } // GetHasWindow is a wrapper around gtk_widget_get_has_window(). func (v *Widget) GetHasWindow() bool { c := C.gtk_widget_get_has_window(v.native()) return gobool(c) } // SetHasWindow is a wrapper around gtk_widget_set_has_window(). func (v *Widget) SetHasWindow(hasWindow bool) { C.gtk_widget_set_has_window(v.native(), gbool(hasWindow)) } // ShowNow is a wrapper around gtk_widget_show_now(). func (v *Widget) ShowNow() { C.gtk_widget_show_now(v.native()) } // ShowAll is a wrapper around gtk_widget_show_all(). func (v *Widget) ShowAll() { C.gtk_widget_show_all(v.native()) } // SetNoShowAll is a wrapper around gtk_widget_set_no_show_all(). func (v *Widget) SetNoShowAll(noShowAll bool) { C.gtk_widget_set_no_show_all(v.native(), gbool(noShowAll)) } // GetNoShowAll is a wrapper around gtk_widget_get_no_show_all(). func (v *Widget) GetNoShowAll() bool { c := C.gtk_widget_get_no_show_all(v.native()) return gobool(c) } // Map is a wrapper around gtk_widget_map(). func (v *Widget) Map() { C.gtk_widget_map(v.native()) } // Unmap is a wrapper around gtk_widget_unmap(). func (v *Widget) Unmap() { C.gtk_widget_unmap(v.native()) } // TODO: //void gtk_widget_draw(GtkWidget *widget, cairo_t *cr); //void gtk_widget_queue_resize(GtkWidget *widget); //void gtk_widget_queue_resize_no_redraw(GtkWidget *widget); // gtk_widget_queue_allocate(). // Realize is a wrapper around gtk_widget_realize(). func (v *Widget) Realize() { C.gtk_widget_realize(v.native()) } // Unrealize is a wrapper around gtk_widget_unrealize(). func (v *Widget) Unrealize() { C.gtk_widget_unrealize(v.native()) } // Event() is a wrapper around gtk_widget_event(). func (v *Widget) Event(event *gdk.Event) bool { c := C.gtk_widget_event(v.native(), (*C.GdkEvent)(unsafe.Pointer(event.Native()))) return gobool(c) } // Activate() is a wrapper around gtk_widget_activate(). func (v *Widget) Activate() bool { return gobool(C.gtk_widget_activate(v.native())) } // Intersect is a wrapper around gtk_widget_intersect(). func (v *Widget) Intersect(area gdk.Rectangle) (*gdk.Rectangle, bool) { var cRect *C.GdkRectangle hadIntersection := C.gtk_widget_intersect(v.native(), nativeGdkRectangle(area), cRect) intersection := gdk.WrapRectangle(uintptr(unsafe.Pointer(cRect))) return intersection, gobool(hadIntersection) } // IsFocus() is a wrapper around gtk_widget_is_focus(). func (v *Widget) IsFocus() bool { return gobool(C.gtk_widget_is_focus(v.native())) } // GrabFocus() is a wrapper around gtk_widget_grab_focus(). func (v *Widget) GrabFocus() { C.gtk_widget_grab_focus(v.native()) } // GrabDefault() is a wrapper around gtk_widget_grab_default(). func (v *Widget) GrabDefault() { C.gtk_widget_grab_default(v.native()) } // SetName() is a wrapper around gtk_widget_set_name(). func (v *Widget) SetName(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_widget_set_name(v.native(), (*C.gchar)(cstr)) } // GetName() is a wrapper around gtk_widget_get_name(). A non-nil // error is returned in the case that gtk_widget_get_name returns NULL to // differentiate between NULL and an empty string. func (v *Widget) GetName() (string, error) { c := C.gtk_widget_get_name(v.native()) if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // GetSensitive is a wrapper around gtk_widget_get_sensitive(). func (v *Widget) GetSensitive() bool { c := C.gtk_widget_get_sensitive(v.native()) return gobool(c) } // IsSensitive is a wrapper around gtk_widget_is_sensitive(). func (v *Widget) IsSensitive() bool { c := C.gtk_widget_is_sensitive(v.native()) return gobool(c) } // SetSensitive is a wrapper around gtk_widget_set_sensitive(). func (v *Widget) SetSensitive(sensitive bool) { C.gtk_widget_set_sensitive(v.native(), gbool(sensitive)) } // GetVisible is a wrapper around gtk_widget_get_visible(). func (v *Widget) GetVisible() bool { c := C.gtk_widget_get_visible(v.native()) return gobool(c) } // SetVisible is a wrapper around gtk_widget_set_visible(). func (v *Widget) SetVisible(visible bool) { C.gtk_widget_set_visible(v.native(), gbool(visible)) } // SetParent is a wrapper around gtk_widget_set_parent(). func (v *Widget) SetParent(parent IWidget) { C.gtk_widget_set_parent(v.native(), parent.toWidget()) } // GetParent is a wrapper around gtk_widget_get_parent(). func (v *Widget) GetParent() (IWidget, error) { c := C.gtk_widget_get_parent(v.native()) if c == nil { return nil, nil } return castWidget(c) } // SetSizeRequest is a wrapper around gtk_widget_set_size_request(). func (v *Widget) SetSizeRequest(width, height int) { C.gtk_widget_set_size_request(v.native(), C.gint(width), C.gint(height)) } // GetSizeRequest is a wrapper around gtk_widget_get_size_request(). func (v *Widget) GetSizeRequest() (width, height int) { var w, h C.gint C.gtk_widget_get_size_request(v.native(), &w, &h) return int(w), int(h) } // SetParentWindow is a wrapper around gtk_widget_set_parent_window(). func (v *Widget) SetParentWindow(parentWindow *gdk.Window) { C.gtk_widget_set_parent_window(v.native(), (*C.GdkWindow)(unsafe.Pointer(parentWindow.Native()))) } // GetParentWindow is a wrapper around gtk_widget_get_parent_window(). func (v *Widget) GetParentWindow() (*gdk.Window, error) { c := C.gtk_widget_get_parent_window(v.native()) if v == nil { return nil, nilPtrErr } w := &gdk.Window{glib.Take(unsafe.Pointer(c))} return w, nil } // SetEvents is a wrapper around gtk_widget_set_events(). func (v *Widget) SetEvents(events int) { C.gtk_widget_set_events(v.native(), C.gint(events)) } // GetEvents is a wrapper around gtk_widget_get_events(). func (v *Widget) GetEvents() int { return int(C.gtk_widget_get_events(v.native())) } // AddEvents is a wrapper around gtk_widget_add_events(). func (v *Widget) AddEvents(events int) { C.gtk_widget_add_events(v.native(), C.gint(events)) } // TODO: /* // gtk_widget_set_device_events(). func (v *Widget) SetDeviceEvents() { } */ /* // gtk_widget_get_device_events(). func (v *Widget) GetDeviceEvents() { } */ /* // gtk_widget_add_device_events(). func (v *Widget) AddDeviceEvents() { } */ // FreezeChildNotify is a wrapper around gtk_widget_freeze_child_notify(). func (v *Widget) FreezeChildNotify() { C.gtk_widget_freeze_child_notify(v.native()) } // ThawChildNotify is a wrapper around gtk_widget_thaw_child_notify(). func (v *Widget) ThawChildNotify() { C.gtk_widget_thaw_child_notify(v.native()) } // HasDefault is a wrapper around gtk_widget_has_default(). func (v *Widget) HasDefault() bool { c := C.gtk_widget_has_default(v.native()) return gobool(c) } // HasFocus is a wrapper around gtk_widget_has_focus(). func (v *Widget) HasFocus() bool { c := C.gtk_widget_has_focus(v.native()) return gobool(c) } // HasVisibleFocus is a wrapper around gtk_widget_has_visible_focus(). func (v *Widget) HasVisibleFocus() bool { c := C.gtk_widget_has_visible_focus(v.native()) return gobool(c) } // HasGrab is a wrapper around gtk_widget_has_grab(). func (v *Widget) HasGrab() bool { c := C.gtk_widget_has_grab(v.native()) return gobool(c) } // IsDrawable is a wrapper around gtk_widget_is_drawable(). func (v *Widget) IsDrawable() bool { c := C.gtk_widget_is_drawable(v.native()) return gobool(c) } // IsToplevel is a wrapper around gtk_widget_is_toplevel(). func (v *Widget) IsToplevel() bool { c := C.gtk_widget_is_toplevel(v.native()) return gobool(c) } // FIXME: // gtk_widget_set_window(). // gtk_widget_set_receives_default(). // gtk_widget_get_receives_default(). // gtk_widget_set_support_multidevice(). // gtk_widget_get_support_multidevice(). // SetDeviceEnabled is a wrapper around gtk_widget_set_device_enabled(). func (v *Widget) SetDeviceEnabled(device *gdk.Device, enabled bool) { C.gtk_widget_set_device_enabled(v.native(), (*C.GdkDevice)(unsafe.Pointer(device.Native())), gbool(enabled)) } // GetDeviceEnabled is a wrapper around gtk_widget_get_device_enabled(). func (v *Widget) GetDeviceEnabled(device *gdk.Device) bool { c := C.gtk_widget_get_device_enabled(v.native(), (*C.GdkDevice)(unsafe.Pointer(device.Native()))) return gobool(c) } // GetToplevel is a wrapper around gtk_widget_get_toplevel(). func (v *Widget) GetToplevel() (IWidget, error) { c := C.gtk_widget_get_toplevel(v.native()) if c == nil { return nil, nilPtrErr } return castWidget(c) } // TODO: // gtk_widget_get_ancestor(). // gtk_widget_get_visual(). // gtk_widget_is_ancestor(). // GetTooltipMarkup is a wrapper around gtk_widget_get_tooltip_markup(). // A non-nil error is returned in the case that gtk_widget_get_tooltip_markup // returns NULL to differentiate between NULL and an empty string. func (v *Widget) GetTooltipMarkup() (string, error) { c := C.gtk_widget_get_tooltip_markup(v.native()) if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // SetTooltipMarkup is a wrapper around gtk_widget_set_tooltip_markup(). func (v *Widget) SetTooltipMarkup(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_widget_set_tooltip_markup(v.native(), (*C.gchar)(cstr)) } // GetTooltipText is a wrapper around gtk_widget_get_tooltip_text(). // A non-nil error is returned in the case that // gtk_widget_get_tooltip_text returns NULL to differentiate between NULL // and an empty string. func (v *Widget) GetTooltipText() (string, error) { c := C.gtk_widget_get_tooltip_text(v.native()) if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // SetTooltipText is a wrapper around gtk_widget_set_tooltip_text(). func (v *Widget) SetTooltipText(text string) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.gtk_widget_set_tooltip_text(v.native(), (*C.gchar)(cstr)) } // TranslateCoordinates is a wrapper around gtk_widget_translate_coordinates(). func (v *Widget) TranslateCoordinates(dest IWidget, srcX, srcY int) (destX, destY int, e error) { cdest := nullableWidget(dest) var cdestX, cdestY C.gint c := C.gtk_widget_translate_coordinates(v.native(), cdest, C.gint(srcX), C.gint(srcY), &cdestX, &cdestY) if !gobool(c) { return 0, 0, errors.New("translate coordinates failed") } return int(cdestX), int(cdestY), nil } // SetVisual is a wrapper around gtk_widget_set_visual(). func (v *Widget) SetVisual(visual *gdk.Visual) { C.gtk_widget_set_visual(v.native(), (*C.GdkVisual)(unsafe.Pointer(visual.Native()))) } // SetAppPaintable is a wrapper around gtk_widget_set_app_paintable(). func (v *Widget) SetAppPaintable(paintable bool) { C.gtk_widget_set_app_paintable(v.native(), gbool(paintable)) } // GetAppPaintable is a wrapper around gtk_widget_get_app_paintable(). func (v *Widget) GetAppPaintable() bool { c := C.gtk_widget_get_app_paintable(v.native()) return gobool(c) } // QueueDraw is a wrapper around gtk_widget_queue_draw(). func (v *Widget) QueueDraw() { C.gtk_widget_queue_draw(v.native()) } // GetAllocation is a wrapper around gtk_widget_get_allocation(). func (v *Widget) GetAllocation() *Allocation { var a Allocation C.gtk_widget_get_allocation(v.native(), a.native()) return &a } // SetAllocation is a wrapper around gtk_widget_set_allocation(). func (v *Widget) SetAllocation(allocation *Allocation) { C.gtk_widget_set_allocation(v.native(), allocation.native()) } // SizeAllocate is a wrapper around gtk_widget_size_allocate(). func (v *Widget) SizeAllocate(allocation *Allocation) { C.gtk_widget_size_allocate(v.native(), allocation.native()) } // TODO: // gtk_widget_size_allocate_with_baseline(). // SetStateFlags is a wrapper around gtk_widget_set_state_flags(). func (v *Widget) SetStateFlags(stateFlags StateFlags, clear bool) { C.gtk_widget_set_state_flags(v.native(), C.GtkStateFlags(stateFlags), gbool(clear)) } // TODO: // gtk_widget_unset_state_flags(). // gtk_widget_get_state_flags(). // GetWindow is a wrapper around gtk_widget_get_window(). func (v *Widget) GetWindow() (*gdk.Window, error) { c := C.gtk_widget_get_window(v.native()) if c == nil { return nil, nilPtrErr } w := &gdk.Window{glib.Take(unsafe.Pointer(c))} return w, nil } /* * GtkRequisition */ // Requisition is a representation of GTK's GtkRequisition type Requisition struct { requisition *C.GtkRequisition Width, Height int } func (v *Requisition) native() *C.GtkRequisition { if v == nil { return nil } v.requisition.width = C.int(v.Width) v.requisition.height = C.int(v.Height) return v.requisition } // Native returns a pointer to the underlying GtkRequisition. func (v *Requisition) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func marshalRequisition(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) requisition := (*C.GtkRequisition)(unsafe.Pointer(c)) return wrapRequisition(requisition), nil } func wrapRequisition(requisition *C.GtkRequisition) *Requisition { if requisition == nil { return nil } return &Requisition{requisition, int(requisition.width), int(requisition.height)} } // requisitionFromNative that handle finalizer. func requisitionFromNative(requisitionNative *C.GtkRequisition) (*Requisition, error) { requisition := wrapRequisition(requisitionNative) if requisition == nil { return nil, nilPtrErr } runtime.SetFinalizer(requisition, func(l *Requisition) { glib.FinalizerStrategy(l.free) }) return requisition, nil } // RequisitionNew is a wrapper around gtk_requisition_new(). func RequisitionNew() (*Requisition, error) { c := C.gtk_requisition_new() if c == nil { return nil, nilPtrErr } return requisitionFromNative(c) } // free is a wrapper around gtk_requisition_free(). func (v *Requisition) free() { C.gtk_requisition_free(v.native()) } // Copy is a wrapper around gtk_requisition_copy(). func (v *Requisition) Copy() (*Requisition, error) { c := C.gtk_requisition_copy(v.native()) if c == nil { return nil, nilPtrErr } return requisitionFromNative(c) } /* * GtkAllocation */ // Allocation is a representation of GTK's GtkAllocation type. type Allocation struct { gdk.Rectangle } // Native returns a pointer to the underlying GtkAllocation. func (v *Allocation) native() *C.GtkAllocation { return (*C.GtkAllocation)(unsafe.Pointer(&v.GdkRectangle)) } // GetAllocatedWidth() is a wrapper around gtk_widget_get_allocated_width(). func (v *Widget) GetAllocatedWidth() int { return int(C.gtk_widget_get_allocated_width(v.native())) } // GetAllocatedHeight() is a wrapper around gtk_widget_get_allocated_height(). func (v *Widget) GetAllocatedHeight() int { return int(C.gtk_widget_get_allocated_height(v.native())) } // TODO: // gtk_widget_get_allocated_baseline(). // gtk_widget_get_allocated_size(). gotk3-0.6.2/gtk/widget_export_since_3_8.go000066400000000000000000000010171431157473000204040ustar00rootroot00000000000000// +build !gtk_3_6 package gtk // #include // #include import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" "github.com/gotk3/gotk3/internal/callback" ) //export goTickCallbacks func goTickCallbacks(widget *C.GtkWidget, frameClock *C.GdkFrameClock, userData C.gpointer) C.gboolean { fn := callback.Get(uintptr(userData)).(TickCallback) return gbool(fn( wrapWidget(glib.Take(unsafe.Pointer(widget))), gdk.WrapFrameClock(unsafe.Pointer(frameClock)), )) } gotk3-0.6.2/gtk/widget_since_3_10.go000066400000000000000000000025231431157473000170570ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8 package gtk // #include import "C" // GetPreferredHeightAndBaselineForWidth is a wrapper around gtk_widget_get_preferred_height_and_baseline_for_width(). func (v *Widget) GetPreferredHeightAndBaselineForWidth(height int) (int, int, int, int) { var minimum, natural, minimum_baseline, natural_baseline C.gint C.gtk_widget_get_preferred_height_and_baseline_for_width( v.native(), C.gint(height), &minimum, &natural, &minimum_baseline, &natural_baseline) return int(minimum), int(natural), int(minimum_baseline), int(natural_baseline) } // TODO: // gtk_widget_get_valign_with_baseline(). // gtk_widget_init_template(). // gtk_widget_class_set_template(). // gtk_widget_class_set_template_from_resource(). // gtk_widget_get_template_child(). // gtk_widget_class_bind_template_child(). // gtk_widget_class_bind_template_child_internal(). // gtk_widget_class_bind_template_child_private(). // gtk_widget_class_bind_template_child_internal_private(). // gtk_widget_class_bind_template_child_full(). // gtk_widget_class_bind_template_callback(). // gtk_widget_class_bind_template_callback_full(). // gtk_widget_class_set_connect_func(). // GetScaleFactor is a wrapper around gtk_widget_get_scale_factor(). func (v *Widget) GetScaleFactor() int { return int(C.gtk_widget_get_scale_factor(v.native())) } gotk3-0.6.2/gtk/widget_since_3_12.go000066400000000000000000000036441431157473000170660ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // This file includes wrapers for symbols included since GTK 3.12, and // and should not be included in a build intended to target any older GTK // versions. To target an older build, such as 3.10, use // 'go build -tags gtk_3_10'. Otherwise, if no build tags are used, GTK 3.12 // is assumed and this file is built. // +build !gtk_3_6,!gtk_3_8,!gtk_3_10 package gtk // #include import "C" // SetMarginStart is a wrapper around gtk_widget_set_margin_start(). func (v *Widget) SetMarginStart(margin int) { C.gtk_widget_set_margin_start(v.native(), C.gint(margin)) } // GetMarginStart is a wrapper around gtk_widget_get_margin_start(). func (v *Widget) GetMarginStart() int { c := C.gtk_widget_get_margin_start(v.native()) return int(c) } // SetMarginEnd is a wrapper around gtk_widget_set_margin_end(). func (v *Widget) SetMarginEnd(margin int) { C.gtk_widget_set_margin_end(v.native(), C.gint(margin)) } // GetMarginEnd is a wrapper around gtk_widget_get_margin_end(). func (v *Widget) GetMarginEnd() int { c := C.gtk_widget_get_margin_end(v.native()) return int(c) } gotk3-0.6.2/gtk/widget_since_3_14.go000066400000000000000000000007631431157473000170670ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12 // See: https://developer.gnome.org/gtk3/3.14/api-index-3-14.html package gtk // #include import "C" // GetClip is a wrapper around gtk_widget_get_clip(). func (v *Widget) GetClip() *Allocation { var clip Allocation C.gtk_widget_get_clip(v.native(), clip.native()) return &clip } // SetClip is a wrapper around gtk_widget_set_clip(). func (v *Widget) SetClip(clip *Allocation) { C.gtk_widget_set_clip(v.native(), clip.native()) } gotk3-0.6.2/gtk/widget_since_3_16.go000066400000000000000000000002751431157473000170670ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14 package gtk // #include import "C" // TODO: // gtk_widget_list_action_prefixes(). // gtk_widget_get_action_group(). gotk3-0.6.2/gtk/widget_since_3_18.go000066400000000000000000000003771431157473000170740ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16 package gtk // #include import "C" // TODO: // gtk_widget_set_font_options(). // gtk_widget_get_font_options(). // gtk_widget_set_font_map(). // gtk_widget_get_font_map(). gotk3-0.6.2/gtk/widget_since_3_20.go000066400000000000000000000011151431157473000170540ustar00rootroot00000000000000// +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16,!gtk_3_18 package gtk // #include import "C" // GetFocusOnClick is a wrapper around gtk_widget_get_focus_on_click(). func (v *Widget) GetFocusOnClick() bool { c := C.gtk_widget_get_focus_on_click(v.native()) return gobool(c) } // SetFocusOnClick is a wrapper around gtk_widget_set_focus_on_click(). func (v *Widget) SetFocusOnClick(focusOnClick bool) { C.gtk_widget_set_focus_on_click(v.native(), gbool(focusOnClick)) } // TODO: // gtk_widget_class_get_css_name(). // gtk_widget_class_set_css_name(). gotk3-0.6.2/gtk/widget_since_3_8.go000066400000000000000000000052641431157473000170130ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // This file includes wrapers for symbols included since GTK 3.8, and // and should not be included in a build intended to target any older GTK // versions. To target an older build, such as 3.8, use // 'go build -tags gtk_3_8'. Otherwise, if no build tags are used, GTK 3.18 // is assumed and this file is built. // +build !gtk_3_6 package gtk // #include // #include "widget_since_3_8.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/internal/callback" ) /* * GtkTickCallback */ // TickCallback is a representation of GtkTickCallback type TickCallback func(widget *Widget, frameClock *gdk.FrameClock) bool /* * GtkWidget */ // IsVisible is a wrapper around gtk_widget_is_visible(). func (v *Widget) IsVisible() bool { c := C.gtk_widget_is_visible(v.native()) return gobool(c) } // SetOpacity is a wrapper around gtk_widget_set_opacity() func (v *Widget) SetOpacity(opacity float64) { C.gtk_widget_set_opacity(v.native(), C.double(opacity)) } // GetOpacity is a wrapper around gtk_widget_get_opacity() func (v *Widget) GetOpacity() float64 { c := C.gtk_widget_get_opacity(v.native()) return float64(c) } // GetFrameClock is a wrapper around gtk_widget_get_frame_clock(). func (v *Widget) GetFrameClock() *gdk.FrameClock { c := C.gtk_widget_get_frame_clock(v.native()) return gdk.WrapFrameClock(unsafe.Pointer(c)) } // AddTickCallback is a wrapper around gtk_widget_add_tick_callback(). func (v *Widget) AddTickCallback(fn TickCallback) int { return int(C._gtk_widget_add_tick_callback(v.native(), C.gpointer(callback.Assign(fn)))) } // RemoveTickCallback is a wrapper around gtk_widget_remove_tick_callback(). func (v *Widget) RemoveTickCallback(id int) { C.gtk_widget_remove_tick_callback(v.native(), C.guint(id)) } // TODO: // gtk_widget_register_window(). // gtk_widget_unregister_window(). gotk3-0.6.2/gtk/widget_since_3_8.go.h000066400000000000000000000025211431157473000172320ustar00rootroot00000000000000/* * Copyright (c) 2013-2014 Conformal Systems * * This file originated from: http://opensource.conformal.com/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include "gtk.go.h" // for gotk3_callbackDelete #include extern gboolean goTickCallbacks(GtkWidget *widget, GdkFrameClock *frame_clock, gpointer user_data); static inline guint _gtk_widget_add_tick_callback(GtkWidget *widget, gpointer user_data) { return gtk_widget_add_tick_callback( widget, (GtkTickCallback)(goTickCallbacks), user_data, (GDestroyNotify)(gotk3_callbackDelete)); } gotk3-0.6.2/gtk/window.go000066400000000000000000000541441431157473000152060ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package gtk // #include // #include "gtk.go.h" import "C" import ( "errors" "runtime" "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) /* * GtkWindow */ // gtk_window_set_has_user_ref_count is NOT included, see GTK documentation for why that is. // Window is a representation of GTK's GtkWindow. type Window struct { Bin } // IWindow is an interface type implemented by all structs embedding a // Window. It is meant to be used as an argument type for wrapper // functions that wrap around a C GTK function taking a GtkWindow. type IWindow interface { toWindow() *C.GtkWindow ToWindow() *Window } // native returns a pointer to the underlying GtkWindow. func (v *Window) native() *C.GtkWindow { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkWindow(p) } func (v *Window) toWindow() *C.GtkWindow { if v == nil { return nil } return v.native() } // ToWindow is a helper getter, e.g.: it returns *gtk.ApplicationWindow as a *gtk.Window. // In other cases, where you have a gtk.IWindow, use the type assertion. func (v *Window) ToWindow() *Window { return v } func marshalWindow(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapWindow(obj), nil } func wrapWindow(obj *glib.Object) *Window { if obj == nil { return nil } return &Window{Bin{Container{Widget{glib.InitiallyUnowned{obj}}}}} } // WindowNew is a wrapper around gtk_window_new(). func WindowNew(t WindowType) (*Window, error) { c := C.gtk_window_new(C.GtkWindowType(t)) if c == nil { return nil, nilPtrErr } return wrapWindow(glib.Take(unsafe.Pointer(c))), nil } // SetTitle is a wrapper around gtk_window_set_title(). func (v *Window) SetTitle(title string) { cstr := C.CString(title) defer C.free(unsafe.Pointer(cstr)) C.gtk_window_set_title(v.native(), (*C.gchar)(cstr)) } // SetResizable is a wrapper around gtk_window_set_resizable(). func (v *Window) SetResizable(resizable bool) { C.gtk_window_set_resizable(v.native(), gbool(resizable)) } // GetResizable is a wrapper around gtk_window_get_resizable(). func (v *Window) GetResizable() bool { c := C.gtk_window_get_resizable(v.native()) return gobool(c) } // ActivateFocus is a wrapper around gtk_window_activate_focus(). func (v *Window) ActivateFocus() bool { c := C.gtk_window_activate_focus(v.native()) return gobool(c) } // ActivateDefault is a wrapper around gtk_window_activate_default(). func (v *Window) ActivateDefault() bool { c := C.gtk_window_activate_default(v.native()) return gobool(c) } // SetModal is a wrapper around gtk_window_set_modal(). func (v *Window) SetModal(modal bool) { C.gtk_window_set_modal(v.native(), gbool(modal)) } // SetDefaultSize is a wrapper around gtk_window_set_default_size(). func (v *Window) SetDefaultSize(width, height int) { C.gtk_window_set_default_size(v.native(), C.gint(width), C.gint(height)) } // SetIcon is a wrapper around gtk_window_set_icon(). func (v *Window) SetIcon(icon *gdk.Pixbuf) { iconPtr := (*C.GdkPixbuf)(unsafe.Pointer(icon.Native())) C.gtk_window_set_icon(v.native(), iconPtr) } // WindowSetDefaultIcon is a wrapper around gtk_window_set_default_icon(). func WindowSetDefaultIcon(icon *gdk.Pixbuf) { iconPtr := (*C.GdkPixbuf)(unsafe.Pointer(icon.Native())) C.gtk_window_set_default_icon(iconPtr) } // SetGeometryHints is a wrapper around gtk_window_set_geometry_hints(). func (v *Window) SetGeometryHints(geometryWidget IWidget, geometry gdk.Geometry, geometryMask gdk.WindowHints) { var gW *C.GtkWidget = nil if geometryWidget != nil { gW = geometryWidget.toWidget() } C.gtk_window_set_geometry_hints(v.native(), gW, nativeGdkGeometry(geometry), C.GdkWindowHints(geometryMask)) } // SetGravity is a wrapper around gtk_window_set_gravity(). func (v *Window) SetGravity(gravity gdk.Gravity) { C.gtk_window_set_gravity(v.native(), C.GdkGravity(gravity)) } // GetGravity is a wrapper around gtk_window_get_gravity(). func (v *Window) GetGravity() gdk.Gravity { c := C.gtk_window_get_gravity(v.native()) return gdk.Gravity(c) } // SetPosition is a wrapper around gtk_window_set_position(). func (v *Window) SetPosition(position WindowPosition) { C.gtk_window_set_position(v.native(), C.GtkWindowPosition(position)) } // SetTransientFor is a wrapper around gtk_window_set_transient_for(). func (v *Window) SetTransientFor(parent IWindow) { var pw *C.GtkWindow = nil if parent != nil { pw = parent.toWindow() } C.gtk_window_set_transient_for(v.native(), pw) } // SetAttachedTo is a wrapper around gtk_window_set_attached_to(). func (v *Window) SetAttachedTo(attachWidget IWidget) { var aW *C.GtkWidget = nil if attachWidget != nil { aW = attachWidget.toWidget() } C.gtk_window_set_attached_to(v.native(), aW) } // SetDestroyWithParent is a wrapper around // gtk_window_set_destroy_with_parent(). func (v *Window) SetDestroyWithParent(setting bool) { C.gtk_window_set_destroy_with_parent(v.native(), gbool(setting)) } // SetHideTitlebarWhenMaximized is a wrapper around // gtk_window_set_hide_titlebar_when_maximized(). func (v *Window) SetHideTitlebarWhenMaximized(setting bool) { C.gtk_window_set_hide_titlebar_when_maximized(v.native(), gbool(setting)) } // IsActive is a wrapper around gtk_window_is_active(). func (v *Window) IsActive() bool { c := C.gtk_window_is_active(v.native()) return gobool(c) } // HasToplevelFocus is a wrapper around gtk_window_has_toplevel_focus(). func (v *Window) HasToplevelFocus() bool { c := C.gtk_window_has_toplevel_focus(v.native()) return gobool(c) } // GetFocus is a wrapper around gtk_window_get_focus(). func (v *Window) GetFocus() (IWidget, error) { c := C.gtk_window_get_focus(v.native()) if c == nil { return nil, nil } return castWidget(c) } // SetFocus is a wrapper around gtk_window_set_focus(). func (v *Window) SetFocus(w *Widget) { C.gtk_window_set_focus(v.native(), w.native()) } // GetDefaultWidget is a wrapper around gtk_window_get_default_widget(). // See SetDefault() for the setter. func (v *Window) GetDefaultWidget() (IWidget, error) { c := C.gtk_window_get_default_widget(v.native()) if c == nil { return nil, nil } return castWidget(c) } // SetDefault is a wrapper around gtk_window_set_default(). // See GetDefaultWidget() for the getter. func (v *Window) SetDefault(widget IWidget) { C.gtk_window_set_default(v.native(), widget.toWidget()) } // Present is a wrapper around gtk_window_present(). func (v *Window) Present() { C.gtk_window_present(v.native()) } // PresentWithTime is a wrapper around gtk_window_present_with_time(). func (v *Window) PresentWithTime(ts uint32) { C.gtk_window_present_with_time(v.native(), C.guint32(ts)) } // Iconify is a wrapper around gtk_window_iconify(). func (v *Window) Iconify() { C.gtk_window_iconify(v.native()) } // Deiconify is a wrapper around gtk_window_deiconify(). func (v *Window) Deiconify() { C.gtk_window_deiconify(v.native()) } // Stick is a wrapper around gtk_window_stick(). func (v *Window) Stick() { C.gtk_window_stick(v.native()) } // Unstick is a wrapper around gtk_window_unstick(). func (v *Window) Unstick() { C.gtk_window_unstick(v.native()) } // Maximize is a wrapper around gtk_window_maximize(). func (v *Window) Maximize() { C.gtk_window_maximize(v.native()) } // Unmaximize is a wrapper around gtk_window_unmaximize(). func (v *Window) Unmaximize() { C.gtk_window_unmaximize(v.native()) } // Fullscreen is a wrapper around gtk_window_fullscreen(). func (v *Window) Fullscreen() { C.gtk_window_fullscreen(v.native()) } // Unfullscreen is a wrapper around gtk_window_unfullscreen(). func (v *Window) Unfullscreen() { C.gtk_window_unfullscreen(v.native()) } // SetKeepAbove is a wrapper around gtk_window_set_keep_above(). func (v *Window) SetKeepAbove(setting bool) { C.gtk_window_set_keep_above(v.native(), gbool(setting)) } // SetKeepBelow is a wrapper around gtk_window_set_keep_below(). func (v *Window) SetKeepBelow(setting bool) { C.gtk_window_set_keep_below(v.native(), gbool(setting)) } // SetDecorated is a wrapper around gtk_window_set_decorated(). func (v *Window) SetDecorated(setting bool) { C.gtk_window_set_decorated(v.native(), gbool(setting)) } // SetDeletable is a wrapper around gtk_window_set_deletable(). func (v *Window) SetDeletable(setting bool) { C.gtk_window_set_deletable(v.native(), gbool(setting)) } // SetTypeHint is a wrapper around gtk_window_set_type_hint(). func (v *Window) SetTypeHint(typeHint gdk.WindowTypeHint) { C.gtk_window_set_type_hint(v.native(), C.GdkWindowTypeHint(typeHint)) } // SetSkipTaskbarHint is a wrapper around gtk_window_set_skip_taskbar_hint(). func (v *Window) SetSkipTaskbarHint(setting bool) { C.gtk_window_set_skip_taskbar_hint(v.native(), gbool(setting)) } // SetSkipPagerHint is a wrapper around gtk_window_set_skip_pager_hint(). func (v *Window) SetSkipPagerHint(setting bool) { C.gtk_window_set_skip_pager_hint(v.native(), gbool(setting)) } // SetUrgencyHint is a wrapper around gtk_window_set_urgency_hint(). func (v *Window) SetUrgencyHint(setting bool) { C.gtk_window_set_urgency_hint(v.native(), gbool(setting)) } // SetAcceptFocus is a wrapper around gtk_window_set_accept_focus(). func (v *Window) SetAcceptFocus(setting bool) { C.gtk_window_set_accept_focus(v.native(), gbool(setting)) } // SetFocusOnMap is a wrapper around gtk_window_set_focus_on_map(). func (v *Window) SetFocusOnMap(setting bool) { C.gtk_window_set_focus_on_map(v.native(), gbool(setting)) } // SetStartupID is a wrapper around gtk_window_set_startup_id(). func (v *Window) SetStartupID(sid string) { cstr := (*C.gchar)(C.CString(sid)) defer C.free(unsafe.Pointer(cstr)) C.gtk_window_set_startup_id(v.native(), cstr) } // SetRole is a wrapper around gtk_window_set_role(). func (v *Window) SetRole(s string) { cstr := (*C.gchar)(C.CString(s)) defer C.free(unsafe.Pointer(cstr)) C.gtk_window_set_role(v.native(), cstr) } // GetDecorated is a wrapper around gtk_window_get_decorated(). func (v *Window) GetDecorated() bool { c := C.gtk_window_get_decorated(v.native()) return gobool(c) } // GetDeletable is a wrapper around gtk_window_get_deletable(). func (v *Window) GetDeletable() bool { c := C.gtk_window_get_deletable(v.native()) return gobool(c) } // WindowGetDefaultIconName is a wrapper around gtk_window_get_default_icon_name(). func WindowGetDefaultIconName() (string, error) { return stringReturn(C.gtk_window_get_default_icon_name()) } // GetDefaultSize is a wrapper around gtk_window_get_default_size(). func (v *Window) GetDefaultSize() (width, height int) { var w, h C.gint C.gtk_window_get_default_size(v.native(), &w, &h) return int(w), int(h) } // GetDestroyWithParent is a wrapper around // gtk_window_get_destroy_with_parent(). func (v *Window) GetDestroyWithParent() bool { c := C.gtk_window_get_destroy_with_parent(v.native()) return gobool(c) } // GetHideTitlebarWhenMaximized is a wrapper around // gtk_window_get_hide_titlebar_when_maximized(). func (v *Window) GetHideTitlebarWhenMaximized() bool { c := C.gtk_window_get_hide_titlebar_when_maximized(v.native()) return gobool(c) } // GetIcon is a wrapper around gtk_window_get_icon(). func (v *Window) GetIcon() (*gdk.Pixbuf, error) { c := C.gtk_window_get_icon(v.native()) if c == nil { return nil, nil } return &gdk.Pixbuf{glib.Take(unsafe.Pointer(c))}, nil } // GetIconName is a wrapper around gtk_window_get_icon_name(). func (v *Window) GetIconName() (string, error) { return stringReturn(C.gtk_window_get_icon_name(v.native())) } // GetModal is a wrapper around gtk_window_get_modal(). func (v *Window) GetModal() bool { c := C.gtk_window_get_modal(v.native()) return gobool(c) } // GetPosition is a wrapper around gtk_window_get_position(). func (v *Window) GetPosition() (int, int) { var x, y C.gint C.gtk_window_get_position(v.native(), &x, &y) return int(x), int(y) } func stringReturn(c *C.gchar) (string, error) { if c == nil { return "", nilPtrErr } return C.GoString((*C.char)(c)), nil } // GetRole is a wrapper around gtk_window_get_role(). func (v *Window) GetRole() (string, error) { return stringReturn(C.gtk_window_get_role(v.native())) } // GetSize is a wrapper around gtk_window_get_size(). func (v *Window) GetSize() (width, height int) { var w, h C.gint C.gtk_window_get_size(v.native(), &w, &h) return int(w), int(h) } // GetTitle is a wrapper around gtk_window_get_title(). func (v *Window) GetTitle() (string, error) { return stringReturn(C.gtk_window_get_title(v.native())) } // GetTransientFor is a wrapper around gtk_window_get_transient_for(). func (v *Window) GetTransientFor() (*Window, error) { c := C.gtk_window_get_transient_for(v.native()) if c == nil { return nil, nil } return wrapWindow(glib.Take(unsafe.Pointer(c))), nil } // GetAttachedTo is a wrapper around gtk_window_get_attached_to(). func (v *Window) GetAttachedTo() (IWidget, error) { c := C.gtk_window_get_attached_to(v.native()) if c == nil { return nil, nil } return castWidget(c) } // GetTypeHint is a wrapper around gtk_window_get_type_hint(). func (v *Window) GetTypeHint() gdk.WindowTypeHint { c := C.gtk_window_get_type_hint(v.native()) return gdk.WindowTypeHint(c) } // GetSkipTaskbarHint is a wrapper around gtk_window_get_skip_taskbar_hint(). func (v *Window) GetSkipTaskbarHint() bool { c := C.gtk_window_get_skip_taskbar_hint(v.native()) return gobool(c) } // GetSkipPagerHint is a wrapper around gtk_window_get_skip_pager_hint(). func (v *Window) GetSkipPagerHint() bool { c := C.gtk_window_get_skip_pager_hint(v.native()) return gobool(c) } // GetUrgencyHint is a wrapper around gtk_window_get_urgency_hint(). func (v *Window) GetUrgencyHint() bool { c := C.gtk_window_get_urgency_hint(v.native()) return gobool(c) } // GetAcceptFocus is a wrapper around gtk_window_get_accept_focus(). func (v *Window) GetAcceptFocus() bool { c := C.gtk_window_get_accept_focus(v.native()) return gobool(c) } // GetFocusOnMap is a wrapper around gtk_window_get_focus_on_map(). func (v *Window) GetFocusOnMap() bool { c := C.gtk_window_get_focus_on_map(v.native()) return gobool(c) } // GetWindowType is a wrapper around gtk_window_get_window_type(). func (v *Window) GetWindowType() WindowType { c := C.gtk_window_get_window_type(v.native()) return WindowType(c) } // HasGroup is a wrapper around gtk_window_has_group(). func (v *Window) HasGroup() bool { c := C.gtk_window_has_group(v.native()) return gobool(c) } // Move is a wrapper around gtk_window_move(). func (v *Window) Move(x, y int) { C.gtk_window_move(v.native(), C.gint(x), C.gint(y)) } // Resize is a wrapper around gtk_window_resize(). func (v *Window) Resize(width, height int) { C.gtk_window_resize(v.native(), C.gint(width), C.gint(height)) } // WindowSetDefaultIconFromFile is a wrapper around gtk_window_set_default_icon_from_file(). func WindowSetDefaultIconFromFile(file string) error { cstr := C.CString(file) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil res := C.gtk_window_set_default_icon_from_file((*C.gchar)(cstr), &err) if res == 0 { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // WindowSetDefaultIconName is a wrapper around gtk_window_set_default_icon_name(). func WindowSetDefaultIconName(s string) { cstr := (*C.gchar)(C.CString(s)) defer C.free(unsafe.Pointer(cstr)) C.gtk_window_set_default_icon_name(cstr) } // SetIconFromFile is a wrapper around gtk_window_set_icon_from_file(). func (v *Window) SetIconFromFile(file string) error { cstr := C.CString(file) defer C.free(unsafe.Pointer(cstr)) var err *C.GError = nil res := C.gtk_window_set_icon_from_file(v.native(), (*C.gchar)(cstr), &err) if res == 0 { defer C.g_error_free(err) return errors.New(C.GoString((*C.char)(err.message))) } return nil } // SetIconName is a wrapper around gtk_window_set_icon_name(). func (v *Window) SetIconName(name string) { cstr := C.CString(name) defer C.free(unsafe.Pointer(cstr)) C.gtk_window_set_icon_name(v.native(), (*C.gchar)(cstr)) } // WindowSetAutoStartupNotification is a wrapper around // gtk_window_set_auto_startup_notification(). func WindowSetAutoStartupNotification(setting bool) { C.gtk_window_set_auto_startup_notification(gbool(setting)) } // GetMnemonicsVisible is a wrapper around // gtk_window_get_mnemonics_visible(). func (v *Window) GetMnemonicsVisible() bool { c := C.gtk_window_get_mnemonics_visible(v.native()) return gobool(c) } // SetMnemonicsVisible is a wrapper around // gtk_window_set_mnemonics_visible(). func (v *Window) SetMnemonicsVisible(setting bool) { C.gtk_window_set_mnemonics_visible(v.native(), gbool(setting)) } // GetFocusVisible is a wrapper around gtk_window_get_focus_visible(). func (v *Window) GetFocusVisible() bool { c := C.gtk_window_get_focus_visible(v.native()) return gobool(c) } // SetFocusVisible is a wrapper around gtk_window_set_focus_visible(). func (v *Window) SetFocusVisible(setting bool) { C.gtk_window_set_focus_visible(v.native(), gbool(setting)) } // GetApplication is a wrapper around gtk_window_get_application(). func (v *Window) GetApplication() (*Application, error) { c := C.gtk_window_get_application(v.native()) if c == nil { return nil, nil } return wrapApplication(glib.Take(unsafe.Pointer(c))), nil } // SetApplication is a wrapper around gtk_window_set_application(). func (v *Window) SetApplication(a *Application) { C.gtk_window_set_application(v.native(), a.native()) } // ActivateKey is a wrapper around gtk_window_activate_key(). func (v *Window) ActivateKey(event *gdk.EventKey) bool { c := C.gtk_window_activate_key(v.native(), (*C.GdkEventKey)(unsafe.Pointer(event.Native()))) return gobool(c) } // AddMnemonic is a wrapper around gtk_window_add_mnemonic(). func (v *Window) AddMnemonic(keyval uint, target *Widget) { C.gtk_window_add_mnemonic(v.native(), C.guint(keyval), target.native()) } // RemoveMnemonic is a wrapper around gtk_window_remove_mnemonic(). func (v *Window) RemoveMnemonic(keyval uint, target *Widget) { C.gtk_window_remove_mnemonic(v.native(), C.guint(keyval), target.native()) } // ActivateMnemonic is a wrapper around gtk_window_mnemonic_activate(). func (v *Window) ActivateMnemonic(keyval uint, mods gdk.ModifierType) bool { c := C.gtk_window_mnemonic_activate(v.native(), C.guint(keyval), C.GdkModifierType(mods)) return gobool(c) } // GetMnemonicModifier is a wrapper around gtk_window_get_mnemonic_modifier(). func (v *Window) GetMnemonicModifier() gdk.ModifierType { c := C.gtk_window_get_mnemonic_modifier(v.native()) return gdk.ModifierType(c) } // SetMnemonicModifier is a wrapper around gtk_window_set_mnemonic_modifier(). func (v *Window) SetMnemonicModifier(mods gdk.ModifierType) { C.gtk_window_set_mnemonic_modifier(v.native(), C.GdkModifierType(mods)) } // SetScreen is a wrapper around gtk_window_set_screen(). func (v *Window) SetScreen(screen *gdk.Screen) { C.gtk_window_set_screen(v.native(), C.toGdkScreen(unsafe.Pointer(screen.Native()))) } // GetScreen is a wrapper around gtk_window_get_screen(). func (v *Window) GetScreen() *gdk.Screen { c := C.gtk_window_get_screen(v.native()) return &gdk.Screen{glib.Take(unsafe.Pointer(c))} } // PropagateKeyEvent is a wrapper around gtk_window_propagate_key_event(). func (v *Window) PropagateKeyEvent(event *gdk.EventKey) bool { c := C.gtk_window_propagate_key_event(v.native(), (*C.GdkEventKey)(unsafe.Pointer(event.Native()))) return gobool(c) } // WindowListToplevels is a wrapper around gtk_window_list_toplevels(). // Returned list is wrapped to return *gtk.Window elements. // TODO: Use IWindow and wrap to correct type func WindowListToplevels() *glib.List { clist := C.gtk_window_list_toplevels() if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return wrapWindow(glib.Take(ptr)) }) runtime.SetFinalizer(glist, func(v *glib.List) { glib.FinalizerStrategy(v.Free) }) return glist } // WindowGetDefaultIconList is a wrapper around gtk_window_get_default_icon_list(). // Returned list is wrapped to return *gdk.Pixbuf elements. func WindowGetDefaultIconList() *glib.List { clist := C.gtk_window_get_default_icon_list() if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return &gdk.Pixbuf{glib.Take(ptr)} }) runtime.SetFinalizer(glist, func(v *glib.List) { glib.FinalizerStrategy(v.Free) }) return glist } // GetIconList is a wrapper around gtk_window_get_icon_list(). // Returned list is wrapped to return *gdk.Pixbuf elements. func (v *Window) GetIconList() *glib.List { clist := C.gtk_window_get_icon_list(v.native()) if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return &gdk.Pixbuf{glib.Take(ptr)} }) runtime.SetFinalizer(glist, func(v *glib.List) { glib.FinalizerStrategy(v.Free) }) return glist } // WindowSetDefaultIconList is a wrapper around gtk_window_set_default_icon_list(). // List should only contain *gdk.Pixbuf elements! func WindowSetDefaultIconList(list *glib.List) { native := (*C.struct__GList)(unsafe.Pointer(list.Native())) C.gtk_window_set_default_icon_list(native) } // SetIconList is a wrapper around gtk_window_set_icon_list(). // List should only contain *gdk.Pixbuf elements! func (v *Window) SetIconList(list *glib.List) { native := (*C.struct__GList)(unsafe.Pointer(list.Native())) C.gtk_window_set_icon_list(v.native(), native) } // BeginResizeDrag is a wrapper around gtk_window_begin_resize_drag(). func (v *Window) BeginResizeDrag(edge gdk.WindowEdge, button gdk.Button, rootX, rootY int, timestamp uint32) { C.gtk_window_begin_resize_drag(v.native(), C.GdkWindowEdge(edge), C.gint(button), C.gint(rootX), C.gint(rootY), C.guint32(timestamp)) } // BeginMoveDrag is a wrapper around gtk_window_begin_move_drag(). func (v *Window) BeginMoveDrag(button gdk.Button, rootX, rootY int, timestamp uint32) { C.gtk_window_begin_move_drag(v.native(), C.gint(button), C.gint(rootX), C.gint(rootY), C.guint32(timestamp)) } // GetGroup is a wrapper around gtk_window_get_group(). func (v *Window) GetGroup() *WindowGroup { c := C.gtk_window_get_group(v.native()) if c == nil { return nil } return wrapWindowGroup(glib.Take(unsafe.Pointer(c))) } gotk3-0.6.2/gtk/window_since_3_10.go000066400000000000000000000011311431157473000170750ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8 // not use this: go build -tags gtk_3_8'. Otherwise, if no build tags are used, GTK 3.10 package gtk // #include // #include // #include "gtk_since_3_10.go.h" import "C" /* * GtkWindow */ // SetTitlebar is a wrapper around gtk_window_set_titlebar(). func (v *Window) SetTitlebar(titlebar IWidget) { C.gtk_window_set_titlebar(v.native(), titlebar.toWidget()) } // Close is a wrapper around gtk_window_close(). func (v *Window) Close() { C.gtk_window_close(v.native()) } gotk3-0.6.2/gtk/window_since_3_12.go000066400000000000000000000005041431157473000171020ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8,!gtk_3_10 package gtk // #include import "C" // IsMaximized is a wrapper around gtk_window_is_maximized(). func (v *Window) IsMaximized() bool { c := C.gtk_window_is_maximized(v.native()) return gobool(c) } gotk3-0.6.2/gtk/window_since_3_14.go000066400000000000000000000005461431157473000171120ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12 package gtk // #include import "C" // SetInteractiveDebugging is a wrapper around gtk_window_set_interactive_debugging(). func SetInteractiveDebugging(enable bool) { C.gtk_window_set_interactive_debugging(gbool(enable)) } gotk3-0.6.2/gtk/window_since_3_16.go000066400000000000000000000006141431157473000171100ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14 package gtk // #include import "C" // GetTitlebar is a wrapper around gtk_window_get_titlebar(). func (v *Window) GetTitlebar() (IWidget, error) { c := C.gtk_window_get_titlebar(v.native()) if c == nil { return nil, nil } return castWidget(c) } gotk3-0.6.2/gtk/window_since_3_16_test.go000066400000000000000000000015651431157473000201550ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14 // Package gtk_test is a separate package for unit tests. // Doing this actually utilizes the go build cache // for package gtk when changing unit test code. package gtk_test import ( "testing" "github.com/gotk3/gotk3/gtk" ) func TestWindowGetSetTitlebar(t *testing.T) { win := createTestWindow(t) // Create test button, SetCanDefault is required for SetDefault to work expected, err := gtk.ButtonNew() if err != nil { t.Error("unexpected error:", err.Error()) } win.SetTitlebar(expected) a, err := win.GetTitlebar() if err != nil { t.Error("unexpected cast failure:", err.Error()) } actual := a.ToWidget() if expected.Native() != actual.Native() { t.Errorf("Expected '0x%x'; Got '0x%x'", expected.Native(), actual.Native()) } } gotk3-0.6.2/gtk/window_since_3_18.go000066400000000000000000000010231431157473000171050ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // +build !gtk_3_6,!gtk_3_8,!gtk_3_10,!gtk_3_12,!gtk_3_14,!gtk_3_16 package gtk // #include // #include "gtk.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/gdk" ) // FullscreenOnMonitor is a wrapper around gtk_window_fullscreen_on_monitor(). func (v *Window) FullscreenOnMonitor(screen *gdk.Screen, monitor int) { C.gtk_window_fullscreen_on_monitor(v.native(), C.toGdkScreen(unsafe.Pointer(screen.Native())), C.gint(monitor)) } gotk3-0.6.2/gtk/window_test.go000066400000000000000000000242011431157473000162340ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project // Package gtk_test is a separate package for unit tests. // Doing this actually utilizes the go build cache // for package gtk when changing unit test code. package gtk_test import ( "testing" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/gtk" ) func TestWindowNew(t *testing.T) { cut, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL) if err != nil { t.Error("unexpected error:", err.Error()) } actual := cut.GetWindowType() if gtk.WINDOW_TOPLEVEL != actual { t.Errorf("Expected WindowType '%d'; Got '%d'", gtk.WINDOW_TOPLEVEL, actual) } } func createTestWindow(t *testing.T) *gtk.Window { win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL) if err != nil { t.Error("unexpected error:", err.Error()) } return win } func TestWindowGetSetTitle(t *testing.T) { win := createTestWindow(t) expected := "Unit Test Window" win.SetTitle(expected) actual, err := win.GetTitle() if err != nil { t.Error("unexpected error:", err.Error()) } if expected != actual { t.Errorf("Expected '%s'; Got '%s'", expected, actual) } } func TestWindowGetSetIconName(t *testing.T) { win := createTestWindow(t) expected := "unit-icon-symbolic" win.SetIconName(expected) actual, err := win.GetIconName() if err != nil { t.Error("unexpected error:", err.Error()) } if expected != actual { t.Errorf("Expected '%s'; Got '%s'", expected, actual) } } func TestWindowGetSetDefaultIconName(t *testing.T) { expected := "unit-icon-symbolic" gtk.WindowSetDefaultIconName(expected) actual, err := gtk.WindowGetDefaultIconName() if err != nil { t.Error("unexpected error:", err.Error()) } if expected != actual { t.Errorf("Expected '%s'; Got '%s'", expected, actual) } } func TestWindowGetSetRole(t *testing.T) { win := createTestWindow(t) expected := "Unit Test Role" win.SetRole(expected) actual, err := win.GetRole() if err != nil { t.Error("unexpected error:", err.Error()) } if expected != actual { t.Errorf("Expected '%s'; Got '%s'", expected, actual) } } func TestWindowGetSetTransientFor(t *testing.T) { win := createTestWindow(t) expected := createTestWindow(t) win.SetTransientFor(expected) actual, err := win.GetTransientFor() if err != nil { t.Error("unexpected error:", err.Error()) } if expected.Native() != actual.Native() { t.Errorf("Expected '0x%x'; Got '0x%x'", expected.Native(), actual.Native()) } } func TestWindowGetSetAttachedTo(t *testing.T) { win := createTestWindow(t) expected := createTestWindow(t) win.SetAttachedTo(expected) a, err := win.GetAttachedTo() if err != nil { t.Error("unexpected error:", err.Error()) } actual := a.ToWidget() if expected.Native() != actual.Native() { t.Errorf("Expected '0x%x'; Got '0x%x'", expected.Native(), actual.Native()) } } func TestWindowGetSetDefaultSize(t *testing.T) { win := createTestWindow(t) expectedW, expectedH := 123, 345 win.SetDefaultSize(expectedW, expectedH) actualW, actualH := win.GetDefaultSize() if expectedW != actualW || expectedH != actualH { t.Errorf("Expected %dx%d; Got %dx%d", expectedW, expectedH, actualW, actualH) } } func TestWindowGetSetGravity(t *testing.T) { win := createTestWindow(t) var expected gdk.Gravity expected = gdk.GDK_GRAVITY_EAST win.SetGravity(expected) actual := win.GetGravity() if expected != actual { t.Errorf("Expected '%d'; Got '%d'", expected, actual) } } func TestWindowGetSetDefaultWidget(t *testing.T) { win := createTestWindow(t) // Create test button, SetCanDefault is required for SetDefault to work expected, err := gtk.ButtonNew() if err != nil { t.Error("unexpected error:", err.Error()) } expected.SetCanDefault(true) win.SetDefault(expected) a, err := win.GetDefaultWidget() if err != nil { t.Error("unexpected error:", err.Error()) } actual := a.ToWidget() if expected.Native() != actual.Native() { t.Errorf("Expected '0x%x'; Got '0x%x'", expected.Native(), actual.Native()) } } func TestWindowGetSetDestroyWithParent(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetDestroyWithParent(tC.value) actual := win.GetDestroyWithParent() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetHideTitlebarWhenMaximized(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetHideTitlebarWhenMaximized(tC.value) actual := win.GetHideTitlebarWhenMaximized() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetResizable(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetResizable(tC.value) actual := win.GetResizable() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetModal(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetModal(tC.value) actual := win.GetModal() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetDecorated(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetDecorated(tC.value) actual := win.GetDecorated() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetDeletable(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetDeletable(tC.value) actual := win.GetDeletable() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetSkipTaskbarHint(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetSkipTaskbarHint(tC.value) actual := win.GetSkipTaskbarHint() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetSkipPagerHint(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetSkipPagerHint(tC.value) actual := win.GetSkipPagerHint() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetUrgencyHint(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetUrgencyHint(tC.value) actual := win.GetUrgencyHint() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetAcceptFocus(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetAcceptFocus(tC.value) actual := win.GetAcceptFocus() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetFocusOnMap(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetFocusOnMap(tC.value) actual := win.GetFocusOnMap() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetMnemonicsVisible(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetMnemonicsVisible(tC.value) actual := win.GetMnemonicsVisible() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetFocusVisible(t *testing.T) { win := createTestWindow(t) testCases := []struct { desc string value bool }{ { desc: "true", value: true, }, { desc: "true", value: false, }, } for _, tC := range testCases { t.Run(tC.desc, func(t *testing.T) { win.SetFocusVisible(tC.value) actual := win.GetFocusVisible() if tC.value != actual { t.Errorf("Expected '%t'; Got '%t'", tC.value, actual) } }) } } func TestWindowGetSetTypeHint(t *testing.T) { win := createTestWindow(t) var expected gdk.WindowTypeHint expected = gdk.WINDOW_TYPE_HINT_UTILITY win.SetTypeHint(expected) actual := win.GetTypeHint() if expected != actual { t.Errorf("Expected '%d'; Got '%d'", expected, actual) } } gotk3-0.6.2/gtk/windowgroup.go000066400000000000000000000052531431157473000162600ustar00rootroot00000000000000// Same copyright and license as the rest of the files in this project package gtk // #include // #include "gtk.go.h" import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/gdk" "github.com/gotk3/gotk3/glib" ) /* * GtkWindowGroup */ type WindowGroup struct { *glib.Object } // native returns a pointer to the underlying GtkWindowGroup. func (v *WindowGroup) native() *C.GtkWindowGroup { if v == nil || v.GObject == nil { return nil } p := unsafe.Pointer(v.GObject) return C.toGtkWindowGroup(p) } func marshalWindowGroup(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := glib.Take(unsafe.Pointer(c)) return wrapWindowGroup(obj), nil } func wrapWindowGroup(obj *glib.Object) *WindowGroup { if obj == nil { return nil } return &WindowGroup{obj} } // WindowGroupNew is a wrapper around gtk_window_group_new(). func WindowGroupNew() (*WindowGroup, error) { c := C.gtk_window_group_new() if c == nil { return nil, nilPtrErr } return wrapWindowGroup(glib.Take(unsafe.Pointer(c))), nil } // AddWindow is a wrapper around gtk_window_group_add_window(). func (v *WindowGroup) AddWindow(window IWindow) { var pw *C.GtkWindow = nil if window != nil { pw = window.toWindow() } C.gtk_window_group_add_window(v.native(), pw) } // RemoveWindow is a wrapper around gtk_window_group_remove_window(). func (v *WindowGroup) RemoveWindow(window IWindow) { var pw *C.GtkWindow = nil if window != nil { pw = window.toWindow() } C.gtk_window_group_remove_window(v.native(), pw) } // ListWindows is a wrapper around gtk_window_group_list_windows(). // Returned list is wrapped to return *gtk.Window elements. // TODO: Use IWindow and wrap to correct type func (v *WindowGroup) ListWindows() *glib.List { clist := C.gtk_window_group_list_windows(v.native()) if clist == nil { return nil } glist := glib.WrapList(uintptr(unsafe.Pointer(clist))) glist.DataWrapper(func(ptr unsafe.Pointer) interface{} { return wrapWindow(glib.Take(ptr)) }) runtime.SetFinalizer(glist, func(l *glib.List) { glib.FinalizerStrategy(l.Free) }) return glist } // GetCurrentGrab is a wrapper around gtk_window_group_get_current_grab(). func (v *WindowGroup) GetCurrentGrab() (IWidget, error) { c := C.gtk_window_group_get_current_grab(v.native()) if c == nil { return nil, nil } return castWidget(c) } // GetCurrentDeviceGrab is a wrapper around gtk_window_group_get_current_device_grab(). func (v *WindowGroup) GetCurrentDeviceGrab(device *gdk.Device) (IWidget, error) { c := C.gtk_window_group_get_current_device_grab(v.native(), C.toGdkDevice(unsafe.Pointer(device.Native()))) if c == nil { return nil, nil } return castWidget(c) } gotk3-0.6.2/internal/000077500000000000000000000000001431157473000143675ustar00rootroot00000000000000gotk3-0.6.2/internal/callback/000077500000000000000000000000001431157473000161235ustar00rootroot00000000000000gotk3-0.6.2/internal/callback/callback.go000066400000000000000000000007751431157473000202170ustar00rootroot00000000000000package callback import ( "sync" "github.com/gotk3/gotk3/internal/slab" ) var ( mutex sync.RWMutex registry slab.Slab ) func Assign(callback interface{}) uintptr { mutex.Lock() defer mutex.Unlock() return registry.Put(callback) } func Get(ptr uintptr) interface{} { mutex.RLock() defer mutex.RUnlock() return registry.Get(ptr) } func Delete(ptr uintptr) { GetAndDelete(ptr) } func GetAndDelete(ptr uintptr) interface{} { mutex.Lock() defer mutex.Unlock() return registry.Pop(ptr) } gotk3-0.6.2/internal/closure/000077500000000000000000000000001431157473000160435ustar00rootroot00000000000000gotk3-0.6.2/internal/closure/closure.go000066400000000000000000000044561431157473000200570ustar00rootroot00000000000000package closure import ( "sync" "unsafe" ) var ( closures = sync.Map{} // unsafe.Pointer(*GClosure) -> reflect.Value // use a bi-directional map to allow lookup of the closure value from both // the SourceHandle and the closure ID in constant time. signalMu sync.Mutex signalClosures = map[uint]unsafe.Pointer{} // uint(SourceHandle) -> uintptr (closure key, callbackID) closureSignals = map[unsafe.Pointer]uint{} // unsafe.Pointer(*GClosure) -> uint(SourceHandle) ) // RegisterSignal registers the given signal handle to be associated with the // closure pointer. This association allows the closure to be removed as well // when the signal removal is requested from the user using DisconnectSignal. func RegisterSignal(handle uint, closure unsafe.Pointer) { // Safety check omitted until the race condition in glib/connect.go is // fixed. Check that file for more info. signalMu.Lock() defer signalMu.Unlock() signalClosures[handle] = closure closureSignals[closure] = handle } // DisconnectSignal removes both the signal and the closure associated with it // from the internal registry. Since this function will also remove the closure // itself from the internal registry, Gtk's disconnect functions should be // called first. func DisconnectSignal(handle uint) { signalMu.Lock() defer signalMu.Unlock() closure, ok := signalClosures[handle] if ok { closures.Delete(closure) delete(closureSignals, closure) delete(signalClosures, handle) } } // Assign assigns the given FuncStack to the given closure. func Assign(closure unsafe.Pointer, fs FuncStack) { closures.Store(closure, fs) } // Get gets the reflect-value callback from the closure pointer. func Get(closure unsafe.Pointer) FuncStack { v, ok := closures.Load(closure) if ok { return v.(FuncStack) } return zeroFuncStack } // Delete deletes the closure pointer from the registry while also checking for // any existing signal handler associated with the given callback ID. If a // signal handler is found, then its behavior is similar to DisconnectSignal. func Delete(closure unsafe.Pointer) { funcStack := getAndDeleteClosure(closure) if !funcStack.IsValid() { return } signalMu.Lock() defer signalMu.Unlock() handle, ok := closureSignals[closure] if ok { delete(closureSignals, closure) delete(signalClosures, handle) } } gotk3-0.6.2/internal/closure/closure_go_1_14.go000066400000000000000000000003511431157473000212560ustar00rootroot00000000000000// +build !go1.15 package closure import "unsafe" func getAndDeleteClosure(closure unsafe.Pointer) FuncStack { v, ok := closures.Load(closure) if ok { closures.Delete(closure) return v.(FuncStack) } return zeroFuncStack } gotk3-0.6.2/internal/closure/closure_go_1_15.go000066400000000000000000000003261431157473000212610ustar00rootroot00000000000000// +build go1.15 package closure import "unsafe" func getAndDeleteClosure(closure unsafe.Pointer) FuncStack { v, ok := closures.LoadAndDelete(closure) if ok { return v.(FuncStack) } return zeroFuncStack } gotk3-0.6.2/internal/closure/funcstack.go000066400000000000000000000063461431157473000203640ustar00rootroot00000000000000package closure import ( "fmt" "reflect" "runtime" "strconv" "strings" "sync" ) // FrameSize is the number of frames that FuncStack should trace back from. const FrameSize = 3 // FuncStack wraps a function value and provides function frames containing the // caller trace for debugging. type FuncStack struct { Func reflect.Value Frames []uintptr } var zeroFuncStack = FuncStack{} // NewFuncStack creates a new FuncStack. It panics if fn is not a function. The // given frameSkip is added 2, meaning the first frame from 0 will start from // the caller of NewFuncStack. func NewFuncStack(fn interface{}, frameSkip int) FuncStack { // Create a reflect.Value from f. This is called when the returned // GClosure runs. rf := reflect.ValueOf(fn) // Closures can only be created from funcs. if rf.Type().Kind() != reflect.Func { panic("closure value is not a func") } frames := make([]uintptr, FrameSize) frames = frames[:runtime.Callers(frameSkip+2, frames)] return FuncStack{ Func: rf, Frames: frames, } } var ( idleTypeCache sync.Map idleTypeSentinel = struct{}{} ) // NewIdleFuncStack works akin to NewFuncStack, but it also validates the given // function type for the correct acceptable signatures for SourceFunc while also // caching the checks. func NewIdleFuncStack(fn interface{}, frameSkip int) FuncStack { fs := NewFuncStack(fn, frameSkip+1) funcType := fs.Func.Type() // LoadOrStore will actually ensure that only 1 check is done at a time, but // future checks on failed functions may trigger a late panic. _, checked := idleTypeCache.LoadOrStore(funcType, idleTypeSentinel) if checked { return fs } // Ensure no parameters prematurely. if funcType.NumIn() > 0 { fs.Panicf("timeout source should have no parameters") } // Ensure proper return types. switch out := funcType.NumOut(); out { case 0: break case 1: out0 := funcType.Out(0) if out0.Kind() != reflect.Bool { fs.Panicf("expected bool in return type, got %v", out0.Kind()) } default: fs.Panicf("unexpected return count (expecting 0 or 1): %d", out) } return fs } // IsValid returns true if the given FuncStack is not a zero-value i.e. valid. func (fs FuncStack) IsValid() bool { return fs.Frames != nil } const headerSignature = "closure error: " // Panicf panics with the given FuncStack printed to standard error. func (fs FuncStack) Panicf(msgf string, v ...interface{}) { msg := strings.Builder{} msg.WriteString(headerSignature) fmt.Fprintf(&msg, msgf, v...) msg.WriteString("\n\nClosure added at:") frames := runtime.CallersFrames(fs.Frames) for { frame, more := frames.Next() msg.WriteString("\n\t") msg.WriteString(frame.Function) msg.WriteString(" at ") msg.WriteString(frame.File) msg.WriteByte(':') msg.WriteString(strconv.Itoa(frame.Line)) if !more { break } } panic(msg.String()) } // TryRepanic attempts to recover a panic. If successful, it will re-panic with // the trace, or none if there is already one. func (fs FuncStack) TryRepanic() { panicking := recover() if panicking == nil { return } if msg, ok := panicking.(string); ok { if strings.HasPrefix(msg, headerSignature) { // We can just repanic as-is. panic(msg) } } fs.Panicf("unexpected panic caught: %v", panicking) } gotk3-0.6.2/internal/slab/000077500000000000000000000000001431157473000153105ustar00rootroot00000000000000gotk3-0.6.2/internal/slab/slab.go000066400000000000000000000020531431157473000165600ustar00rootroot00000000000000package slab type slabEntry struct { Value interface{} Index uintptr } func (entry slabEntry) IsValid() bool { return entry.Value != nil } // Slab is an implementation of the internal registry free list. A zero-value // instance is a valid instance. This data structure is not thread-safe. type Slab struct { entries []slabEntry free uintptr } func (s *Slab) Put(entry interface{}) uintptr { if s.free == uintptr(len(s.entries)) { index := uintptr(len(s.entries)) s.entries = append(s.entries, slabEntry{entry, 0}) s.free++ return index } index := s.free s.free = s.entries[index].Index s.entries[index] = slabEntry{entry, 0} return index } func (s *Slab) Get(i uintptr) interface{} { // Perform bound check. if i >= uintptr(len(s.entries)) { return nil } // Perform validity check in case of invalid ID. if entry := s.entries[i]; entry.IsValid() { return entry.Value } return nil } func (s *Slab) Pop(i uintptr) interface{} { popped := s.entries[i].Value s.entries[i] = slabEntry{nil, s.free} s.free = i return popped } gotk3-0.6.2/pango/000077500000000000000000000000001431157473000136575ustar00rootroot00000000000000gotk3-0.6.2/pango/fontconfig.go.h000066400000000000000000000002651431157473000165730ustar00rootroot00000000000000 #include static int addFont(unsigned char *font) { FcBool fontAddStatus = FcConfigAppFontAddFile(FcConfigGetCurrent(), font); return fontAddStatus; }gotk3-0.6.2/pango/pango-attributes.go000066400000000000000000000364321431157473000175060ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package pango // #include // #include "pango.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.pango_attr_type_get_type()), marshalAttrType}, {glib.Type(C.pango_underline_get_type()), marshalUnderline}, } glib.RegisterGValueMarshalers(tm) } /* PangoColor */ // Color is a representation of PangoColor. type Color struct { pangoColor *C.PangoColor } // Native returns a pointer to the underlying PangoColor. func (v *Color) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *Color) native() *C.PangoColor { return (*C.PangoColor)(unsafe.Pointer(v.pangoColor)) } // Set sets the new values for the red, green, and blue color properties. func (v *Color) Set(red, green, blue uint16) { v.native().red = C.guint16(red) v.native().green = C.guint16(green) v.native().blue = C.guint16(blue) } // Get returns the red, green, and blue color values. func (v *Color) Get() (red, green, blue uint16) { return uint16(v.native().red), uint16(v.native().green), uint16(v.native().blue) } // Copy is a wrapper around "pango_color_copy". func (v *Color) Copy(c *Color) *Color { w := new(Color) w.pangoColor = C.pango_color_copy(v.native()) return w } // Free is a wrapper around "pango_color_free". func (v *Color) Free() { C.pango_color_free(v.native()) } // Parse is a wrapper around "pango_color_parse". func (v *Color) Parse(spec string) bool { cstr := C.CString(spec) defer C.free(unsafe.Pointer(cstr)) c := C.pango_color_parse(v.native(), (*C.char)(cstr)) return gobool(c) } // ToString is a wrapper around "pango_color_to_string". func (v *Color) ToString() string { c := C.pango_color_to_string(v.native()) return C.GoString((*C.char)(c)) } /* --- --- --- Attributes --- --- --- */ // AttrList is a representation of PangoAttrList. type AttrList struct { internal *C.PangoAttrList } // Native returns a pointer to the underlying PangoLayout. func (v *AttrList) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *AttrList) native() *C.PangoAttrList { return C.toPangoAttrList(unsafe.Pointer(v.internal)) } func wrapAttrList(c *C.PangoAttrList) *AttrList { if c == nil { return nil } return &AttrList{c} } // WrapAttrList wraps a unsafe.Pointer as a AttrList. // This function is exported for visibility in other gotk3 packages and // is not meant to be used by applications. func WrapAttrList(ptr unsafe.Pointer) *AttrList { internal := C.toPangoAttrList(ptr) if internal == nil { return nil } return &AttrList{internal} } // Insert is a wrapper around "pango_attr_list_insert". func (v *AttrList) Insert(attribute *Attribute) { C.pango_attr_list_insert(v.internal, attribute.native()) } // GetAttributes is a wrapper around "pango_attr_list_get_attributes". func (v *AttrList) GetAttributes() (*glib.SList, error) { orig := C.pango_attr_list_get_iterator(v.internal) iter := C.pango_attr_iterator_copy(orig) gslist := (*C.struct__GSList)(C.pango_attr_iterator_get_attrs(iter)) list := glib.WrapSList(uintptr(unsafe.Pointer(gslist))) if list == nil { return nil, nilPtrErr } list.DataWrapper(func(ptr unsafe.Pointer) interface{} { return &Attribute{(*C.PangoAttribute)(ptr)} }) return list, nil } // AttrListNew is a wrapper around "pango_attr_list_new". func AttrListNew() *AttrList { c := C.pango_attr_list_new() return wrapAttrList(c) } // AttrType is a representation of Pango's PangoAttrType. type AttrType int const ( ATTR_INVALID AttrType = C.PANGO_ATTR_INVALID /* 0 is an invalid attribute type */ ATTR_LANGUAGE AttrType = C.PANGO_ATTR_LANGUAGE /* PangoAttrLanguage */ ATTR_FAMILY AttrType = C.PANGO_ATTR_FAMILY /* PangoAttrString */ ATTR_STYLE AttrType = C.PANGO_ATTR_STYLE /* PangoAttrInt */ ATTR_WEIGHT AttrType = C.PANGO_ATTR_WEIGHT /* PangoAttrInt */ ATTR_VARIANT AttrType = C.PANGO_ATTR_VARIANT /* PangoAttrInt */ ATTR_STRETCH AttrType = C.PANGO_ATTR_STRETCH /* PangoAttrInt */ ATTR_SIZE AttrType = C.PANGO_ATTR_SIZE /* PangoAttrSize */ ATTR_FONT_DESC AttrType = C.PANGO_ATTR_FONT_DESC /* PangoAttrFontDesc */ ATTR_FOREGROUND AttrType = C.PANGO_ATTR_FOREGROUND /* PangoAttrColor */ ATTR_BACKGROUND AttrType = C.PANGO_ATTR_BACKGROUND /* PangoAttrColor */ ATTR_UNDERLINE AttrType = C.PANGO_ATTR_UNDERLINE /* PangoAttrInt */ ATTR_STRIKETHROUGH AttrType = C.PANGO_ATTR_STRIKETHROUGH /* PangoAttrInt */ ATTR_RISE AttrType = C.PANGO_ATTR_RISE /* PangoAttrInt */ ATTR_SHAPE AttrType = C.PANGO_ATTR_SHAPE /* PangoAttrShape */ ATTR_SCALE AttrType = C.PANGO_ATTR_SCALE /* PangoAttrFloat */ ATTR_FALLBACK AttrType = C.PANGO_ATTR_FALLBACK /* PangoAttrInt */ ATTR_LETTER_SPACING AttrType = C.PANGO_ATTR_LETTER_SPACING /* PangoAttrInt */ ATTR_UNDERLINE_COLOR AttrType = C.PANGO_ATTR_UNDERLINE_COLOR /* PangoAttrColor */ ATTR_STRIKETHROUGH_COLOR AttrType = C.PANGO_ATTR_STRIKETHROUGH_COLOR /* PangoAttrColor */ ATTR_ABSOLUTE_SIZE AttrType = C.PANGO_ATTR_ABSOLUTE_SIZE /* PangoAttrSize */ ATTR_GRAVITY AttrType = C.PANGO_ATTR_GRAVITY /* PangoAttrInt */ ATTR_GRAVITY_HINT AttrType = C.PANGO_ATTR_GRAVITY_HINT /* PangoAttrInt */ ) func marshalAttrType(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return AttrType(c), nil } // Underline is a representation of Pango's PangoUnderline. type Underline int const ( UNDERLINE_NONE Underline = C.PANGO_UNDERLINE_NONE UNDERLINE_SINGLE Underline = C.PANGO_UNDERLINE_SINGLE UNDERLINE_DOUBLE Underline = C.PANGO_UNDERLINE_DOUBLE UNDERLINE_LOW Underline = C.PANGO_UNDERLINE_LOW UNDERLINE_ERROR Underline = C.PANGO_UNDERLINE_ERROR ) func marshalUnderline(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Underline(c), nil } const ( ATTR_INDEX_FROM_TEXT_BEGINNING uint = 0 ATTR_INDEX_TO_TEXT_END uint = C.G_MAXUINT ) // Attribute is a representation of Pango's PangoAttribute. type Attribute struct { internal *C.PangoAttribute } // Native returns a pointer to the underlying PangoColor. func (v *Attribute) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *Attribute) native() *C.PangoAttribute { return (*C.PangoAttribute)(unsafe.Pointer(v.internal)) } // GetStartIndex returns the index of the start of the attribute application in the text. func (v *Attribute) GetStartIndex() uint { return uint(v.internal.start_index) } // SetStartIndex sets the index of the start of the attribute application in the text. func (v *Attribute) SetStartIndex(setting uint) { v.internal.start_index = C.guint(setting) } // GetEndIndex returns the index of the end of the attribute application in the text. func (v *Attribute) GetEndIndex() uint { return uint(v.internal.end_index) } // SetEndIndex the index of the end of the attribute application in the text. func (v *Attribute) SetEndIndex(setting uint) { v.internal.end_index = C.guint(setting) } /* //typedef gboolean (*PangoAttrFilterFunc) (PangoAttribute *attribute, // gpointer user_data); func (v *Attribute) AttrFilterFunc(user_data uintptr) bool { c := C.PangoAttrFilterFunc(Attribute.native(), C.gpointer(user_data)) return gobool(c) } //typedef gpointer (*PangoAttrDataCopyFunc) (gconstpointer user_data); func AttrDataCopyFunc(user_data uintptr) uintptr { c := C.PangoAttrDataCopyFunc(C.gpointer(user_data)) return uintptr(c) } */ // AttrClass is a representation of Pango's PangoAttrClass. type AttrClass struct { //PangoAttrType type; } // AttrString is a representation of Pango's PangoAttrString. type AttrString struct { Attribute //char *value; } // AttrLanguage is a representation of Pango's PangoAttrLanguage. type AttrLanguage struct { Attribute //PangoLanguage *value; } // AttrInt is a representation of Pango's PangoAttrInt. type AttrInt struct { Attribute //int value; } // AttrFloat is a representation of Pango's PangoAttrFloat. type AttrFloat struct { Attribute //double value; } // AttrColor is a representation of Pango's AttrColor. type AttrColor struct { Attribute Color } // AttrSize is a representation of Pango's PangoAttrSize. type AttrSize struct { Attribute //int size; //guint absolute : 1; } // AttrShape is a representation of Pango's PangoAttrShape. type AttrShape struct { Attribute //PangoRectangle ink_rect; //PangoRectangle logical_rect; //gpointer data; //PangoAttrDataCopyFunc copy_func; //GDestroyNotify destroy_func; } // AttrFontDesc is a representation of Pango's PangoAttrFontDesc. type AttrFontDesc struct { Attribute //PangoFontDescription *desc; } /* PangoAttrType pango_attr_type_register (const gchar *name); const char * pango_attr_type_get_name (PangoAttrType type) G_GNUC_CONST; void pango_attribute_init (PangoAttribute *attr, const PangoAttrClass *klass); PangoAttribute * pango_attribute_copy (const PangoAttribute *attr); void pango_attribute_destroy (PangoAttribute *attr); gboolean pango_attribute_equal (const PangoAttribute *attr1, const PangoAttribute *attr2) G_GNUC_PURE; PangoAttribute *pango_attr_language_new (PangoLanguage *language); PangoAttribute *pango_attr_family_new (const char *family); PangoAttribute *pango_attr_foreground_new (guint16 red, guint16 green, guint16 blue); PangoAttribute *pango_attr_background_new (guint16 red, guint16 green, guint16 blue); PangoAttribute *pango_attr_size_new (int size); PangoAttribute *pango_attr_size_new_absolute (int size); PangoAttribute *pango_attr_style_new (PangoStyle style); PangoAttribute *pango_attr_weight_new (PangoWeight weight); PangoAttribute *pango_attr_variant_new (PangoVariant variant); PangoAttribute *pango_attr_stretch_new (PangoStretch stretch); PangoAttribute *pango_attr_font_desc_new (const PangoFontDescription *desc); PangoAttribute *pango_attr_underline_new (PangoUnderline underline); PangoAttribute *pango_attr_underline_color_new (guint16 red, guint16 green, guint16 blue); PangoAttribute *pango_attr_strikethrough_new (gboolean strikethrough); PangoAttribute *pango_attr_strikethrough_color_new (guint16 red, guint16 green, guint16 blue); PangoAttribute *pango_attr_rise_new (int rise); PangoAttribute *pango_attr_scale_new (double scale_factor); PangoAttribute *pango_attr_fallback_new (gboolean enable_fallback); PangoAttribute *pango_attr_letter_spacing_new (int letter_spacing); PangoAttribute *pango_attr_shape_new (const PangoRectangle *ink_rect, const PangoRectangle *logical_rect); PangoAttribute *pango_attr_shape_new_with_data (const PangoRectangle *ink_rect, const PangoRectangle *logical_rect, gpointer data, PangoAttrDataCopyFunc copy_func, GDestroyNotify destroy_func); PangoAttribute *pango_attr_gravity_new (PangoGravity gravity); PangoAttribute *pango_attr_gravity_hint_new (PangoGravityHint hint); GType pango_attr_list_get_type (void) G_GNUC_CONST; PangoAttrList * pango_attr_list_new (void); PangoAttrList * pango_attr_list_ref (PangoAttrList *list); void pango_attr_list_unref (PangoAttrList *list); PangoAttrList * pango_attr_list_copy (PangoAttrList *list); void pango_attr_list_insert (PangoAttrList *list, PangoAttribute *attr); void pango_attr_list_insert_before (PangoAttrList *list, PangoAttribute *attr); void pango_attr_list_change (PangoAttrList *list, PangoAttribute *attr); void pango_attr_list_splice (PangoAttrList *list, PangoAttrList *other, gint pos, gint len); PangoAttrList *pango_attr_list_filter (PangoAttrList *list, PangoAttrFilterFunc func, gpointer data); PangoAttrIterator *pango_attr_list_get_iterator (PangoAttrList *list); void pango_attr_iterator_range (PangoAttrIterator *iterator, gint *start, gint *end); gboolean pango_attr_iterator_next (PangoAttrIterator *iterator); PangoAttrIterator *pango_attr_iterator_copy (PangoAttrIterator *iterator); void pango_attr_iterator_destroy (PangoAttrIterator *iterator); PangoAttribute * pango_attr_iterator_get (PangoAttrIterator *iterator, PangoAttrType type); void pango_attr_iterator_get_font (PangoAttrIterator *iterator, PangoFontDescription *desc, PangoLanguage **language, GSList **extra_attrs); GSList * pango_attr_iterator_get_attrs (PangoAttrIterator *iterator); gboolean pango_parse_markup (const char *markup_text, int length, gunichar accel_marker, PangoAttrList **attr_list, char **text, gunichar *accel_char, GError **error); GMarkupParseContext * pango_markup_parser_new (gunichar accel_marker); gboolean pango_markup_parser_finish (GMarkupParseContext *context, PangoAttrList **attr_list, char **text, gunichar *accel_char, GError **error); */ gotk3-0.6.2/pango/pango-attributes.go.h000066400000000000000000000021021431157473000177170ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include #include #include static PangoColor * toPangoColor(void *p) { return ((PangoColor *)(p)); } static PangoAttrList * toPangoAttrList(void *p) { return ((PangoAttrList *)(p)); } gotk3-0.6.2/pango/pango-attributes_since_1_44.go000066400000000000000000000006011431157473000214030ustar00rootroot00000000000000// +build !pango_1_36,!pango_1_38,!pango_1_40,!pango_1_42 package pango // #include // #include "pango.go.h" import "C" var ( ATTR_INSERT_HYPHENS AttrType = C.PANGO_ATTR_INSERT_HYPHENS ) func AttrInsertHyphensNew(insertHyphens bool) *Attribute { c := C.pango_attr_insert_hyphens_new(gbool(insertHyphens)) attr := new(Attribute) attr.internal = c return attr } gotk3-0.6.2/pango/pango-context.go000066400000000000000000000132031431157473000167730ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package pango // #include // #include "pango.go.h" import "C" import ( "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums // {glib.Type(C.pango_alignment_get_type()), marshalAlignment}, // {glib.Type(C.pango_ellipsize_mode_get_type()), marshalEllipsizeMode}, // {glib.Type(C.pango_wrap_mode_get_type()), marshalWrapMode}, // Objects/Interfaces // {glib.Type(C.pango_context_get_type()), marshalContext}, } glib.RegisterGValueMarshalers(tm) } // Context is a representation of PangoContext. type Context struct { pangoContext *C.PangoContext } // Native returns a pointer to the underlying PangoLayout. func (v *Context) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *Context) native() *C.PangoContext { return (*C.PangoContext)(unsafe.Pointer(v.pangoContext)) } /* func marshalContext(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := wrapObject(unsafe.Pointer(c)) return wrapContext(obj), nil } func wrapContext(obj *glib.Object) *Context { return &Context{obj} } */ func WrapContext(p uintptr) *Context { context := new(Context) context.pangoContext = (*C.PangoContext)(unsafe.Pointer(p)) return context } //PangoContext *pango_context_new (void); func ContextNew() *Context { c := C.pango_context_new() context := new(Context) context.pangoContext = (*C.PangoContext)(c) return context } //void pango_context_changed (PangoContext *context); //void pango_context_set_font_map (PangoContext *context, // PangoFontMap *font_map); //PangoFontMap *pango_context_get_font_map (PangoContext *context); //guint pango_context_get_serial (PangoContext *context); //void pango_context_list_families (PangoContext *context, // PangoFontFamily ***families, // int *n_families); //PangoFont * pango_context_load_font (PangoContext *context, // const PangoFontDescription *desc); //PangoFontset *pango_context_load_fontset (PangoContext *context, // const PangoFontDescription *desc, // PangoLanguage *language); // //PangoFontMetrics *pango_context_get_metrics (PangoContext *context, // const PangoFontDescription *desc, // PangoLanguage *language); // //void pango_context_set_font_description (PangoContext *context, // const PangoFontDescription *desc); //PangoFontDescription * pango_context_get_font_description (PangoContext *context); //PangoLanguage *pango_context_get_language (PangoContext *context); //void pango_context_set_language (PangoContext *context, // PangoLanguage *language); //void pango_context_set_base_dir (PangoContext *context, // PangoDirection direction); //PangoDirection pango_context_get_base_dir (PangoContext *context); //void pango_context_set_base_gravity (PangoContext *context, // PangoGravity gravity); //PangoGravity pango_context_get_base_gravity (PangoContext *context); //PangoGravity pango_context_get_gravity (PangoContext *context); //void pango_context_set_gravity_hint (PangoContext *context, // PangoGravityHint hint); //PangoGravityHint pango_context_get_gravity_hint (PangoContext *context); // //void pango_context_set_matrix (PangoContext *context, // const PangoMatrix *matrix); //const PangoMatrix * pango_context_get_matrix (PangoContext *context); /* Break a string of Unicode characters into segments with * consistent shaping/language engine and bidrectional level. * Returns a #GList of #PangoItem's */ //GList *pango_itemize (PangoContext *context, // const char *text, // int start_index, // int length, // PangoAttrList *attrs, // PangoAttrIterator *cached_iter); //GList *pango_itemize_with_base_dir (PangoContext *context, // PangoDirection base_dir, // const char *text, // int start_index, // int length, // PangoAttrList *attrs, // PangoAttrIterator *cached_iter); gotk3-0.6.2/pango/pango-font.go000066400000000000000000000633041431157473000162640ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package pango // #include // #include "pango.go.h" // #include "fontconfig.go.h" import "C" import ( // "github.com/andre-hub/gotk3/glib" // "github.com/andre-hub/gotk3/cairo" "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums // Objects/Interfaces {glib.Type(C.pango_font_description_get_type()), marshalFontDescription}, } glib.RegisterGValueMarshalers(tm) } // AddFont adds the font to the configuration. func AddFont(fontPath string) { path := (*C.uchar)(unsafe.Pointer(C.CString(fontPath))) C.addFont(path) } // FontDescription is a representation of PangoFontDescription. type FontDescription struct { pangoFontDescription *C.PangoFontDescription } // Native returns a pointer to the underlying PangoLayout. func (v *FontDescription) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *FontDescription) native() *C.PangoFontDescription { return (*C.PangoFontDescription)(unsafe.Pointer(v.pangoFontDescription)) } // FontMetrics is a representation of PangoFontMetrics. type FontMetrics struct { pangoFontMetrics *C.PangoFontMetrics } // Native returns a pointer to the underlying PangoLayout. func (v *FontMetrics) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *FontMetrics) native() *C.PangoFontMetrics { return (*C.PangoFontMetrics)(unsafe.Pointer(v.pangoFontMetrics)) } const ( PANGO_SCALE = C.PANGO_SCALE ) type Style int const ( STYLE_NORMAL Style = C.PANGO_STYLE_NORMAL STYLE_OBLIQUE Style = C.PANGO_STYLE_OBLIQUE STYLE_ITALIC Style = C.PANGO_STYLE_ITALIC ) type Variant int const ( VARIANT_NORMAL Variant = C.PANGO_VARIANT_NORMAL VARIANT_SMALL_CAPS Variant = C.PANGO_VARIANT_SMALL_CAPS ) type Weight int const ( WEIGHT_THIN Weight = C.PANGO_WEIGHT_THIN /* 100 */ WEIGHT_ULTRALIGHT Weight = C.PANGO_WEIGHT_ULTRALIGHT /* 200 */ WEIGHT_LIGHT Weight = C.PANGO_WEIGHT_LIGHT /* 300 */ WEIGHT_SEMILIGHT Weight = 350 /* 350 */ WEIGHT_BOOK Weight = C.PANGO_WEIGHT_BOOK /* 380 */ WEIGHT_NORMAL Weight = C.PANGO_WEIGHT_NORMAL /* 400 */ WEIGHT_MEDIUM Weight = C.PANGO_WEIGHT_MEDIUM /* 500 */ WEIGHT_SEMIBOLD Weight = C.PANGO_WEIGHT_SEMIBOLD /* 600 */ WEIGHT_BOLD Weight = C.PANGO_WEIGHT_BOLD /* 700 */ WEIGHT_ULTRABOLD Weight = C.PANGO_WEIGHT_ULTRABOLD /* 800 */ WEIGHT_HEAVY Weight = C.PANGO_WEIGHT_HEAVY /* 900 */ WEIGHT_ULTRAHEAVY Weight = C.PANGO_WEIGHT_ULTRAHEAVY /* 1000 */ ) type Stretch int const ( STRETCH_ULTRA_CONDENSED Stretch = C.PANGO_STRETCH_ULTRA_CONDENSED STRETCH_EXTRA_CONDENSEDStretch Stretch = C.PANGO_STRETCH_EXTRA_CONDENSED STRETCH_CONDENSEDStretch Stretch = C.PANGO_STRETCH_CONDENSED STRETCH_SEMI_CONDENSEDStretch Stretch = C.PANGO_STRETCH_SEMI_CONDENSED STRETCH_NORMALStretch Stretch = C.PANGO_STRETCH_NORMAL STRETCH_SEMI_EXPANDEDStretch Stretch = C.PANGO_STRETCH_SEMI_EXPANDED STRETCH_EXPANDEDStretch Stretch = C.PANGO_STRETCH_EXPANDED STRETCH_EXTRA_EXPANDEDStretch Stretch = C.PANGO_STRETCH_EXTRA_EXPANDED STRETCH_ULTRA_EXPANDEDStretch Stretch = C.PANGO_STRETCH_ULTRA_EXPANDED ) type FontMask int const ( FONT_MASK_FAMILY FontMask = C.PANGO_FONT_MASK_FAMILY /* 1 << 0 */ FONT_MASK_STYLEFontMask FontMask = C.PANGO_FONT_MASK_STYLE /* 1 << 1 */ FONT_MASK_VARIANTFontMask FontMask = C.PANGO_FONT_MASK_VARIANT /* 1 << 2 */ FONT_MASK_WEIGHTFontMask FontMask = C.PANGO_FONT_MASK_WEIGHT /* 1 << 3 */ FONT_MASK_STRETCHFontMask FontMask = C.PANGO_FONT_MASK_STRETCH /* 1 << 4 */ FONT_MASK_SIZEFontMask FontMask = C.PANGO_FONT_MASK_SIZE /* 1 << 5 */ FONT_MASK_GRAVITYFontMask FontMask = C.PANGO_FONT_MASK_GRAVITY /* 1 << 6 */ ) type Scale float64 const ( SCALE_XX_SMALL Scale = /* C.PANGO_SCALE_XX_SMALL */ 0.5787037037037 SCALE_X_SMALL Scale = /*C.PANGO_SCALE_X_SMALL */ 0.6444444444444 SCALE_SMALL Scale = /*C.PANGO_SCALE_SMALL */ 0.8333333333333 SCALE_MEDIUM Scale = /*C.PANGO_SCALE_MEDIUM */ 1.0 SCALE_LARGE Scale = /*C.PANGO_SCALE_LARGE */ 1.2 SCALE_X_LARGE Scale = /*C.PANGO_SCALE_X_LARGE */ 1.4399999999999 SCALE_XX_LARGE Scale = /*C.PANGO_SCALE_XX_LARGE */ 1.728 ) /* * PangoFontDescription */ func marshalFontDescription(p uintptr) (interface{}, error) { c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p))) c2 := (*C.PangoFontDescription)(unsafe.Pointer(c)) return wrapFontDescription(c2), nil } func wrapFontDescription(obj *C.PangoFontDescription) *FontDescription { return &FontDescription{obj} } //PangoFontDescription *pango_font_description_new (void); func FontDescriptionNew() *FontDescription { c := C.pango_font_description_new() v := new(FontDescription) v.pangoFontDescription = c return v } //PangoFontDescription *pango_font_description_copy (const PangoFontDescription *desc); func (v *FontDescription) Copy() *FontDescription { c := C.pango_font_description_copy(v.native()) v2 := new(FontDescription) v2.pangoFontDescription = c return v2 } //PangoFontDescription *pango_font_description_copy_static (const PangoFontDescription *desc); func (v *FontDescription) CopyStatic() *FontDescription { c := C.pango_font_description_copy_static(v.native()) v2 := new(FontDescription) v2.pangoFontDescription = c return v2 } //guint pango_font_description_hash (const PangoFontDescription *desc) G_GNUC_PURE; func (v *FontDescription) Hash() uint { c := C.pango_font_description_hash(v.native()) return uint(c) } //gboolean pango_font_description_equal (const PangoFontDescription *desc1, // const PangoFontDescription *desc2) G_GNUC_PURE; func (v *FontDescription) Equal(v2 *FontDescription) bool { c := C.pango_font_description_equal(v.native(), v2.native()) return gobool(c) } //void pango_font_description_free (PangoFontDescription *desc); func (v *FontDescription) Free() { C.pango_font_description_free(v.native()) } //void pango_font_descriptions_free (PangoFontDescription **descs, // int n_descs); //func (v *FontDescription) FontDescriptionsFree(n_descs int) { // C.pango_font_descriptions_free(v.native(), C.int(n_descs)) //} //void pango_font_description_set_family (PangoFontDescription *desc, // const char *family); func (v *FontDescription) SetFamily(family string) { cstr := C.CString(family) defer C.free(unsafe.Pointer(cstr)) C.pango_font_description_set_family(v.native(), (*C.char)(cstr)) } //void pango_font_description_set_family_static (PangoFontDescription *desc, // const char *family); func (v *FontDescription) SetFamilyStatic(family string) { cstr := C.CString(family) defer C.free(unsafe.Pointer(cstr)) C.pango_font_description_set_family_static(v.native(), (*C.char)(cstr)) } //const char *pango_font_description_get_family (const PangoFontDescription *desc) G_GNUC_PURE; func (v *FontDescription) GetFamily() string { c := C.pango_font_description_get_family(v.native()) return C.GoString((*C.char)(c)) } //void pango_font_description_set_style (PangoFontDescription *desc, // PangoStyle style); func (v *FontDescription) SetStyle(style Style) { C.pango_font_description_set_style(v.native(), (C.PangoStyle)(style)) } //PangoStyle pango_font_description_get_style (const PangoFontDescription *desc) G_GNUC_PURE; func (v *FontDescription) GetStyle() Style { c := C.pango_font_description_get_style(v.native()) return Style(c) } //void pango_font_description_set_variant (PangoFontDescription *desc, // PangoVariant variant); func (v *FontDescription) SetVariant(variant Variant) { C.pango_font_description_set_variant(v.native(), (C.PangoVariant)(variant)) } //PangoVariant pango_font_description_get_variant (const PangoFontDescription *desc) G_GNUC_PURE; func (v *FontDescription) GetVariant() Variant { c := C.pango_font_description_get_variant(v.native()) return Variant(c) } //void pango_font_description_set_weight (PangoFontDescription *desc, // PangoWeight weight); func (v *FontDescription) SetWeight(weight Weight) { C.pango_font_description_set_weight(v.native(), (C.PangoWeight)(weight)) } //PangoWeight pango_font_description_get_weight (const PangoFontDescription *desc) G_GNUC_PURE; func (v *FontDescription) GetWeight() Weight { c := C.pango_font_description_get_weight(v.native()) return Weight(c) } //void pango_font_description_set_stretch (PangoFontDescription *desc, // PangoStretch stretch); func (v *FontDescription) SetStretch(stretch Stretch) { C.pango_font_description_set_stretch(v.native(), (C.PangoStretch)(stretch)) } //PangoStretch pango_font_description_get_stretch (const PangoFontDescription *desc) G_GNUC_PURE; func (v *FontDescription) GetStretch() Stretch { c := C.pango_font_description_get_stretch(v.native()) return Stretch(c) } //void pango_font_description_set_size (PangoFontDescription *desc, // gint size); func (v *FontDescription) SetSize(size int) { C.pango_font_description_set_size(v.native(), (C.gint)(size)) } //gint pango_font_description_get_size (const PangoFontDescription *desc) G_GNUC_PURE; func (v *FontDescription) GetSize() int { c := C.pango_font_description_get_size(v.native()) return int(c) } //void pango_font_description_set_absolute_size (PangoFontDescription *desc, // double size); func (v *FontDescription) SetAbsoluteSize(size float64) { C.pango_font_description_set_absolute_size(v.native(), (C.double)(size)) } //gboolean pango_font_description_get_size_is_absolute (const PangoFontDescription *desc) G_GNUC_PURE; func (v *FontDescription) GetSizeIsAbsolute() bool { c := C.pango_font_description_get_size_is_absolute(v.native()) return gobool(c) } //void pango_font_description_set_gravity (PangoFontDescription *desc, // PangoGravity gravity); func (v *FontDescription) SetGravity(gravity Gravity) { C.pango_font_description_set_gravity(v.native(), (C.PangoGravity)(gravity)) } //PangoGravity pango_font_description_get_gravity (const PangoFontDescription *desc) G_GNUC_PURE; func (v *FontDescription) GetGravity() Gravity { c := C.pango_font_description_get_gravity(v.native()) return Gravity(c) } //PangoFontMask pango_font_description_get_set_fields (const PangoFontDescription *desc) G_GNUC_PURE; func (v *FontDescription) GetSetFields() FontMask { c := C.pango_font_description_get_set_fields(v.native()) return FontMask(c) } //void pango_font_description_unset_fields (PangoFontDescription *desc, // PangoFontMask to_unset); func (v *FontDescription) GetUnsetFields(to_unset FontMask) { C.pango_font_description_unset_fields(v.native(), (C.PangoFontMask)(to_unset)) } //void pango_font_description_merge (PangoFontDescription *desc, // const PangoFontDescription *desc_to_merge, // gboolean replace_existing); func (v *FontDescription) Merge(desc_to_merge *FontDescription, replace_existing bool) { C.pango_font_description_merge(v.native(), desc_to_merge.native(), gbool(replace_existing)) } //void pango_font_description_merge_static (PangoFontDescription *desc, // const PangoFontDescription *desc_to_merge, // gboolean replace_existing); func (v *FontDescription) MergeStatic(desc_to_merge *FontDescription, replace_existing bool) { C.pango_font_description_merge_static(v.native(), desc_to_merge.native(), gbool(replace_existing)) } //gboolean pango_font_description_better_match (const PangoFontDescription *desc, // const PangoFontDescription *old_match, // const PangoFontDescription *new_match) G_GNUC_PURE; func (v *FontDescription) BetterMatch(old_match, new_match *FontDescription) bool { c := C.pango_font_description_better_match(v.native(), old_match.native(), new_match.native()) return gobool(c) } //PangoFontDescription *pango_font_description_from_string (const char *str); func FontDescriptionFromString(str string) *FontDescription { cstr := C.CString(str) defer C.free(unsafe.Pointer(cstr)) c := C.pango_font_description_from_string((*C.char)(cstr)) v := new(FontDescription) v.pangoFontDescription = c return v } //char * pango_font_description_to_string (const PangoFontDescription *desc); func (v *FontDescription) ToString() string { c := C.pango_font_description_to_string(v.native()) return C.GoString((*C.char)(c)) } //char * pango_font_description_to_filename (const PangoFontDescription *desc); func (v *FontDescription) ToFilename() string { c := C.pango_font_description_to_filename(v.native()) return C.GoString((*C.char)(c)) } ///* // * PangoFontMetrics // */ // ///** // * PANGO_TYPE_FONT_METRICS: // * // * The #GObject type for #PangoFontMetrics. // */ //#define PANGO_TYPE_FONT_METRICS (pango_font_metrics_get_type ()) //GType pango_font_metrics_get_type (void) G_GNUC_CONST; //PangoFontMetrics *pango_font_metrics_ref (PangoFontMetrics *metrics); //void pango_font_metrics_unref (PangoFontMetrics *metrics); //int pango_font_metrics_get_ascent (PangoFontMetrics *metrics) G_GNUC_PURE; //int pango_font_metrics_get_descent (PangoFontMetrics *metrics) G_GNUC_PURE; //int pango_font_metrics_get_approximate_char_width (PangoFontMetrics *metrics) G_GNUC_PURE; //int pango_font_metrics_get_approximate_digit_width (PangoFontMetrics *metrics) G_GNUC_PURE; //int pango_font_metrics_get_underline_position (PangoFontMetrics *metrics) G_GNUC_PURE; //int pango_font_metrics_get_underline_thickness (PangoFontMetrics *metrics) G_GNUC_PURE; //int pango_font_metrics_get_strikethrough_position (PangoFontMetrics *metrics) G_GNUC_PURE; //int pango_font_metrics_get_strikethrough_thickness (PangoFontMetrics *metrics) G_GNUC_PURE; // //#ifdef PANGO_ENABLE_BACKEND // //PangoFontMetrics *pango_font_metrics_new (void); // //struct _PangoFontMetrics //{ // guint ref_count; // // int ascent; // int descent; // int approximate_char_width; // int approximate_digit_width; // int underline_position; // int underline_thickness; // int strikethrough_position; // int strikethrough_thickness; //}; // //#endif /* PANGO_ENABLE_BACKEND */ // ///* // * PangoFontFamily // */ // ///** // * PANGO_TYPE_FONT_FAMILY: // * // * The #GObject type for #PangoFontFamily. // */ ///** // * PANGO_FONT_FAMILY: // * @object: a #GObject. // * // * Casts a #GObject to a #PangoFontFamily. // */ ///** // * PANGO_IS_FONT_FAMILY: // * @object: a #GObject. // * // * Returns: %TRUE if @object is a #PangoFontFamily. // */ //#define PANGO_TYPE_FONT_FAMILY (pango_font_family_get_type ()) //#define PANGO_FONT_FAMILY(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FAMILY, PangoFontFamily)) //#define PANGO_IS_FONT_FAMILY(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FAMILY)) // //typedef struct _PangoFontFamily PangoFontFamily; //typedef struct _PangoFontFace PangoFontFace; // //GType pango_font_family_get_type (void) G_GNUC_CONST; // //void pango_font_family_list_faces (PangoFontFamily *family, // PangoFontFace ***faces, // int *n_faces); //const char *pango_font_family_get_name (PangoFontFamily *family) G_GNUC_PURE; //gboolean pango_font_family_is_monospace (PangoFontFamily *family) G_GNUC_PURE; // //#ifdef PANGO_ENABLE_BACKEND // //#define PANGO_FONT_FAMILY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_FAMILY, PangoFontFamilyClass)) //#define PANGO_IS_FONT_FAMILY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_FAMILY)) //#define PANGO_FONT_FAMILY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_FAMILY, PangoFontFamilyClass)) // //typedef struct _PangoFontFamilyClass PangoFontFamilyClass; // // ///** // * PangoFontFamily: // * // * The #PangoFontFamily structure is used to represent a family of related // * font faces. The faces in a family share a common design, but differ in // * slant, weight, width and other aspects. // */ //struct _PangoFontFamily //{ // GObject parent_instance; //}; // //struct _PangoFontFamilyClass //{ // GObjectClass parent_class; // // /*< public >*/ // // void (*list_faces) (PangoFontFamily *family, // PangoFontFace ***faces, // int *n_faces); // const char * (*get_name) (PangoFontFamily *family); // gboolean (*is_monospace) (PangoFontFamily *family); // // /*< private >*/ // // /* Padding for future expansion */ // void (*_pango_reserved2) (void); // void (*_pango_reserved3) (void); // void (*_pango_reserved4) (void); //}; // //#endif /* PANGO_ENABLE_BACKEND */ // ///* // * PangoFontFace // */ // ///** // * PANGO_TYPE_FONT_FACE: // * // * The #GObject type for #PangoFontFace. // */ ///** // * PANGO_FONT_FACE: // * @object: a #GObject. // * // * Casts a #GObject to a #PangoFontFace. // */ ///** // * PANGO_IS_FONT_FACE: // * @object: a #GObject. // * // * Returns: %TRUE if @object is a #PangoFontFace. // */ //#define PANGO_TYPE_FONT_FACE (pango_font_face_get_type ()) //#define PANGO_FONT_FACE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FACE, PangoFontFace)) //#define PANGO_IS_FONT_FACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FACE)) // //GType pango_font_face_get_type (void) G_GNUC_CONST; // //PangoFontDescription *pango_font_face_describe (PangoFontFace *face); //const char *pango_font_face_get_face_name (PangoFontFace *face) G_GNUC_PURE; //void pango_font_face_list_sizes (PangoFontFace *face, // int **sizes, // int *n_sizes); //gboolean pango_font_face_is_synthesized (PangoFontFace *face) G_GNUC_PURE; // //#ifdef PANGO_ENABLE_BACKEND // //#define PANGO_FONT_FACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_FACE, PangoFontFaceClass)) //#define PANGO_IS_FONT_FACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_FACE)) //#define PANGO_FONT_FACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_FACE, PangoFontFaceClass)) // //typedef struct _PangoFontFaceClass PangoFontFaceClass; // ///** // * PangoFontFace: // * // * The #PangoFontFace structure is used to represent a group of fonts with // * the same family, slant, weight, width, but varying sizes. // */ //struct _PangoFontFace //{ // GObject parent_instance; //}; // //struct _PangoFontFaceClass //{ // GObjectClass parent_class; // // /*< public >*/ // // const char * (*get_face_name) (PangoFontFace *face); // PangoFontDescription * (*describe) (PangoFontFace *face); // void (*list_sizes) (PangoFontFace *face, // int **sizes, // int *n_sizes); // gboolean (*is_synthesized) (PangoFontFace *face); // // /*< private >*/ // // /* Padding for future expansion */ // void (*_pango_reserved3) (void); // void (*_pango_reserved4) (void); //}; // //#endif /* PANGO_ENABLE_BACKEND */ // ///* // * PangoFont // */ // ///** // * PANGO_TYPE_FONT: // * // * The #GObject type for #PangoFont. // */ ///** // * PANGO_FONT: // * @object: a #GObject. // * // * Casts a #GObject to a #PangoFont. // */ ///** // * PANGO_IS_FONT: // * @object: a #GObject. // * // * Returns: %TRUE if @object is a #PangoFont. // */ //#define PANGO_TYPE_FONT (pango_font_get_type ()) //#define PANGO_FONT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT, PangoFont)) //#define PANGO_IS_FONT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT)) // //GType pango_font_get_type (void) G_GNUC_CONST; // //PangoFontDescription *pango_font_describe (PangoFont *font); //PangoFontDescription *pango_font_describe_with_absolute_size (PangoFont *font); //PangoCoverage * pango_font_get_coverage (PangoFont *font, // PangoLanguage *language); //PangoEngineShape * pango_font_find_shaper (PangoFont *font, // PangoLanguage *language, // guint32 ch); //PangoFontMetrics * pango_font_get_metrics (PangoFont *font, // PangoLanguage *language); //void pango_font_get_glyph_extents (PangoFont *font, // PangoGlyph glyph, // PangoRectangle *ink_rect, // PangoRectangle *logical_rect); //PangoFontMap *pango_font_get_font_map (PangoFont *font); // //#ifdef PANGO_ENABLE_BACKEND // //#define PANGO_FONT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT, PangoFontClass)) //#define PANGO_IS_FONT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT)) //#define PANGO_FONT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT, PangoFontClass)) // //typedef struct _PangoFontClass PangoFontClass; // ///** // * PangoFont: // * // * The #PangoFont structure is used to represent // * a font in a rendering-system-independent matter. // * To create an implementation of a #PangoFont, // * the rendering-system specific code should allocate // * a larger structure that contains a nested // * #PangoFont, fill in the klass member of // * the nested #PangoFont with a pointer to // * a appropriate #PangoFontClass, then call // * pango_font_init() on the structure. // * // * The #PangoFont structure contains one member // * which the implementation fills in. // */ //struct _PangoFont //{ // GObject parent_instance; //}; // //struct _PangoFontClass //{ // GObjectClass parent_class; // // /*< public >*/ // // PangoFontDescription *(*describe) (PangoFont *font); // PangoCoverage * (*get_coverage) (PangoFont *font, // PangoLanguage *lang); // PangoEngineShape * (*find_shaper) (PangoFont *font, // PangoLanguage *lang, // guint32 ch); // void (*get_glyph_extents) (PangoFont *font, // PangoGlyph glyph, // PangoRectangle *ink_rect, // PangoRectangle *logical_rect); // PangoFontMetrics * (*get_metrics) (PangoFont *font, // PangoLanguage *language); // PangoFontMap * (*get_font_map) (PangoFont *font); // PangoFontDescription *(*describe_absolute) (PangoFont *font); // /*< private >*/ // // /* Padding for future expansion */ // void (*_pango_reserved1) (void); // void (*_pango_reserved2) (void); //}; // ///* used for very rare and miserable situtations that we cannot even // * draw a hexbox // */ //#define PANGO_UNKNOWN_GLYPH_WIDTH 10 //#define PANGO_UNKNOWN_GLYPH_HEIGHT 14 // //#endif /* PANGO_ENABLE_BACKEND */ // ///** // * PANGO_GLYPH_EMPTY: // * // * The %PANGO_GLYPH_EMPTY macro represents a #PangoGlyph value that has a // * special meaning, which is a zero-width empty glyph. This is useful for // * example in shaper modules, to use as the glyph for various zero-width // * Unicode characters (those passing pango_is_zero_width()). // */ ///** // * PANGO_GLYPH_INVALID_INPUT: // * // * The %PANGO_GLYPH_INVALID_INPUT macro represents a #PangoGlyph value that has a // * special meaning of invalid input. #PangoLayout produces one such glyph // * per invalid input UTF-8 byte and such a glyph is rendered as a crossed // * box. // * // * Note that this value is defined such that it has the %PANGO_GLYPH_UNKNOWN_FLAG // * on. // * // * Since: 1.20 // */ ///** // * PANGO_GLYPH_UNKNOWN_FLAG: // * // * The %PANGO_GLYPH_UNKNOWN_FLAG macro is a flag value that can be added to // * a #gunichar value of a valid Unicode character, to produce a #PangoGlyph // * value, representing an unknown-character glyph for the respective #gunichar. // */ ///** // * PANGO_GET_UNKNOWN_GLYPH: // * @wc: a Unicode character // * // * The way this unknown glyphs are rendered is backend specific. For example, // * a box with the hexadecimal Unicode code-point of the character written in it // * is what is done in the most common backends. // * // * Returns: a #PangoGlyph value that means no glyph was found for @wc. // */ //#define PANGO_GLYPH_EMPTY ((PangoGlyph)0x0FFFFFFF) //#define PANGO_GLYPH_INVALID_INPUT ((PangoGlyph)0xFFFFFFFF) //#define PANGO_GLYPH_UNKNOWN_FLAG ((PangoGlyph)0x10000000) //#define PANGO_GET_UNKNOWN_GLYPH(wc) ((PangoGlyph)(wc)|PANGO_GLYPH_UNKNOWN_FLAG) // // gotk3-0.6.2/pango/pango-glyph-item.go000066400000000000000000000026151431157473000173730ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package pango // #include // #include "pango.go.h" // #include import "C" import ( // "github.com/andre-hub/gotk3/glib" // "github.com/andre-hub/gotk3/cairo" "unsafe" ) // GlyphItem is a representation of PangoGlyphItem. type GlyphItem struct { pangoGlyphItem *C.PangoGlyphItem } // Native returns a pointer to the underlying PangoGlyphItem. func (v *GlyphItem) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *GlyphItem) native() *C.PangoGlyphItem { return (*C.PangoGlyphItem)(unsafe.Pointer(v.pangoGlyphItem)) } gotk3-0.6.2/pango/pango-glyph.go000066400000000000000000000051211431157473000164320ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package pango // #include // #include "pango.go.h" // #include import "C" import ( // "github.com/andre-hub/gotk3/glib" // "github.com/andre-hub/gotk3/cairo" "unsafe" ) // GlyphGeometry is a representation of PangoGlyphGeometry. type GlyphGeometry struct { pangoGlyphGeometry *C.PangoGlyphGeometry } // Native returns a pointer to the underlying PangoLayout. func (v *GlyphGeometry) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *GlyphGeometry) native() *C.PangoGlyphGeometry { return (*C.PangoGlyphGeometry)(unsafe.Pointer(v.pangoGlyphGeometry)) } // GlyphVisAttr is a representation of PangoGlyphVisAttr. type GlyphVisAttr struct { pangoGlyphVisAttr *C.PangoGlyphGeometry } // Native returns a pointer to the underlying PangoGlyphVisAttr. func (v *GlyphVisAttr) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *GlyphVisAttr) native() *C.PangoGlyphVisAttr { return (*C.PangoGlyphVisAttr)(unsafe.Pointer(v.pangoGlyphVisAttr)) } // GlyphInfo is a representation of PangoGlyphInfo. type GlyphInfo struct { pangoGlyphInfo *C.PangoGlyphInfo } // Native returns a pointer to the underlying PangoGlyphInfo. func (v *GlyphInfo) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *GlyphInfo) native() *C.PangoGlyphInfo { return (*C.PangoGlyphInfo)(unsafe.Pointer(v.pangoGlyphInfo)) } // GlyphGeometry is a representation of PangoGlyphString. type GlyphString struct { pangoGlyphString *C.PangoGlyphString } // Native returns a pointer to the underlying PangoGlyphString. func (v *GlyphString) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *GlyphString) native() *C.PangoGlyphString { return (*C.PangoGlyphString)(unsafe.Pointer(v.pangoGlyphString)) } gotk3-0.6.2/pango/pango-gravity.go000066400000000000000000000042141431157473000167760ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package pango // #include // #include "pango.go.h" import "C" // "github.com/andre-hub/gotk3/glib" // "github.com/andre-hub/gotk3/cairo" // "unsafe" type Gravity int const ( GRAVITY_SOUTH Gravity = C.PANGO_GRAVITY_SOUTH GRAVITY_EAST Gravity = C.PANGO_GRAVITY_EAST GRAVITY_NORTH Gravity = C.PANGO_GRAVITY_NORTH GRAVITY_WEST Gravity = C.PANGO_GRAVITY_WEST GRAVITY_AUTO Gravity = C.PANGO_GRAVITY_AUTO ) type GravityHint int const ( GRAVITY_HINT_NATURAL GravityHint = C.PANGO_GRAVITY_HINT_NATURAL GRAVITY_HINT_STRONG GravityHint = C.PANGO_GRAVITY_HINT_STRONG GRAVITY_HINT_LINE GravityHint = C.PANGO_GRAVITY_HINT_LINE ) //double pango_gravity_to_rotation (PangoGravity gravity) G_GNUC_CONST; func GravityToRotation(gravity Gravity) float64 { c := C.pango_gravity_to_rotation((C.PangoGravity)(gravity)) return float64(c) } //PangoGravity pango_gravity_get_for_matrix (const PangoMatrix *matrix) G_GNUC_PURE; //PangoGravity pango_gravity_get_for_script (PangoScript script, // PangoGravity base_gravity, // PangoGravityHint hint) G_GNUC_CONST; //PangoGravity pango_gravity_get_for_script_and_width // (PangoScript script, // gboolean wide, // PangoGravity base_gravity, // PangoGravityHint hint) G_GNUC_CONST; gotk3-0.6.2/pango/pango-layout.go000066400000000000000000000500651431157473000166330ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package pango // #include // #include "pango.go.h" import "C" import ( "runtime" "unsafe" "github.com/gotk3/gotk3/glib" ) func init() { tm := []glib.TypeMarshaler{ // Enums {glib.Type(C.pango_alignment_get_type()), marshalAlignment}, {glib.Type(C.pango_ellipsize_mode_get_type()), marshalEllipsizeMode}, {glib.Type(C.pango_wrap_mode_get_type()), marshalWrapMode}, {glib.Type(C.pango_tab_align_get_type()), marshalTabAlign}, // Objects/Interfaces // {glib.Type(C.pango_layout_get_type()), marshalLayout}, } glib.RegisterGValueMarshalers(tm) } // Layout is a representation of PangoLayout. type Layout struct { pangoLayout *C.PangoLayout } // Native returns a pointer to the underlying PangoLayout. func (v *Layout) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *Layout) native() *C.PangoLayout { if v == nil { return nil } return (*C.PangoLayout)(unsafe.Pointer(v.pangoLayout)) } func WrapLayout(p uintptr) *Layout { layout := new(Layout) layout.pangoLayout = (*C.PangoLayout)(unsafe.Pointer(p)) return layout } // LayoutLine is a representation of PangoLayoutLine. type LayoutLine struct { pangoLayoutLine *C.PangoLayout } // Native returns a pointer to the underlying PangoLayoutLine. func (v *LayoutLine) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *LayoutLine) native() *C.PangoLayoutLine { if v == nil { return nil } return (*C.PangoLayoutLine)(unsafe.Pointer(v.pangoLayoutLine)) } /* * Constants */ // Alignment is a representation of Pango's PangoAlignment. type Alignment int const ( ALIGN_LEFT Alignment = C.PANGO_ALIGN_LEFT ALIGN_CENTER Alignment = C.PANGO_ALIGN_CENTER ALIGN_RIGHT Alignment = C.PANGO_ALIGN_RIGHT ) func marshalAlignment(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return Alignment(c), nil } // WrapMode is a representation of Pango's PangoWrapMode. type WrapMode int const ( WRAP_WORD WrapMode = C.PANGO_WRAP_WORD WRAP_CHAR WrapMode = C.PANGO_WRAP_CHAR WRAP_WORD_CHAR WrapMode = C.PANGO_WRAP_WORD_CHAR ) func marshalWrapMode(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return WrapMode(c), nil } // EllipsizeMode is a representation of Pango's PangoEllipsizeMode. type EllipsizeMode int const ( ELLIPSIZE_NONE EllipsizeMode = C.PANGO_ELLIPSIZE_NONE ELLIPSIZE_START EllipsizeMode = C.PANGO_ELLIPSIZE_START ELLIPSIZE_MIDDLE EllipsizeMode = C.PANGO_ELLIPSIZE_MIDDLE ELLIPSIZE_END EllipsizeMode = C.PANGO_ELLIPSIZE_END ) func marshalEllipsizeMode(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return EllipsizeMode(c), nil } type TabAlign int const ( TAB_LEFT TabAlign = C.PANGO_TAB_LEFT ) func marshalTabAlign(p uintptr) (interface{}, error) { c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p))) return TabAlign(c), nil } /* func marshalLayout(p uintptr) (interface{}, error) { c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) obj := wrapObject(unsafe.Pointer(c)) return wrapLayout(obj), nil } func wrapLayout(obj *glib.Object) *Layout { return &Layout{obj} } */ // LayoutNew is a wrapper around pango_layout_new(). func LayoutNew(context *Context) *Layout { c := C.pango_layout_new(context.native()) layout := new(Layout) layout.pangoLayout = (*C.PangoLayout)(c) return layout } // Copy is a wrapper around pango_layout_copy(). func (v *Layout) Copy() *Layout { c := C.pango_layout_copy(v.native()) layout := new(Layout) layout.pangoLayout = (*C.PangoLayout)(c) return layout } // GetContext is a wrapper around pango_layout_get_context(). func (v *Layout) GetContext() *Context { c := C.pango_layout_get_context(v.native()) context := new(Context) context.pangoContext = (*C.PangoContext)(c) return context } // SetAttributes is a wrapper around pango_layout_set_attributes(). func (v *Layout) SetAttributes(attrs *AttrList) { C.pango_layout_set_attributes(v.native(), attrs.native()) } // GetAttributes is a wrapper around pango_layout_get_attributes(). func (v *Layout) GetAttributes() *AttrList { c := C.pango_layout_get_attributes(v.native()) return wrapAttrList(c) } // SetText is a wrapper around pango_layout_set_text(). func (v *Layout) SetText(text string, length int) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.pango_layout_set_text(v.native(), (*C.char)(cstr), (C.int)(length)) } // GetText is a wrapper around pango_layout_get_text(). func (v *Layout) GetText() string { c := C.pango_layout_get_text(v.native()) return C.GoString((*C.char)(c)) } // GetCharacterCount is a wrapper around pango_layout_get_character_count(). func (v *Layout) GetCharacterCount() int { c := C.pango_layout_get_character_count(v.native()) return int(c) } // SetMarkup is a wrapper around pango_layout_set_markup(). func (v *Layout) SetMarkup(text string, length int) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.pango_layout_set_markup(v.native(), (*C.char)(cstr), (C.int)(length)) } //void pango_layout_set_markup_with_accel (PangoLayout *layout, // const char *markup, // int length, // gunichar accel_marker, // gunichar *accel_char); /* func (v *Layout) SetMarkupWithAccel (text string, length int, accel_marker, accel_char rune){ cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.pango_layout_set_markup_with_accel (v.native(), (*C.char)(cstr), (C.int)(length), (C.gunichar)(accel_marker), (C.gunichar)(accel_char) ) } */ // SetFontDescription is a wrapper around pango_layout_set_font_description(). func (v *Layout) SetFontDescription(desc *FontDescription) { C.pango_layout_set_font_description(v.native(), desc.native()) } // GetFontDescription is a wrapper around pango_layout_get_font_description(). func (v *Layout) GetFontDescription() *FontDescription { c := C.pango_layout_get_font_description(v.native()) desc := new(FontDescription) desc.pangoFontDescription = (*C.PangoFontDescription)(c) return desc } // SetWidth is a wrapper around pango_layout_set_width(). func (v *Layout) SetWidth(width int) { C.pango_layout_set_width(v.native(), C.int(width)) } // GetWidth is a wrapper around pango_layout_get_width(). func (v *Layout) GetWidth() int { c := C.pango_layout_get_width(v.native()) return int(c) } // SetHeight is a wrapper around pango_layout_set_height(). func (v *Layout) SetHeight(width int) { C.pango_layout_set_height(v.native(), C.int(width)) } // GetHeight is a wrapper around pango_layout_get_height(). func (v *Layout) GetHeight() int { c := C.pango_layout_get_height(v.native()) return int(c) } // SetWrap is a wrapper around pango_layout_set_wrap(). func (v *Layout) SetWrap(wrap WrapMode) { C.pango_layout_set_wrap(v.native(), C.PangoWrapMode(wrap)) } // WrapMode is a wrapper around pango_layout_get_wrap(). func (v *Layout) GetWrap() WrapMode { c := C.pango_layout_get_wrap(v.native()) return WrapMode(c) } // IsWrapped is a wrapper around pango_layout_is_wrapped(). func (v *Layout) IsWrapped() bool { c := C.pango_layout_is_wrapped(v.native()) return gobool(c) } // SetIndent is a wrapper around pango_layout_set_indent(). func (v *Layout) SetIndent(indent int) { C.pango_layout_set_indent(v.native(), C.int(indent)) } // GetIndent is a wrapper around pango_layout_get_indent(). func (v *Layout) GetIndent() int { c := C.pango_layout_get_indent(v.native()) return int(c) } // SetTabs is a wrapper around pango_layout_set_tabs(). func (v *Layout) SetTabs(tabs *TabArray) { C.pango_layout_set_tabs(v.native(), tabs.native()) } // GetTabs is a wrapper around pango_layout_get_tabs(). func (v *Layout) GetTabs() (*TabArray, error) { c := C.pango_layout_get_tabs(v.native()) if c == nil { return nil, nilPtrErr } ta := wrapTabArray(c) runtime.SetFinalizer(ta, func(v *TabArray) { glib.FinalizerStrategy(v.free) }) return ta, nil } // GetSize is a wrapper around pango_layout_get_size(). func (v *Layout) GetSize() (int, int) { var w, h C.int C.pango_layout_get_size(v.native(), &w, &h) return int(w), int(h) } /* * TabArray */ // TabArray is a representation of PangoTabArray. type TabArray struct { pangoTabArray *C.PangoTabArray } // Native returns a pointer to the underlying PangoTabArray. func (v *TabArray) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *TabArray) native() *C.PangoTabArray { if v == nil { return nil } return (*C.PangoTabArray)(unsafe.Pointer(v.pangoTabArray)) } func wrapTabArray(tabArray *C.PangoTabArray) *TabArray { return &TabArray{tabArray} } func WrapTabArray(p uintptr) *TabArray { tabArray := new(TabArray) tabArray.pangoTabArray = (*C.PangoTabArray)(unsafe.Pointer(p)) return tabArray } // TabArrayNew is a wrapper around pango_tab_array_new(). func TabArrayNew(initialSize int, positionsInPixels bool) *TabArray { c := C.pango_tab_array_new(C.gint(initialSize), gbool(positionsInPixels)) tabArray := new(TabArray) runtime.SetFinalizer(tabArray, func(v *TabArray) { glib.FinalizerStrategy(v.free) }) tabArray.pangoTabArray = (*C.PangoTabArray)(c) return tabArray } // TabArrayNewWithPositions is a wrapper around pango_tab_array_new_with_positions(). // func TabArrayNewWithPositions(size int, positionsInPixels bool, ...) *TabArray { // c := C.pango_tab_array_new_with_positions(C.gint(size), gbool(positionsInPixels), ...) // tabArray := new(TabArray) // runtime.SetFinalizer(e, func(v *TabArray) { glib.FinalizerStrategy(v.free) }) // tabArray.pangoTabArray = (*C.PangoTabArray)(c) // return tabArray // } // Copy is a wrapper around pango_tab_array_copy(). func (v *TabArray) Copy() (*TabArray, error) { c := C.pango_tab_array_copy(v.native()) if c == nil { return nil, nilPtrErr } ta := wrapTabArray(c) runtime.SetFinalizer(ta, func(v *TabArray) { glib.FinalizerStrategy(v.free) }) return ta, nil } // free is a wrapper around pango_tab_array_free(). func (v *TabArray) free() { C.pango_tab_array_free(v.native()) } // free is a wrapper around pango_tab_array_free(). // This is only to enable other packages within gotk. Should not be used outside the gotk library. func (v *TabArray) Free() { C.pango_tab_array_free(v.native()) } // GetSize is a wrapper around pango_tab_array_get_size(). func (v *TabArray) GetSize() int { return int(C.pango_tab_array_get_size(v.native())) } // Resize is a wrapper around pango_tab_array_resize(). func (v *TabArray) Resize(newSize int) { C.pango_tab_array_resize(v.native(), C.gint(newSize)) } // SetTab is a wrapper around pango_tab_array_set_tab(). func (v *TabArray) SetTab(tabIndex int, alignment TabAlign, location int) { C.pango_tab_array_set_tab(v.native(), C.gint(tabIndex), C.PangoTabAlign(alignment), C.gint(location)) } // GetTab is a wrapper around pango_tab_array_get_tab(). func (v *TabArray) GetTab(tabIndex int) (TabAlign, int) { var alignment C.PangoTabAlign var location C.gint C.pango_tab_array_get_tab(v.native(), C.gint(tabIndex), &alignment, &location) return TabAlign(alignment), int(location) } // GetTabs is a wrapper around pango_tab_array_get_tabs(). // func (v *TabArray) GetTabs() ([]TabAlign, []int) { // var alignment *C.PangoTabAlign // var location *C.gint // C.pango_tab_array_get_tabs(v.native(), &alignment, &location) // size := v.GetSize() // var goAlignments []TabAlign // var goLocations []int // if &alignment != nil { // var ginthelp C.gint // sizeOf := unsafe.Sizeof(ginthelp) // for i := 0; i < int(size); i++ { // goAlignmentElement := TabAlign(*((*C.gint)(unsafe.Pointer(location)))) // goAlignments = append(goAlignments, goAlignmentElement) // location += sizeOf // } // } // if &location != nil { // var ginthelp C.gint // sizeOf := unsafe.Sizeof(ginthelp) // for i := 0; i < int(size); i++ { // goLocationElement := int(*((*C.gint)(unsafe.Pointer(location)))) // goLocations = append(goLocations, goLocationElement) // location += sizeOf // } // // TODO: free locations // } // return goAlignments, goLocations // } // GetPositionsInPixels is a wrapper around pango_tab_array_get_positions_in_pixels(). func (v *TabArray) GetPositionsInPixels() bool { return gobool(C.pango_tab_array_get_positions_in_pixels(v.native())) } //void pango_layout_set_spacing (PangoLayout *layout, // int spacing); //int pango_layout_get_spacing (PangoLayout *layout); //void pango_layout_set_justify (PangoLayout *layout, // gboolean justify); //gboolean pango_layout_get_justify (PangoLayout *layout); //void pango_layout_set_auto_dir (PangoLayout *layout, // gboolean auto_dir); //gboolean pango_layout_get_auto_dir (PangoLayout *layout); //void pango_layout_set_alignment (PangoLayout *layout, // PangoAlignment alignment); //PangoAlignment pango_layout_get_alignment (PangoLayout *layout); // //void pango_layout_set_single_paragraph_mode (PangoLayout *layout, // gboolean setting); //gboolean pango_layout_get_single_paragraph_mode (PangoLayout *layout); // //void pango_layout_set_ellipsize (PangoLayout *layout, // PangoEllipsizeMode ellipsize); //PangoEllipsizeMode pango_layout_get_ellipsize (PangoLayout *layout); //gboolean pango_layout_is_ellipsized (PangoLayout *layout); // //int pango_layout_get_unknown_glyphs_count (PangoLayout *layout); // //void pango_layout_context_changed (PangoLayout *layout); //guint pango_layout_get_serial (PangoLayout *layout); // //void pango_layout_get_log_attrs (PangoLayout *layout, // PangoLogAttr **attrs, // gint *n_attrs); // //const PangoLogAttr *pango_layout_get_log_attrs_readonly (PangoLayout *layout, // gint *n_attrs); // //void pango_layout_index_to_pos (PangoLayout *layout, // int index_, // PangoRectangle *pos); //void pango_layout_index_to_line_x (PangoLayout *layout, // int index_, // gboolean trailing, // int *line, // int *x_pos); //void pango_layout_get_cursor_pos (PangoLayout *layout, // int index_, // PangoRectangle *strong_pos, // PangoRectangle *weak_pos); //void pango_layout_move_cursor_visually (PangoLayout *layout, // gboolean strong, // int old_index, // int old_trailing, // int direction, // int *new_index, // int *new_trailing); //gboolean pango_layout_xy_to_index (PangoLayout *layout, // int x, // int y, // int *index_, // int *trailing); //void pango_layout_get_extents (PangoLayout *layout, // PangoRectangle *ink_rect, // PangoRectangle *logical_rect); //void pango_layout_get_pixel_extents (PangoLayout *layout, // PangoRectangle *ink_rect, // PangoRectangle *logical_rect); //void pango_layout_get_pixel_size (PangoLayout *layout, // int *width, // int *height); //int pango_layout_get_baseline (PangoLayout *layout); // //int pango_layout_get_line_count (PangoLayout *layout); //PangoLayoutLine *pango_layout_get_line (PangoLayout *layout, // int line); //PangoLayoutLine *pango_layout_get_line_readonly (PangoLayout *layout, // int line); //GSList * pango_layout_get_lines (PangoLayout *layout); //GSList * pango_layout_get_lines_readonly (PangoLayout *layout); // // //#define PANGO_TYPE_LAYOUT_LINE (pango_layout_line_get_type ()) // //GType pango_layout_line_get_type (void) G_GNUC_CONST; // //PangoLayoutLine *pango_layout_line_ref (PangoLayoutLine *line); //void pango_layout_line_unref (PangoLayoutLine *line); // //gboolean pango_layout_line_x_to_index (PangoLayoutLine *line, // int x_pos, // int *index_, // int *trailing); //void pango_layout_line_index_to_x (PangoLayoutLine *line, // int index_, // gboolean trailing, // int *x_pos); //void pango_layout_line_get_x_ranges (PangoLayoutLine *line, // int start_index, // int end_index, // int **ranges, // int *n_ranges); //void pango_layout_line_get_extents (PangoLayoutLine *line, // PangoRectangle *ink_rect, // PangoRectangle *logical_rect); //void pango_layout_line_get_pixel_extents (PangoLayoutLine *layout_line, // PangoRectangle *ink_rect, // PangoRectangle *logical_rect); // //typedef struct _PangoLayoutIter PangoLayoutIter; // //#define PANGO_TYPE_LAYOUT_ITER (pango_layout_iter_get_type ()) // //GType pango_layout_iter_get_type (void) G_GNUC_CONST; // //PangoLayoutIter *pango_layout_get_iter (PangoLayout *layout); //PangoLayoutIter *pango_layout_iter_copy (PangoLayoutIter *iter); //void pango_layout_iter_free (PangoLayoutIter *iter); // //int pango_layout_iter_get_index (PangoLayoutIter *iter); //PangoLayoutRun *pango_layout_iter_get_run (PangoLayoutIter *iter); //PangoLayoutRun *pango_layout_iter_get_run_readonly (PangoLayoutIter *iter); //PangoLayoutLine *pango_layout_iter_get_line (PangoLayoutIter *iter); //PangoLayoutLine *pango_layout_iter_get_line_readonly (PangoLayoutIter *iter); //gboolean pango_layout_iter_at_last_line (PangoLayoutIter *iter); //PangoLayout *pango_layout_iter_get_layout (PangoLayoutIter *iter); // //gboolean pango_layout_iter_next_char (PangoLayoutIter *iter); //gboolean pango_layout_iter_next_cluster (PangoLayoutIter *iter); //gboolean pango_layout_iter_next_run (PangoLayoutIter *iter); //gboolean pango_layout_iter_next_line (PangoLayoutIter *iter); // //void pango_layout_iter_get_char_extents (PangoLayoutIter *iter, // PangoRectangle *logical_rect); //void pango_layout_iter_get_cluster_extents (PangoLayoutIter *iter, // PangoRectangle *ink_rect, // PangoRectangle *logical_rect); //void pango_layout_iter_get_run_extents (PangoLayoutIter *iter, // PangoRectangle *ink_rect, // PangoRectangle *logical_rect); //void pango_layout_iter_get_line_extents (PangoLayoutIter *iter, // PangoRectangle *ink_rect, // PangoRectangle *logical_rect); /* All the yranges meet, unlike the logical_rect's (i.e. the yranges * assign between-line spacing to the nearest line) */ //void pango_layout_iter_get_line_yrange (PangoLayoutIter *iter, // int *y0_, // int *y1_); //void pango_layout_iter_get_layout_extents (PangoLayoutIter *iter, // PangoRectangle *ink_rect, // PangoRectangle *logical_rect); //int pango_layout_iter_get_baseline (PangoLayoutIter *iter); // gotk3-0.6.2/pango/pango-layout.go.h000066400000000000000000000017561431157473000170640ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include #include #include static PangoLayout *toPangoLayout(void *p) { return ((PangoLayout *)(p)); } gotk3-0.6.2/pango/pango-types.go000066400000000000000000000073611431157473000164630ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package pango // #include // #include "pango.go.h" // #include import "C" import ( "unsafe" ) // LogAttr is a representation of PangoLogAttr. type LogAttr struct { pangoLogAttr *C.PangoLogAttr } // Native returns a pointer to the underlying PangoLayout. func (v *LogAttr) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *LogAttr) native() *C.PangoLogAttr { return (*C.PangoLogAttr)(unsafe.Pointer(v.pangoLogAttr)) } // EngineLang is a representation of PangoEngineLang. type EngineLang struct { pangoEngineLang *C.PangoEngineLang } // Native returns a pointer to the underlying PangoLayout. func (v *EngineLang) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *EngineLang) native() *C.PangoEngineLang { return (*C.PangoEngineLang)(unsafe.Pointer(v.pangoEngineLang)) } // EngineShape is a representation of PangoEngineShape. type EngineShape struct { pangoEngineShape *C.PangoEngineShape } // Native returns a pointer to the underlying PangoLayout. func (v *EngineShape) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *EngineShape) native() *C.PangoEngineShape { return (*C.PangoEngineShape)(unsafe.Pointer(v.pangoEngineShape)) } // Font is a representation of PangoFont. type Font struct { pangoFont *C.PangoFont } // Native returns a pointer to the underlying PangoLayout. func (v *Font) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *Font) native() *C.PangoFont { return (*C.PangoFont)(unsafe.Pointer(v.pangoFont)) } // FontMap is a representation of PangoFontMap. type FontMap struct { pangoFontMap *C.PangoFontMap } // Native returns a pointer to the underlying PangoLayout. func (v *FontMap) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *FontMap) native() *C.PangoFontMap { return (*C.PangoFontMap)(unsafe.Pointer(v.pangoFontMap)) } func wrapFontMap(fontMap *C.PangoFontMap) *FontMap { return &FontMap{fontMap} } func WrapFontMap(p uintptr) *FontMap { fontMap := (*C.PangoFontMap)(unsafe.Pointer(p)) return wrapFontMap(fontMap) } // Rectangle is a representation of PangoRectangle. type Rectangle struct { pangoRectangle *C.PangoRectangle } // Native returns a pointer to the underlying PangoLayout. func (v *Rectangle) Native() uintptr { return uintptr(unsafe.Pointer(v.native())) } func (v *Rectangle) native() *C.PangoRectangle { return (*C.PangoRectangle)(unsafe.Pointer(v.pangoRectangle)) } // Glyph is a representation of PangoGlyph type Glyph uint32 //void pango_extents_to_pixels (PangoRectangle *inclusive, // PangoRectangle *nearest); func (inclusive *Rectangle) ExtentsToPixels(nearest *Rectangle) { C.pango_extents_to_pixels(inclusive.native(), nearest.native()) } func RectangleNew(x, y, width, height int) *Rectangle { r := new(Rectangle) r.pangoRectangle = C.createPangoRectangle((C.int)(x), (C.int)(y), (C.int)(width), (C.int)(height)) return r } gotk3-0.6.2/pango/pango.go000066400000000000000000000026671431157473000153250ustar00rootroot00000000000000// Copyright (c) 2013-2014 Conformal Systems // // This file originated from: http://opensource.conformal.com/ // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // Go bindings for Pango. package pango // #cgo pkg-config: fontconfig gobject-2.0 glib-2.0 pango pangocairo // #include // #include "pango.go.h" import "C" import "errors" // "github.com/andre-hub/gotk3/glib" // "unsafe" func init() { } /* * Type conversions */ func gbool(b bool) C.gboolean { if b { return C.gboolean(1) } return C.gboolean(0) } func gobool(b C.gboolean) bool { if b != 0 { return true } return false } /* * Unexported vars */ var nilPtrErr = errors.New("cgo returned unexpected nil pointer") /* * Constantes */ const ( SCALE int = 1024 ) gotk3-0.6.2/pango/pango.go.h000066400000000000000000000024371431157473000155460ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include #include #include #include "pango-attributes.go.h" #include "pango-layout.go.h" #include "pangocairo.go.h" static PangoRectangle *createPangoRectangle(int x, int y, int width, int height) { PangoRectangle *r = (PangoRectangle *)malloc(sizeof(PangoRectangle)); r->x = x; r->y = y; r->width = width; r->height = height; return r; }gotk3-0.6.2/pango/pangocairo.go000066400000000000000000000111411431157473000163260ustar00rootroot00000000000000/* * Copyright (c) 2015- terrak * * This file originated from: http://www.terrak.net/ * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ package pango // #include // #include // #include // #include "pango.go.h" import "C" import ( // "github.com/gotk3/gotk3/glib" "unsafe" "github.com/gotk3/gotk3/cairo" ) func init() { // tm := []glib.TypeMarshaler{ // // Enums // {glib.Type(C.pango_alignement_get_type()), marshalAlignment}, // {glib.Type(C.pango_ellipsize_mode_get_type()), marshalEllipsizeMode}, // {glib.Type(C.pango_wrap_mode_get_type()), marshalWrapMode}, // } // glib.RegisterGValueMarshalers(tm) } func cairo_context(cr *cairo.Context) *C.cairo_t { return (*C.cairo_t)(cr.GetCContext()) } /* Convenience */ //PangoContext *pango_cairo_create_context (cairo_t *cr); func CairoCreateContext(cr *cairo.Context) *Context { c := C.pango_cairo_create_context(cairo_context(cr)) context := new(Context) context.pangoContext = (*C.PangoContext)(c) return context } //PangoLayout *pango_cairo_create_layout (cairo_t *cr); func CairoCreateLayout(cr *cairo.Context) *Layout { c := C.pango_cairo_create_layout(cairo_context(cr)) layout := new(Layout) layout.pangoLayout = (*C.PangoLayout)(c) return layout } //void pango_cairo_update_layout (cairo_t *cr, // PangoLayout *layout); func CairoUpdateLayout(cr *cairo.Context, v *Layout) { C.pango_cairo_update_layout(cairo_context(cr), v.native()) } /* * Rendering */ //void pango_cairo_show_glyph_string (cairo_t *cr, // PangoFont *font, // PangoGlyphString *glyphs); func CairoShowGlyphString(cr *cairo.Context, font *Font, glyphs *GlyphString) { C.pango_cairo_show_glyph_string(cairo_context(cr), font.native(), glyphs.native()) } //void pango_cairo_show_glyph_item (cairo_t *cr, // const char *text, // PangoGlyphItem *glyph_item); func CairoShowGlyphItem(cr *cairo.Context, text string, glyph_item *GlyphItem) { cstr := C.CString(text) defer C.free(unsafe.Pointer(cstr)) C.pango_cairo_show_glyph_item(cairo_context(cr), (*C.char)(cstr), glyph_item.native()) } //void pango_cairo_show_layout_line (cairo_t *cr, // PangoLayoutLine *line); func CairoShowLayoutLine(cr *cairo.Context, line *LayoutLine) { C.pango_cairo_show_layout_line(cairo_context(cr), line.native()) } //void pango_cairo_show_layout (cairo_t *cr, // PangoLayout *layout); func CairoShowLayout(cr *cairo.Context, layout *Layout) { C.pango_cairo_show_layout(cairo_context(cr), layout.native()) } //void pango_cairo_show_error_underline (cairo_t *cr, // double x, // double y, // double width, // double height); /* * Rendering to a path */ //void pango_cairo_glyph_string_path (cairo_t *cr, // PangoFont *font, // PangoGlyphString *glyphs); func CairoGlyphStringPath(cr *cairo.Context, font *Font, glyphs *GlyphString) { C.pango_cairo_glyph_string_path(cairo_context(cr), font.native(), glyphs.native()) } //void pango_cairo_layout_line_path (cairo_t *cr, // PangoLayoutLine *line); func CairoLayoutLinePath(cr *cairo.Context, line *LayoutLine) { C.pango_cairo_layout_line_path(cairo_context(cr), line.native()) } //void pango_cairo_layout_path (cairo_t *cr, // PangoLayout *layout); func CairoLayoutPath(cr *cairo.Context, layout *Layout) { C.pango_cairo_layout_path(cairo_context(cr), layout.native()) } //void pango_cairo_error_underline_path (cairo_t *cr, // double x, // double y, // double width, // double height); func CairoErrorUnderlinePath(cr *cairo.Context, x, y, width, height float64) { C.pango_cairo_error_underline_path(cairo_context(cr), C.double(x), C.double(y), C.double(width), C.double(height)) } gotk3-0.6.2/pango/pangocairo.go.h000066400000000000000000000000001431157473000165440ustar00rootroot00000000000000gotk3-0.6.2/shippable.yml000066400000000000000000000020311431157473000152410ustar00rootroot00000000000000language: go build_image: shippableimages/ubuntu1404_go go: - tip before_install: - sudo apt-get update -y - sudo apt-get install -y libglib2.0-dev libcairo2-dev libgtk-3-dev xvfb - source $HOME/.gvm/scripts/gvm; - if [[ $SHIPPABLE_GO_VERSION == "tip" ]]; then gvm install tip; gvm use tip; fi - if [[ $SHIPPABLE_GO_VERSION == *release* ]]; then gvm install release; gvm use release; fi - if [[ $SHIPPABLE_GO_VERSION =~ [0-9].[0-9] ]]; then gvm install go$SHIPPABLE_GO_VERSION; gvm use go$SHIPPABLE_GO_VERSION; fi - export GOPATH=$SHIPPABLE_GOPATH - go get github.com/t-yuki/gocover-cobertura - go get github.com/onsi/gomega - go get github.com/onsi/ginkgo - go get code.google.com/p/go.tools/cmd/cover - "export DISPLAY=:99.0" - /usr/bin/Xvfb :99 & install: - go build -tags gtk_3_10 -v ./... script: - go test -tags gtk_3_10 -coverprofile=coverage_gtk.txt -covermode count ./gtk - go test -tags gtk_3_10 ./glib - $GOPATH/bin/gocover-cobertura < coverage_gtk.txt > shippable/codecoverage/coverage_gtk.xml