//____________________________________________
// Used to pack an icon onto a button
// Adapted from GTK API tutorial
//____________________________________________
GtkWidget *GUI_PixmapButton(GdkWindow * window, const gchar ** xpmd,
const gchar * tooltip, gint border)
{
//
GtkWidget *button;
GtkWidget *pixmap;
GdkPixmap *xpm;
GdkBitmap *mask;
xpm = gdk_pixmap_create_from_xpm_d(window, &mask, NULL, (gchar **)xpmd);
pixmap = gtk_pixmap_new(xpm, mask);
button = gtk_button_new();
gtk_container_set_border_width(GTK_CONTAINER(button), border);
gtk_container_add(GTK_CONTAINER(button), pixmap);
if (tooltips == NULL)
tooltips = gtk_tooltips_new();
if (tooltip != NULL)
gtk_tooltips_set_tip(tooltips, button, tooltip, NULL);
gtk_widget_show_all(button);
return button;
}
static void
gimp_pixmap_create_from_xpm_d (GimpPixmap *pixmap)
{
GtkStyle *style;
GdkPixmap *gdk_pixmap = NULL;
GdkBitmap *mask = NULL;
if (pixmap->xpm_data)
{
GtkWidget *widget;
widget = GTK_WIDGET (pixmap);
style = gtk_widget_get_style (widget);
gdk_pixmap = gdk_pixmap_create_from_xpm_d (gtk_widget_get_window (widget),
&mask,
&style->bg[GTK_STATE_NORMAL],
pixmap->xpm_data);
}
gtk_image_set_from_pixmap (GTK_IMAGE (pixmap), gdk_pixmap, mask);
if (gdk_pixmap)
g_object_unref (gdk_pixmap);
if (mask)
g_object_unref (mask);
}
GtkWidget * AddSubMenu( GtkWidget *window1, const char * immagine_xpm, GtkWidget * Menu,const char * label )
{
GtkWidget * Label = NULL;
GtkWidget * Pixmap = NULL;
GtkWidget * hbox = NULL;
GtkWidget * Item = NULL;
GtkWidget * SubItem = NULL;
GdkPixmap * PixmapIcon = NULL;
GdkColor transparent;
GdkBitmap * MaskIcon = NULL;
PixmapIcon = gdk_pixmap_create_from_xpm_d (window1->window, &MaskIcon, &transparent,(gchar **)immagine_xpm);
Pixmap = gtk_pixmap_new (PixmapIcon, MaskIcon);
gdk_pixmap_unref (PixmapIcon);
SubItem=gtk_menu_item_new();
Item=gtk_menu_new();
Label = gtk_label_new (label);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (hbox), Pixmap, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), Label, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (SubItem), hbox);
gtk_menu_append( GTK_MENU( Menu ),SubItem );
gtk_menu_item_set_submenu( GTK_MENU_ITEM( SubItem ),Item );
gtk_widget_show_all( SubItem );
return Item;
}
static void
gb_custom_on_widget_realize (GtkWidget *widget, gpointer data)
{
static GdkPixmap *background_pixmap = NULL;
#if 0
g_print ("In gb_custom_on_widget_realize widget:%s (%p)\n",
gtk_widget_get_name (widget), widget);
#endif
/* Create the background pixmap if it hasn't already been created. */
if (background_pixmap == NULL)
{
background_pixmap = gdk_pixmap_create_from_xpm_d (widget->window,
NULL, NULL,
custom_bg_xpm);
if (!background_pixmap)
{
g_warning ("Couldn't create background pixmap\n");
/* FIXME: Use a color instead? */
}
}
if (background_pixmap != NULL)
gdk_window_set_back_pixmap (widget->window, background_pixmap, FALSE);
}
static void
createPixmap(PluginInstance *This)
{
int err = 0;
if (nullPluginGdkPixmap == 0)
{
GtkStyle *style;
GdkBitmap *mask;
GdkWindow *gdk_window = getGdkWindow(This);
if (gdk_window)
{
GtkWidget *widget;
#ifndef MOZ_WIDGET_GTK2
widget = (GtkWidget *)gdk_window->user_data;
#else
gpointer user_data = NULL;
gdk_window_get_user_data( gdk_window, &user_data);
widget = GTK_WIDGET(user_data);
#endif
style = gtk_widget_get_style(widget);
nullPluginGdkPixmap = gdk_pixmap_create_from_xpm_d(gdk_window , &mask,
&style->bg[GTK_STATE_NORMAL], npnul320_xpm);
#ifdef MOZ_X11
/* Pixmap is created on original X session but used by new session */
XSync(GDK_DISPLAY(), False);
#endif
}
}
}
static GtkWidget *
create_button_with_pixmap(GtkWidget *window, gchar **bits, gint data, gchar *thelp)
{
GtkWidget *pw, *button;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
style = gtk_widget_get_style(window);
pixmap = gdk_pixmap_create_from_xpm_d(window->window,
&mask,
&style->bg[GTK_STATE_NORMAL],
bits);
pw = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pw);
button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(button), pw);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(generic_cb),
GINT_TO_POINTER(data));
gtk_widget_show(button);
gtk_tooltips_set_tip(ttip, button, thelp, NULL);
return button;
}
/* Loads the mini collapsed/expanded directory icons (from XPM data) */
static void
dirtree_icons_init( void )
{
static char **dir_colexp_mini_xpms[] = {
mini_folder_closed_xpm,
mini_folder_open_xpm
};
GtkStyle *style;
GdkColor *trans_color;
GdkWindow *window;
GdkPixmap *pixmap;
GdkBitmap *mask;
int i;
style = gtk_widget_get_style( dir_ctree_w );
trans_color = &style->bg[GTK_STATE_NORMAL];
gtk_widget_realize( dir_ctree_w );
window = dir_ctree_w->window;
/* Make icons for collapsed and expanded directories */
for (i = 0; i < 2; i++) {
pixmap = gdk_pixmap_create_from_xpm_d( window, &mask, trans_color, dir_colexp_mini_xpms[i] );
dir_colexp_mini_icons[i].pixmap = pixmap;
dir_colexp_mini_icons[i].mask = mask;
}
}
static void xpm_reg(GdkDrawable *drawable, XPM_ID_T id, gchar *data[])
{
GdkBitmap* mask;
GdkColor color;
gdk_color_parse("#FFFFFF", &color);
g_xpm_images[id].pixbuf = NULL;
GdkPixmap *pixmap = gdk_pixmap_create_from_xpm_d(drawable, &mask, &color, data);
int w, h;
gdk_drawable_get_size(pixmap, &w, &h);
GdkPixbuf *pixbuf = gdk_pixbuf_get_from_drawable (NULL, pixmap, NULL, 0, 0, 0, 0, w, h);
g_object_unref(pixmap);
if (! pixbuf)
return;
g_xpm_images[id].pixbuf = gdk_pixbuf_add_alpha (pixbuf, TRUE,
color.red >> 8, color.green >> 8, color.blue >> 8);
g_xpm_images[id].width = w;
g_xpm_images[id].height = h;
g_object_unref(pixbuf);
}
void add_to_toolbar (GtkWidget *mainWin, gchar *tooltipText,
gchar ** xpmIcon, GtkSignalFunc f, gpointer data,
GtkWidget *box, int Beginning) {
GtkWidget *button, *gpixmap;
GdkPixmap *pixmap;
GdkBitmap *bitmap;
GtkTooltips *tooltip;
GtkStyle *style;
if (f == NULL)
button = gtk_label_new(" ");
else {
button = gtk_button_new();
tooltip = gtk_tooltips_new();
gtk_tooltips_set_tip(tooltip,button,tooltipText, NULL);
gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
f, (gpointer)data);
style = gtk_widget_get_style(mainWin);
pixmap = gdk_pixmap_create_from_xpm_d(mainWin->window,&bitmap,
&style->bg[GTK_STATE_NORMAL],
xpmIcon);
gpixmap = gtk_pixmap_new(pixmap,bitmap);
gtk_widget_show(gpixmap);
gtk_container_add(GTK_CONTAINER(button), gpixmap);
}
gtk_widget_show(button);
if (Beginning)
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
else
gtk_box_pack_end(GTK_BOX(box), button, FALSE, FALSE, 0);
}
GtkWidget * AddMenuItem( GtkWidget *window1, const char * immagine_xpm, GtkWidget * SubMenu,const char * label,int Number )
{
GtkWidget * Label = NULL;
GtkWidget * Pixmap = NULL;
GtkWidget * hbox = NULL;
GtkWidget * Item = NULL;
GdkPixmap * PixmapIcon = NULL;
GdkColor transparent;
GdkBitmap * MaskIcon = NULL;
PixmapIcon = gdk_pixmap_create_from_xpm_d (window1->window, &MaskIcon, &transparent,(gchar **)immagine_xpm );
Pixmap = gtk_pixmap_new (PixmapIcon, MaskIcon);
gdk_pixmap_unref (PixmapIcon);
Item=gtk_menu_item_new();
Label = gtk_label_new (label);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (hbox), Pixmap, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), Label, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (Item), hbox);
gtk_menu_append( GTK_MENU( SubMenu ),Item );
gtk_signal_connect_object( GTK_OBJECT(Item),"activate",
GTK_SIGNAL_FUNC(ActivateMenuItem),GINT_TO_POINTER(Number) );
gtk_menu_item_right_justify (GTK_MENU_ITEM (Item));
gtk_widget_show_all(Item);
return Item;
}
gint icons_load_toolbar ( GtkWindow *w)
{
GdkColor transparent = { 0 };
if ( w != NULL )
{
PixNew = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskNew, &transparent, New_xpm);
PixOpen = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskOpen, &transparent, Open_xpm);
PixSave = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskSave, &transparent, Save_xpm);
PixSendMail = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskSendMail, &transparent, Send_mail_xpm);
PixClose = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskClose, &transparent, Close_xpm);
return 0;
}
return -1;
}
GtkWidget *make_pixmap_toggle_button(struct mapwin *mw,char **xpmdata)
{
GdkBitmap *mask=NULL;
GdkPixmap *gpm = gdk_pixmap_create_from_xpm_d(mw->map->window,
&mask,NULL,xpmdata);
GtkWidget *gtpm = gtk_pixmap_new(gpm,mask);
GtkWidget *but=gtk_toggle_button_new();
gtk_container_add(GTK_CONTAINER(but),gtpm);
gtk_widget_show(gtpm);
return but;
}
GtkWidget *NewPixmap(gchar ** data, GdkWindow * window, GdkColor * background)
{
GtkWidget *wpixmap;
GdkPixmap *pixmap;
GdkBitmap *mask;
pixmap = gdk_pixmap_create_from_xpm_d(window, &mask, background, data);
wpixmap = gtk_pixmap_new(pixmap, mask);
return wpixmap;
}
static void sanalyzer_init(void)
{
GdkColor color;
int i;
if(window)
return;
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_window_set_title(GTK_WINDOW(window),_("Spectrum analyzer"));
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_widget_realize(window);
bg_pixmap = gdk_pixmap_create_from_xpm_d(window->window,NULL,NULL,sanalyzer_xmms_logo_xpm);
gdk_window_set_back_pixmap(window->window,bg_pixmap,0);
gtk_signal_connect(GTK_OBJECT(window),"destroy",GTK_SIGNAL_FUNC(sanalyzer_destroy_cb),NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
gtk_widget_set_usize(window, WIDTH, HEIGHT);
gc = gdk_gc_new(window->window);
draw_pixmap = gdk_pixmap_new(window->window,WIDTH,HEIGHT,gdk_rgb_get_visual()->depth);
bar = gdk_pixmap_new(window->window,25, HEIGHT, gdk_rgb_get_visual()->depth);
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = 0xFFFF;
color.green = ((i * 255) / (HEIGHT / 2)) << 8;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i,24,i);
}
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = (255 - ((i * 255) / (HEIGHT / 2))) <<8;
color.green = 0xFFFF;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i + (HEIGHT / 2),24,i + (HEIGHT / 2));
}
scale = HEIGHT / log(256);
gdk_color_black(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window),area);
gtk_widget_realize(area);
gdk_window_set_back_pixmap(area->window,bg_pixmap,0);
gtk_widget_show(area);
gtk_widget_show(window);
gdk_window_clear(window->window);
gdk_window_clear(area->window);
}
GtkWidget *make_image(GdkDrawable *drawable, char **xpm, const char *tooltip)
{
GdkPixmap *pixmap;
GtkWidget *image;
GdkColor white = get_color("white");
pixmap = gdk_pixmap_create_from_xpm_d(drawable, NULL, &white, xpm);
image = gtk_image_new_from_pixmap(pixmap, NULL);
gtk_misc_set_padding(GTK_MISC(image), 1, 1);
if (tooltip)
gtk_widget_set_tooltip_markup(image, tooltip);
return image;
}
static void
get_icon (GtkFileBrowser *file_browser, const gchar *name,
GdkPixmap **close_pixmap, GdkBitmap **close_mask,
GdkPixmap **open_pixmap, GdkBitmap **open_mask)
{
GtkFileBrowserIconType type = ICON_CLOSE;
gchar buf[1];
g_return_if_fail (GTK_IS_FILE_BROWSER(file_browser));
if (file_browser->use_icons==FALSE)
{
*close_pixmap = *close_mask = *open_pixmap = *open_mask = NULL;
return;
}
// symbolic link to directory
if (readlink(name,buf,1)>0) type = ICON_LINK;
// directory is accessible
if (access(name,X_OK)) type = ICON_LOCK;
if (folder_pixmap[ICON_OPEN]==NULL)
{
folder_pixmap[ICON_OPEN] = gdk_pixmap_create_from_xpm_d (
GTK_WIDGET(file_browser)->window, &folder_mask[ICON_OPEN], NULL, folder_icons[ICON_OPEN]);
}
if (folder_pixmap[type]==NULL)
{
folder_pixmap[type] = gdk_pixmap_create_from_xpm_d (
GTK_WIDGET(file_browser)->window, &folder_mask[type], NULL, folder_icons[type]);
}
*close_pixmap = folder_pixmap[type];
*close_mask = folder_mask[type];
*open_pixmap = folder_pixmap[ICON_OPEN];
*open_mask = folder_mask[ICON_OPEN];
}
GtkWidget *make_transparent_image(GdkDrawable *drawable, char **xpm,
const char *tooltip)
{
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkWidget *image;
pixmap = gdk_pixmap_create_from_xpm_d(drawable, &mask, NULL, xpm);
image = gtk_image_new_from_pixmap(pixmap, mask);
gtk_misc_set_padding(GTK_MISC(image), 1, 1);
if (tooltip)
gtk_widget_set_tooltip_markup(image, tooltip);
return image;
}
void about (void)
{
GtkWidget *AboutWindow;
GtkWidget *PixmapWidget;
GtkWidget *HSeparator;
GdkPixmap *Pixmap;
GdkBitmap *Mask;
GtkStyle *Style;
GtkWidget *Button;
GtkWidget *AboutLabel;
AboutWindow = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW(AboutWindow), "About " APP_NAME);
gtk_window_set_policy (GTK_WINDOW(AboutWindow), FALSE, FALSE, FALSE);
gtk_window_set_position (GTK_WINDOW(AboutWindow), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW(AboutWindow), TRUE);
gtk_window_set_transient_for (GTK_WINDOW(AboutWindow),
GTK_WINDOW(MainWindow));
gtk_signal_connect_object (GTK_OBJECT(AboutWindow), "delete_event",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT(AboutWindow));
gtk_signal_connect_object (GTK_OBJECT (AboutWindow), "destroy",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT(AboutWindow));
gtk_widget_realize (AboutWindow);
Style = gtk_widget_get_style (AboutWindow);
Pixmap = gdk_pixmap_create_from_xpm_d (AboutWindow->window, &Mask,
&Style->bg[GTK_STATE_NORMAL],
about_xpm);
PixmapWidget = gtk_pixmap_new (Pixmap, Mask);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> vbox),
PixmapWidget, FALSE, FALSE, 0);
HSeparator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> vbox),
HSeparator, FALSE, FALSE, 0);
AboutLabel = gtk_label_new (APP_NAME " " VERSION_NUMBER "\n"
APP_MOTTO "\n\n" APP_URL);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> vbox),
AboutLabel, FALSE, FALSE, 10);
Button = gtk_button_new_with_label (" Resume ");
gtk_signal_connect_object (GTK_OBJECT(Button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT(AboutWindow));
GTK_WIDGET_SET_FLAGS (Button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(AboutWindow) -> action_area),
Button, TRUE, TRUE, 0);
gtk_widget_grab_default (Button);
gtk_widget_show_all (AboutWindow);
print_msg ("Display About window...");
}
gint icons_load_catalog ( GtkWindow *w)
{
GdkColor transparent = { 0 };
if ( w != NULL )
{
PixCDRomDisk = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskCDRomDisk, &transparent, cdrom_disk_xpm);
PixFloppyDisk = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskFloppyDisk, &transparent, floppy_disk_xpm);
PixHardDriveDisk = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskHardDriveDisk, &transparent, harddrive_disk_xpm);
PixZipDisk = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskZipDisk, &transparent, zip_disk_xpm);
PixFolder = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskFolder, &transparent, folder_xpm);
PixParentFolder = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskParentFolder, &transparent, parent_folder_xpm);
PixLockedFolder = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskLockedFolder, &transparent, locked_folder_xpm);
PixOpenFolder = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskOpenFolder, &transparent, open_folder_xpm);
PixFile = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskFile, &transparent, file_xpm);
PixCatalog = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( w)->window, &MskCatalog, &transparent, catalog_xpm);
return 0;
}
return -1;
}
static void
set_icon_pixmap(GtkWidget *window, gchar **bits)
{
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
style = gtk_widget_get_style(window);
pixmap = gdk_pixmap_create_from_xpm_d(window->window,
&mask,
&style->bg[GTK_STATE_NORMAL],
bits);
gdk_window_set_icon(window->window, NULL, pixmap, mask);
gdk_window_set_icon_name(window->window, "TiMidity");
}
/*
* LoadPixmaps
*
* Load the image into the sprite.
*/
void LoadPixmaps (GtkWidget *widget, typSprite *sprites)
{
/* --- Create a pixmap from the xpm data --- */
sprites->pixmap = gdk_pixmap_create_from_xpm_d (
widget->window,
&sprites->mask,
NULL,
sprites->xpm_data);
/* --- Get the width and height --- */
GetWidthHeight (sprites->xpm_data,
&sprites->width,
&sprites->height);
}
GtkWidget *
CreateWidgetFromXpm (GtkWidget * parent, gchar ** xpm_data)
{
GdkBitmap *mask;
GdkPixmap *pixmap_data;
GtkWidget *pixmap_widget;
pixmap_data = gdk_pixmap_create_from_xpm_d (parent->window,
&mask,
NULL,
(gchar **) xpm_data);
pixmap_widget = gtk_pixmap_new (pixmap_data, mask);
gtk_widget_show (pixmap_widget);
return (pixmap_widget);
}
static VALUE
gdkpmap_create_from_xpm_d(VALUE self, VALUE win, VALUE tcolor, VALUE data)
{
GdkPixmap *result;
GdkBitmap *mask;
const gchar **buf = RVAL2STRV(data);
result = gdk_pixmap_create_from_xpm_d(GDK_WINDOW(RVAL2GOBJ(win)),
&mask,
RVAL2GDKCOLOR(tcolor),
(gchar **)buf);
g_free(buf);
return rb_assoc_new(GOBJ2RVAL(result), GOBJ2RVAL(mask));
}
static void headerview_show_xface(HeaderView *headerview, MsgInfo *msginfo)
{
gchar xface[2048];
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkWidget *hbox = headerview->hbox;
if (!msginfo->xface || strlen(msginfo->xface) < 5) {
if (headerview->image &&
GTK_WIDGET_VISIBLE(headerview->image)) {
gtk_widget_hide(headerview->image);
gtk_widget_queue_resize(hbox);
}
return;
}
if (!GTK_WIDGET_VISIBLE(headerview->hbox)) return;
strncpy(xface, msginfo->xface, sizeof(xface));
if (uncompface(xface) < 0) {
g_warning("uncompface failed\n");
if (headerview->image)
gtk_widget_hide(headerview->image);
return;
}
create_xpm_from_xface(xpm_xface, xface);
pixmap = gdk_pixmap_create_from_xpm_d
(hbox->window, &mask, &hbox->style->white, xpm_xface);
if (!headerview->image) {
GtkWidget *image;
image = gtk_image_new_from_pixmap(pixmap, mask);
gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
gtk_widget_show(image);
headerview->image = image;
} else {
gtk_image_set_from_pixmap(GTK_IMAGE(headerview->image),
pixmap, mask);
gtk_widget_show(headerview->image);
}
gdk_pixmap_unref(pixmap);
}
void replace_button_icon(GladeXML * xml, GdkDrawable * window,
GtkStyle * style, gchar * btn_name, gchar ** xpm)
{
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkToolButton *button;
GtkWidget *image;
pixmap = gdk_pixmap_create_from_xpm_d(window, &mask,
&style->bg[GTK_STATE_NORMAL],
xpm);
button = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, btn_name));
image = gtk_image_new_from_pixmap(pixmap, mask);
gtk_widget_show(image);
gtk_tool_button_set_icon_widget(button, image);
}
/*** sfeBuildTreeItemWithImage - create a new treeview item which contains
*** the appropriate image for the given node type as well as a label with
*** the node's name.
***/
GtkWidget*
sfeBuildTreeItemWithImage(pStructInf data_item)
{
GtkWidget *hbox, *label, *pixmap, *treeitem, *hiddenlabel;
int i, n_icons, found;
GtkStyle *style;
gchar hiddenlabel_text[32];
/** Figure out which pixmap file to use. **/
found = SFE_DEFAULT_ICON;
n_icons = sizeof(icon_table) / sizeof(icon_table[0]);
for (i=0;i<n_icons;i++)
if (!strcasecmp(data_item->UsrType, icon_table[i].Type))
found = i;
/** build the gdk pixmap structure if needed **/
if (!icon_table[found].Pixmap)
{
style = gtk_widget_get_style(SFE_Globals.TreeView);
icon_table[found].Pixmap = gdk_pixmap_create_from_xpm_d(SFE_Globals.Window->window,
&(icon_table[found].Mask), &style->bg[GTK_STATE_NORMAL],
(gchar**) icon_table[found].XPM);
}
/** Create the hbox, label, and pixmap **/
hbox = gtk_hbox_new(FALSE,1);
pixmap = gtk_pixmap_new(icon_table[found].Pixmap, icon_table[found].Mask);
gtk_box_pack_start(GTK_BOX(hbox), pixmap, FALSE, FALSE, 0);
gtk_widget_show(pixmap);
label = gtk_label_new(data_item->Name);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
gtk_widget_show(hbox);
/** We need a hidden label to reference the structure **/
snprintf(hiddenlabel_text, 32, "%16.16lx", (unsigned long)(data_item));
hiddenlabel = gtk_label_new(hiddenlabel_text);
gtk_box_pack_start(GTK_BOX(hbox), hiddenlabel, FALSE, FALSE, 0);
/** Create the tree item and plop the hbox in it **/
treeitem = gtk_tree_item_new();
gtk_container_add(GTK_CONTAINER(treeitem), hbox);
return treeitem;
}
int main (int argc,
char *argv[] )
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window, *pixmap, *fixed;
GdkPixmap *gdk_pixmap;
GdkBitmap *mask;
GtkStyle *style;
GdkGC *gc;
/* Create the main window, and attach delete_event signal to terminate
* the application. Note that the main window will not have a titlebar
* since we're making it a popup. */
gtk_init (&argc, &argv);
window = gtk_window_new( GTK_WINDOW_POPUP );
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (close_application), NULL);
gtk_widget_show (window);
/* Now for the pixmap and the pixmap widget */
style = gtk_widget_get_default_style();
gc = style->black_gc;
gdk_pixmap = gdk_pixmap_create_from_xpm_d( window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
WheelbarrowFull_xpm );
pixmap = gtk_pixmap_new( gdk_pixmap, mask );
gtk_widget_show( pixmap );
/* To display the pixmap, we use a fixed widget to place the pixmap */
fixed = gtk_fixed_new();
gtk_widget_set_usize( fixed, 200, 200 );
gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
gtk_container_add( GTK_CONTAINER(window), fixed );
gtk_widget_show( fixed );
/* This masks out everything except for the image itself */
gtk_widget_shape_combine_mask( window, mask, 0, 0 );
/* show the window */
gtk_widget_set_uposition( window, 20, 400 );
gtk_widget_show( window );
gtk_main ();
return(0);
}
static gint configure_event(GtkWidget *widget, GdkEventConfigure *event, void *disp)
{
GdkBitmap *mask;
GtkStyle *style;
if (pixmap)
gdk_pixmap_unref(pixmap);
pixmap = gdk_pixmap_new(widget->window, 40, 40, -1);
style = gtk_widget_get_style(window);
pixmap2 = gdk_pixmap_create_from_xpm_d(widget->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) wall1_xpm);
gdk_draw_pixmap(pixmap,
widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
pixmap2, 0, 0, 0, 0, 14, 14);
return (TRUE);
}
static GtkWidget *
create_pixmap_label(GtkWidget *window, gchar **bits)
{
GtkWidget *pw;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
style = gtk_widget_get_style(window);
pixmap = gdk_pixmap_create_from_xpm_d(window->window,
&mask,
&style->bg[GTK_STATE_NORMAL],
bits);
pw = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pw);
return pw;
}
static GtkWidget *
create_border_pixmap(GtkBorderCombo *border_combo, gchar *border[18])
{
GtkWidget *widget;
GtkWidget *pixmap;
GdkPixmap *border_pixmap;
widget=GTK_WIDGET(border_combo);
border_pixmap=gdk_pixmap_create_from_xpm_d(
widget->window,
NULL,
&(widget->style->bg[GTK_STATE_NORMAL]),
border);
pixmap=gtk_pixmap_new(border_pixmap, NULL);
return pixmap;
}
