Gtk2
view release on metacpan or search on metacpan
ChangeLog.pre-git view on Meta::CPAN
* t/02.GtkContainer.t
* t/GtkDnd.t
* t/GtkTextTag.t
* t/GtkTreeView.t: Remove the Gtk2::Gdk::Event::new skips.
* t/GtkTreeView.t: Use true values to test functions that
return/take a boolean. Only test stuff inside the cell_data_func
once.
* xs/GtkClipboard.xs: Use void for the return value of
wait_for_targets - it uses PPCODE. Check targets for NULL instead
of n_targets.
* xs/GtkCalendar.xs
* xs/GtkComboBox.xs: Mark ix as unused.
* xs/GtkFileChooser.xs: Initialize ret to hush a compiler warning.
* MANIFEST
A t/GdkProperty.t
* xs/GdkProperty.xs: Fix and test property_get and
ChangeLog.pre-git view on Meta::CPAN
* pm/SimpleList.pm, pm/SimpleMenu.pm: quit using base and just add the
parent type to @ISA by hand. this will prevent some problems with
co-existing (really old) inline versions of Gtk2-Perl.
2004/01/04 11:49 (-0500) rwmcfa1
* xs/GdkWindow.xs: for some reason get_pointer was having issues with
certian versions of perl/xsubpp. it seemed to be related to the both
having a return value and having OUTLIST's. this implements it as a
PPCODE section doing the same thing.
2004/01/04 02:50 (+0100) kaffeetisch
* t/10.GtkProgressBar.t: Test get_orientation, get_fraction,
[sg]et_text, and [sg]et_pulse_step.
* t/14.GtkToolbar.t: Test get_orientation, unset_style, get_style,
and get_tooltips.
* xs/GtkInvisible.xs: Add a class parameter to new_for_screen.
ChangeLog.pre-git view on Meta::CPAN
2003/11/17 23:21 (-0500) rwmcfa1
* xs/GdkDisplayManager.xs, xs/GdkDnd.xs, xs/GdkPixmap.xs,
xs/GdkProperty.xs, xs/GdkScreen.xs, xs/GdkTypes.xs, xs/GdkWindow.xs,
xs/Gtk2.xs, xs/GtkAccelGroup.xs, xs/GtkCellRenderer.xs,
xs/GtkColorSelection.xs, xs/GtkCurve.xs, xs/GtkEditable.xs,
xs/GtkFileSelection.xs, xs/GtkIconFactory.xs, xs/GtkLabel.xs,
xs/GtkRadioMenuItem.xs, xs/GtkSelection.xs, xs/GtkStock.xs,
xs/GtkTextBuffer.xs, xs/GtkTreeModel.xs, xs/GtkTreeSortable.xs,
xs/GtkTreeViewColumn.xs, xs/PangoLayout.xs, xs/PangoTabs.xs: apidoc
added, almost all PPCODE xsubs now have it
* xs/GtkTreeDnd.xs: gtk_tree_get_row_drag_data had the outlist params
in the prototype. apidoc added, almost all PPCODE xsubs now have it
* xs/GtkContainer.xs: PPCODE -> CODE, return was always void. apidoc
added, almost all PPCODE xsubs now have it
* xs/GdkSelection.xs: added a class parameter to
gdk_selection_property_get. apidoc added, almost all PPCODE xsubs now
have it
2003/11/17 16:27 (-0500) muppetman
* xs/GdkPixbuf.xs: i borked the get_from_(drawable|image) xsubs...
this fixes them, and adds docs.
2003/11/17 22:04 (+0100) kaffeetisch
* CodeGen.pm: Create INPUT typemaps for the 'const' equivalents of
ChangeLog.pre-git view on Meta::CPAN
comments
* xs/GdkDisplay.xs: added const qualifier to gchar * return value
* xs/GdkDnd.xs: copy-and-paste bug fixed, get_protocol(_for_display)
* xs/GdkPixbuf.xs: formatting cleanup
* xs/GdkWindow.xs: quited warning about invalid paramter type
* xs/GtkIconFactory.xs: non-void paramter with PPCODE, fixed
* xs/GtkTearoffMenuItem.xs: teamoff -> tearoff, big bug
* xs/GtkTreeModel.xs: looking for -1 list terminator incorrectly,
bug-fix
2003/09/14 01:31 muppetman
* maps: remove some deprecated types
* xs/GtkIconFactory.xs: implement gtk_icon_set_render_icon
xs/GdkColor.xs view on Meta::CPAN
void
gdk_colormap_alloc_colors (colormap, writeable, best_match, ...)
GdkColormap *colormap
gboolean writeable
gboolean best_match
PREINIT:
gint ncolors, i;
GdkColor *colors = NULL;
GdkColor **argcolors = NULL; /* so we can modify the ones passed in */
gboolean *success = NULL;
PPCODE:
#define first 3
ncolors = items - first;
if (ncolors < 1)
XSRETURN_EMPTY;
colors = g_new0 (GdkColor, ncolors);
argcolors = g_new0 (GdkColor*, ncolors);
success = g_new0 (gboolean, ncolors);
for (i = 0 ; i < ncolors ; i++) {
argcolors[i] = SvGdkColor (ST (first + i));
colors[i] = *(argcolors[i]);
xs/GdkDisplay.xs view on Meta::CPAN
## GList * gdk_display_list_devices (GdkDisplay *display)
=forapi
Returns a list of Gtk2::Gdk::Devices
=cut
void
gdk_display_list_devices (display)
GdkDisplay *display
PREINIT:
GList * devices, * i;
PPCODE:
devices = gdk_display_list_devices (display);
for (i = devices ; i != NULL ; i = i->next)
XPUSHs (sv_2mortal (newSVGdkDevice (i->data)));
GdkEvent* gdk_display_get_event (GdkDisplay *display)
GdkEvent* gdk_display_peek_event (GdkDisplay *display)
void gdk_display_put_event (GdkDisplay *display, GdkEvent *event)
xs/GdkDisplay.xs view on Meta::CPAN
gdk_display_get_core_pointer (display)
GdkDisplay *display
## void gdk_display_get_pointer (GdkDisplay *display, GdkScreen **screen, gint *x, gint *y, GdkModifierType *mask)
void gdk_display_get_pointer (GdkDisplay *display)
PREINIT:
GdkScreen *screen = NULL;
gint x;
gint y;
GdkModifierType mask;
PPCODE:
gdk_display_get_pointer (display, &screen, &x, &y, &mask);
EXTEND (SP, 4);
PUSHs (sv_2mortal (newSVGdkScreen (screen)));
PUSHs (sv_2mortal (newSViv (x)));
PUSHs (sv_2mortal (newSViv (y)));
PUSHs (sv_2mortal (newSVGdkModifierType (mask)));
## GdkWindow * gdk_display_get_window_at_pointer (GdkDisplay *display, gint *win_x, gint *win_y)
###GdkWindow * gdk_display_get_window_at_pointer (GdkDisplay *display, OUTLIST gint win_x, OUTLIST gint win_y)
=for apidoc
=for signature (window, win_x, win_y) = $display->get_window_at_pointer ($display)
=cut
void
gdk_display_get_window_at_pointer (GdkDisplay *display)
PREINIT:
GdkWindow * window;
gint win_x = 0, win_y = 0;
PPCODE:
window = gdk_display_get_window_at_pointer (display, &win_x, &win_y);
if (!window)
XSRETURN_EMPTY;
EXTEND (SP, 3);
PUSHs (sv_2mortal (newSVGdkWindow (window)));
PUSHs (sv_2mortal (newSViv (win_x)));
PUSHs (sv_2mortal (newSViv (win_y)));
# API reference says this shouldn't be used by apps, and is only useful for
xs/GdkDisplayManager.xs view on Meta::CPAN
## GSList * gdk_display_manager_list_displays (GdkDisplayManager *display_manager)
=for apidoc
Returns a list of Gtk2::Gdk::Display's.
=cut
void
gdk_display_manager_list_displays (display_manager)
GdkDisplayManager *display_manager
PREINIT:
GSList * displays, * i;
PPCODE:
displays = gdk_display_manager_list_displays (display_manager);
for (i = displays ; i != NULL ; i = i->next)
XPUSHs (sv_2mortal (newSVGdkDisplay (i->data)));
g_slist_free (displays);
#endif /* >= 2.2.0 */
xs/GdkDnd.xs view on Meta::CPAN
RETVAL
=for apidoc
Returns a list of Gtk2::Gdk::Atom's, the targets.
=cut
void
targets (dc)
GdkDragContext * dc
PREINIT:
GList * i;
PPCODE:
for (i = dc->targets; i != NULL ; i = i->next)
XPUSHs (sv_2mortal (newSVGdkAtom ((GdkAtom)i->data)));
## GdkDragContext * gdk_drag_context_new (void)
GdkDragContext_noinc *
gdk_drag_context_new (class)
C_ARGS:
/* void */
# deprecated
xs/GdkDnd.xs view on Meta::CPAN
GdkDragAction gdk_drag_context_get_selected_action (GdkDragContext *context);
GdkDragAction gdk_drag_context_get_suggested_action (GdkDragContext *context);
# GList * gdk_drag_context_list_targets (GdkDragContext *context);
void
gdk_drag_context_list_targets (GdkDragContext *context)
PREINIT:
GList * i;
PPCODE:
for (i = gdk_drag_context_list_targets (context); i != NULL ; i = i->next)
XPUSHs (sv_2mortal (newSVGdkAtom ((GdkAtom)i->data)));
GdkWindow * gdk_drag_context_get_source_window (GdkDragContext *context);
#endif /* 2.22 */
# --------------------------------------------------------------------------- #
MODULE = Gtk2::Gdk::Dnd PACKAGE = Gtk2::Gdk::DragContext PREFIX = gdk_drag_
xs/GdkDnd.xs view on Meta::CPAN
=for apidoc
=for signature (ret, protocol) = Gtk2::Gdk::DragContext->get_protocol_for_display ($display, $xid)
=cut
void
gdk_drag_get_protocol_for_display (class, display, xid)
GdkDisplay *display
guint32 xid
PREINIT:
GdkDragProtocol protocol;
guint32 ret;
PPCODE:
ret = gdk_drag_get_protocol_for_display (display, xid, &protocol);
XPUSHs (sv_2mortal (newSVuv (ret)));
XPUSHs (sv_2mortal (ret
? newSVGdkDragProtocol (protocol)
: newSVsv (&PL_sv_undef)));
## void gdk_drag_find_window_for_screen (GdkDragContext *context, GdkWindow *drag_window, GdkScreen *screen, gint x_root, gint y_root, GdkWindow **dest_window, GdkDragProtocol *protocol)
=for apidoc
=for signature (dest_window, protocol) = $context->find_window_for_screen ($drag_window, $screen, $x_root, $y_root)
=cut
void
gdk_drag_find_window_for_screen (context, drag_window, screen, x_root, y_root)
GdkDragContext *context
GdkWindow *drag_window
GdkScreen *screen
gint x_root
gint y_root
PREINIT:
GdkWindow *dest_window = NULL;
GdkDragProtocol protocol;
PPCODE:
gdk_drag_find_window_for_screen (context, drag_window, screen,
x_root, y_root,
&dest_window, &protocol);
XPUSHs (sv_2mortal (newSVGdkWindow (dest_window)));
XPUSHs (sv_2mortal ((dest_window
? newSVGdkDragProtocol (protocol)
: newSVsv (&PL_sv_undef))));
#endif /* >= 2.2.0 */
## guint32 gdk_drag_get_protocol (guint32 xid, GdkDragProtocol *protocol)
=for apidoc
=for signature (ret, protocol) = Gtk2::Gdk::DragContext->get_protocol ($xid)
=cut
void
gdk_drag_get_protocol (class, xid)
guint32 xid
PREINIT:
GdkDragProtocol protocol;
guint32 ret;
PPCODE:
ret = gdk_drag_get_protocol (xid, &protocol);
XPUSHs (sv_2mortal (newSVuv (ret)));
XPUSHs (sv_2mortal (newSVGdkDragProtocol (protocol)));
## void gdk_drag_find_window (GdkDragContext *context, GdkWindow *drag_window, gint x_root, gint y_root, GdkWindow **dest_window, GdkDragProtocol *protocol)
=for apidoc
=for signature (dest_window, protocol) = $context->find_window ($drag_window, $x_root, $y_root)
=cut
void
gdk_drag_find_window (context, drag_window, x_root, y_root)
GdkDragContext *context
GdkWindow *drag_window
gint x_root
gint y_root
PREINIT:
GdkWindow *dest_window;
GdkDragProtocol protocol;
PPCODE:
gdk_drag_find_window (context, drag_window, x_root, y_root,
&dest_window, &protocol);
XPUSHs (sv_2mortal (newSVGdkWindow_ornull (dest_window)));
XPUSHs (sv_2mortal (dest_window
? newSVGdkDragProtocol (protocol)
: newSVsv (&PL_sv_undef)));
## gboolean gdk_drag_motion (GdkDragContext *context, GdkWindow *dest_window, GdkDragProtocol protocol, gint x_root, gint y_root, GdkDragAction suggested_action, GdkDragAction possible_actions, guint32 time_)
gboolean
xs/GdkEvent.xs view on Meta::CPAN
## gboolean gdk_event_get_coords (GdkEvent *event, gdouble *x_win, gdouble *y_win)
void
gdk_event_get_coords (event)
GdkEvent *event
ALIAS:
Gtk2::Gdk::Event::coords = 1
PREINIT:
gdouble x;
gdouble y;
PPCODE:
if (!gdk_event_get_coords (event, &x, &y))
XSRETURN_EMPTY;
PERL_UNUSED_VAR (ix);
EXTEND (SP, 2);
PUSHs (sv_2mortal (newSVnv (x)));
PUSHs (sv_2mortal (newSVnv (y)));
=for apidoc Gtk2::Gdk::Event::get_root_coords
=for signature ($x_root, $y_root) = $event->get_root_coords
=cut
xs/GdkEvent.xs view on Meta::CPAN
void
gdk_event_get_root_coords (event)
GdkEvent *event
ALIAS:
Gtk2::Gdk::Event::root_coords = 1
Gtk2::Gdk::Event::x_root = 2
Gtk2::Gdk::Event::y_root = 3
PREINIT:
gdouble x_root;
gdouble y_root;
PPCODE:
if (!gdk_event_get_root_coords (event, &x_root, &y_root))
XSRETURN_EMPTY;
switch (ix) {
case 2: /* x */
PUSHs (sv_2mortal (newSVnv (x_root)));
break;
case 3: /* y */
PUSHs (sv_2mortal (newSVnv (y_root)));
break;
default:
xs/GdkEvent.xs view on Meta::CPAN
| Gtk2::Gdk::CHARS | a string of length 20 |
| Gtk2::Gdk::SHORTS | a list of ten shorts |
| Gtk2::Gdk::LONGS | a list of five longs |
+-------------------+-----------------------+
=cut
void
data (GdkEvent * eventclient, ...)
PREINIT:
int i, first_index = 1;
PPCODE:
switch (eventclient->client.data_format) {
case 8: {
if (items == first_index + 1) {
char *data = SvPV_nolen (ST (first_index));
char old[20];
for (i = 0; i < 20; i++) {
old[i] = eventclient->client.data.b[i];
eventclient->client.data.b[i] = data[i];
}
xs/GdkInput.xs view on Meta::CPAN
=for apidoc
Returns a list of I<GdkDevice>s.
=cut
## GList * gdk_devices_list (void)
void
gdk_devices_list (class)
PREINIT:
GList *i, *list = NULL;
PPCODE:
PERL_UNUSED_VAR (ax);
list = gdk_devices_list ();
for (i = list; i != NULL; i = i->next)
XPUSHs (sv_2mortal (newSVGdkDevice (i->data)));
#endif /* ! GDK_MULTIHEAD_SAFE */
MODULE = Gtk2::Gdk::Device PACKAGE = Gtk2::Gdk::Device PREFIX = gdk_device_
gchar *
xs/GdkInput.xs view on Meta::CPAN
Returns a list of hash references that resemble the I<GdkDeviceAxis> structure,
i.e. that have three keys: "use", "min", and "max".
=cut
void
axes (device)
GdkDevice *device
PREINIT:
int i;
PPCODE:
EXTEND (sp, device->num_axes);
for (i = 0; i < device->num_axes; i++) {
HV *axis = newHV ();
gperl_hv_take_sv_s (axis, "use", newSVGdkAxisUse (device->axes[i].use));
gperl_hv_take_sv_s (axis, "min", newSVnv (device->axes[i].min));
gperl_hv_take_sv_s (axis, "max", newSVnv (device->axes[i].max));
PUSHs (sv_2mortal (newRV_noinc ((SV *) axis)));
xs/GdkInput.xs view on Meta::CPAN
Returns a list of hash references that resemble the I<GdkDeviceKey> structure,
i.e. that have two keys: "keyval" and "modifiers".
=cut
void
keys (device)
GdkDevice *device
PREINIT:
int i;
PPCODE:
EXTEND (sp, device->num_keys);
for (i = 0; i < device->num_keys; i++) {
HV *key = newHV ();
gperl_hv_take_sv_s (key, "keyval", newSVuv (device->keys[i].keyval));
gperl_hv_take_sv_s (key, "modifiers", newSVGdkModifierType (device->keys[i].modifiers));
PUSHs (sv_2mortal (newRV_noinc ((SV *) key)));
}
xs/GdkInput.xs view on Meta::CPAN
=cut
## void gdk_device_get_state (GdkDevice *device, GdkWindow *window, gdouble *axes, GdkModifierType *mask)
void
gdk_device_get_state (device, window)
GdkDevice *device
GdkWindow *window
PREINIT:
gdouble *axes = NULL;
GdkModifierType mask;
int i;
PPCODE:
axes = g_new0 (gdouble, device->num_axes);
gdk_device_get_state (device, window, axes, &mask);
EXTEND (sp, device->num_axes + 1);
PUSHs (sv_2mortal (newSVGdkModifierType (mask)));
for (i = 0; i < device->num_axes; i++)
PUSHs (sv_2mortal (newSVnv (axes[i])));
xs/GdkInput.xs view on Meta::CPAN
## gboolean gdk_device_get_history (GdkDevice *device, GdkWindow *window, guint32 start, guint32 stop, GdkTimeCoord ***events, gint *n_events)
void
gdk_device_get_history (device, window, start, stop)
GdkDevice *device
GdkWindow *window
guint32 start
guint32 stop
PREINIT:
GdkTimeCoord **events = NULL;
gint i, j, n_events = 0;
PPCODE:
if (! gdk_device_get_history (device, window, start, stop, &events, &n_events))
XSRETURN_EMPTY;
EXTEND (sp, n_events);
for (i = 0; i < n_events; i++) {
HV *event;
AV *axes;
axes = newAV ();
xs/GdkKeys.xs view on Meta::CPAN
gdk_keymap_translate_keyboard_state (keymap, hardware_keycode, state, group)
GdkKeymap_orclass * keymap
guint hardware_keycode
GdkModifierType state
gint group
PREINIT:
guint keyval;
gint effective_group;
gint level;
GdkModifierType consumed_modifiers;
PPCODE:
if (!gdk_keymap_translate_keyboard_state (keymap, hardware_keycode,
state, group, &keyval,
&effective_group, &level,
&consumed_modifiers))
XSRETURN_EMPTY;
EXTEND (SP, 4);
PUSHs (sv_2mortal (newSViv (keyval)));
PUSHs (sv_2mortal (newSViv (effective_group)));
PUSHs (sv_2mortal (newSViv (level)));
PUSHs (sv_2mortal (newSVGdkModifierType (consumed_modifiers)));
xs/GdkKeys.xs view on Meta::CPAN
=cut
## gboolean gdk_keymap_get_entries_for_keyval (GdkKeymap *keymap, guint keyval, GdkKeymapKey **keys, gint *n_keys)
void
gdk_keymap_get_entries_for_keyval (keymap, keyval)
GdkKeymap_orclass * keymap
guint keyval
PREINIT:
GdkKeymapKey * keys = NULL;
gint n_keys;
int i;
PPCODE:
if (!gdk_keymap_get_entries_for_keyval (keymap, keyval, &keys, &n_keys))
XSRETURN_EMPTY;
EXTEND (SP, n_keys);
for (i = 0; i < n_keys; i++)
PUSHs (sv_2mortal (newSVGdkKeymapKey (&keys[i])));
g_free (keys);
=for apidoc
=for signature ({ key1, keyval1 }, { ... }) = $keymap->get_entries_for_keycode (hardware_keycode)
Returns a list of hash references, each with two keys: "key" pointing to a
xs/GdkKeys.xs view on Meta::CPAN
void
gdk_keymap_get_entries_for_keycode (keymap, hardware_keycode)
GdkKeymap_orclass * keymap
guint hardware_keycode
PREINIT:
GdkKeymapKey * keys = NULL;
guint * keyvals = NULL;
gint n_entries;
int i;
HV * hv;
PPCODE:
if (!gdk_keymap_get_entries_for_keycode (keymap, hardware_keycode,
&keys, &keyvals, &n_entries))
XSRETURN_EMPTY;
EXTEND (SP, n_entries);
for (i = 0; i < n_entries; i++) {
hv = newHV ();
gperl_hv_take_sv_s (hv, "key", newSVGdkKeymapKey (&keys[i]));
gperl_hv_take_sv_s (hv, "keyval", newSVuv (keyvals[i]));
PUSHs (sv_2mortal (newRV_noinc ((SV*) hv)));
}
xs/GdkKeys.xs view on Meta::CPAN
OUTPUT:
RETVAL
=for apidoc
=for signature (bool, new_state) = $keymap->map_virtual_modifiers (keymap, state)
=cut
void
gdk_keymap_map_virtual_modifiers (GdkKeymap *keymap, GdkModifierType state)
PREINIT:
gboolean result;
PPCODE:
result = gdk_keymap_map_virtual_modifiers (keymap, &state);
EXTEND (SP, 2);
PUSHs (sv_2mortal (boolSV (result)));
PUSHs (sv_2mortal (newSVGdkModifierType (state)));
#endif /* 2.20 */
MODULE = Gtk2::Gdk::Keys PACKAGE = Gtk2::Gdk PREFIX = gdk_
gchar *
xs/GdkKeys.xs view on Meta::CPAN
## void gdk_keyval_convert_case (guint symbol, guint *lower, guint *upper)
=for apidoc
=for signature (lower, upper) = Gtk2::Gdk->keyval_convert_case ($symbol)
=cut
void
gdk_keyval_convert_case (class, symbol)
guint symbol
PREINIT:
guint lower;
guint upper;
PPCODE:
gdk_keyval_convert_case (symbol, &lower, &upper);
EXTEND (SP, 2);
PUSHs (sv_2mortal (newSViv (lower)));
PUSHs (sv_2mortal (newSViv (upper)));
## guint gdk_keyval_to_upper (guint keyval) G_GNUC_CONST
guint
gdk_keyval_to_upper (class, keyval)
guint keyval
C_ARGS:
xs/GdkPixbuf.xs view on Meta::CPAN
=for apidoc
=for signature pixmap = $pixbuf->render_pixmap_and_mask_for_colormap ($colormap, $alpha_threshold)
=for signature (pixmap, mask) = $pixbuf->render_pixmap_and_mask_for_colormap ($colormap, $alpha_threshold)
=cut
void
gdk_pixbuf_render_pixmap_and_mask_for_colormap (pixbuf, colormap, alpha_threshold)
GdkPixbuf *pixbuf
GdkColormap *colormap
int alpha_threshold
PPCODE:
{
GdkPixmap *pm;
GdkBitmap *bm;
gdk_pixbuf_render_pixmap_and_mask_for_colormap (pixbuf, colormap, &pm, GIMME_V == G_ARRAY ? &bm : 0, alpha_threshold);
XPUSHs (sv_2mortal (newSVGdkPixmap_noinc (pm)));
if (GIMME_V == G_ARRAY)
XPUSHs (sv_2mortal (newSVGdkBitmap_noinc (bm)));
}
=for apidoc
=for signature pixmap = $pixbuf->render_pixmap_and_mask ($alpha_threshold)
=for signature (pixmap, mask) = $pixbuf->render_pixmap_and_mask ($alpha_threshold)
=cut
void
gdk_pixbuf_render_pixmap_and_mask (pixbuf, alpha_threshold)
GdkPixbuf *pixbuf
int alpha_threshold
PPCODE:
{
GdkPixmap *pm;
GdkBitmap *bm;
gdk_pixbuf_render_pixmap_and_mask (pixbuf, &pm, GIMME_V == G_ARRAY ? &bm : 0, alpha_threshold);
XPUSHs (sv_2mortal (newSVGdkPixmap_noinc (pm)));
if (GIMME_V == G_ARRAY)
XPUSHs (sv_2mortal (newSVGdkBitmap_noinc (bm)));
}
xs/GdkPixbuf.xs view on Meta::CPAN
### GSList *gdk_pixbuf_get_formats (void)
## list should be freed, but not formats
=for apidoc
Returns a list of hashes with information about the formats supported by
Gtk2::Gdk::Pixbuf.
=cut
void
gdk_pixbuf_get_formats (class=NULL)
PREINIT:
GSList * formats, * i;
PPCODE:
formats = gdk_pixbuf_get_formats ();
for (i = formats ; i != NULL ; i = i->next) {
XPUSHs (sv_2mortal (newSVGdkPixbufFormat (i->data)));
}
g_slist_free (formats);
PERL_UNUSED_VAR (ax);
#endif /* >= 2.2.0 */
#if GTK_CHECK_VERSION(2,4,0)
xs/GdkPixbuf.xs view on Meta::CPAN
Parses enough of I<$filename> to determine and return the format and size.
If the format is unknown or the file can't be opened, returns an empty list.
=cut
void gdk_pixbuf_get_file_info (class, filename)
GPerlFilename filename
PREINIT:
GdkPixbufFormat *format;
gint width = -1;
gint height = -1;
PPCODE:
format = gdk_pixbuf_get_file_info (filename, &width, &height);
if (format) {
EXTEND (sp, 3);
PUSHs (sv_2mortal (newSVGdkPixbufFormat (format)));
PUSHs (sv_2mortal (newSViv (width)));
PUSHs (sv_2mortal (newSViv (height)));
}
#endif
xs/GdkPixmap.xs view on Meta::CPAN
=for signature (pixmap, mask) = Gtk2::Gdk::Pixmap->create_from_xpm ($drawable, $transparent_color, $filename)
=cut
void
gdk_pixmap_create_from_xpm (class, drawable, transparent_color, filename)
GdkDrawable *drawable
GdkColor_ornull *transparent_color
GPerlFilename filename
PREINIT:
GdkPixmap * pixmap;
GdkBitmap * mask;
PPCODE:
pixmap = gdk_pixmap_create_from_xpm (drawable, &mask,
transparent_color, filename);
if (!pixmap)
/* this keeps us from segfaulting, but there's no error
* reporting for the caller or user. the docs don't
* mention the failure mode. we choose to fail in kind. */
XSRETURN_EMPTY;
EXTEND (SP, 2);
PUSHs (sv_2mortal (newSVGdkPixmap_noinc (pixmap)));
PUSHs (sv_2mortal (newSVGdkBitmap_noinc (mask)));
xs/GdkPixmap.xs view on Meta::CPAN
=cut
void
gdk_pixmap_colormap_create_from_xpm (class, drawable, colormap, transparent_color, filename)
GdkDrawable_ornull *drawable
GdkColormap_ornull *colormap
GdkColor_ornull *transparent_color
GPerlFilename filename
PREINIT:
GdkPixmap * pixmap;
GdkBitmap * mask;
PPCODE:
pixmap = gdk_pixmap_colormap_create_from_xpm (drawable, colormap,
&mask, transparent_color, filename);
EXTEND (SP, 2);
PUSHs (sv_2mortal (newSVGdkPixmap_noinc (pixmap)));
PUSHs (sv_2mortal (newSVGdkBitmap_noinc (mask)));
## ## GdkPixmap* gdk_pixmap_create_from_xpm_d (GdkDrawable *drawable, GdkBitmap **mask, GdkColor *transparent_color, gchar **data)
=for apidoc
=for signature ($pixmap, $mask) = Gtk2::Gdk::Pixmap->create_from_xpm_d ($drawable, $transparent_color, @xpm_data)
=for arg drawable used to determine the colormap and visual of the image.
xs/GdkPixmap.xs view on Meta::CPAN
=cut
void
gdk_pixmap_create_from_xpm_d (class, drawable, transparent_color, data, ...)
GdkDrawable *drawable
GdkColor_ornull *transparent_color
PREINIT:
GdkBitmap * mask = NULL;
GdkPixmap * pixmap = NULL;
char ** lines;
int i;
PPCODE:
lines = g_new (char*, items - 3);
for (i = 3 ; i < items ; i++)
lines[i-3] = SvPV_nolen (ST (i));
pixmap = gdk_pixmap_create_from_xpm_d (drawable,
GIMME == G_ARRAY ? &mask : NULL,
transparent_color,
lines);
g_free (lines);
if (pixmap) XPUSHs (sv_2mortal (newSVGdkPixmap_noinc (pixmap)));
if (mask) XPUSHs (sv_2mortal (newSVGdkBitmap_noinc (mask)));
xs/GdkPixmap.xs view on Meta::CPAN
void
gdk_pixmap_colormap_create_from_xpm_d (class, drawable, colormap, transparent_color, data, ...)
GdkDrawable_ornull *drawable
GdkColormap_ornull *colormap
GdkColor_ornull *transparent_color
PREINIT:
GdkBitmap * mask = NULL;
GdkPixmap * pixmap = NULL;
char ** lines;
int i;
PPCODE:
lines = g_new (char*, items - 4);
for (i = 4 ; i < items ; i++)
lines[i-4] = SvPV_nolen (ST (i));
pixmap = gdk_pixmap_colormap_create_from_xpm_d (drawable, colormap,
GIMME == G_ARRAY ? &mask : NULL,
transparent_color,
lines);
g_free (lines);
if (pixmap) XPUSHs (sv_2mortal (newSVGdkPixmap_noinc (pixmap)));
if (mask) XPUSHs (sv_2mortal (newSVGdkBitmap_noinc (mask)));
xs/GdkProperty.xs view on Meta::CPAN
GdkAtom type
gulong offset
gulong length
gint pdelete
PREINIT:
GdkAtom actual_property_type;
gint actual_format;
gint actual_length;
guchar *data;
guint i;
PPCODE:
if (! gdk_property_get (window, property, type, offset, length, pdelete,
&actual_property_type, &actual_format,
&actual_length, &data))
XSRETURN_EMPTY;
EXTEND (SP, 2);
PUSHs (sv_2mortal (newSVGdkAtom (actual_property_type)));
PUSHs (sv_2mortal (newSViv (actual_format)));
if (data) {
xs/GdkProperty.xs view on Meta::CPAN
Returns a list of strings.
=cut
## gint gdk_text_property_to_text_list (GdkAtom encoding, gint format, const guchar *text, gint length, gchar ***list)
void
gdk_text_property_to_text_list (class, encoding, format, text)
GdkAtom encoding
gint format
SV *text
PREINIT:
GDK2PERL_TEXT_LIST_DECLARE;
PPCODE:
GDK2PERL_TEXT_LIST_FETCH;
elements = gdk_text_property_to_text_list (encoding, format, real_text, length, &list);
GDK2PERL_TEXT_LIST_STORE;
gdk_free_text_list (list);
=for apidoc
Returns a list of strings.
=cut
## gint gdk_text_property_to_utf8_list (GdkAtom encoding, gint format, const guchar *text, gint length, gchar ***list)
void
gdk_text_property_to_utf8_list (class, encoding, format, text)
GdkAtom encoding
gint format
SV *text
PREINIT:
GDK2PERL_TEXT_LIST_DECLARE;
PPCODE:
GDK2PERL_TEXT_LIST_FETCH;
elements = gdk_text_property_to_utf8_list (encoding, format, real_text, length, &list);
GDK2PERL_TEXT_LIST_STORE;
g_strfreev (list);
=for apidoc
Returns a list of strings.
=cut
## gint gdk_string_to_compound_text (const gchar *str, GdkAtom *encoding, gint *format, guchar **ctext, gint *length)
void
gdk_string_to_compound_text (class, str)
const gchar *str
PREINIT:
GDK2PERL_TEXT_CONVERSION_DECALRE;
PPCODE:
if (0 != gdk_string_to_compound_text (str, &encoding, &format, &ctext, &length))
XSRETURN_EMPTY;
GDK2PERL_TEXT_CONVERSION_STORE;
gdk_free_compound_text (ctext);
=for apidoc
Returns a list of strings.
=cut
## gboolean gdk_utf8_to_compound_text (const gchar *str, GdkAtom *encoding, gint *format, guchar **ctext, gint *length)
void
gdk_utf8_to_compound_text (class, str)
const gchar *str
PREINIT:
GDK2PERL_TEXT_CONVERSION_DECALRE;
PPCODE:
if (! gdk_utf8_to_compound_text (str, &encoding, &format, &ctext, &length))
XSRETURN_EMPTY;
GDK2PERL_TEXT_CONVERSION_STORE;
gdk_free_compound_text (ctext);
#if GTK_CHECK_VERSION (2, 2, 0)
=for apidoc
xs/GdkProperty.xs view on Meta::CPAN
=cut
## gint gdk_text_property_to_text_list_for_display (GdkDisplay *display, GdkAtom encoding, gint format, const guchar *text, gint length, gchar ***list)
void
gdk_text_property_to_text_list_for_display (class, display, encoding, format, text)
GdkDisplay *display
GdkAtom encoding
gint format
SV *text
PREINIT:
GDK2PERL_TEXT_LIST_DECLARE;
PPCODE:
GDK2PERL_TEXT_LIST_FETCH;
elements = gdk_text_property_to_text_list_for_display (display, encoding, format, real_text, length, &list);
GDK2PERL_TEXT_LIST_STORE;
gdk_free_text_list (list);
=for apidoc
Returns a list of strings.
=cut
## gint gdk_text_property_to_utf8_list_for_display (GdkDisplay *display, GdkAtom encoding, gint format, const guchar *text, gint length, gchar ***list)
void
gdk_text_property_to_utf8_list_for_display (class, display, encoding, format, text)
GdkDisplay *display
GdkAtom encoding
gint format
SV *text
PREINIT:
GDK2PERL_TEXT_LIST_DECLARE;
PPCODE:
GDK2PERL_TEXT_LIST_FETCH;
elements = gdk_text_property_to_utf8_list_for_display (display, encoding, format, real_text, length, &list);
GDK2PERL_TEXT_LIST_STORE;
g_strfreev (list);
=for apidoc
Returns a list of strings.
=cut
## gint gdk_string_to_compound_text_for_display (GdkDisplay *display, const gchar *str, GdkAtom *encoding, gint *format, guchar **ctext, gint *length)
void
gdk_string_to_compound_text_for_display (class, display, str)
GdkDisplay *display
const gchar *str
PREINIT:
GDK2PERL_TEXT_CONVERSION_DECALRE;
PPCODE:
if (0 != gdk_string_to_compound_text_for_display (display, str, &encoding, &format, &ctext, &length))
XSRETURN_EMPTY;
GDK2PERL_TEXT_CONVERSION_STORE;
gdk_free_compound_text (ctext);
=for apidoc
Returns a list of strings.
=cut
## gboolean gdk_utf8_to_compound_text_for_display (GdkDisplay *display, const gchar *str, GdkAtom *encoding, gint *format, guchar **ctext, gint *length)
void
gdk_utf8_to_compound_text_for_display (class, display, str)
GdkDisplay *display
const gchar *str
PREINIT:
GDK2PERL_TEXT_CONVERSION_DECALRE;
PPCODE:
if (! gdk_utf8_to_compound_text_for_display (display, str, &encoding, &format, &ctext, &length))
XSRETURN_EMPTY;
GDK2PERL_TEXT_CONVERSION_STORE;
gdk_free_compound_text (ctext);
#endif /* 2.2.0 */
=for apidoc
xs/GdkRegion.xs view on Meta::CPAN
Returns a list of rectangles (Gtk2::Gdk::Rectangle's), the area covered by the
region.
=cut
void
gdk_region_get_rectangles (region)
GdkRegion *region
PREINIT:
GdkRectangle *rectangles = NULL;
gint n_rectangles;
int i;
PPCODE:
gdk_region_get_rectangles (region, &rectangles, &n_rectangles);
EXTEND (SP, n_rectangles);
for (i = 0 ; i < n_rectangles ; i++)
PUSHs (sv_2mortal (newSVGdkRectangle_copy (rectangles + i)));
g_free (rectangles);
## gboolean gdk_region_empty (GdkRegion *region)
gboolean
gdk_region_empty (region)
GdkRegion *region
xs/GdkScreen.xs view on Meta::CPAN
## GList * gdk_screen_list_visuals (GdkScreen *screen)
=for apidoc
Returns a list of Gtk2::Gdk::Visual's.
=cut
void
gdk_screen_list_visuals (screen)
GdkScreen *screen
PREINIT:
GList * list, * i;
PPCODE:
list = gdk_screen_list_visuals (screen);
for (i = list ; i != NULL ; i = i->next)
XPUSHs (sv_2mortal (newSVGdkVisual (i->data)));
g_list_free (list);
## GList * gdk_screen_get_toplevel_windows (GdkScreen *screen)
=for apidoc
Returns a list of Gtk2::Gdk::Window's.
=cut
void
gdk_screen_get_toplevel_windows (screen)
GdkScreen *screen
PREINIT:
GList * list, * i;
PPCODE:
list = gdk_screen_get_toplevel_windows (screen);
for (i = list ; i != NULL ; i = i->next)
XPUSHs (sv_2mortal (newSVGdkWindow (i->data)));
g_list_free (list);
## gchar * gdk_screen_make_display_name (GdkScreen *screen)
gchar_own *
gdk_screen_make_display_name (screen)
GdkScreen *screen
xs/GdkScreen.xs view on Meta::CPAN
gdouble gdk_screen_get_resolution (GdkScreen *screen);
GdkWindow * gdk_screen_get_active_window (GdkScreen * screen);
##GList * gdk_screen_get_window_stack (GdkScreen *screen)
void
gdk_screen_get_window_stack (GdkScreen *screen)
PREINIT:
GList *list, *i;
PPCODE:
list = gdk_screen_get_window_stack (screen);
for (i = list; i != NULL; i = i->next)
/* The list owns a reference to the windows. */
XPUSHs (sv_2mortal (newSVGdkWindow_noinc (i->data)));
g_list_free (list);
gboolean gdk_screen_is_composited (GdkScreen *screen);
#endif /* 2.10 */
xs/GdkSelection.xs view on Meta::CPAN
=for signature (data, prop_type, prop_format) = Gtk2::Gdk::Selection->property_get ($requestor)
Use Gtk2::Clipboard instead.
=cut
void
gdk_selection_property_get (class, requestor)
GdkWindow *requestor
PREINIT:
guchar * data;
GdkAtom prop_type;
gint prop_format;
PPCODE:
if (!gdk_selection_property_get (requestor, &data,
&prop_type, &prop_format))
XSRETURN_EMPTY;
EXTEND (SP, 3);
PUSHs (sv_2mortal (newSVpv ((gchar *) data, 0)));
PUSHs (sv_2mortal (newSVGdkAtom (prop_type)));
PUSHs (sv_2mortal (newSViv (prop_format)));
g_free (data);
xs/GdkTypes.xs view on Meta::CPAN
}
OUTPUT:
RETVAL
=for apidoc
=for signature (x, y, width, height) = $rectangle->values
=cut
void
values (rectangle)
GdkRectangle * rectangle
PPCODE:
EXTEND (SP, 4);
PUSHs (sv_2mortal (newSViv (rectangle->x)));
PUSHs (sv_2mortal (newSViv (rectangle->y)));
PUSHs (sv_2mortal (newSViv (rectangle->width)));
PUSHs (sv_2mortal (newSViv (rectangle->height)));
MODULE = Gtk2::Gdk::Types PACKAGE = Gtk2::Gdk::Geometry
GdkGeometry *
new (class)
xs/GdkTypes.xs view on Meta::CPAN
void
constrain_size (geometry_ref, ...)
SV *geometry_ref
PREINIT:
GdkGeometry *geometry;
GdkWindowHints flags;
gint width;
gint height;
gint new_width;
gint new_height;
PPCODE:
if (items == 4) {
if (!gperl_sv_is_defined (ST (1)))
warn ("Warning: You passed undef for the flags parameter. Consider simply omitting it instead.");
geometry = SvGdkGeometry (geometry_ref);
flags = SvGdkWindowHints (ST (1));
width = SvIV (ST (2));
height = SvIV (ST (3));
} else if (items == 3) {
geometry = SvGdkGeometryReal (geometry_ref, &flags);
xs/GdkVisual.xs view on Meta::CPAN
=for apidoc
Returns a list of depths.
=cut
## void gdk_query_depths (gint **depths, gint *count)
void
gdk_query_depths (class)
PREINIT:
gint *depths = NULL;
gint i, count = 0;
PPCODE:
gdk_query_depths (&depths, &count);
if (count <= 0 || depths == NULL)
XSRETURN_EMPTY;
EXTEND (sp, count);
for (i = 0; i < count; i++)
PUSHs (sv_2mortal (newSViv (depths[i])));
## void gdk_query_visual_types (GdkVisualType **visual_types, gint *count)
void
gdk_query_visual_types (class)
PREINIT:
GdkVisualType *visual_types = NULL;
gint i, count = 0;
PPCODE:
gdk_query_visual_types (&visual_types, &count);
if (count <= 0 || visual_types == NULL)
XSRETURN_EMPTY;
EXTEND (sp, count);
for (i = 0; i < count; i++)
PUSHs (sv_2mortal (newSVGdkVisualType (visual_types[i])));
## GList* gdk_list_visuals (void)
void
gdk_list_visuals (class)
PREINIT:
GList *i, *visuals = NULL;
PPCODE:
PERL_UNUSED_VAR (ax);
visuals = gdk_list_visuals ();
for (i = visuals; i != NULL; i = i->next)
XPUSHs (sv_2mortal (newSVGdkVisual (i->data)));
g_list_free (visuals);
MODULE = Gtk2::Gdk::Visual PACKAGE = Gtk2::Gdk::Visual PREFIX = gdk_visual_
## gint gdk_visual_get_best_depth (void)
gint
xs/GdkWindow.xs view on Meta::CPAN
## GdkWindow* gdk_window_at_pointer (gint *win_x, gint *win_y)
=for apidoc
=for signature (window, win_x, win_y) = Gtk2::Gdk::Window->at_pointer
Returns window, a Gtk2::Gdk::Window and win_x and win_y, integers.
=cut
void
gdk_window_at_pointer (class)
PREINIT:
GdkWindow * window;
gint win_x, win_y;
PPCODE:
window = gdk_window_at_pointer (&win_x, &win_y);
EXTEND (SP, 3);
PUSHs (sv_2mortal (newSVGdkWindow (window)));
PUSHs (sv_2mortal (newSViv (win_x)));
PUSHs (sv_2mortal (newSViv (win_y)));
PERL_UNUSED_VAR (ax);
## void gdk_window_show (GdkWindow *window)
void
gdk_window_show (window)
xs/GdkWindow.xs view on Meta::CPAN
mask, a Gtk2::Gdk::ModifierType.
=cut
## GdkWindow * gdk_window_get_pointer (GdkWindow *window, gint *x, gint *y, GdkModifierType *mask)
void
gdk_window_get_pointer (GdkWindow *window)
PREINIT:
GdkWindow * win;
gint x;
gint y;
GdkModifierType mask;
PPCODE:
win = gdk_window_get_pointer (window, &x, &y, &mask);
EXTEND (SP, 4);
PUSHs (sv_2mortal (newSVGdkWindow_ornull (win)));
PUSHs (sv_2mortal (newSViv (x)));
PUSHs (sv_2mortal (newSViv (y)));
PUSHs (sv_2mortal (newSVGdkModifierType (mask)));
## GdkWindow * gdk_window_get_parent (GdkWindow *window)
GdkWindow *
xs/GdkWindow.xs view on Meta::CPAN
=for apidoc
Returns the list of children (Gtk2::Gdk::Window's) known to gdk.
=cut
void
gdk_window_get_children (window)
GdkWindow *window
ALIAS:
Gtk2::Gdk::Window::peek_children = 1
PREINIT:
GList *windows = NULL, *i;
PPCODE:
PERL_UNUSED_VAR (ix);
windows = gdk_window_peek_children (window);
for (i = windows; i != NULL; i = i->next)
XPUSHs (sv_2mortal (newSVGdkWindow (i->data)));
## GdkEventMask gdk_window_get_events (GdkWindow *window)
GdkEventMask
gdk_window_get_events (window)
GdkWindow *window
xs/GdkWindow.xs view on Meta::CPAN
gdk_window_set_decorations (window, decorations)
GdkWindow *window
GdkWMDecoration decorations
## gboolean gdk_window_get_decorations (GdkWindow *window, GdkWMDecoration *decorations)
void
gdk_window_get_decorations (GdkWindow *window)
PREINIT:
gboolean result;
GdkWMDecoration decorations;
PPCODE:
result = gdk_window_get_decorations (window, &decorations);
EXTEND (SP, 2);
PUSHs (sv_2mortal (boolSV (result)));
PUSHs (sv_2mortal (newSVGdkWMDecoration (decorations)));
## void gdk_window_set_functions (GdkWindow *window, GdkWMFunction functions)
void
gdk_window_set_functions (window, functions)
GdkWindow *window
GdkWMFunction functions
## GList * gdk_window_get_toplevels (void)
=for apidoc
Returns a list of top level windows (Gtk2::Gdk::Window's) known to gdk, on the
default screen. A toplevel window is a child of the root window.
=cut
void
gdk_window_get_toplevels (class)
PREINIT:
GList *windows = NULL, *i;
PPCODE:
windows = gdk_window_get_toplevels ();
for (i = windows; i != NULL; i = i->next)
XPUSHs (sv_2mortal (newSVGdkWindow (i->data)));
g_list_free (windows);
PERL_UNUSED_VAR (ax);
## void gdk_window_iconify (GdkWindow *window)
void
xs/GdkWindow.xs view on Meta::CPAN
void
gdk_window_process_updates (GdkWindow * window, gboolean update_children)
## void gdk_window_get_internal_paint_info (GdkWindow *window, GdkDrawable **real_drawable, gint *x_offset, gint *y_offset)
void
gdk_window_get_internal_paint_info (GdkWindow *window)
PREINIT:
GdkDrawable *real_drawable = NULL;
gint x_offset;
gint y_offset;
PPCODE:
gdk_window_get_internal_paint_info (window, &real_drawable, &x_offset, &y_offset);
EXTEND (SP, 3);
PUSHs (sv_2mortal (newSVGdkDrawable (real_drawable)));
PUSHs (sv_2mortal (newSViv (x_offset)));
PUSHs (sv_2mortal (newSViv (y_offset)));
#if GTK_CHECK_VERSION (2, 6, 0)
void gdk_window_enable_synchronized_configure (GdkWindow *window);
##GTKMAIN_C_VAR const guint gtk_binary_age;
##GTKMAIN_C_VAR const guint gtk_interface_age;
=for apidoc
=for signature (major, minor, micro) = Gtk2->get_version_info
Shorthand to fetch as a list the gtk+ version against which Gtk2 is linked.
See C<Gtk2::major_version>, etc.
=cut
void
gtk_get_version_info (class)
PPCODE:
EXTEND(SP,3);
PUSHs(sv_2mortal(newSViv(gtk_major_version)));
PUSHs(sv_2mortal(newSViv(gtk_minor_version)));
PUSHs(sv_2mortal(newSViv(gtk_micro_version)));
PERL_UNUSED_VAR (ax);
=for apidoc
Returns undef if the version of gtk+ currently in use is compatible with the
given version, otherwise returns a string describing the mismatch. Note that
this is not the same logic as C<Gtk2::CHECK_VERSION>. This check is not
OUTPUT:
RETVAL
=for apidoc
=for signature (MAJOR, MINOR, MICRO) = Gtk2->GET_VERSION_INFO
Shorthand to fetch as a list the gtk+ version for which Gtk2 was compiled.
See C<Gtk2::MAJOR_VERSION>, etc.
=cut
void
GET_VERSION_INFO (class)
PPCODE:
EXTEND (SP, 3);
PUSHs (sv_2mortal (newSViv (GTK_MAJOR_VERSION)));
PUSHs (sv_2mortal (newSViv (GTK_MINOR_VERSION)));
PUSHs (sv_2mortal (newSViv (GTK_MICRO_VERSION)));
PERL_UNUSED_VAR (ax);
=for apidoc
Provides a mechanism for checking the version information that Gtk2 was
compiled against. Essentially equvilent to the macro GTK_CHECK_VERSION. In most
cases this function should be used rather than
xs/GtkAboutDialog.xs view on Meta::CPAN
const gchar_ornull * gtk_about_dialog_get_website_label (GtkAboutDialog * about);
void gtk_about_dialog_set_website_label (GtkAboutDialog * about, const gchar_ornull * website_label);
##const gchar * const * gtk_about_dialog_get_authors (GtkAboutDialog * about);
void
gtk_about_dialog_get_authors (GtkAboutDialog * about)
PREINIT:
gint i;
const gchar * const * authors = NULL;
PPCODE:
authors = gtk_about_dialog_get_authors (about);
GETTER (authors);
##void gtk_about_dialog_set_authors (GtkAboutDialog * about, gchar ** authors);
=for apidoc
=arg author1 (string)
=cut
void
gtk_about_dialog_set_authors (about, author1, ...)
GtkAboutDialog * about
xs/GtkAboutDialog.xs view on Meta::CPAN
SETTER (authors);
gtk_about_dialog_set_authors (about, (const gchar **) authors);
g_free (authors);
##const gchar * const * gtk_about_dialog_get_documenters (GtkAboutDialog * about);
void
gtk_about_dialog_get_documenters (GtkAboutDialog * about)
PREINIT:
gint i;
const gchar * const * documenters = NULL;
PPCODE:
documenters = gtk_about_dialog_get_documenters (about);
GETTER (documenters);
##void gtk_about_dialog_set_documenters (GtkAboutDialog * about, gchar ** documenters);
=for apidoc
=arg documenter1 (string)
=cut
void
gtk_about_dialog_set_documenters (about, documenter1, ...)
GtkAboutDialog * about
xs/GtkAboutDialog.xs view on Meta::CPAN
SETTER (documenters);
gtk_about_dialog_set_documenters (about, (const gchar **) documenters);
g_free (documenters);
##const gchar * const * gtk_about_dialog_get_artists (GtkAboutDialog * about);
void
gtk_about_dialog_get_artists (GtkAboutDialog * about)
PREINIT:
gint i;
const gchar * const * artists = NULL;
PPCODE:
artists = gtk_about_dialog_get_artists (about);
GETTER (artists);
##void gtk_about_dialog_set_artists (GtkAboutDialog * about, gchar ** artists);
=for apidoc
=arg artist1 (string)
=cut
void
gtk_about_dialog_set_artists (about, artist1, ...);
GtkAboutDialog * about
xs/GtkAccelGroup.xs view on Meta::CPAN
=for signature (accelerator_key, accelerator_mods) = Gtk2::Accelerator->parse ($accelerator)
Returns accelerator_key, an unsigned integer and accelerator_mods, a
Gtk2::Gdk::ModifierType.
=cut
void
gtk_accelerator_parse (class, accelerator)
const gchar * accelerator
PREINIT:
guint accelerator_key;
GdkModifierType accelerator_mods;
PPCODE:
gtk_accelerator_parse (accelerator, &accelerator_key,
&accelerator_mods);
XPUSHs (sv_2mortal (newSVuv (accelerator_key)));
XPUSHs (sv_2mortal (newSVGdkModifierType (accelerator_mods)));
## gchar* gtk_accelerator_name (guint accelerator_key, GdkModifierType accelerator_mods)
gchar_own *
gtk_accelerator_name (class, accelerator_key, accelerator_mods)
guint accelerator_key
GdkModifierType accelerator_mods
xs/GtkAccelGroup.xs view on Meta::CPAN
##GtkAccelGroupEntry* gtk_accel_group_query (GtkAccelGroup *accel_group, guint accel_key, GdkModifierType accel_mods, guint *n_entries)
#void
#gtk_accel_group_query (accel_group, accel_key, accel_mods)
# GtkAccelGroup * accel_group
# guint accel_key
# GdkModifierType accel_mods
# PREINIT:
# gint i;
# gint n_entries;
# GtkAccelGroupEntry * entries;
# PPCODE:
# entries = gtk_accel_group_query(accel_group, accel_key,
# accel_mods, &n_entries);
## if( !entries )
# XSRETURN_EMPTY;
# EXTEND(SP,n_entries);
# for( i = 0; i < n_entries; i++ )
# PUSHs(sv_2mortal(newSVGtkAccelGroupEntry(entries[i])));
#if GTK_CHECK_VERSION (2, 6, 0)
xs/GtkAccelGroup.xs view on Meta::CPAN
## GSList* gtk_accel_groups_from_object (GObject *object)
=for apidoc
Returns a list of Gtk2::AccelGroup's.
=cut
void
gtk_accel_groups_from_object (class, object)
GObject * object
PREINIT:
GSList * groups, * i;
PPCODE:
groups = gtk_accel_groups_from_object (object);
for (i = groups ; i != NULL ; i = i->next)
XPUSHs (sv_2mortal (newSVGtkAccelGroup (i->data)));
/* according to the source, we should not free the list */
xs/GtkAccelMap.xs view on Meta::CPAN
=for signature (accel_key, accel_mods, accel_flags) = Gtk2::AccelMap->lookup_entry ($accel_path)
Returns empty if no accelerator is found for the given path, accel_key
(integer), accel_mods (Gtk2::Gdk::ModifierType), and accel_flags (integer)
otherwise.
=cut
void
gtk_accel_map_lookup_entry (class, accel_path)
const gchar * accel_path
PREINIT:
GtkAccelKey key;
PPCODE:
if (gtk_accel_map_lookup_entry (accel_path, &key))
{
EXTEND (SP, 3);
PUSHs (sv_2mortal (newSViv (key.accel_key)));
PUSHs (sv_2mortal (newSVGdkModifierType (key.accel_mods)));
PUSHs (sv_2mortal (newSViv (key.accel_flags)));
}
else
XSRETURN_EMPTY;
xs/GtkAction.xs view on Meta::CPAN
GtkWidget* gtk_action_create_tool_item (GtkAction *action);
void gtk_action_connect_proxy (GtkAction *action, GtkWidget *proxy);
void gtk_action_disconnect_proxy (GtkAction *action, GtkWidget *proxy);
void gtk_action_get_proxies (GtkAction *action);
PREINIT:
GSList * i;
PPCODE:
for (i = gtk_action_get_proxies (action) ; i != NULL ; i = i->next)
/* We can't use newSVGtkWidget here because it always sinks the
* widget. gtk_action_get_proxies might return floating
* widgets though, and with newSVGtkWidget we would end up
* owning them. When the SV wrapper then goes out of scope,
* the widgets would be destroyed -- and GtkAction would hold
* on to dangling pointers. */
XPUSHs (sv_2mortal (gperl_new_object (G_OBJECT (i->data), FALSE)));
void gtk_action_connect_accelerator (GtkAction *action);
xs/GtkActionGroup.xs view on Meta::CPAN
void gtk_action_group_set_visible (GtkActionGroup *action_group, gboolean sensitive);
gboolean gtk_action_group_get_visible (GtkActionGroup *action_group);
GtkAction *gtk_action_group_get_action (GtkActionGroup *action_group, const gchar *action_name);
void gtk_action_group_list_actions (GtkActionGroup *action_group);
PREINIT:
GList * actions, * i;
PPCODE:
actions = gtk_action_group_list_actions (action_group);
for (i = actions ; i != NULL ; i = i->next)
XPUSHs (sv_2mortal (newSVGtkAction (i->data)));
g_list_free (actions);
void gtk_action_group_add_action (GtkActionGroup *action_group, GtkAction *action);
void gtk_action_group_add_action_with_accel (GtkActionGroup *action_group, GtkAction *action, const gchar_ornull *accelerator);
void gtk_action_group_remove_action (GtkActionGroup *action_group, GtkAction *action);
xs/GtkBox.xs view on Meta::CPAN
gint position
# void gtk_box_query_child_packing (GtkBox * box, GtkWidget * child, gboolean &expand, gboolean &fill, guint &padding, GtkPackType &pack_type)
void
gtk_box_query_child_packing (GtkBox * box, GtkWidget * child)
PREINIT:
gboolean expand;
gboolean fill;
guint padding;
GtkPackType pack_type;
PPCODE:
gtk_box_query_child_packing (box, child, &expand, &fill, &padding, &pack_type);
EXTEND (SP, 4);
PUSHs (sv_2mortal (boolSV (expand)));
PUSHs (sv_2mortal (boolSV (fill)));
PUSHs (sv_2mortal (newSVuv (padding)));
PUSHs (sv_2mortal (newSVGtkPackType (pack_type)));
void
gtk_box_set_child_packing (box, child, expand, fill, padding, pack_type)
GtkBox *box
xs/GtkBuildable.xs view on Meta::CPAN
=for apidoc
=for signature list = $parse_context->get_element_stack
Returns the element stack; the first item is the currently-open tag
(which would be returned by C<get_element()>), and the next item is
its immediate parent.
=cut
void g_markup_parse_context_get_element_stack (SV * sv);
PREINIT:
const GSList * list;
PPCODE:
list = g_markup_parse_context_get_element_stack
(SvGtkBuildableParseContext (sv));
while (list) {
XPUSHs (sv_2mortal (newSVGChar (list->data)));
list = list->next;
}
#endif
=for apidoc
=for signature (line_number, char_number) = $parse_context->get_position
=cut
void
g_markup_parse_context_get_position (SV * sv)
PREINIT:
int line_number;
int char_number;
PPCODE:
g_markup_parse_context_get_position (SvGtkBuildableParseContext (sv),
&line_number, &char_number);
EXTEND (SP, 2);
PUSHs (sv_2mortal (newSViv (line_number)));
PUSHs (sv_2mortal (newSViv (char_number)));
MODULE = Gtk2::Buildable PACKAGE = Gtk2::Buildable
=for position SYNOPSIS
xs/GtkBuilder.xs view on Meta::CPAN
OUTPUT:
RETVAL
GObject * gtk_builder_get_object (GtkBuilder *builder, const gchar *name);
# GSList * gtk_builder_get_objects (GtkBuilder *builder);
void
gtk_builder_get_objects (GtkBuilder *builder)
PREINIT:
GSList *list, *i;
PPCODE:
list = gtk_builder_get_objects (builder);
for (i = list; i != NULL; i = i->next) {
XPUSHs (sv_2mortal (newSVGObject (i->data)));
}
g_slist_free (list);
#if 0 /* evil hack to convince Glib::GenPod to output docs for connect_signals */
# connect_signals is implemented in Gtk2.pm
=for apidoc Gtk2::Builder::connect_signals
xs/GtkCalendar.xs view on Meta::CPAN
=for signature value = $widget->num_marked_dates
=cut
void
num_marked_dates (cal)
GtkCalendar* cal
ALIAS:
marked_date = 1
year = 2
month = 3
selected_day = 4
PPCODE:
switch (ix) {
case 0:
PUSHs (sv_2mortal (newSViv (cal->num_marked_dates)));
break;
case 1:
{
int i;
EXTEND (SP, 31);
for (i = 0; i < 31; i++) {
PUSHs (sv_2mortal (newSViv (cal->marked_date[i])));
xs/GtkCellLayout.xs view on Meta::CPAN
=for apidoc
Fetch all of the cell renderers which have been added to I<$cell_layout>.
Note that if there are no cells this functions returns 'undef' instead of an
empty list.
=cut
void
gtk_cell_layout_get_cells (GtkCellLayout *cell_layout)
PREINIT:
GList *result, *i;
PPCODE:
PUTBACK;
result = gtk_cell_layout_get_cells (cell_layout);
SPAGAIN;
if (!result) /* can happen if the widget doesn't implement get_cells */
XSRETURN_UNDEF;
for (i = result; i != NULL; i = i->next)
XPUSHs (sv_2mortal (newSVGtkCellRenderer (i->data)));
g_list_free (result);
#endif
xs/GtkCellRenderer.xs view on Meta::CPAN
void
gtk_cell_renderer_get_size (cell, widget, cell_area)
GtkCellRenderer * cell
GtkWidget * widget
GdkRectangle_ornull * cell_area
PREINIT:
gint x_offset;
gint y_offset;
gint width;
gint height;
PPCODE:
PUTBACK;
gtk_cell_renderer_get_size(cell, widget, cell_area,
&x_offset, &y_offset, &width, &height);
SPAGAIN;
EXTEND(SP,4);
PUSHs(sv_2mortal(newSViv(x_offset)));
PUSHs(sv_2mortal(newSViv(y_offset)));
PUSHs(sv_2mortal(newSViv(width)));
PUSHs(sv_2mortal(newSViv(height)));
xs/GtkCellRenderer.xs view on Meta::CPAN
Gtk2::CellRenderer::RENDER = 1
Gtk2::CellRenderer::ACTIVATE = 2
Gtk2::CellRenderer::START_EDITING = 3
Gtk2::CellRenderer::parent_get_size = 4
Gtk2::CellRenderer::parent_render = 5
Gtk2::CellRenderer::parent_activate = 6
Gtk2::CellRenderer::parent_start_editing = 7
PREINIT:
GtkCellRendererClass *parent_class = NULL;
GType this, parent;
PPCODE:
/* look up the parent.
*
* FIXME: this approach runs into an endless loop with a hierarchy
* where a Perl class inherits from a C class which inherits from a
* Perl class. Like this:
*
* ...
* +- GtkCellRenderer
* +- Foo::RendererOne (Perl subclass)
* +- FooRendererTwo (C subclass)
xs/GtkCellView.xs view on Meta::CPAN
OUTPUT:
RETVAL
void gtk_cell_view_set_background_color (GtkCellView * cell_view, const GdkColor * color);
## GList * gtk_cell_view_get_cell_renderers (GtkCellView * cellview);
void
gtk_cell_view_get_cell_renderers (GtkCellView * cellview);
PREINIT:
GList * list;
PPCODE:
list = gtk_cell_view_get_cell_renderers (cellview);
if (list)
{
GList * curr;
for (curr = list; curr; curr = g_list_next (curr))
XPUSHs (sv_2mortal (newSVGtkCellRenderer (curr->data)));
g_list_free (list);
}
( run in 2.710 seconds using v1.01-cache-2.11-cpan-71847e10f99 )