Gtk
14 results

 view release on metacpan or  search on metacpan

GdkImlib.xs  view on Meta::CPAN 


int
gdk_imlib_save_image_to_ppm(self, file)
	Gtk::Gdk::ImlibImage self
	char* file

void
gdk_imlib_load_file_to_pixmap(Class, file)
	SV * Class
	char* file
	PPCODE:
	{
		GdkPixmap * result = 0;
		GdkBitmap * mask = 0;
		int ret;
		ret = gdk_imlib_load_file_to_pixmap(file, &result, &mask);
		if (result) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGdkPixmap(result)));
		}
		if (mask) {

GdkImlib.xs  view on Meta::CPAN 

			lines[i-1] = SvPV(ST(i),na);
		RETVAL = gdk_imlib_create_image_from_xpm_data(lines);
		free(lines);
	}
	OUTPUT:
	RETVAL

void
gdk_imlib_data_to_pixmap(Class, data, ...)
	SV *	data
	PPCODE:
	{
		GdkPixmap * result = 0;
		GdkBitmap * mask = 0;
		int ret;
		char ** lines = (char**)malloc(sizeof(char*)*(items-1));
		int i;
		for(i=1;i<items;i++)
			lines[i-1] = SvPV(ST(i),na);
		ret = gdk_imlib_data_to_pixmap(lines, &result, &mask);
		if (result) {

Gtk.xs  view on Meta::CPAN 

void
gtk_menu_factory_remove_subfactory(factory, subfactory, path)
	Gtk::MenuFactory	factory
	Gtk::MenuFactory	subfactory
	char *	path

void
gtk_menu_factory_find(factory, path)
	Gtk::MenuFactory	factory
	char *	path
	PPCODE:
	{
		GtkMenuPath * p = gtk_menu_factory_find(factory, path);
		if (p) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGtkObjectRef(GTK_OBJECT(p->widget), 0)));
			if (GIMME == G_ARRAY) {
				EXTEND(sp,1);
				PUSHs(sv_2mortal(newSVpv(p->path, 0)));
			}
		}

Gtk.xs  view on Meta::CPAN 

events_pending(Class)
	SV *	Class
	CODE:
	RETVAL = gdk_events_pending();
	OUTPUT:
	RETVAL

void
event_get(Class)
	SV *	Class
	PPCODE:
	{
		GdkEvent * e;
		HV * hash;
		GV * stash;
		int i, dohandle=0;

		if (e = gdk_event_get()) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGdkEvent(e)));
		}

Gtk.xs  view on Meta::CPAN 


void
gdk_window_set_back_pixmap(window, pixmap, parent_relative)
	Gtk::Gdk::Window	window
	Gtk::Gdk::Pixmap	pixmap
	int	parent_relative

void
gdk_window_get_geometry(window)
	Gtk::Gdk::Window	window
	PPCODE:
	{
		int x,y,width,height,depth;
		gdk_window_get_geometry(window,&x,&y,&width,&height,&depth);
		if (GIMME != G_ARRAY)
			croak("must accept array");
		EXTEND(sp,5);
		PUSHs(sv_2mortal(newSViv(x)));
		PUSHs(sv_2mortal(newSViv(y)));
		PUSHs(sv_2mortal(newSViv(width)));
		PUSHs(sv_2mortal(newSViv(height)));
		PUSHs(sv_2mortal(newSViv(depth)));
	}

void
gdk_window_get_position(window)
	Gtk::Gdk::Window	window
	PPCODE:
	{
		int x,y;
		gdk_window_get_position(window,&x,&y);
		if (GIMME != G_ARRAY)
			croak("must accept array");
		EXTEND(sp,2);
		PUSHs(sv_2mortal(newSViv(x)));
		PUSHs(sv_2mortal(newSViv(y)));
	}

Gtk.xs  view on Meta::CPAN 

gdk_window_get_visual(window)
	Gtk::Gdk::Window	window

Gtk::Gdk::Colormap
gdk_window_get_colormap(window)
	Gtk::Gdk::Window	window

void
gdk_window_get_origin(window)
	Gtk::Gdk::Window	window
	PPCODE:
	{
		int x,y;
		gdk_window_get_origin(window,&x,&y);
		if (GIMME != G_ARRAY)
			croak("must accept array");
		EXTEND(sp,2);
		PUSHs(sv_2mortal(newSViv(x)));
		PUSHs(sv_2mortal(newSViv(y)));
	}

void
gdk_window_get_pointer(window)
	Gtk::Gdk::Window	window
	PPCODE:
	{
		int x,y;
		GdkModifierType mask;
		GdkWindow * w = gdk_window_get_pointer(window,&x,&y,&mask);
		if (GIMME != G_ARRAY)
			croak("must accept array");
		EXTEND(sp,4);
		PUSHs(sv_2mortal(newSViv(x)));
		PUSHs(sv_2mortal(newSViv(y)));
		PUSHs(sv_2mortal(newSVGdkWindow(w)));

Gtk.xs  view on Meta::CPAN 

gdk_window_get_parent(window)
	Gtk::Gdk::Window	window

Gtk::Gdk::Window
gdk_window_get_toplevel(window)
	Gtk::Gdk::Window	window

void
gdk_window_get_children(window)
	Gtk::Gdk::Window	window
	PPCODE:
	{
		GList * l = gdk_window_get_children(window);
		while(l) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGdkWindow((GdkWindow*)l->data)));
			l=l->next;
		}
	}

Gtk::Gdk::EventMask

Gtk.xs  view on Meta::CPAN 


MODULE = Gtk        PACKAGE = Gtk::Gdk::Pixmap  PREFIX = gdk_window_

Gtk::Gdk::WindowType
gdk_window_get_type(window)
	Gtk::Gdk::Window	window

void
gdk_window_get_size(window)
	Gtk::Gdk::Window	window
	PPCODE:
	{
		int width,height;
		gdk_window_get_size(window,&width,&height);
		if (GIMME != G_ARRAY)
			croak("must accept array");
		EXTEND(sp,2);
		PUSHs(sv_2mortal(newSViv(height)));
		PUSHs(sv_2mortal(newSViv(width)));
	}

Gtk.xs  view on Meta::CPAN 

	RETVAL = gdk_pixmap_create_from_data(window, SvPV(data,na), width, height, depth, fg, bg);
	OUTPUT:
	RETVAL

void
create_from_xpm(Class, window, transparent_color, filename)
	SV *	Class
	Gtk::Gdk::Window	window
	Gtk::Gdk::Color	transparent_color
	char *	filename
	PPCODE:
	{
		GdkPixmap * result = 0;
		GdkBitmap * mask = 0;
		result = gdk_pixmap_create_from_xpm(window, (GIMME == G_ARRAY) ? &mask : 0,
			transparent_color, filename); 
		if (result) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGdkPixmap(result)));
		}
		if (mask) {

Gtk.xs  view on Meta::CPAN 

			PUSHs(sv_2mortal(newSVGdkBitmap(mask)));
		}
	}

void
create_from_xpm_d(Class, window, transparent_color, data, ...)
	SV *	Class
	Gtk::Gdk::Window	window
	Gtk::Gdk::Color	transparent_color
	SV *	data
	PPCODE:
	{
		GdkPixmap * result = 0;
		GdkBitmap * mask = 0;
		char ** lines = (char**)malloc(sizeof(char*)*(items-3));
		int i;
		for(i=3;i<items;i++)
			lines[i-3] = SvPV(ST(i),na);
		result = gdk_pixmap_create_from_xpm_d(window, (GIMME == G_ARRAY) ? &mask : 0,
			transparent_color, lines); 
		free(lines);

Gtk.xs  view on Meta::CPAN 

				RETVAL = gdk_visual_get_best_with_depth(d);
			else
				RETVAL = gdk_visual_get_best();
	}
	OUTPUT:
	RETVAL

void
depths(Class)
	SV *	Class
	PPCODE:
	{
		gint *depths;
		gint count;
		int i;
		gdk_query_depths(&depths, &count);
		for(i=0;i<count;i++) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSViv(depths[i])));
		}
	}

void
visual_types(Class)
	SV *	Class
	PPCODE:
	{
		GdkVisualType *types;
		gint count;
		int i;
		gdk_query_visual_types(&types, &count);
		for(i=0;i<count;i++) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGdkVisualType(types[i])));
		}
	}

void
visuals(Class)
	SV *	Class
	PPCODE:
	{
		GList *list, *tmp;
		list = gdk_list_visuals();
		tmp = list;
		while (tmp) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGdkVisual((GdkVisual*)tmp->data)));
			tmp = tmp->next;
		}
		g_list_free(list);

Gtk.xs  view on Meta::CPAN 


void
gdk_property_get(Class, window, property, type, offset, length, pdelete)
	SV *	Class
	Gtk::Gdk::Window	window
	Gtk::Gdk::Atom	property
	Gtk::Gdk::Atom	type
	int	offset
	int	length
	int	pdelete
	PPCODE:
	{
		guchar * data;
		GdkAtom actual_type;
		int actual_format, actual_length;
		int result = gdk_property_get(window, property, type, offset, length, pdelete, &actual_type, &actual_format, &actual_length, &data);
		if (result) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVpv(data,0)));
			if (GIMME == G_ARRAY) {
				EXTEND(sp,2);

Gtk.xs  view on Meta::CPAN 

	OUTPUT:
	RETVAL

MODULE = Gtk		PACKAGE = Gtk::Gdk::Rectangle	PREFIX = gdk_rectangle_

void
gdk_rectangle_intersect(Class, src1, src2)
	SV *	Class
	Gtk::Gdk::Rectangle	src1
	Gtk::Gdk::Rectangle	src2
	PPCODE:
	{
		GdkRectangle dest;
		int result = gdk_rectangle_intersect(src1,src2,&dest);
		if (result) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGdkRectangle(&dest)));
		}
	}

MODULE = Gtk		PACKAGE = Gtk::Gdk::Event	PREFIX = gdk_event_

GtkBox.xs  view on Meta::CPAN 

	Gtk::Widget child
	int pos

void
gtk_box_query_child_packing (box, child)
	Gtk::Box    box
	Gtk::Widget child
	PREINIT:
	int expand, fill, padding;
	GtkPackType pack_type;
	PPCODE:
		gtk_box_query_child_packing (box, child, &expand, &fill, &padding, &pack_type);
		EXTEND(sp,4);
		PUSHs(sv_2mortal(newSViv(expand)));
		PUSHs(sv_2mortal(newSViv(fill)));
		PUSHs(sv_2mortal(newSViv(padding)));
		PUSHs(sv_2mortal(newSViv(pack_type)));
		

void
gtk_box_set_child_packing (box, child, expand, fill, padding, pack_type)

GtkButtonBox.xs  view on Meta::CPAN 

gtk_button_box_set_child_size_default(Class, min_width, min_height)
	SV *	Class
	int	min_width
	int	min_height
	CODE:
	gtk_button_box_set_child_size_default(min_width, min_height);

void
gtk_button_box_get_child_size_default (Class)
	SV *    Class
	PPCODE:
	{
		int min_width, min_height;
		gtk_button_box_get_child_size_default(&min_width, &min_height);
		EXTEND(sp,2);
		PUSHs(sv_2mortal(newSViv(min_width)));
		PUSHs(sv_2mortal(newSViv(min_height)));
	}

void
gtk_button_box_get_child_size(self)
	Gtk::ButtonBox   self
	PPCODE:
	{
		int min_width, min_height;
		gtk_button_box_get_child_size(self, &min_width, &min_height);
		EXTEND(sp,2);
		PUSHs(sv_2mortal(newSViv(min_width)));
		PUSHs(sv_2mortal(newSViv(min_height)));
	}

void
gtk_button_box_set_child_ipadding(buttonbox, ipad_x, ipad_y)

GtkButtonBox.xs  view on Meta::CPAN 

gtk_button_box_set_child_ipadding_default(Class, ipad_x, ipad_y)
	Gtk::ButtonBox	Class
	int	ipad_x
	int	ipad_y
	CODE:
	gtk_button_box_set_child_size_default(ipad_x, ipad_y);

void
gtk_button_box_get_child_ipadding_default (Class)
	SV *    Class
	PPCODE:
	{
		int ipad_x, ipad_y;
		gtk_button_box_get_child_ipadding_default(&ipad_x, &ipad_y);
		EXTEND(sp,2);
		PUSHs(sv_2mortal(newSViv(ipad_x)));
		PUSHs(sv_2mortal(newSViv(ipad_y)));
	}

void
gtk_button_box_get_child_ipadding(self)
	Gtk::ButtonBox    self
	PPCODE:
	{
		int ipad_x, ipad_y;
		gtk_button_box_get_child_ipadding(self, &ipad_x, &ipad_y);
		EXTEND(sp,2);
		PUSHs(sv_2mortal(newSViv(ipad_x)));
		PUSHs(sv_2mortal(newSViv(ipad_y)));
	}

#endif

GtkCList.xs  view on Meta::CPAN 

	int		row
	int		column
	Gtk::Gdk::Pixmap		pixmap
	Gtk::Gdk::Bitmap	mask

void
gtk_clist_get_pixmap (self, row, column)
	Gtk::CList  self
	int		row
	int		column
	PPCODE:
	{
		GdkPixmap * pixmap = NULL;
		GdkBitmap * bitmap = NULL;
		int result;
		result = gtk_clist_get_pixmap(self, row, column, &pixmap, (GIMME == G_ARRAY) ?&bitmap: NULL);
		if ( result ) {
			if ( pixmap ) {
				EXTEND(sp, 1);
				PUSHs(sv_2mortal(newSVGdkPixmap(pixmap)));
			}

GtkCList.xs  view on Meta::CPAN 

	char*	text
	int		spacing
	Gtk::Gdk::Pixmap	pixmap
	Gtk::Gdk::Bitmap	mask

void
gtk_clist_get_pixtext (self, row, column)
	Gtk::CList  self
	int		row
	int		column
	PPCODE:
	{
		gchar* text = NULL;
		guint8 spacing;
		GdkPixmap * pixmap = NULL;
		GdkBitmap * bitmap = NULL;
		int result;
		/* FIXME: require GIMME == G_ARRAY? */
		result = gtk_clist_get_pixtext(self, row, column, &text, &spacing, &pixmap, &bitmap);
		if ( result ) {
			EXTEND(sp, 4);

GtkCList.xs  view on Meta::CPAN 

gtk_clist_clear(self)
	Gtk::CList  self

#if 0

void
gtk_clist_get_selection_info (self, x, y)
	Gtk::CList  self
	int x
	int y
	PPCODE:
	{
		int row, column;
		gtk_clist_get_selection_info (self, x, y, &row, &column);
	}

#endif

#endif

GtkColorSelection.xs  view on Meta::CPAN 

		c[0] = red;
		c[1] = green;
		c[2] = blue;
		c[3] = opacity;
		gtk_color_selection_set_color(self, c);
	}

void
get_color(self)
	Gtk::ColorSelection	self
	PPCODE:
	{
		double c[4];
		gtk_color_selection_get_color(self, c);
		EXTEND(sp,3);
		PUSHs(sv_2mortal(newSVnv(c[0])));
		PUSHs(sv_2mortal(newSVnv(c[1])));
		PUSHs(sv_2mortal(newSVnv(c[2])));
		if (self->use_opacity) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVnv(c[3])));

GtkContainer.xs  view on Meta::CPAN 

gtk_container_register_toplevel (self)
	Gtk::Container  self

void
gtk_container_unregister_toplevel (self)
	Gtk::Container  self

void
children(self)
	Gtk::Container	self
	PPCODE:
	{
		GList * c = gtk_container_children(self);
		GList * start = c;
		while(c) {
			EXTEND(sp, 1);
			PUSHs(sv_2mortal(newSVGtkObjectRef(GTK_OBJECT((GtkWidget*)c->data), 0)));
			c = c->next;
		}
		if (start)
			g_list_free(start);
	}

void
foreach(self, code, ...)
	Gtk::Container	self
	SV *	code
	PPCODE:
	{
		AV * args;
		SV * arg;
		int i;
		int type;
		args = newAV();
		
		av_push(args, newRV(SvRV(ST(0))));
		av_push(args, newSVsv(ST(1)));
		for (i=2;i<items;i++)

GtkCurve.xs  view on Meta::CPAN 

		for(i=1;i<items;i++)
			vec[i-1] = SvNV(ST(i));
		gtk_curve_set_vector(self, items-1, vec);
		free(vec);
	}

void
get_vector(self, points=32)
	Gtk::Curve	self
	int	points
	PPCODE:
	{
		gfloat * vec;
		int i;
		if (points<=0)
			croak("points must be positive integer");
		vec = malloc(points * sizeof(gfloat));
		gtk_curve_get_vector(self, points, vec);
		EXTEND(sp, points);
		for(i=0;i<points;i++)
			PUSHs(sv_2mortal(newSVnv(vec[i])));

GtkImage.xs  view on Meta::CPAN 


void
gtk_image_set(image, val, mask)
	Gtk::Image	image
	Gtk::Gdk::Image	val
	Gtk::Gdk::Bitmap	mask

void
gtk_image_get(image)
	Gtk::Image	image
	PPCODE:
	{
		GdkImage * val;
		GdkBitmap * mask;
		gtk_image_get(image, &val, &mask);
		EXTEND(sp,2);
		PUSHs(sv_2mortal(val ? newSVGdkImage(val) : newSVsv(&sv_undef)));
		PUSHs(sv_2mortal(mask ? newSVGdkBitmap(mask) : newSVsv(&sv_undef)));
	}

#endif

GtkList.xs  view on Meta::CPAN 

	Gtk::Widget	widget

void
gtk_list_set_selection_mode(self, mode)
	Gtk::List	self
	Gtk::SelectionMode	mode

void
selection(list)
	Gtk::List	list
	PPCODE:
	{
		GList * selection = list->selection;
		while(selection) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGtkObjectRef(GTK_OBJECT(selection->data),0)));
			selection=selection->next;
		}
	}

void
children(list)
	Gtk::List	list
	PPCODE:
	{
		GList * children = list->children;
		while(children) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGtkObjectRef(GTK_OBJECT(children->data),0)));
			children=children->next;
		}
	}

#endif

GtkMenuFactory.xs  view on Meta::CPAN 

void
gtk_menu_factory_remove_subfactory(factory, subfactory, path)
	Gtk::MenuFactory	factory
	Gtk::MenuFactory	subfactory
	char *	path

void
gtk_menu_factory_find(factory, path)
	Gtk::MenuFactory	factory
	char *	path
	PPCODE:
	{
		GtkMenuPath * p = gtk_menu_factory_find(factory, path);
		if (p) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGtkObjectRef(GTK_OBJECT(p->widget), 0)));
			if (GIMME == G_ARRAY) {
				EXTEND(sp,1);
				PUSHs(sv_2mortal(newSVpv(p->path, 0)));
			}
		}

GtkObject.xs  view on Meta::CPAN 

			p += 1 + argc;
		}
	}
	OUTPUT:
	RETVAL

void
get(self, name, ...)
	Gtk::Object	self
	SV *	name
	PPCODE:
	{
		GtkType t;
		GtkArg	argv[3];
		int p;
		int argc;
		
		for(p=1;p<items;) {
		
			argv[0].name = SvPV(ST(p),na);
			t = gtk_object_get_arg_type(argv[0].name);

GtkPixmap.xs  view on Meta::CPAN 


void
gtk_pixmap_set(pixmap, val, mask )
	Gtk::Pixmap	pixmap
	Gtk::Gdk::Pixmap	val
	Gtk::Gdk::Bitmap	mask

void
gtk_pixmap_get(pixmap)
	Gtk::Pixmap	pixmap
	PPCODE:
	{
		GdkPixmap * result = 0;
		GdkBitmap * mask = 0;
		gtk_pixmap_get(pixmap, &result, (GIMME == G_ARRAY) ? &mask : 0);
		if (result) {
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVGdkPixmap(result)));
		}
		if (mask) {
			EXTEND(sp,1);

GtkWidget.xs  view on Meta::CPAN 

gtk_widget_get_events(widget)
	Gtk::Widget	widget

int
gtk_widget_get_extension_events(widget)
	Gtk::Widget	widget

void
gtk_widget_get_pointer(widget)
	Gtk::Widget	widget
	PPCODE:
	{
		int x,y;
		gtk_widget_get_pointer(widget, &x, &y);
		EXTEND(sp,2);
		PUSHs(sv_2mortal(newSViv(x)));
		PUSHs(sv_2mortal(newSViv(y)));
	}

void
gtk_widget_push_colormap(Class, colormap)



( run in 3.271 seconds using v1.01-cache-2.11-cpan-71847e10f99 )