static int ui_main() { #ifndef _WIN32 GList *icons = NULL; GdkPixbuf *icon = NULL; char *icon_path; #endif if (current_smiley_theme == NULL) { smiley_theme_probe(); if (smiley_themes) { struct smiley_theme *smile = smiley_themes->data; load_smiley_theme(smile->path, TRUE); } } gaim_gtk_blist_setup_sort_methods(); #ifndef _WIN32 /* use the nice PNG icon for all the windows */ icon_path = g_build_filename(DATADIR, "pixmaps", "gaim", "icons", "online.png", NULL); icon = gdk_pixbuf_new_from_file(icon_path, NULL); g_free(icon_path); if (icon) { icons = g_list_append(icons,icon); gtk_window_set_default_icon_list(icons); g_object_unref(G_OBJECT(icon)); g_list_free(icons); } else { gaim_debug(GAIM_DEBUG_ERROR, "ui_main", "Failed to load the default window icon!\n"); } #endif return 0; }
static void set_icons () { static gchar const *icon_infos[] = { "gitg16x16.png", "gitg22x22.png", "gitg24x24.png", "gitg32x32.png", "gitg48x48.png", "gitg64x64.png", "gitg128x128.png", NULL }; int i; GList *icons = NULL; for (i = 0; icon_infos[i]; ++i) { gchar *filename = gitg_dirs_get_data_filename ("icons", icon_infos[i], NULL); GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file (filename, NULL); g_free (filename); if (pixbuf) { icons = g_list_prepend (icons, pixbuf); } } gtk_window_set_default_icon_list (icons); g_list_foreach (icons, (GFunc)g_object_unref, NULL); g_list_free (icons); }
static void logo_setup () { GdkPixbuf *pixbuf = NULL; GError *error = NULL; GList *list = NULL; gchar *path = NULL; path = g_build_filename (DATAROOTDIR, "icons", "hicolor", "48x48", "apps", "utt-wubi.png", NULL); pixbuf = gdk_pixbuf_new_from_file (path, &error); if (!g_file_test (path, G_FILE_TEST_EXISTS)) { g_error (G_STRLOC ": %s doesn't exists.", path); } if (error) { g_error_free (error); } g_free (path); if (error) { g_error_free (error); return; } if (pixbuf) { list = g_list_append (list, pixbuf); /* LAZY: not beautifual code, learn scim_setup_ui.cpp:create_main_ui() please */ gtk_window_set_default_icon_list (list); g_list_free (list); g_object_unref (pixbuf); } }
int main (int argc, char **argv) { GList *list; GdkPixbuf *pixbuf; GError *err; gtk_init (&argc, &argv); err = NULL; pixbuf = gdk_pixbuf_new_from_file (METACITY_ICON_DIR"/metacity-window-demo.png", &err); if (pixbuf) { list = g_list_prepend (NULL, pixbuf); gtk_window_set_default_icon_list (list); g_list_free (list); g_object_unref (G_OBJECT (pixbuf)); } else { g_printerr ("Could not load icon: %s\n", err->message); g_error_free (err); } do_appwindow (NULL, NULL, NULL); gtk_main (); return 0; }
/** * gnome_window_icon_set_default_from_file_list: * @filenames: NULL terminated string array * * Description: Wrapper around gtk_window_set_default_icon_list(), * which loads the icons in @filenames. **/ void gnome_window_icon_set_default_from_file_list (const char **filenames) { GList *list; g_return_if_fail (filenames != NULL); list = list_from_char_array (filenames); gtk_window_set_default_icon_list (list); free_list (list); }
static void setup_default_icon (void) { GdkPixbuf *pixbuf; char *filename; GError *err; err = NULL; pixbuf = NULL; filename = demo_find_file ("gtk-logo-rgb.gif", &err); if (filename) { pixbuf = gdk_pixbuf_new_from_file (filename, &err); g_free (filename); } /* Ignoring this error (passing NULL instead of &err above) * would probably be reasonable for most apps. We're just * showing off. */ if (err) { GtkWidget *dialog; dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Failed to read icon file: %s", err->message); g_error_free (err); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); } if (pixbuf) { GList *list; GdkPixbuf *transparent; /* The gtk-logo-rgb icon has a white background, make it transparent */ transparent = gdk_pixbuf_add_alpha (pixbuf, TRUE, 0xff, 0xff, 0xff); list = NULL; list = g_list_append (list, transparent); gtk_window_set_default_icon_list (list); g_list_free (list); g_object_unref (pixbuf); g_object_unref (transparent); } }
static int ui_main(void) { #ifndef _WIN32 GList *icons = NULL; GdkPixbuf *icon = NULL; char *icon_path; int i; struct { const char *dir; const char *filename; } icon_sizes[] = { {"16x16", "pidgin.png"}, {"24x24", "pidgin.png"}, {"32x32", "pidgin.png"}, {"48x48", "pidgin.png"}, {"scalable", "pidgin.svg"} }; #endif pidgin_themes_init(); pidgin_blist_setup_sort_methods(); #ifndef _WIN32 /* use the nice PNG icon for all the windows */ for(i=0; i<G_N_ELEMENTS(icon_sizes); i++) { icon_path = g_build_filename(DATADIR, "icons", "hicolor", icon_sizes[i].dir, "apps", icon_sizes[i].filename, NULL); icon = pidgin_pixbuf_new_from_file(icon_path); g_free(icon_path); if (icon) { icons = g_list_append(icons,icon); } else { purple_debug_error("ui_main", "Failed to load the default window icon (%spx version)!\n", icon_sizes[i].dir); } } if(NULL == icons) { purple_debug_error("ui_main", "Unable to load any size of default window icon!\n"); } else { gtk_window_set_default_icon_list(icons); g_list_foreach(icons, (GFunc)g_object_unref, NULL); g_list_free(icons); } #endif return 0; }
static void setup_default_icon() { GdkPixbuf *pixbuf; pixbuf = gdk_pixbuf_new_from_file(UIM_PIXMAPSDIR "/uim-dict.png", NULL); if (pixbuf) { GList *list; list = NULL; list = g_list_append(list, pixbuf); gtk_window_set_default_icon_list(list); g_list_free(list); g_object_unref(pixbuf); } }
/* Set the application icons. */ void set_icons(void) { #include "app_icons.h" GList* icons = NULL; /* Setup the application icons. */ icons = g_list_append(icons, gdk_pixbuf_new_from_inline(-1, icon_16x16_inline, FALSE, NULL)); icons = g_list_append(icons, gdk_pixbuf_new_from_inline(-1, icon_24x24_inline, FALSE, NULL)); icons = g_list_append(icons, gdk_pixbuf_new_from_inline(-1, icon_32x32_inline, FALSE, NULL)); icons = g_list_append(icons, gdk_pixbuf_new_from_inline(-1, icon_36x36_inline, FALSE, NULL)); gtk_window_set_default_icon_list(icons); }
static void load_icon(void) { GdkPixbuf *pix = NULL; gchar *filename; if(program_logo && !g_strcasecmp(program_logo,"none")) return; if(program_logo) filename = g_strdup(program_logo); else filename = g_build_filename(program_data,PROGRAM_LOGO,NULL); if(!g_file_test(filename,G_FILE_TEST_IS_REGULAR)) { g_free(filename); return; } pix = gdk_pixbuf_new_from_file(filename, NULL); if(pix) { static const size[] = { 16, 32, 48, 64, 128, 256 }; GList *icon = NULL; int f; gtk_window_set_default_icon(pix); g_object_set_data_full(G_OBJECT(topwindow),"logo",pix,g_object_unref); #if defined( HAVE_IGEMAC ) gtk_osxapplication_set_dock_icon_pixbuf(osxapp,pix); #endif for(f=0;f<G_N_ELEMENTS(size);f++) { pix = gdk_pixbuf_new_from_file_at_size(filename,size[f],size[f],NULL); if(pix) icon = g_list_append(icon, pix); } gtk_window_set_default_icon_list(icon); } g_free(filename); }
static void icons_setup(AWeatherGui *self) { gchar *icons[] = { ICONDIR "/hicolor/16x16/apps/aweather.png", ICONDIR "/hicolor/22x22/apps/aweather.png", ICONDIR "/hicolor/24x24/apps/aweather.png", ICONDIR "/hicolor/32x32/apps/aweather.png", ICONDIR "/hicolor/48x48/apps/aweather.png", ICONDIR "/hicolor/scalable/apps/aweather.svg", }; GList *list = NULL; for (int i = 0; i < G_N_ELEMENTS(icons); i++) { GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(icons[i], NULL); if (!pixbuf) g_warning("AWeatherGui: icons_setup - %s failed", icons[i]); list = g_list_prepend(list, pixbuf); } gtk_window_set_default_icon_list(list); g_list_free(list); }
/** * Initialize the application icons for the program. These icons are * the ones shown by the window manager within title bars and pagers. * The last icon listed in the array will be displayed in the About * dialog. * * @param top Toplevel whose icon to set. All child windows will * inherit these icons. */ static void init_icons(toplevel_t * top) { static const char *icon_names[] = { "sediffx-small.png", "sediffx.png" }; GdkPixbuf *icon; char *path; GList *icon_list = NULL; size_t i; for (i = 0; i < sizeof(icon_names) / sizeof(icon_names[0]); i++) { if ((path = apol_file_find_path(icon_names[i])) == NULL) { continue; } icon = gdk_pixbuf_new_from_file(path, NULL); free(path); if (icon == NULL) { continue; } icon_list = g_list_append(icon_list, icon); } gtk_window_set_default_icon_list(icon_list); gtk_window_set_icon_list(top->w, icon_list); }
void ctk_main(ParsedAttribute *p, ConfigProperties *conf, CtrlHandles *h, const char *page) { int i, has_nv_control = FALSE; GList *list = NULL; GtkWidget *window; list = g_list_append (list, gdk_pixbuf_from_pixdata(&nvidia_icon_pixdata, TRUE, NULL)); gtk_window_set_default_icon_list(list); window = ctk_window_new(p, conf, h); for (i = 0; i < h->targets[X_SCREEN_TARGET].n; i++) { if (h->targets[X_SCREEN_TARGET].t[i].h) { has_nv_control = TRUE; break; } } if (!has_nv_control) { GtkWidget *dlg; dlg = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "You do not appear to be using the NVIDIA " "X driver. Please edit your X configuration " "file (just run `nvidia-xconfig` " "as root), and restart the X server."); gtk_dialog_run(GTK_DIALOG(dlg)); gtk_widget_destroy (dlg); } ctk_window_set_active_page(CTK_WINDOW(window), page); gtk_main(); }
void icons_initialize(void) { GtkIconFactory *factory; GdkPixbuf *goat; GList *l; factory = gtk_icon_factory_new(); goat = add(factory, logjam_goat, "logjam-goat"); add(factory, logjam_pencil, "logjam-server"); add(factory, logjam_ljuser, "logjam-ljuser"); add(factory, logjam_ljcomm, "logjam-ljcomm"); add(factory, logjam_twuser, "logjam-twuser"); add(factory, logjam_protected, "logjam-protected"); add(factory, logjam_private, "logjam-private"); add(factory, logjam_blogger, "logjam-blogger"); gtk_icon_factory_add_default(factory); l = g_list_append(NULL, goat); gtk_window_set_default_icon_list(l); g_list_free(l); gtk_stock_add_static(logjam_stock_items, G_N_ELEMENTS(logjam_stock_items)); }
int CUIHandler::CreateMainWnd() { GtkWidget* menubar; GtkWidget* filemenu, *helpmenu; GtkWidget* file, *quit; GtkWidget* help, *about; GtkWidget* vbox, *hbox; GtkWidget* align; GtkToolItem* toolitem; GtkWidget* frame; GtkWidget* status_menu; GtkWidget* status_menu_item; GtkWidget *hseparator; GtkWidget *statusbarHBox; GtkWidget *statusbarFrameConnection; GtkWidget *statusbarAlignmentConnection; GtkWidget *statusbarHBoxConnection; GtkWidget *statusbarFrameFps; GtkWidget *statusbarAlignmentFps; GtkWidget *statusbarFrameResolution; GtkWidget *statusbarAlignmentResolution; // set up tray icon trayIcon = gtk_status_icon_new_from_pixbuf(disconnectedTrayIcon); gtk_status_icon_set_tooltip(trayIcon, TRAY_TOOLTIP_DISCONNECTED); gtk_status_icon_set_visible(trayIcon, TRUE); g_signal_connect(G_OBJECT(trayIcon), "popup-menu", G_CALLBACK(status_popup), NULL); g_signal_connect(G_OBJECT(trayIcon), "activate", G_CALLBACK(status_activate), NULL); // set up main mainWindow mainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(G_OBJECT(mainWindow), "delete_event", G_CALLBACK(delete_event), NULL); g_signal_connect(G_OBJECT(mainWindow), "destroy", G_CALLBACK(destroy), NULL); g_signal_connect(G_OBJECT(mainWindow), "window_state_event", G_CALLBACK(track_minimize), NULL); gtk_window_set_title(GTK_WINDOW(mainWindow), SMARTCAM_WND_TITLE); gtk_container_set_border_width(GTK_CONTAINER(mainWindow), 1); gtk_window_set_resizable(GTK_WINDOW(mainWindow), FALSE); gtk_widget_set_size_request(mainWindow, MAIN_WND_WIDTH, MAIN_WND_HEIGHT); gtk_window_set_position(GTK_WINDOW(mainWindow), GTK_WIN_POS_NONE); gtk_window_set_gravity(GTK_WINDOW (mainWindow), GDK_GRAVITY_CENTER); gtk_window_set_default_icon(connectedTrayIcon); GdkPixbuf* icon; GList* icon_list = NULL; icon = gdk_pixbuf_new_from_file(DATADIR "/icons/hicolor/16x16/apps/smartcam.png", NULL); icon_list = g_list_append(icon_list, icon); icon = gdk_pixbuf_new_from_file(DATADIR "/icons/hicolor/22x22/apps/smartcam.png", NULL); icon_list = g_list_append(icon_list, icon); icon = gdk_pixbuf_new_from_file(DATADIR "/icons/hicolor/24x24/apps/smartcam.png", NULL); icon_list = g_list_append(icon_list, icon); icon = gdk_pixbuf_new_from_file(DATADIR "/icons/hicolor/32x32/apps/smartcam.png", NULL); icon_list = g_list_append(icon_list, icon); icon = gdk_pixbuf_new_from_file(DATADIR "/icons/hicolor/48x48/apps/smartcam.png", NULL); icon_list = g_list_append(icon_list, icon); gtk_window_set_default_icon_list(icon_list); g_list_foreach(icon_list, (GFunc)g_object_unref, NULL ); g_list_free(icon_list); // create menubar menubar = gtk_menu_bar_new(); filemenu = gtk_menu_new(); file = gtk_menu_item_new_with_mnemonic("_File"); miSettings = gtk_image_menu_item_new_with_label("Settings"); gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(miSettings), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU)); g_signal_connect(G_OBJECT(miSettings), "activate", G_CALLBACK(OnSettingsClicked), (gpointer) NULL); quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL); g_signal_connect(G_OBJECT(quit), "activate", G_CALLBACK(destroy), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), miSettings); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit); helpmenu = gtk_menu_new(); help = gtk_menu_item_new_with_mnemonic("_Help"); about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL); g_signal_connect(about, "activate", G_CALLBACK(show_about_dialog), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help); gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), helpmenu); gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), about); // create toolbar toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_MENU); g_object_set(G_OBJECT(toolbar), "can-focus", FALSE, NULL); tbSettings = gtk_tool_button_new_from_stock(GTK_STOCK_PREFERENCES); g_signal_connect(G_OBJECT(tbSettings), "clicked", G_CALLBACK(OnSettingsClicked), NULL); g_object_set(G_OBJECT(tbSettings), "tooltip-text", "Settings", NULL); g_object_set(G_OBJECT(tbSettings), "can-focus", FALSE, NULL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tbSettings, 0); tbDisconnect = gtk_tool_button_new_from_stock(GTK_STOCK_DISCONNECT); g_signal_connect(G_OBJECT(tbDisconnect), "clicked", G_CALLBACK(OnDisconnectClicked), NULL); g_object_set(G_OBJECT(tbDisconnect), "tooltip-text", "Disconnect", NULL); g_object_set(G_OBJECT(tbDisconnect), "can-focus", FALSE, NULL); g_object_set(G_OBJECT(tbDisconnect), "sensitive", FALSE, NULL); // disable disconnect gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tbDisconnect, 1); // create preview frame vbox = gtk_vbox_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(vbox), 1); gtk_container_add(GTK_CONTAINER(mainWindow), vbox); align = gtk_alignment_new(0.5, 0.5, 0, 0); frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT); image = gtk_image_new_from_pixbuf(logoIcon); gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), align, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(align), frame); gtk_container_add(GTK_CONTAINER(frame), image); // set up status bar hseparator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, FALSE, 0); statusbarHBox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), statusbarHBox, FALSE, FALSE, 0); statusbarFrameConnection = gtk_frame_new (NULL); gtk_box_pack_start (GTK_BOX (statusbarHBox), statusbarFrameConnection, TRUE, TRUE, 0); gtk_widget_set_size_request (statusbarFrameConnection, 55, 25); gtk_frame_set_label_align (GTK_FRAME (statusbarFrameConnection), 0, 0); gtk_frame_set_shadow_type (GTK_FRAME (statusbarFrameConnection), GTK_SHADOW_IN); statusbarAlignmentConnection = gtk_alignment_new (0, 0.5, 1, 1); gtk_container_add (GTK_CONTAINER (statusbarFrameConnection), statusbarAlignmentConnection); gtk_alignment_set_padding (GTK_ALIGNMENT (statusbarAlignmentConnection), 0, 0, 3, 0); statusbarHBoxConnection = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (statusbarAlignmentConnection), statusbarHBoxConnection); if(pSmartEngine->GetSettings().connectionType == CONN_BLUETOOTH) { statusbarImageConnection = gtk_image_new_from_pixbuf(btStatusIcon); } else { statusbarImageConnection = gtk_image_new_from_pixbuf(inetStatusIcon); } gtk_box_pack_start (GTK_BOX (statusbarHBoxConnection), statusbarImageConnection, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (statusbarImageConnection), 0, 0.5); statusbarLabelConnection = gtk_label_new ("Disconnected"); gtk_box_pack_start (GTK_BOX (statusbarHBoxConnection), statusbarLabelConnection, TRUE, TRUE, 0); gtk_misc_set_alignment (GTK_MISC (statusbarLabelConnection), 0, 0.5); statusbarFrameFps = gtk_frame_new (NULL); gtk_box_pack_start (GTK_BOX (statusbarHBox), statusbarFrameFps, TRUE, TRUE, 0); gtk_widget_set_size_request (statusbarFrameFps, 17, 25); gtk_frame_set_shadow_type (GTK_FRAME (statusbarFrameFps), GTK_SHADOW_IN); statusbarAlignmentFps = gtk_alignment_new (0, 0.5, 1, 1); gtk_container_add (GTK_CONTAINER (statusbarFrameFps), statusbarAlignmentFps); gtk_alignment_set_padding (GTK_ALIGNMENT (statusbarAlignmentFps), 0, 0, 3, 0); statusbarLabelFps = gtk_label_new (CUIHandler::STATUS_LABEL_FPS); gtk_container_add (GTK_CONTAINER (statusbarAlignmentFps), statusbarLabelFps); gtk_misc_set_alignment (GTK_MISC (statusbarLabelFps), 0, 0.5); statusbarFrameResolution = gtk_frame_new (NULL); gtk_box_pack_start (GTK_BOX (statusbarHBox), statusbarFrameResolution, TRUE, TRUE, 0); gtk_widget_set_size_request (statusbarFrameResolution, 92, 25); gtk_frame_set_shadow_type (GTK_FRAME (statusbarFrameResolution), GTK_SHADOW_IN); statusbarAlignmentResolution = gtk_alignment_new (0, 0.5, 1, 1); gtk_container_add (GTK_CONTAINER (statusbarFrameResolution), statusbarAlignmentResolution); gtk_alignment_set_padding (GTK_ALIGNMENT (statusbarAlignmentResolution), 0, 0, 3, 0); statusbarLabelResolution = gtk_label_new (CUIHandler::STATUS_LABEL_RESOLUTION); gtk_container_add (GTK_CONTAINER (statusbarAlignmentResolution), statusbarLabelResolution); gtk_misc_set_alignment (GTK_MISC (statusbarLabelResolution), 0, 0.5); gtk_widget_show_all(mainWindow); return 0; }
/** * gens_window_create(): Create the Gens window. */ void gens_window_create(void) { // Create the icon for the Gens window, and set it as default for all windows. // TODO: Move this to a common C file. // TODO: Use the standard icon directory layout. GList *gens_icon_list = NULL; static const char* const gens_icon_filename[3] = { GENS_DATADIR "/gensgs_48x48.png", GENS_DATADIR "/gensgs_32x32.png", GENS_DATADIR "/gensgs_16x16.png" }; // Add the icons. for (int i = 0; i < 3; i++) { if (!g_file_test(gens_icon_filename[i], G_FILE_TEST_EXISTS)) { // File not found. LOG_MSG(gens, LOG_MSG_LEVEL_WARNING, "Image file not found: %s", gens_icon_filename[i]); continue; } // Load the icon. GError *error = NULL; GdkPixbuf *gens_icon = gdk_pixbuf_new_from_file(gens_icon_filename[i], &error); if (!gens_icon) { LOG_MSG(gens, LOG_MSG_LEVEL_WARNING, "Error loading image file %s: %s", gens_icon_filename[i], error->message); g_error_free(error); continue; } // Add the icon to the icon list. gens_icon_list = g_list_append(gens_icon_list, gens_icon); } // Set the icon list as the default icon list. gtk_window_set_default_icon_list(gens_icon_list); // Free the icon list. g_list_free(gens_icon_list); // Create the Gens window. gens_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_resizable(GTK_WINDOW(gens_window), FALSE); gtk_container_set_border_width(GTK_CONTAINER(gens_window), 0); gtk_window_set_position(GTK_WINDOW(gens_window), GTK_WIN_POS_CENTER); gtk_window_set_title(GTK_WINDOW(gens_window), "Gens"); // Create the main VBox. gens_vbox_main = gtk_vbox_new(FALSE, 0); gtk_widget_show(gens_vbox_main); gtk_container_add(GTK_CONTAINER(gens_window), gens_vbox_main); // Create the HBox for the SDL "socket". GtkWidget *hboxSocket = gtk_hbox_new(FALSE, 0); gtk_widget_show(hboxSocket); gtk_box_pack_end(GTK_BOX(gens_vbox_main), hboxSocket, TRUE, TRUE, 0); // Create the SDL "socket". gens_window_sdlsock = gtk_event_box_new(); gtk_box_pack_start(GTK_BOX(hboxSocket), gens_window_sdlsock, TRUE, FALSE, 0); // Set the background color of the SDL "socket" to black. GdkColor bg = {0, 0, 0, 0}; gtk_widget_modify_bg(gens_window_sdlsock, GTK_STATE_NORMAL, &bg); // Callbacks for if the window is closed. g_signal_connect((gpointer)gens_window, "delete-event", G_CALLBACK(on_gens_window_close), NULL); g_signal_connect((gpointer)gens_window, "destroy-event", G_CALLBACK(on_gens_window_close), NULL); // Callbacks for Auto Pause. g_signal_connect((gpointer)gens_window, "focus-in-event", G_CALLBACK(gens_window_focus_in), NULL); g_signal_connect((gpointer)gens_window, "focus-out-event", G_CALLBACK(gens_window_focus_out), NULL); // Enable drag & drop for ROM loading. static const GtkTargetEntry target_list[] = { {"text/plain", 0, 0}, {"text/uri-list", 0, 1}, }; gtk_drag_dest_set ( gens_window_sdlsock, (GtkDestDefaults)(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT), target_list, G_N_ELEMENTS(target_list), (GdkDragAction)(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_PRIVATE | GDK_ACTION_ASK) ); // Set drag & drop callbacks. g_signal_connect(gens_window_sdlsock, "drag-data-received", G_CALLBACK(gens_window_drag_data_received), NULL); g_signal_connect(gens_window_sdlsock, "drag-drop", G_CALLBACK(gens_window_drag_drop), NULL); // Expose event. g_signal_connect(gens_window_sdlsock, "expose-event", G_CALLBACK(gens_window_sdlsock_expose), NULL); // Button Press event. g_signal_connect(gens_window_sdlsock, "button-press-event", G_CALLBACK(gens_window_sdlsock_button_press), NULL); // Window State event. g_signal_connect(gens_window, "window-state-event", G_CALLBACK(gens_window_window_state_event), NULL); // Window is active. Settings.Active = 1; }
void gnc_gnome_init (int argc, char **argv, const char * version) { GError *error = NULL; gchar *prefix = gnc_path_get_prefix (); gchar *pkgsysconfdir = gnc_path_get_pkgsysconfdir (); gchar *pkgdatadir = gnc_path_get_pkgdatadir (); gchar *pkglibdir = gnc_path_get_pkglibdir (); gboolean installation_ok = TRUE; /* Verify all the various directory before proceeding */ if (!g_file_test(pkgdatadir, G_FILE_TEST_IS_DIR)) { g_critical("The installation data directory \"%s\" was not found. Your installation is incomplete and cannot be run.", pkgdatadir); installation_ok = FALSE; } if (!g_file_test(pkglibdir, G_FILE_TEST_IS_DIR)) { g_critical("The installation lib directory \"%s\" was not found. Your installation is incomplete and cannot be run.", pkglibdir); installation_ok = FALSE; } if (!g_file_test(pkgsysconfdir, G_FILE_TEST_IS_DIR)) { g_critical("The installation sysconf directory \"%s\" was not found. Your installation is incomplete and cannot be run.", pkgsysconfdir); installation_ok = FALSE; } gnc_gtk_add_rc_file(); gnucash_program = gnome_program_init( "gnucash", version, LIBGNOMEUI_MODULE, argc, argv, GNOME_PARAM_APP_PREFIX, prefix, GNOME_PARAM_APP_SYSCONFDIR, pkgsysconfdir, GNOME_PARAM_APP_DATADIR, pkgdatadir, GNOME_PARAM_APP_LIBDIR, pkglibdir, GNOME_PARAM_NONE); if (!installation_ok) { /* The following string does not need translation because if * it shows up, the program is unusable anyway. */ gnc_error_dialog(NULL, "The installation directories were not found.\n\ndatadir=%s\nlibdir=%s\nsysconfdir=%s\n\nYour installation is incomplete and cannot be run.", pkgdatadir, pkglibdir, pkgsysconfdir); /* gnc_error_dialog must not be called before gnome_program_init. */ } g_free (prefix); g_free (pkgsysconfdir); g_free (pkgdatadir); g_free (pkglibdir); /* Did the installation directory check fail? Terminate * immediately because it will inevitably fail in the glade file * lookup. */ if (!installation_ok) { /* No correct installation? Shut down immediately. */ exit(-1); } #ifdef G_OS_WIN32 /* workaround for bug #421792 */ xmlCleanupInputCallbacks(); #endif /* initialization required for gtkhtml (is it also needed for webkit?) */ gtk_widget_set_default_colormap (gdk_rgb_get_colormap ()); /* use custom icon */ { int idx; char *icon_filenames[] = {"gnucash-icon-16x16.png", "gnucash-icon-32x32.png", "gnucash-icon-48x48.png", NULL }; GList *icons = NULL; char *fullname, *name_iter; for (idx = 0; icon_filenames[idx] != NULL; idx++) { GdkPixbuf *buf = NULL; fullname = gnc_gnome_locate_pixmap(icon_filenames[idx]); if (fullname == NULL) { g_warning("couldn't find icon file [%s]", icon_filenames[idx]); continue; } buf = gnc_gnome_get_gdkpixbuf(fullname); if (buf == NULL) { g_warning("error loading image from [%s]", fullname); g_free(fullname); continue; } g_free(fullname); icons = g_list_append(icons, buf); } gtk_window_set_default_icon_list(icons); g_list_foreach(icons, (GFunc)g_object_unref, NULL); g_list_free(icons); } assistant_gconf_install_check_schemas(); return; }
/* GUI init */ void gzrt_gui_init ( int argc, char **argv ) { /* Set up icons */ N64Rom *ctx = NULL; GList *list = NULL; char *icons[] = { GZRT_GUI_ICON_1, GZRT_GUI_ICON_2, GZRT_GUI_ICON_3, GZRT_GUI_ICON_4, NULL }, i; for( i = 0; icons[i]; i++ ) { GdkPixbuf *g = gdk_pixbuf_new_from_file(icons[i], NULL); list = g_list_append( list, g ); } /* Set default icon */ gtk_window_set_default_icon_list( list ); /* Show debug window */ #ifdef GZRT_DEBUG gzrt_gui_debug_create(); #endif /* Load configuration */ gzrt_config_load(); /* Load plugins */ gzrt_load_plugins(); /* Find a file to open */ int opened = FALSE; /* Is the default file set? */ if( GZRTConfig.default_rom ) { /* Yep, try it */ if( (ctx = n64rom_load(GZRTConfig.default_rom)) ) { /* Goes */ if( !gzrt_wmain_create_new( ctx ) ) /* File selection */ gzrt_wfilesel_show(); else opened = TRUE; } else gzrt_notice( "Notice!", "There was a default ROM specified, but it wasn't found.\nPlease fix this!" ); } /* Try command line arguments also */ if( argc > 1 ) for( i = 1; i < argc; i++ ) { if( !(ctx = n64rom_load( argv[i] )) ) { char buffer[128]; sprintf(buffer, "Failed to open \"%s\".", argv[i]); gzrt_notice( "Error", buffer ); } else if( gzrt_wmain_create_new( ctx ) ) opened = TRUE; } /* Show splash? */ if( !opened ) gzrt_wsplash_init( gzrt_wfilesel_show ); }
int gnoclConfigureCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { GnoclOption options[] = { { "-tooltip", GNOCL_BOOL, NULL }, { "-defaultIcon", GNOCL_OBJ, NULL }, { NULL } }; const int tooltipIdx = 0; const int defaultIconIdx = 1; int ret = TCL_ERROR; if ( gnoclParseOptions ( interp, objc, objv, options ) != TCL_OK ) goto cleanExit; if ( options[defaultIconIdx].status == GNOCL_STATUS_CHANGED ) { GnoclStringType type = gnoclGetStringType ( options[defaultIconIdx].val.obj ); switch ( type ) { case GNOCL_STR_EMPTY: gtk_window_set_default_icon_list ( NULL ); break; case GNOCL_STR_FILE: { GdkPixbuf *pix = gnoclPixbufFromObj ( interp, options + defaultIconIdx ); GList *list = NULL; if ( pix == NULL ) goto cleanExit; list = g_list_append ( list, pix ); gtk_window_set_default_icon_list ( list ); g_list_free ( list ); } break; default: Tcl_AppendResult ( interp, "Unknown type for \"", Tcl_GetString ( options[defaultIconIdx].val.obj ), "\" must be of type FILE (%/) or empty", NULL ); goto cleanExit; } } if ( options[tooltipIdx].status == GNOCL_STATUS_CHANGED ) { if ( options[tooltipIdx].val.b ) gtk_tooltips_enable ( gnoclGetTooltips() ); else gtk_tooltips_disable ( gnoclGetTooltips() ); } ret = TCL_OK; cleanExit: gnoclClearOptions ( options ); return ret; }
void gnc_gnome_init (int argc, char **argv, const char * version) { GError *error = NULL; gchar *prefix = gnc_path_get_prefix (); gchar *pkgsysconfdir = gnc_path_get_pkgsysconfdir (); gchar *pkgdatadir = gnc_path_get_pkgdatadir (); gchar *pkglibdir = gnc_path_get_pkglibdir (); gnc_gtk_add_rc_file(); gnucash_program = gnome_program_init( "gnucash", version, LIBGNOMEUI_MODULE, argc, argv, GNOME_PARAM_APP_PREFIX, prefix, GNOME_PARAM_APP_SYSCONFDIR, pkgsysconfdir, GNOME_PARAM_APP_DATADIR, pkgdatadir, GNOME_PARAM_APP_LIBDIR, pkglibdir, GNOME_PARAM_NONE); g_free (prefix); g_free (pkgsysconfdir); g_free (pkgdatadir); g_free (pkglibdir); #ifdef G_OS_WIN32 /* workaround for bug #421792 */ xmlCleanupInputCallbacks(); #endif /* initialization required for gtkhtml */ gtk_widget_set_default_colormap (gdk_rgb_get_colormap ()); /* use custom icon */ { int idx; char *icon_filenames[] = {"gnucash-icon-16x16.png", "gnucash-icon-32x32.png", "gnucash-icon-48x48.png", NULL }; GList *icons = NULL; char *fullname, *name_iter; for (idx = 0; icon_filenames[idx] != NULL; idx++) { GdkPixbuf *buf = NULL; fullname = gnc_gnome_locate_pixmap(icon_filenames[idx]); if (fullname == NULL) { g_warning("couldn't find icon file [%s]", icon_filenames[idx]); continue; } buf = gnc_gnome_get_gdkpixbuf(fullname); if (buf == NULL) { g_warning("error loading image from [%s]", fullname); g_free(fullname); continue; } g_free(fullname); icons = g_list_append(icons, buf); } gtk_window_set_default_icon_list(icons); g_list_foreach(icons, (GFunc)g_object_unref, NULL); g_list_free(icons); } druid_gconf_install_check_schemas(); return; }
SludgeApplication::SludgeApplication(const char * gladeFileName, const char * iconName, const char * configFile) { configfile = configFile; GError *err = NULL; initSuccess = TRUE; char buf[1000]; GdkPixbuf *pixbuf16, *pixbuf32, *pixbuf128, *pixbuf256; GList *list = NULL; sprintf(buf, "%s%s_16x16x32.png", DATADIR, iconName); pixbuf16 = gdk_pixbuf_new_from_file (buf, &err); if (err == NULL) { sprintf(buf, "%s%s_32x32x32.png", DATADIR, iconName); pixbuf32 = gdk_pixbuf_new_from_file (buf, &err); } if (err == NULL) { sprintf(buf, "%s%s_128x128x32.png", DATADIR, iconName); pixbuf128 = gdk_pixbuf_new_from_file (buf, &err); } if (err == NULL) { sprintf(buf, "%s%s_256x256x32.png", DATADIR, iconName); pixbuf256 = gdk_pixbuf_new_from_file (buf, &err); } if (err != NULL) { fprintf (stderr, "Unable to open icon file: %s\n", err->message); g_error_free (err); } else { list = g_list_append (list, pixbuf16); list = g_list_append (list, pixbuf32); list = g_list_append (list, pixbuf128); list = g_list_append (list, pixbuf256); gtk_window_set_default_icon_list(list); } /* * Load the GTK interface. */ theXml = gtk_builder_new (); if (!gtk_builder_add_from_file (theXml, gladeFileName, NULL)) { g_critical ("Failed to load the GTK file.\n"); errorBox("Error!", joinTwoStrings("Failed to load resource file:\n", gladeFileName)); initSuccess = FALSE; return; } /* * Get the top-level window reference from loaded Glade file. */ theWindow = GTK_WIDGET (gtk_builder_get_object (theXml, "window1")); if (theWindow == NULL) { g_critical ("Failed to get the window from the builder.\n"); initSuccess = FALSE; return; } // Set unassigned widgets to get handled automatically by the window manager. gtk_container_set_reallocate_redraws (GTK_CONTAINER (theWindow), TRUE); char folderFile[300]; sprintf(folderFile, "%s/sludge-devkit/%s", g_get_user_config_dir(), configfile); FILE * fp = fopen (folderFile, "r"); if (fp) { char readChar = ' '; for (int i = 0; i < 300; i++) { readChar = fgetc(fp); if (readChar != '\n') { currentFolder[i] = readChar; } else { currentFolder[i] = 0; break; } } fclose (fp); } else { sprintf (currentFolder, "%s", g_get_home_dir()); } fileChanged = FALSE; currentFilename[0] = 0; currentShortname[0] = 0; }
/* Gobj */ static void bjb_window_base_init (BjbWindowBase *self) { BjbWindowBasePriv *priv; const gchar *icons_path; gchar *full_path; GList *icons = NULL; GdkPixbuf *bjb ; GError *error = NULL ; GtkClutterEmbed *embed; self->priv = G_TYPE_INSTANCE_GET_PRIVATE(self, BJB_TYPE_WINDOW_BASE, BjbWindowBasePriv); priv = self->priv; gtk_window_set_default_size (GTK_WINDOW (self), BJB_WIDTH, BJB_HEIGHT); gtk_window_set_position (GTK_WINDOW (self),GTK_WIN_POS_CENTER); gtk_window_set_title (GTK_WINDOW (self), BIJIBEN_MAIN_WIN_TITLE); /* Icon for window. TODO - Should be BjbApp */ icons_path = bijiben_get_bijiben_dir (); full_path = g_build_filename (icons_path, "icons", "hicolor", "48x48", "apps", "bijiben.png", NULL); bjb = gdk_pixbuf_new_from_file (full_path, &error); g_free (full_path); if ( error ) { g_message("%s", error->message); g_error_free(error); } icons = g_list_prepend(icons,bjb); gtk_window_set_default_icon_list(icons); g_list_foreach (icons, (GFunc) g_object_unref, NULL); g_list_free (icons); /* We probably want to offer a no entry window at first (startup) */ priv->entry = NULL ; priv->tags = get_all_tracker_tags(); priv->font = pango_font_description_from_string (BJB_DEFAULT_FONT); /* UI */ embed = GTK_CLUTTER_EMBED (gtk_clutter_embed_new()); gtk_clutter_embed_set_use_layout_size (embed, TRUE); gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (embed)); priv->stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (embed)); /* Signals */ g_signal_connect(GTK_WIDGET(self),"destroy", G_CALLBACK(bjb_window_base_destroy),self); }