func goError(err *C.GError) error {
if err != nil {
defer C.g_error_free(err)
return errors.New(C.GoString((*C.char)(err.message)))
}
return nil
}
// RunJavaScript runs script asynchronously in the context of the current page
// in the WebView. Upon completion, resultCallback will be called with the
// result of evaluating the script, or with an error encountered during
// execution. To get the stack trace and other error logs, use the
// ::console-message signal.
//
// See also: webkit_web_view_run_javascript at
// http://webkitgtk.org/reference/webkit2gtk/stable/WebKitWebView.html#webkit-web-view-run-javascript
func (v *WebView) RunJavaScript(script string, resultCallback func(result *gojs.Value, err error)) {
var cCallback C.GAsyncReadyCallback
var userData C.gpointer
var err error
if resultCallback != nil {
callback := func(result *C.GAsyncResult) {
var jserr *C.GError
jsResult := C.webkit_web_view_run_javascript_finish(v.webView, result, &jserr)
if jsResult == nil {
defer C.g_error_free(jserr)
msg := C.GoString((*C.char)(jserr.message))
resultCallback(nil, errors.New(msg))
return
}
ctxRaw := gojs.RawGlobalContext(unsafe.Pointer(C.webkit_javascript_result_get_global_context(jsResult)))
jsValRaw := gojs.RawValue(unsafe.Pointer(C.webkit_javascript_result_get_value(jsResult)))
ctx := (*gojs.Context)(gojs.NewGlobalContextFrom(ctxRaw))
jsVal := ctx.NewValueFrom(jsValRaw)
resultCallback(jsVal, nil)
}
cCallback, userData, err = newGAsyncReadyCallback(callback)
if err != nil {
panic(err)
}
}
cScript := C.CString(script)
defer C.free(unsafe.Pointer(cScript))
C.webkit_web_view_run_javascript(v.webView, (*C.gchar)(cScript), nil, cCallback, userData)
}
// 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
}
// ParseWarning() is a wrapper around gst_message_parse_warning().
func (v *Message) ParseWarning() (err error, debug string) {
var e *C.GError
var d *C.gchar
C.gst_message_parse_warning(v.native(), &e, &d)
eMessage := C.GoString((*C.char)(e.message))
defer C.g_error_free(e)
debug = C.GoString((*C.char)(d))
defer C.g_free((C.gpointer)(d))
return errors.New(eMessage), debug
}
// 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
}
func PixbufSaveToStreamFinish(async_result *C.GAsyncResult) (_go__return__ bool, _error_ error) {
var _cgo_error_ *C.GError
var _return_ C.gboolean
_return_ = C._gdk_pixbuf_save_to_stream_finish(async_result, unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = _return_ == (C.gboolean)(C.TRUE)
return
}
func PixbufNewFromStream(stream *C.GInputStream, cancellable *C.GCancellable) (_go__return__ Pixbuf, _error_ error) {
var _cgo_error_ *C.GError
var _return_ *C.GdkPixbuf
_return_ = C._gdk_pixbuf_new_from_stream(stream, cancellable, unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = ToPixbuf(unsafe.Pointer(_return_))
return
}
func (_self_ *PixbufLoader) Close() (_go__return__ bool, _error_ error) {
var _cgo_error_ *C.GError
var _return_ C.gboolean
_return_ = C._gdk_pixbuf_loader_close((*C.GdkPixbufLoader)(_self_._value_), unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = _return_ == (C.gboolean)(C.TRUE)
return
}
func PixbufNewFromStreamFinish(async_result *C.GAsyncResult) (_go__return__ Pixbuf, _error_ error) {
var _cgo_error_ *C.GError
var _return_ *C.GdkPixbuf
_return_ = C._gdk_pixbuf_new_from_stream_finish(async_result, unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = ToPixbuf(unsafe.Pointer(_return_))
return
}
func NewElementFromUri(t C.GstURIType, uri, name string) (*C.GstElement, error) {
var err *C.GError
element := C.gst_element_make_from_uri(t, toGStr(uri), toGStr(name), &err)
if element == nil {
defer C.g_error_free(err)
return nil, errors.New(fmt.Sprintf("%s", err.message))
}
runtime.SetFinalizer(element, func(e *C.GstElement) {
C.gst_object_unref(asGPtr(element))
})
return element, nil
}
// GetSnapshotCustom runs asynchronously, taking a snapshot of the WebView.
// Upon completion, resultCallback will be called with a copy of the underlying
// bitmap backing store for the frame, or with an error encountered during
// execution.
//
// See also: webkit_web_view_get_snapshot at
// http://webkitgtk.org/reference/webkit2gtk/stable/WebKitWebView.html#webkit-web-view-get-snapshot
func (v *WebView) GetSnapshotCustom(region SnapshotRegion, options SnapshotOptions, resultCallback func(result *image.RGBA, err error)) {
var cCallback C.GAsyncReadyCallback
var userData C.gpointer
var err error
if resultCallback != nil {
callback := func(result *C.GAsyncResult) {
var snapErr *C.GError
snapResult := C.webkit_web_view_get_snapshot_finish(v.webView, result, &snapErr)
if snapResult == nil {
defer C.g_error_free(snapErr)
msg := C.GoString((*C.char)(snapErr.message))
resultCallback(nil, errors.New(msg))
return
}
defer C.cairo_surface_destroy(snapResult)
if C.cairo_surface_get_type(snapResult) != cairoSurfaceTypeImage ||
C.cairo_image_surface_get_format(snapResult) != cairoImageSurfaceFormatARGB32 {
panic("Snapshot in unexpected format")
}
w := int(C.cairo_image_surface_get_width(snapResult))
h := int(C.cairo_image_surface_get_height(snapResult))
stride := int(C.cairo_image_surface_get_stride(snapResult))
C.cairo_surface_flush(snapResult)
data := unsafe.Pointer(C.cairo_image_surface_get_data(snapResult))
//(miha) fix endianes depended byte order, and copy to go slice at the same time.
data_fixed := make([]byte, stride*h)
C.gowk2_cairo_endian_depended_ARGB32_to_RGBA((*C.uchar)(data), (*C.uchar)(&data_fixed[0]), C.uint(stride*h))
rgba := &image.RGBA{data_fixed, stride, image.Rect(0, 0, w, h)}
// slower but doesn't use Go pointers inside C. See https://github.com/golang/go/issues/8310 !!!!!!!
//C.gowk2_cairo_endian_depended_ARGB32_to_RGBA((*C.uchar)(data), C.uint(stride*h))
//rgba := &image.RGBA{C.GoBytes(data, C.int(stride*h)), stride, image.Rect(0, 0, w, h)}
resultCallback(rgba, nil)
}
cCallback, userData, err = newGAsyncReadyCallback(callback)
if err != nil {
panic(err)
}
}
C.webkit_web_view_get_snapshot(v.webView,
(C.WebKitSnapshotRegion)(region),
(C.WebKitSnapshotOptions)(options),
nil,
cCallback,
userData)
}
// SavePNG is a wrapper around gdk_pixbuf_save().
// 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
}
// SaveJPEG is a wrapper around gdk_pixbuf_save().
// 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
}
// PixbufNewFromFileAtScale() is a wrapper around gdk_pixbuf_new_from_file_at_scale().
func PixbufNewFromFileAtScale(fileName string, width, height int, preserveAspectRatio bool) (*Pixbuf, error) {
var cerr *C.GError
cstr := C.CString(fileName)
defer C.free(unsafe.Pointer(cstr))
c := C.gdk_pixbuf_new_from_file_at_scale(cstr, C.int(width), C.int(height), gbool(preserveAspectRatio), &cerr)
if c == nil {
defer C.g_error_free(cerr)
return nil, errors.New(C.GoString((*C.char)(C.error_get_message(cerr))))
}
obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))}
p := wrapPixbuf(obj)
runtime.SetFinalizer(obj, (*glib.Object).Unref)
return p, nil
}
// PixbufNewFromFile() is a wrapper around gdk_pixbuf_new_from_file().
func PixbufNewFromFile(fileName string) (*Pixbuf, error) {
var cerr *C.GError
cstr := C.CString(fileName)
defer C.free(unsafe.Pointer(cstr))
c := C.gdk_pixbuf_new_from_file(cstr, &cerr)
if c == nil {
defer C.g_error_free(cerr)
return nil, errors.New(C.GoString((*C.char)(C.error_get_message(cerr))))
}
obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))}
p := wrapPixbuf(obj)
runtime.SetFinalizer(obj, (*glib.Object).Unref)
return p, nil
}
// Delete removes credentials from the store.
func (h Secretservice) Delete(serverURL string) error {
if serverURL == "" {
return errors.New("missing server url")
}
server := C.CString(serverURL)
defer C.free(unsafe.Pointer(server))
if err := C.delete(server); err != nil {
defer C.g_error_free(err)
errMsg := (*C.char)(unsafe.Pointer(err.message))
return errors.New(C.GoString(errMsg))
}
return nil
}
func PixbufNewFromResource(resource_path string) (_go__return__ Pixbuf, _error_ error) {
var _cgo_error_ *C.GError
var _return_ *C.GdkPixbuf
_cstring_resource_path_ := C.CString(resource_path)
_cgo_resource_path_ := (*C.char)(unsafe.Pointer(_cstring_resource_path_))
defer C.free(unsafe.Pointer(_cstring_resource_path_))
_return_ = C._gdk_pixbuf_new_from_resource(_cgo_resource_path_, unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = ToPixbuf(unsafe.Pointer(_return_))
return
}
// 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
res := C.gdk_pixbuf_new_from_file((*C.char)(cstr), &err)
if res == nil {
defer C.g_error_free(err)
return nil, errors.New(C.GoString((*C.char)(err.message)))
}
obj := &glib.Object{glib.ToGObject(unsafe.Pointer(res))}
p := &Pixbuf{obj}
runtime.SetFinalizer(obj, (*glib.Object).Unref)
return p, nil
}
func PixbufNewFromFileAtSize(filename string, width C.int, height C.int) (_go__return__ Pixbuf, _error_ error) {
var _cgo_error_ *C.GError
var _return_ *C.GdkPixbuf
_cstring_filename_ := C.CString(filename)
_cgo_filename_ := (*C.char)(unsafe.Pointer(_cstring_filename_))
defer C.free(unsafe.Pointer(_cstring_filename_))
_return_ = C._gdk_pixbuf_new_from_file_at_size(_cgo_filename_, width, height, unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = ToPixbuf(unsafe.Pointer(_return_))
return
}
func PixbufLoaderNewWithType(image_type string) (_go__return__ PixbufLoader, _error_ error) {
var _cgo_error_ *C.GError
var _return_ *C.GdkPixbufLoader
_cstring_image_type_ := C.CString(image_type)
_cgo_image_type_ := (*C.char)(unsafe.Pointer(_cstring_image_type_))
defer C.free(unsafe.Pointer(_cstring_image_type_))
_return_ = C._gdk_pixbuf_loader_new_with_type(_cgo_image_type_, unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = ToPixbufLoader(unsafe.Pointer(_return_))
return
}
func (m *Message) ParseError() (err *glib.Error, debug string) {
var d *C.gchar
var e, ret_e *C.GError
C.gst_message_parse_error(m.g(), &e, &d)
defer C.g_error_free(e)
defer C.free(unsafe.Pointer(d))
debug = C.GoString((*C.char)(d))
ret_e = new(C.GError)
*ret_e = *e
err = (*glib.Error)(unsafe.Pointer(ret_e))
return
}
func PixbufAnimationNewFromFile(filename string) (_go__return__ PixbufAnimation, _error_ error) {
var _cgo_error_ *C.GError
var _return_ *C.GdkPixbufAnimation
_cstring_filename_ := C.CString(filename)
_cgo_filename_ := (*C.char)(unsafe.Pointer(_cstring_filename_))
defer C.free(unsafe.Pointer(_cstring_filename_))
_return_ = C._gdk_pixbuf_animation_new_from_file(_cgo_filename_, unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = ToPixbufAnimation(unsafe.Pointer(_return_))
return
}
// 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
res := 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 res == nil {
return nil, nilPtrErr
}
obj := &glib.Object{glib.ToGObject(unsafe.Pointer(res))}
p := &Pixbuf{obj}
runtime.SetFinalizer(obj, (*glib.Object).Unref)
return p, nil
}
func PixbufNewFromStreamAtScale(stream *C.GInputStream, width int, height int, preserve_aspect_ratio bool, cancellable *C.GCancellable) (_go__return__ Pixbuf, _error_ error) {
var _cgo_error_ *C.GError
var _return_ *C.GdkPixbuf
_cgo_width_ := (C.gint)(width)
_cgo_height_ := (C.gint)(height)
_cgo_preserve_aspect_ratio_ := (C.gboolean)(C.FALSE)
if preserve_aspect_ratio {
_cgo_preserve_aspect_ratio_ = (C.gboolean)(C.TRUE)
}
_return_ = C._gdk_pixbuf_new_from_stream_at_scale(stream, _cgo_width_, _cgo_height_, _cgo_preserve_aspect_ratio_, cancellable, unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = ToPixbuf(unsafe.Pointer(_return_))
return
}
// Add adds new credentials to the keychain.
func (h Secretservice) Add(creds *credentials.Credentials) error {
if creds == nil {
return errors.New("missing credentials")
}
server := C.CString(creds.ServerURL)
defer C.free(unsafe.Pointer(server))
username := C.CString(creds.Username)
defer C.free(unsafe.Pointer(username))
secret := C.CString(creds.Secret)
defer C.free(unsafe.Pointer(secret))
if err := C.add(server, username, secret); err != nil {
defer C.g_error_free(err)
errMsg := (*C.char)(unsafe.Pointer(err.message))
return errors.New(C.GoString(errMsg))
}
return nil
}
func PixbufNewFromResourceAtScale(resource_path string, width C.int, height C.int, preserve_aspect_ratio bool) (_go__return__ Pixbuf, _error_ error) {
var _cgo_error_ *C.GError
var _return_ *C.GdkPixbuf
_cstring_resource_path_ := C.CString(resource_path)
_cgo_resource_path_ := (*C.char)(unsafe.Pointer(_cstring_resource_path_))
defer C.free(unsafe.Pointer(_cstring_resource_path_))
_cgo_preserve_aspect_ratio_ := (C.gboolean)(C.FALSE)
if preserve_aspect_ratio {
_cgo_preserve_aspect_ratio_ = (C.gboolean)(C.TRUE)
}
_return_ = C._gdk_pixbuf_new_from_resource_at_scale(_cgo_resource_path_, width, height, _cgo_preserve_aspect_ratio_, unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = ToPixbuf(unsafe.Pointer(_return_))
return
}
func gErrorToGoError(gerr *C.GError) error {
if gerr == nil {
return errors.New("Poppler/GLib: unknown error")
}
defer C.g_error_free(gerr)
message := C.GoString((*C.char)(gerr.message))
if message == "No error" {
// Work around inconsistent error message when named file doesn't exist.
quarkString := C.GoString((*C.char)(C.g_quark_to_string(gerr.domain)))
if "g-file-error-quark" == quarkString {
return fmt.Errorf("Poppler/GLib: file error, code %d", gerr.code)
}
return fmt.Errorf("Poppler/GLib: unknown error, domain %d, code %d", gerr.domain, gerr.code)
}
return fmt.Errorf("Poppler/GLib: %s", C.GoString((*C.char)(gerr.message)))
}
// Write() is a wrapper around gdk_pixbuf_loader_write().
func (v *PixbufLoader) Write(data []byte) (n int, err 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 cerr *C.GError
ok := gobool(C.gdk_pixbuf_loader_write(v.Native(), (*C.guchar)(unsafe.Pointer(&data[0])), C.gsize(len(data)), &cerr))
if !ok {
defer C.g_error_free(cerr)
return 0, errors.New(C.GoString((*C.char)(C.error_get_message(cerr))))
}
return len(data), nil
}
func PixbufNewFromInline(data_length int, data []byte, copy_pixels bool) (_go__return__ Pixbuf, _error_ error) {
var _cgo_error_ *C.GError
var _return_ *C.GdkPixbuf
_cgo_data_length_ := (C.gint)(data_length)
_cgo_copy_pixels_ := (C.gboolean)(C.FALSE)
if copy_pixels {
_cgo_copy_pixels_ = (C.gboolean)(C.TRUE)
}
_cstring_data_ := C.CString(string(data))
defer C.free(unsafe.Pointer(_cstring_data_))
_cgo_data_ := (*C.guint8)(unsafe.Pointer(_cstring_data_))
_return_ = C._gdk_pixbuf_new_from_inline(_cgo_data_length_, _cgo_data_, _cgo_copy_pixels_, unsafe.Pointer(&_cgo_error_))
if _cgo_error_ != nil {
_error_ = &Error{C.GoString((*C.char)(unsafe.Pointer(_cgo_error_.message)))}
defer C.g_error_free(_cgo_error_)
}
_go__return__ = ToPixbuf(unsafe.Pointer(_return_))
return
}
// Similar to gst_parse_launch, but makes a bin instead of a pipeline
func ParseBinFromDescription(desc string) (*Bin, error) {
en := (*C.gchar)(C.CString(desc))
defer C.free(unsafe.Pointer(en))
ghost_unlinked_pads := C.gboolean(1) // probably should be true? http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gstreamer/html/gstreamer-GstParse.html#gst-parse-bin-from-description
var Cerr *C.GError
p := glib.Pointer(C.gst_parse_bin_from_description(en, ghost_unlinked_pads, &Cerr))
if Cerr != nil {
errStr := (*glib.Error)(unsafe.Pointer(Cerr)).Error()
C.g_error_free(Cerr)
return nil, errors.New(errStr)
}
if p == nil {
return nil, nil
}
b := new(Bin)
b.SetPtr(p)
return b, nil
}
