func PixbufFromFileAtSize(path string, imgW int, imgH int) (pixbuf *GdkPixbuf, err **glib.Error) {
var error *C.GError
ptr := C.CString(path)
defer C.free_string(ptr)
pixbuf = &GdkPixbuf{C.gdk_pixbuf_new_from_file_at_size(ptr, C.int(imgW), C.int(imgH), &error)}
if err != nil && error != nil {
*err = glib.ErrorFromNative(unsafe.Pointer(error))
}
return
}
func NewPixbufFromFileAtSize(filename string, width, heigth int) (*Pixbuf, *glib.Error) {
var err *C.GError
ptr := C.CString(filename)
defer cfree(ptr)
gpixbuf := C.gdk_pixbuf_new_from_file_at_size(ptr, C.int(width), C.int(heigth), &err)
if err != nil {
return nil, glib.ErrorFromNative(unsafe.Pointer(err))
}
return &Pixbuf{
GdkPixbuf: &GdkPixbuf{gpixbuf},
GObject: glib.ObjectFromNative(unsafe.Pointer(gpixbuf)),
}, nil
}
func NewFromFileAtSize(path string, imgW int, imgH int) (pixbuf *Pixbuf, err **glib.Error) {
var error *C.GError
ptr := C.CString(path)
defer C.free_string(ptr)
gpixbuf := C.gdk_pixbuf_new_from_file_at_size(ptr, C.int(imgW), C.int(imgH), &error)
pixbuf = &Pixbuf{
GPixbuf: gpixbuf,
GObject: glib.ObjectFromNative(unsafe.Pointer(gpixbuf)),
}
if err != nil && error != nil {
*err = glib.ErrorFromNative(unsafe.Pointer(error))
}
return
}
// PixbufNewFromFileAtSize() is a wrapper around gdk_pixbuf_new_from_file_at_size().
func PixbufNewFromFileAtSize(fileName string, width, height int) (*Pixbuf, error) {
var cerr *C.GError
cstr := C.CString(fileName)
defer C.free(unsafe.Pointer(cstr))
c := C.gdk_pixbuf_new_from_file_at_size(cstr, C.int(width), C.int(height), &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
}
/*
Creates a new pixbuf by loading an image from a file.
The file format is detected automatically. If %NULL is returned, then
@error will be set. Possible errors are in the #GDK_PIXBUF_ERROR and
#G_FILE_ERROR domains.
The image will be scaled to fit in the requested size, preserving
the image's aspect ratio. Note that the returned pixbuf may be smaller
than @width x @height, if the aspect ratio requires it. To load
and image at the requested size, regardless of aspect ratio, use
gdk_pixbuf_new_from_file_at_scale().
*/
func PixbufNewFromFileAtSize(filename string, width int, height int) (return__ *Pixbuf, __err__ error) {
__cgo__filename := C.CString(filename)
var __cgo_error__ *C.GError
var __cgo__return__ interface{}
__cgo__return__ = C.gdk_pixbuf_new_from_file_at_size(__cgo__filename, C.int(width), C.int(height), &__cgo_error__)
C.free(unsafe.Pointer(__cgo__filename))
if __cgo__return__ != nil {
return__ = NewPixbufFromCPointer(unsafe.Pointer(reflect.ValueOf(__cgo__return__).Pointer()))
}
if __cgo_error__ != nil {
__err__ = errors.New(C.GoString((*C.char)(unsafe.Pointer(__cgo_error__.message))))
}
return
}
func NewFromFileAtSize(filename string, width, heigth int) (*Pixbuf, *glib.Error) {
var error *C.GError
ptr := C.CString(filename)
defer cfree(ptr)
gpixbuf := C.gdk_pixbuf_new_from_file_at_size(ptr, C.int(width), C.int(heigth), &error)
if error != nil {
err := glib.ErrorFromNative(unsafe.Pointer(error))
return nil, err
}
pixbuf := &Pixbuf{
GPixbuf: gpixbuf,
GObject: glib.ObjectFromNative(unsafe.Pointer(gpixbuf)),
}
return pixbuf, nil
}
// 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
}
