void orcaGtk::alloc()/*{{{*/ { switch(type) { case GUI_WINDOW: handle = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(handle), text.c_str()); gtk_window_set_default_size(GTK_WINDOW(handle), 800, 600); gtk_window_set_position(GTK_WINDOW(handle), GTK_WIN_POS_CENTER); g_signal_connect_swapped(G_OBJECT(handle), "destroy", G_CALLBACK(gtk_main_quit), G_OBJECT(handle)); break; case GUI_FIXED: handle = gtk_fixed_new(); break; case GUI_VBOX: handle = gtk_vbox_new(FALSE, 0); break; case GUI_HBOX: handle = gtk_hbox_new(FALSE, 0); break; case GUI_HSEP: handle = gtk_hseparator_new(); break; case GUI_BUTTON: handle = gtk_button_new_with_label(text.c_str()); gtk_widget_set_size_request(handle, 100, 100); break; case GUI_CHECK: handle = gtk_check_button_new_with_label(text.c_str()); break; case GUI_RADIO: handle = gtk_radio_button_new_with_label (NULL, text.c_str()); break; case GUI_COMBO: handle = gtk_combo_box_new_text(); break; case GUI_LABEL: handle = gtk_label_new(text.c_str()); break; case GUI_ENTRY: handle = gtk_entry_new(); break; case GUI_TEXT: handle = gtk_text_view_new(); break; case GUI_MENUBAR: handle = gtk_menu_bar_new(); break; case GUI_LIST: case GUI_TREE: handle = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(handle), TRUE); break; case GUI_SCROLL: handle = gtk_scrolled_window_new(NULL, NULL); break; case GUI_TABLE: handle = NULL; break; case GUI_IMAGE: handle = gtk_image_new(); break; case GUI_STATUSBAR: handle = gtk_statusbar_new(); break; } }
static int gtkToggleMapMethod(Ihandle* ih) { Ihandle* radio = iupRadioFindToggleParent(ih); char *value; int is3state = 0; if (!ih->parent) return IUP_ERROR; value = iupAttribGet(ih, "IMAGE"); if (value) ih->data->type = IUP_TOGGLE_IMAGE; else ih->data->type = IUP_TOGGLE_TEXT; if (radio) { GtkRadioButton* last_tg = (GtkRadioButton*)iupAttribGet(radio, "_IUPGTK_LASTRADIOBUTTON"); if (last_tg) ih->handle = gtk_radio_button_new_from_widget(last_tg); else ih->handle = gtk_radio_button_new(NULL); iupAttribSet(radio, "_IUPGTK_LASTRADIOBUTTON", (char*)ih->handle); /* make sure it has at least one name */ if (!iupAttribGetHandleName(ih)) iupAttribSetHandleName(ih); ih->data->is_radio = 1; } else { if (ih->data->type == IUP_TOGGLE_TEXT) { ih->handle = gtk_check_button_new(); if (iupAttribGetBoolean(ih, "3STATE")) is3state = 1; } else ih->handle = gtk_toggle_button_new(); } if (!ih->handle) return IUP_ERROR; if (ih->data->type == IUP_TOGGLE_TEXT) { gtk_button_set_image((GtkButton*)ih->handle, gtk_label_new(NULL)); gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, TRUE); } else { gtk_button_set_image((GtkButton*)ih->handle, gtk_image_new()); gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, FALSE); } iupgtkClearSizeStyleCSS(ih->handle); /* add to the parent, all GTK controls must call this. */ iupgtkAddToParent(ih); if (!iupAttribGetBoolean(ih, "CANFOCUS")) iupgtkSetCanFocus(ih->handle, 0); if (ih->data->type == IUP_TOGGLE_IMAGE && ih->data->flat) { gtk_button_set_relief((GtkButton*)ih->handle, GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(gtkToggleEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(gtkToggleEnterLeaveEvent), ih); } else { g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); } g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); g_signal_connect(G_OBJECT(ih->handle), "toggled", G_CALLBACK(gtkToggleToggled), ih); if (ih->data->type == IUP_TOGGLE_IMAGE || is3state) { g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(gtkToggleButtonEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(gtkToggleButtonEvent), ih); } if (is3state) { g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkToggleKeyEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-release-event", G_CALLBACK(gtkToggleKeyEvent), ih); } gtk_widget_realize(ih->handle); /* update a mnemonic in a label if necessary */ iupgtkUpdateMnemonic(ih); return IUP_NOERROR; }
GtkWindow* create_notification(Settings settings) { WindowData *windata; GtkWidget *win; #ifdef USE_COMPOSITE GdkColormap *colormap; GdkScreen *screen; #endif // create WindowData object windata = g_new0(WindowData, 1); // create GTK window win = gtk_window_new(GTK_WINDOW_POPUP); gtk_window_set_resizable(GTK_WINDOW (win), FALSE); gtk_widget_set_app_paintable(win, TRUE); windata->win = win; windata->settings = settings; // connect signals g_signal_connect (G_OBJECT (win), "style-set", G_CALLBACK (on_style_set), windata); g_signal_connect (G_OBJECT (win), "map-event", G_CALLBACK (on_window_map), windata); g_signal_connect (G_OBJECT (win), "expose-event", G_CALLBACK (on_window_expose), windata); g_signal_connect (G_OBJECT (win), "realize", G_CALLBACK (on_window_realize), windata); // prepare composite windata->composited = FALSE; #ifdef USE_COMPOSITE screen = gtk_window_get_screen (GTK_WINDOW (win)); colormap = gdk_screen_get_rgba_colormap (screen); if (colormap != NULL) { gtk_widget_set_colormap (win, colormap); if (gdk_screen_is_composited (screen)) { windata->composited = TRUE; } } g_signal_connect(win, "composited-changed", G_CALLBACK (on_composited_changed), windata); #endif gtk_window_set_title(GTK_WINDOW (win), "Notification"); gtk_window_set_type_hint(GTK_WINDOW (win), GDK_WINDOW_TYPE_HINT_NOTIFICATION); gtk_window_set_default_size(GTK_WINDOW(win), 400, 400); gtk_window_set_position(GTK_WINDOW(win), GTK_WIN_POS_CENTER); g_object_set_data_full (G_OBJECT (win), "windata", windata, (GDestroyNotify)destroy_windata); g_signal_connect (G_OBJECT (win), "configure-event", G_CALLBACK (on_configure_event), windata); windata->main_vbox = gtk_vbox_new(FALSE, 0); g_signal_connect(G_OBJECT(windata->main_vbox), "style-set", G_CALLBACK(on_style_set), windata); gtk_widget_show(windata->main_vbox); gtk_container_add(GTK_CONTAINER(win), windata->main_vbox); gtk_container_set_border_width(GTK_CONTAINER(windata->main_vbox), DEFAULT_BORDER); // windata->main_hbox = gtk_hbox_new (FALSE, 0); // gtk_widget_show (windata->main_hbox); // gtk_box_pack_start (GTK_BOX (main_vbox), // windata->main_hbox, // FALSE, FALSE, 0); // icon box windata->iconbox = gtk_alignment_new (0.5f, 0, 0, 0); gtk_widget_show (windata->iconbox); gtk_alignment_set_padding (GTK_ALIGNMENT (windata->iconbox), 0, IMAGE_PADDING, 0, 0); gtk_box_pack_start (GTK_BOX (windata->main_vbox), windata->iconbox, FALSE, FALSE, 0); gtk_widget_set_size_request (windata->iconbox, BODY_X_OFFSET, -1); // icon windata->icon = gtk_image_new (); gtk_widget_show (windata->icon); gtk_container_add (GTK_CONTAINER (windata->iconbox), windata->icon); // progress bar box windata->progressbarbox = gtk_alignment_new (0.5f, 0, 0, 0); gtk_widget_show (windata->progressbarbox); // gtk_alignment_set_padding (GTK_ALIGNMENT (windata->iconbox), // 5, 0, 0, 0); gtk_box_pack_start (GTK_BOX (windata->main_vbox), windata->progressbarbox, FALSE, FALSE, 0); gtk_widget_set_size_request (windata->progressbarbox, BODY_X_OFFSET, -1); // progress bar windata->progressbar = gtk_image_new (); gtk_widget_show (windata->progressbar); gtk_container_add (GTK_CONTAINER (windata->progressbarbox), windata->progressbar); return GTK_WINDOW(win); }
static void prefs_themes_create_widget(PrefsPage *page, GtkWindow *window, gpointer data) { ThemesPage *prefs_themes = (ThemesPage *)page; ThemesData *tdata = prefs_themes_data; GtkWidget *vbox1; GtkWidget *frame1; GtkWidget *vbox2; GtkWidget *hbox3; GtkWidget *menu_themes; GtkWidget *btn_install; GtkWidget *btn_more; GtkWidget *label_global_status; GtkWidget *frame_info; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *label3; GtkWidget *label_name; GtkWidget *label_author; GtkWidget *label_url; GtkWidget *label4; GtkWidget *label_status; GtkWidget *frame_preview; GtkWidget *hbox1; GtkWidget *icon_1; GtkWidget *icon_2; GtkWidget *icon_3; GtkWidget *icon_4; GtkWidget *icon_5; GtkWidget *icon_6; GtkWidget *icon_7; GtkWidget *frame_buttons; GtkWidget *hbuttonbox1; GtkWidget *btn_use; GtkWidget *btn_remove; GtkCellRenderer *renderer; vbox1 = gtk_vbox_new (FALSE, VSPACING); gtk_container_set_border_width (GTK_CONTAINER (vbox1), VBOX_BORDER); gtk_widget_show (vbox1); vbox2 = gtkut_get_options_frame(vbox1, &frame1, _("Selector")); hbox3 = gtk_hbox_new (FALSE, 5); gtk_widget_show (hbox3); gtk_box_pack_start (GTK_BOX (vbox2), hbox3, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox3), 5); menu_themes = gtk_combo_box_new(); gtk_widget_show (menu_themes); gtk_box_pack_start (GTK_BOX (hbox3), menu_themes, FALSE, FALSE, 0); btn_install = gtk_button_new_with_label (_("Install new...")); gtk_widget_show (btn_install); gtk_box_pack_start (GTK_BOX (hbox3), btn_install, FALSE, FALSE, 0); gtkut_widget_set_can_default (btn_install, TRUE); btn_more = gtkut_get_link_btn((GtkWidget *)window, THEMES_URI, _("Get more...")); gtk_widget_show (btn_more); gtk_box_pack_start (GTK_BOX (hbox3), btn_more, FALSE, FALSE, 0); label_global_status = gtk_label_new (""); gtk_widget_show (label_global_status); gtk_box_pack_start (GTK_BOX (vbox2), label_global_status, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label_global_status), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_global_status), 0, 0.5); gtk_misc_set_padding (GTK_MISC (label_global_status), 6, 0); PACK_FRAME(vbox1, frame_info, _("Information")); table1 = gtk_table_new (4, 2, FALSE); gtk_widget_show (table1); gtk_container_add (GTK_CONTAINER (frame_info), table1); label1 = gtk_label_new (_("Name: ")); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 8, 2); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); label2 = gtk_label_new (_("Author: ")); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 8, 2); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); label3 = gtk_label_new (_("URL:")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 8, 2); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label_name = gtk_label_new (""); gtk_widget_show (label_name); gtk_table_attach (GTK_TABLE (table1), label_name, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label_name), 0, 0.5); label_author = gtk_label_new (""); gtk_widget_show (label_author); gtk_table_attach (GTK_TABLE (table1), label_author, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label_author), 0, 0.5); label_url = gtk_label_new (""); gtk_widget_show (label_url); gtk_table_attach (GTK_TABLE (table1), label_url, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label_url), 0, 0.5); label4 = gtk_label_new (_("Status:")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 8, 2); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); label_status = gtk_label_new (""); gtk_widget_show (label_status); gtk_table_attach (GTK_TABLE (table1), label_status, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label_status), 0, 0.5); PACK_FRAME(vbox1, frame_preview, _("Preview")); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (frame_preview), hbox1); icon_1 = gtk_image_new(); gtk_widget_show (icon_1); gtk_box_pack_start (GTK_BOX (hbox1), icon_1, TRUE, TRUE, 2); gtk_misc_set_padding (GTK_MISC (icon_1), 0, 5); icon_2 = gtk_image_new(); gtk_widget_show (icon_2); gtk_box_pack_start (GTK_BOX (hbox1), icon_2, TRUE, TRUE, 2); gtk_misc_set_padding (GTK_MISC (icon_2), 0, 5); icon_3 = gtk_image_new(); gtk_widget_show (icon_3); gtk_box_pack_start (GTK_BOX (hbox1), icon_3, TRUE, TRUE, 2); gtk_misc_set_padding (GTK_MISC (icon_3), 0, 5); icon_4 = gtk_image_new(); gtk_widget_show (icon_4); gtk_box_pack_start (GTK_BOX (hbox1), icon_4, TRUE, TRUE, 2); gtk_misc_set_padding (GTK_MISC (icon_4), 0, 5); icon_5 = gtk_image_new(); gtk_widget_show (icon_5); gtk_box_pack_start (GTK_BOX (hbox1), icon_5, TRUE, TRUE, 2); gtk_misc_set_padding (GTK_MISC (icon_5), 0, 5); icon_6 = gtk_image_new(); gtk_widget_show (icon_6); gtk_box_pack_start (GTK_BOX (hbox1), icon_6, TRUE, TRUE, 0); gtk_misc_set_padding (GTK_MISC (icon_6), 0, 5); icon_7 = gtk_image_new(); gtk_widget_show (icon_7); gtk_box_pack_start (GTK_BOX (hbox1), icon_7, TRUE, TRUE, 0); gtk_misc_set_padding (GTK_MISC (icon_7), 0, 5); PACK_FRAME(vbox1, frame_buttons, _("Actions")); hbuttonbox1 = gtk_hbutton_box_new (); gtk_widget_show (hbuttonbox1); gtk_container_add (GTK_CONTAINER (frame_buttons), hbuttonbox1); gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox1), 5); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_START); gtk_box_set_spacing (GTK_BOX (hbuttonbox1), 5); btn_use = gtk_button_new_with_label (_("Use this")); gtk_widget_show (btn_use); gtk_container_add (GTK_CONTAINER (hbuttonbox1), btn_use); gtkut_widget_set_can_default (btn_use, TRUE); btn_remove = gtk_button_new_with_label (_("Remove")); gtk_widget_show (btn_remove); gtk_container_add (GTK_CONTAINER (hbuttonbox1), btn_remove); gtkut_widget_set_can_default (btn_remove, TRUE); g_signal_connect(G_OBJECT(btn_use), "clicked", G_CALLBACK(prefs_themes_btn_use_clicked_cb), NULL); g_signal_connect(G_OBJECT(btn_remove), "clicked", G_CALLBACK(prefs_themes_btn_remove_clicked_cb), NULL); g_signal_connect(G_OBJECT(btn_install), "clicked", G_CALLBACK(prefs_themes_btn_install_clicked_cb), NULL); prefs_themes->window = GTK_WIDGET(window); prefs_themes->name = label_name; prefs_themes->author = label_author; prefs_themes->url = label_url; prefs_themes->status = label_status; prefs_themes->global = label_global_status; prefs_themes->icons[0] = icon_1; prefs_themes->icons[1] = icon_2; prefs_themes->icons[2] = icon_3; prefs_themes->icons[3] = icon_4; prefs_themes->icons[4] = icon_5; prefs_themes->icons[5] = icon_6; prefs_themes->icons[6] = icon_7; prefs_themes->btn_use = btn_use; prefs_themes->btn_remove = btn_remove; prefs_themes->btn_install = btn_install; prefs_themes->btn_more = btn_more; prefs_themes->op_menu = menu_themes; prefs_themes->page.widget = vbox1; prefs_themes_set_themes_menu(GTK_COMBO_BOX(menu_themes), tdata); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(menu_themes), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(menu_themes), renderer, "text", 0, NULL); prefs_themes_get_theme_info(tdata); prefs_themes_display_global_stats(tdata); }
wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message, const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard, long style, const wxPoint& pos, const wxSize& sz, const wxString& name) : wxFileDialogBase() { parent = GetParentForModalDialog(parent, style); if (!wxFileDialogBase::Create(parent, message, defaultDir, defaultFileName, wildCard, style, pos, sz, name)) { return; } if (!PreCreation(parent, pos, wxDefaultSize) || !CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style, wxDefaultValidator, wxT("filedialog"))) { wxFAIL_MSG( wxT("wxFileDialog creation failed") ); return; } GtkFileChooserAction gtk_action; GtkWindow* gtk_parent = NULL; if (parent) gtk_parent = GTK_WINDOW( gtk_widget_get_toplevel(parent->m_widget) ); const gchar* ok_btn_stock; if ( style & wxFD_SAVE ) { gtk_action = GTK_FILE_CHOOSER_ACTION_SAVE; ok_btn_stock = GTK_STOCK_SAVE; } else { gtk_action = GTK_FILE_CHOOSER_ACTION_OPEN; ok_btn_stock = GTK_STOCK_OPEN; } m_widget = gtk_file_chooser_dialog_new( wxGTK_CONV(m_message), gtk_parent, gtk_action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, ok_btn_stock, GTK_RESPONSE_ACCEPT, NULL); g_object_ref(m_widget); GtkFileChooser* file_chooser = GTK_FILE_CHOOSER(m_widget); m_fc.SetWidget(file_chooser); gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT); if ( style & wxFD_MULTIPLE ) gtk_file_chooser_set_select_multiple(file_chooser, true); // gtk_widget_hide_on_delete is used here to avoid that Gtk automatically // destroys the dialog when the user press ESC on the dialog: in that case // a second call to ShowModal() would result in a bunch of Gtk-CRITICAL // errors... g_signal_connect(m_widget, "delete_event", G_CALLBACK (gtk_widget_hide_on_delete), this); // local-only property could be set to false to allow non-local files to be // loaded. In that case get/set_uri(s) should be used instead of // get/set_filename(s) everywhere and the GtkFileChooserDialog should // probably also be created with a backend, e.g. "gnome-vfs", "default", ... // (gtk_file_chooser_dialog_new_with_backend). Currently local-only is kept // as the default - true: // gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true); g_signal_connect (m_widget, "response", G_CALLBACK (gtk_filedialog_response_callback), this); // deal with extensions/filters SetWildcard(wildCard); wxString defaultFileNameWithExt = defaultFileName; if ( !wildCard.empty() && !defaultFileName.empty() && !wxFileName(defaultFileName).HasExt() ) { // append the default extension to the initial file name: GTK won't do // it for us by default (unlike e.g. MSW) const wxString defaultExt = m_fc.GetCurrentWildCard().AfterFirst('.'); if ( defaultExt.find_first_of("?*") == wxString::npos ) defaultFileNameWithExt += "." + defaultExt; } // if defaultDir is specified it should contain the directory and // defaultFileName should contain the default name of the file, however if // directory is not given, defaultFileName contains both wxFileName fn; if ( defaultDir.empty() ) fn.Assign(defaultFileNameWithExt); else if ( !defaultFileNameWithExt.empty() ) fn.Assign(defaultDir, defaultFileNameWithExt); else fn.AssignDir(defaultDir); // set the initial file name and/or directory fn.MakeAbsolute(); // GTK+ needs absolute path const wxString dir = fn.GetPath(); if ( !dir.empty() ) { gtk_file_chooser_set_current_folder(file_chooser, dir.fn_str()); } const wxString fname = fn.GetFullName(); if ( style & wxFD_SAVE ) { if ( !fname.empty() ) { gtk_file_chooser_set_current_name(file_chooser, fname.fn_str()); } #if GTK_CHECK_VERSION(2,7,3) if ((style & wxFD_OVERWRITE_PROMPT) && !gtk_check_version(2,7,3)) gtk_file_chooser_set_do_overwrite_confirmation(file_chooser, true); #endif } else // wxFD_OPEN { if ( !fname.empty() ) { gtk_file_chooser_set_filename(file_chooser, fn.GetFullPath().fn_str()); } } if ( style & wxFD_PREVIEW ) { GtkWidget *previewImage = gtk_image_new(); gtk_file_chooser_set_preview_widget(file_chooser, previewImage); g_signal_connect(m_widget, "update-preview", G_CALLBACK(gtk_filedialog_update_preview_callback), previewImage); } }
static void gdaui_dsn_editor_init (GdauiDsnEditor *config, G_GNUC_UNUSED GdauiDsnEditorClass *klass) { GtkWidget *grid; GtkWidget *label; GtkWidget *exp; gchar *str; g_return_if_fail (GDAUI_IS_DSN_EDITOR (config)); gtk_orientable_set_orientation (GTK_ORIENTABLE (config), GTK_ORIENTATION_VERTICAL); /* allocate private structure */ config->priv = g_new0 (GdauiDsnEditorPrivate, 1); config->priv->dsn_info = g_new0 (GdaDsnInfo, 1); config->priv->no_change_signal = TRUE; /* data source's name and icon */ GtkWidget *hbox_header; hbox_header = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (config), hbox_header, FALSE, FALSE, 6); config->priv->icon = gtk_image_new (); gtk_widget_set_size_request (config->priv->icon, -1, SUPPORT_ICON_SIZE); gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->icon, FALSE, FALSE, 0); config->priv->wname = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->wname, FALSE, FALSE, 10); GtkWidget *menu_button; menu_button = gtk_menu_button_new (); gtk_box_pack_end (GTK_BOX (hbox_header), menu_button, FALSE, FALSE, 0); GtkWidget *menu_icon; menu_icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (menu_button), menu_icon); GMenu *smenu; smenu = g_menu_new (); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), G_MENU_MODEL (smenu)); GMenuItem *mitem; mitem = g_menu_item_new ("Test data source", "win.DSNTest"); g_menu_insert_item (smenu, -1, mitem); mitem = g_menu_item_new ("Reset data source's changes", "win.DSNReset"); g_menu_insert_item (smenu, -1, mitem); mitem = g_menu_item_new ("Duplicate data source", "win.DSNCopy"); g_menu_insert_item (smenu, -1, mitem); GtkWindow *win; win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ())); g_action_map_add_action_entries (G_ACTION_MAP (win), win_entries, G_N_ELEMENTS (win_entries), config); /* stack in a scrolled window */ GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_vexpand (sw, TRUE); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE); gtk_box_pack_start (GTK_BOX (config), sw, TRUE, TRUE, 6); /* Stack */ config->priv->stack = gtk_stack_new (); gtk_stack_set_transition_type (GTK_STACK (config->priv->stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT); gtk_container_add (GTK_CONTAINER (sw), config->priv->stack); /* set up widgets */ grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_widget_show (grid); label = gtk_label_new_with_mnemonic (_("_System wide data source:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); config->priv->is_system = gtk_check_button_new (); gtk_widget_show (config->priv->is_system); g_signal_connect (G_OBJECT (config->priv->is_system), "toggled", G_CALLBACK (field_toggled_cb), config); gtk_grid_attach (GTK_GRID (grid), config->priv->is_system, 1, 1, 1, 1); str = g_strdup_printf ("%s <span foreground='red' weight='bold'>*</span>", _("_Provider:")); label = gtk_label_new (""); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), str); g_free (str); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); config->priv->wprovider = gdaui_provider_selector_new (); gtk_widget_set_hexpand (config->priv->wprovider, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wprovider); gtk_widget_show (config->priv->wprovider); g_signal_connect (G_OBJECT (config->priv->wprovider), "changed", G_CALLBACK (field_changed_cb), config); gtk_grid_attach (GTK_GRID (grid), config->priv->wprovider, 1, 2, 1, 1); label = gtk_label_new_with_mnemonic (_("_Description:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); config->priv->wdesc = gtk_text_view_new (); gtk_container_add (GTK_CONTAINER (sw), config->priv->wdesc); gtk_text_view_set_editable (GTK_TEXT_VIEW (config->priv->wdesc), TRUE); gtk_widget_set_vexpand (config->priv->wdesc, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wdesc); g_signal_connect (gtk_text_view_get_buffer (GTK_TEXT_VIEW (config->priv->wdesc)), "changed", G_CALLBACK (field_changed_cb), config); gtk_grid_attach (GTK_GRID (grid), sw, 1, 3, 1, 1); config->priv->warning = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (config->priv->warning), _("<span foreground='red'>The database provider used by this data source is not available,\n" "editing the data source's attributes is disabled</span>")); gtk_widget_set_halign (config->priv->warning, GTK_ALIGN_CENTER); gtk_widget_set_hexpand (config->priv->warning, TRUE); g_object_set (G_OBJECT (config->priv->warning), "xalign", 0.5, NULL); gtk_label_set_justify (GTK_LABEL (config->priv->warning), GTK_JUSTIFY_CENTER); gtk_label_set_line_wrap (GTK_LABEL (config->priv->warning), TRUE); gtk_grid_attach (GTK_GRID (grid), config->priv->warning, 0, 8, 2, 1); gtk_stack_add_named (GTK_STACK (config->priv->stack), grid, PANE_DEFINITION); /* connection's spec */ config->priv->dsn_spec = _gdaui_provider_spec_editor_new (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider))); g_signal_connect (G_OBJECT (config->priv->dsn_spec), "changed", G_CALLBACK (field_changed_cb), config); gtk_widget_show (config->priv->dsn_spec); gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_spec, PANE_PARAMS); /* connection's authentication */ config->priv->dsn_auth = _gdaui_provider_auth_editor_new (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider))); g_signal_connect (G_OBJECT (config->priv->dsn_auth), "changed", G_CALLBACK (field_changed_cb), config); gtk_widget_show (config->priv->dsn_auth); gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_auth, PANE_AUTH); config->priv->no_change_signal = FALSE; }
GtkWindow* create_notification(UrlClickedCb url_clicked) { GtkWidget* win; GtkWidget* main_vbox; GtkWidget* vbox; GtkWidget* close_button; GtkWidget* image; GtkWidget* alignment; AtkObject* atkobj; GtkRcStyle* rcstyle; WindowData* windata; #ifdef USE_COMPOSITE GdkColormap* colormap; GdkScreen* screen; #endif windata = g_new0(WindowData, 1); windata->urgency = URGENCY_NORMAL; windata->url_clicked = url_clicked; win = gtk_window_new(GTK_WINDOW_POPUP); gtk_window_set_resizable(GTK_WINDOW(win), FALSE); gtk_widget_set_app_paintable(win, TRUE); g_signal_connect(G_OBJECT(win), "style-set", G_CALLBACK(on_style_set), windata); g_signal_connect(G_OBJECT(win), "map-event", G_CALLBACK(on_window_map), windata); g_signal_connect(G_OBJECT(win), "expose-event", G_CALLBACK(on_window_expose), windata); g_signal_connect(G_OBJECT(win), "realize", G_CALLBACK(on_window_realize), windata); windata->win = win; windata->composited = FALSE; #ifdef USE_COMPOSITE screen = gtk_window_get_screen(GTK_WINDOW(win)); colormap = gdk_screen_get_rgba_colormap(screen); if (colormap != NULL) { gtk_widget_set_colormap(win, colormap); if (gdk_screen_is_composited(screen)) { windata->composited = TRUE; } } g_signal_connect(win, "composited-changed", G_CALLBACK(on_composited_changed), windata); #endif gtk_window_set_title(GTK_WINDOW(win), "Notification"); gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_NOTIFICATION); gtk_widget_add_events(win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); g_object_set_data_full(G_OBJECT(win), "windata", windata, (GDestroyNotify) destroy_windata); atk_object_set_role(gtk_widget_get_accessible(win), ATK_ROLE_ALERT); g_signal_connect(G_OBJECT(win), "configure-event", G_CALLBACK(on_configure_event), windata); main_vbox = gtk_vbox_new(FALSE, 0); g_signal_connect(G_OBJECT(main_vbox), "style-set", G_CALLBACK(on_style_set), windata); gtk_widget_show(main_vbox); gtk_container_add(GTK_CONTAINER(win), main_vbox); gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 12); windata->main_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(windata->main_hbox); gtk_box_pack_start(GTK_BOX(main_vbox), windata->main_hbox, FALSE, FALSE, 0); /* First row (icon, vbox, close) */ windata->iconbox = gtk_alignment_new(0.5, 0, 0, 0); gtk_widget_show(windata->iconbox); gtk_alignment_set_padding(GTK_ALIGNMENT(windata->iconbox), 5, 0, 0, 0); gtk_box_pack_start(GTK_BOX(windata->main_hbox), windata->iconbox, FALSE, FALSE, 0); gtk_widget_set_size_request(windata->iconbox, BODY_X_OFFSET, -1); windata->icon = gtk_image_new(); gtk_widget_show(windata->icon); gtk_container_add(GTK_CONTAINER(windata->iconbox), windata->icon); vbox = gtk_vbox_new(FALSE, 6); gtk_widget_show(vbox); gtk_box_pack_start(GTK_BOX(windata->main_hbox), vbox, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), 10); /* Add the close button */ alignment = gtk_alignment_new(0.5, 0, 0, 0); gtk_widget_show(alignment); gtk_box_pack_start(GTK_BOX(windata->main_hbox), alignment, FALSE, FALSE, 0); close_button = gtk_button_new(); g_signal_connect(G_OBJECT(close_button), "style-set", G_CALLBACK(on_style_set), windata); gtk_widget_show(close_button); windata->close_button = close_button; gtk_container_add(GTK_CONTAINER(alignment), close_button); gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE); gtk_container_set_border_width(GTK_CONTAINER(close_button), 0); g_signal_connect_swapped(G_OBJECT(close_button), "clicked", G_CALLBACK(gtk_widget_destroy), win); rcstyle = gtk_rc_style_new(); rcstyle->xthickness = rcstyle->ythickness = 0; gtk_widget_modify_style(close_button, rcstyle); g_object_unref(rcstyle); atkobj = gtk_widget_get_accessible(close_button); atk_action_set_description(ATK_ACTION(atkobj), 0, "Closes the notification."); atk_object_set_name(atkobj, ""); atk_object_set_description(atkobj, "Closes the notification."); image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_widget_show(image); gtk_container_add(GTK_CONTAINER(close_button), image); /* center vbox */ windata->summary_label = gtk_label_new(NULL); g_signal_connect(G_OBJECT(windata->summary_label), "style-set", G_CALLBACK(on_style_set), windata); gtk_widget_show(windata->summary_label); gtk_box_pack_start(GTK_BOX(vbox), windata->summary_label, TRUE, TRUE, 0); gtk_misc_set_alignment(GTK_MISC(windata->summary_label), 0, 0); gtk_label_set_line_wrap(GTK_LABEL(windata->summary_label), TRUE); atkobj = gtk_widget_get_accessible(windata->summary_label); atk_object_set_description(atkobj, "Notification summary text."); windata->content_hbox = gtk_hbox_new(FALSE, 6); gtk_widget_show(windata->content_hbox); gtk_box_pack_start(GTK_BOX(vbox), windata->content_hbox, FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 6); gtk_widget_show(vbox); gtk_box_pack_start(GTK_BOX(windata->content_hbox), vbox, TRUE, TRUE, 0); windata->body_label = gtk_label_new(NULL); g_signal_connect(G_OBJECT(windata->body_label), "style-set", G_CALLBACK(on_style_set), windata); gtk_widget_show(windata->body_label); gtk_box_pack_start(GTK_BOX(vbox), windata->body_label, TRUE, TRUE, 0); gtk_misc_set_alignment(GTK_MISC(windata->body_label), 0, 0); gtk_label_set_line_wrap(GTK_LABEL(windata->body_label), TRUE); g_signal_connect_swapped(G_OBJECT(windata->body_label), "activate-link", G_CALLBACK(windata->url_clicked), win); atkobj = gtk_widget_get_accessible(windata->body_label); atk_object_set_description(atkobj, "Notification body text."); alignment = gtk_alignment_new(1, 0.5, 0, 0); gtk_widget_show(alignment); gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0); windata->actions_box = gtk_hbox_new(FALSE, 6); gtk_widget_show(windata->actions_box); gtk_container_add(GTK_CONTAINER(alignment), windata->actions_box); return GTK_WINDOW(win); }
void gui_show_dialog(gpointer signal, gboolean change) { GGaduSignal *sig = (GGaduSignal *) signal; GtkWidget *dialog_widget = NULL; GtkWidget *image = NULL; GtkWidget *table = NULL; GtkWidget *label = NULL; GtkWidget *hbox = NULL; GdkPixbuf *windowicon = NULL; GGaduDialog *dialog = (sig) ? sig->data : NULL; gchar *markup = NULL; if (!sig) return; if ((ggadu_dialog_get_flags(dialog) & GGADU_DIALOG_FLAG_ONLY_OK) == GGADU_DIALOG_FLAG_ONLY_OK) dialog_widget = gtk_dialog_new_with_buttons(dialog->title, NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); else dialog_widget = gtk_dialog_new_with_buttons(dialog->title, NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response(GTK_DIALOG(dialog_widget), GTK_RESPONSE_OK); gtk_window_set_resizable(GTK_WINDOW(dialog_widget), FALSE); if ((windowicon = create_pixbuf(GGADU_DEFAULT_ICON_FILENAME)) != NULL) { gtk_window_set_icon(GTK_WINDOW(dialog_widget), windowicon); gdk_pixbuf_unref(windowicon); } hbox = gtk_hbox_new(FALSE, 0); if (ggadu_dialog_get_type(dialog)) { gint type = ggadu_dialog_get_type(dialog); print_debug("d->type = %d\n", type); switch (type) { case GGADU_DIALOG_CONFIG: image = gtk_image_new(); gtk_image_set_from_stock(GTK_IMAGE(image), "gtk-preferences", GTK_ICON_SIZE_DND); break; case GGADU_DIALOG_YES_NO: image = gtk_image_new(); gtk_image_set_from_stock(GTK_IMAGE(image), "gtk-dialog-question", GTK_ICON_SIZE_DND); break; default: break; } gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 5); } label = gtk_label_new(NULL); markup = g_strdup_printf("<span weight=\"bold\">%s</span>", ggadu_dialog_get_title(dialog)); gtk_label_set_markup(GTK_LABEL(label), markup); g_free(markup); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_widget)->vbox), hbox, TRUE, TRUE, 10); if (dialog->flags & GGADU_DIALOG_FLAG_PROGRESS) table = gui_build_dialog_gtk_table(ggadu_dialog_get_entries(dialog), 1, TRUE); else table = gui_build_dialog_gtk_table(ggadu_dialog_get_entries(dialog), 1, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 7); gtk_table_set_col_spacings(GTK_TABLE(table), 5); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_widget)->vbox), table, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(dialog_widget), "response", G_CALLBACK(gui_dialog_response), signal_cpy(signal)); /* if (ggadu_dialog_get_type(dialog) == GGADU_DIALOG_PROGRESS) { g_timeout_add(1000,dialog->watch_func,NULL); } */ gtk_widget_show_all(dialog_widget); }
static GtkWidget *create_dialog(void) { GtkWidget *dialog; GtkWidget *header_image; GtkWidget *header_label; GtkWidget *label_info; GtkWidget *codename_label; GtkWidget *builddate_label; GtkWidget *url_button; GtkWidget *cop_label; GtkWidget *label; GtkWidget *license_textview; GtkWidget *notebook; GtkWidget *box; GtkWidget *credits_scrollwin; GtkWidget *table; GtkWidget *license_scrollwin; GtkWidget *info_box; GtkWidget *header_hbox; GtkWidget *header_eventbox; GdkPixbuf *icon; GtkTextBuffer* tb; gchar *license_text = NULL; gchar buffer[512]; gchar buffer2[128]; guint i, row = 0; dialog = gtk_dialog_new(); /* configure dialog */ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window)); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany")); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL); /* create header */ header_eventbox = gtk_event_box_new(); gtk_widget_show(header_eventbox); header_hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4); gtk_widget_show(header_hbox); gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox); header_image = gtk_image_new(); gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0); header_label = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE); /* print the subversion revision generated by ./configure if it is available */ g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string()); gtk_label_set_markup(GTK_LABEL(header_label), buffer); gtk_widget_show(header_label); gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0); header_eventbox_style_set(header_eventbox); header_label_style_set(header_label); g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL); g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0); /* set image */ icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO); gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon); gtk_window_set_icon(GTK_WINDOW(dialog), icon); g_object_unref(icon); /* free our reference */ /* create notebook */ notebook = gtk_notebook_new(); gtk_widget_show(notebook); gtk_container_set_border_width(GTK_CONTAINER(notebook), 2); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0); /* create "Info" tab */ info_box = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(info_box), 6); gtk_widget_show(info_box); label_info = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(label_info), TRUE); gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE); g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE")); gtk_label_set_markup(GTK_LABEL(label_info), buffer); gtk_misc_set_padding(GTK_MISC(label_info), 2, 11); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0); /* Codename label */ codename_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE); gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME); gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8); gtk_widget_show(codename_label); gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0); /* build date label */ builddate_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE); g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__); g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2); gtk_label_set_markup(GTK_LABEL(builddate_label), buffer); gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2); gtk_widget_show(builddate_label); gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0); box = gtk_hbutton_box_new(); url_button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE); g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE); label = gtk_label_new(NULL); gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE); gtk_widget_show(label); gtk_container_add(GTK_CONTAINER(url_button), label); gtk_widget_show(url_button); gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0); gtk_widget_show(box); gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10); /* copyright label */ cop_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE); gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE); gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT); gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10); gtk_widget_show(cop_label); gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0); /*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */ label = gtk_label_new(_("Info")); gtk_widget_show(label); gtk_widget_show_all(info_box); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label); /* create "Credits" tab */ credits_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 10); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 10); row = 0; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < translators_len; i++) { ROW(translators[i][0], row, 0, 1, 4, 0); ROW(translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < prev_translators_len; i++) { ROW(prev_translators[i][0], row, 0, 1, 4, 0); ROW(prev_translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; g_snprintf(buffer, sizeof(buffer), _("Some of the many contributors (for a more detailed list, see the file %s):"), #ifdef G_OS_WIN32 "Thanks.txt" #else "THANKS" #endif ); label = geany_wrap_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; label = geany_wrap_label_new(contributors); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE); gtk_widget_show_all(table); label = gtk_label_new(_("Credits")); gtk_widget_show(label); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label); /* create "License" tab */ license_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); license_textview = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE); gtk_widget_show(license_textview); gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview); label = gtk_label_new(_("License")); gtk_widget_show(label); g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir); g_file_get_contents(buffer, &license_text, NULL, NULL); if (license_text == NULL) { license_text = g_strdup( _("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online.")); } tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview)); gtk_text_buffer_set_text(tb, license_text, -1); g_free(license_text); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label); gtk_widget_show_all(dialog); return dialog; }
GtkWidget * pgd_page_create_widget (PopplerDocument *document) { PgdPageDemo *demo; GtkWidget *vbox; GtkWidget *hbox, *page_selector; GtkWidget *button; GtkWidget *frame, *alignment; GtkWidget *table; GtkWidget *label; GtkWidget *thumnail_box; gchar *str; gint n_pages; gint row = 0; demo = g_new0 (PgdPageDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_page_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); button = gtk_button_new_with_label ("Get Info"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_page_get_info), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Page Properties</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_widget_show (alignment); table = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (table), 6); gtk_grid_set_row_spacing (GTK_GRID (table), 6); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Index:</b>", &(demo->index), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Label:</b>", &(demo->label), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Size:</b>", &(demo->size), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Duration:</b>", &(demo->duration), NULL, &row); gtk_container_add (GTK_CONTAINER (alignment), table); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Page Thumbnail</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_widget_show (alignment); thumnail_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); demo->thumbnail = gtk_image_new (); gtk_box_pack_start (GTK_BOX (thumnail_box), demo->thumbnail, TRUE, TRUE, 0); gtk_widget_show (demo->thumbnail); demo->thumbnail_size = gtk_label_new (NULL); g_object_set (G_OBJECT (demo->thumbnail_size), "xalign", 0.5, NULL); gtk_box_pack_start (GTK_BOX (thumnail_box), demo->thumbnail_size, TRUE, TRUE, 0); gtk_widget_show (demo->thumbnail_size); gtk_container_add (GTK_CONTAINER (alignment), thumnail_box); gtk_widget_show (thumnail_box); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_page_free, (gpointer)demo); return vbox; }
static void moko_talking_init (MokoTalking *talking) { MokoTalkingPrivate *priv; GtkWidget *notebook; GtkWidget *toolbar, *image, *vbox, *hbox, *label, *align, *frame, *main_vbox; GtkWidget *duration; GtkToolItem *item; gint i; priv = talking->priv = MOKO_TALKING_GET_PRIVATE (talking); /* initialize dtimer to NULL */ priv->dtimer = NULL; notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_BOTTOM); priv->notebook = notebook; /* status page */ main_vbox = gtk_vbox_new (FALSE, 0); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox, gtk_image_new_from_file (PKGDATADIR"/phone.png")); gtk_container_child_set (GTK_CONTAINER (notebook), main_vbox, "tab-expand", TRUE, NULL); priv->incoming_bar = toolbar = gtk_toolbar_new (); gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0); image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_ANSWER, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Answer"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_answer_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_IGNORE, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Ignore"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_silence_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_REJECT, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Reject"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_reject_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* Volume controls */ priv->headphone = moko_alsa_volume_control_new (); moko_alsa_volume_control_set_device_from_name (priv->headphone, "neo1973"); moko_alsa_volume_control_set_element_from_name (priv->headphone, "Headphone"); priv->volume = moko_alsa_volume_scale_new (GTK_ORIENTATION_HORIZONTAL); moko_alsa_volume_scale_set_control (MOKO_ALSA_VOLUME_SCALE (priv->volume), priv->headphone); /* Outgoing call and talking share the same toolbar */ priv->main_bar = toolbar = gtk_toolbar_new (); gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0); image = gtk_image_new_from_icon_name (MOKO_STOCK_SPEAKER, GTK_ICON_SIZE_BUTTON); item = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (item), image); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "toggled", G_CALLBACK (on_speaker_toggled), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); priv->speaker_toggle_btn = item; image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_HANGUP, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Hangup"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_cancel_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* The title label and image */ vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); priv->title = label = gtk_label_new ("Incoming Call"); gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 8); priv->icon = image = gtk_image_new (); gtk_container_add (GTK_CONTAINER (align), image); priv->duration = duration = gtk_label_new ("00:00:00"); gtk_misc_set_alignment (GTK_MISC (duration), 0.5, 0.5); gtk_box_pack_start (GTK_BOX (vbox), duration, FALSE, FALSE, 0); /* The status area */ align = gtk_alignment_new (0.5, 0.5, 1, 0 ); gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0); frame = gtk_frame_new (NULL); gtk_container_set_border_width (GTK_CONTAINER (frame), 10); gtk_container_add (GTK_CONTAINER (align), frame); hbox = gtk_hbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (frame), hbox); priv->person = image = gtk_image_new (); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); priv->status = label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); /* The volume control */ gtk_box_pack_start (GTK_BOX (vbox), priv->volume, FALSE, TRUE, 12); /* Load the pixbufs */ for (i = 0; i < N_PICS; i++) { if (i == 0) priv->talking[i] = gdk_pixbuf_new_from_file (PKGDATADIR"/talking.png", NULL); else { gchar *name = g_strdup_printf ("%s/talking_%d.png", PKGDATADIR, i-1); priv->talking[i] = gdk_pixbuf_new_from_file (name, NULL); g_free (name); } if (G_IS_OBJECT (priv->talking[i])) g_object_ref (priv->talking[i]); } for (i = 0; i < N_PICS-1; i++) { gchar *name = g_strdup_printf ("%s/outgoing_%d.png", PKGDATADIR, i); priv->outgoing[i] = gdk_pixbuf_new_from_file (name, NULL); g_free (name); if (G_IS_OBJECT (priv->outgoing[i])) g_object_ref (priv->outgoing[i]); } for (i = 0; i < N_PICS-1; i++) { gchar *name = g_strdup_printf ("%s/incoming_%d.png", PKGDATADIR, i); priv->incoming[i] = gdk_pixbuf_new_from_file (name, NULL); g_free (name); if (G_IS_OBJECT (priv->incoming[i])) g_object_ref (priv->incoming[i]); } /* dtmf page */ GtkWidget *pad, *display; main_vbox = gtk_vbox_new (FALSE, 0); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox, gtk_image_new_from_file (PKGDATADIR"/dtmf.png")); gtk_container_child_set (GTK_CONTAINER (notebook), main_vbox, "tab-expand", TRUE, NULL); display = moko_dialer_textview_new (); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), display); priv->dtmf_display = display; pad = moko_dialer_panel_new (); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), pad); g_signal_connect (pad, "user_input", G_CALLBACK (on_pad_user_input), talking); priv->dtmf_pad = pad; priv->window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (priv->window, "delete-event", G_CALLBACK (window_delete_event_cb), talking); gtk_container_add (GTK_CONTAINER (priv->window), notebook); gtk_widget_show_all (notebook); }
static void create_sub_menu (ShellStatusMenu *status) { ShellStatusMenuPrivate *priv = status->priv; GtkWidget *item; priv->menu = gtk_menu_new (); g_signal_connect (priv->menu, "style-set", G_CALLBACK (menu_style_set_cb), status); g_signal_connect (priv->manager, "users-loaded", G_CALLBACK (on_manager_users_loaded), status); g_signal_connect (priv->manager, "user-added", G_CALLBACK (on_manager_user_added), status); g_signal_connect (priv->manager, "user-removed", G_CALLBACK (on_manager_user_removed), status); priv->account_item = gtk_image_menu_item_new_with_label (_("Account Information...")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (priv->account_item), gtk_image_new ()); gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->account_item); g_signal_connect (priv->account_item, "style-set", G_CALLBACK (menuitem_style_set_cb), status); g_signal_connect (priv->account_item, "activate", G_CALLBACK (on_account_activate), status); gtk_widget_show (priv->account_item); priv->sidebar_item = gtk_check_menu_item_new_with_label (_("Sidebar")); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->sidebar_item), gconf_client_get_bool (priv->client, SIDEBAR_VISIBLE_KEY, NULL)); gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->sidebar_item); g_signal_connect (priv->sidebar_item, "toggled", G_CALLBACK (on_sidebar_toggled), status); gtk_widget_show (priv->sidebar_item); priv->control_panel_item = gtk_image_menu_item_new_with_label (_("System Preferences...")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (priv->control_panel_item), gtk_image_new ()); gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->control_panel_item); g_signal_connect (priv->control_panel_item, "style-set", G_CALLBACK (menuitem_style_set_cb), status); g_signal_connect (priv->control_panel_item, "activate", G_CALLBACK (on_control_panel_activate), status); gtk_widget_show (priv->control_panel_item); item = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), item); gtk_widget_show (item); priv->lock_screen_item = gtk_image_menu_item_new_with_label (_("Lock Screen")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (priv->lock_screen_item), gtk_image_new ()); gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->lock_screen_item); g_signal_connect (priv->lock_screen_item, "style-set", G_CALLBACK (menuitem_style_set_cb), status); g_signal_connect (priv->lock_screen_item, "activate", G_CALLBACK (on_lock_screen_activate), status); gtk_widget_show (priv->lock_screen_item); priv->login_screen_item = gtk_image_menu_item_new_with_label (_("Switch User")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (priv->login_screen_item), gtk_image_new ()); gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->login_screen_item); g_signal_connect (priv->login_screen_item, "style-set", G_CALLBACK (menuitem_style_set_cb), status); g_signal_connect (priv->login_screen_item, "activate", G_CALLBACK (on_login_screen_activate), status); /* Only show switch user if there are other users */ priv->quit_session_item = gtk_image_menu_item_new_with_label (_("Quit...")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (priv->quit_session_item), gtk_image_new ()); gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), priv->quit_session_item); g_signal_connect (priv->quit_session_item, "style-set", G_CALLBACK (menuitem_style_set_cb), status); g_signal_connect (priv->quit_session_item, "activate", G_CALLBACK (on_quit_session_activate), status); gtk_widget_show (priv->quit_session_item); g_signal_connect (G_OBJECT (priv->menu), "deactivate", G_CALLBACK (on_deactivate), status); }
void gui_create_about(GtkWidget *notebook) { GtkWidget *vbox1; GtkWidget *label; GtkWidget *hseparator; GtkWidget *logo_area; GdkPixbuf *logo; GtkWidget *viewport; GtkWidget *hbuttonbox; GSList *radiobutton_group = NULL; label = gtk_label_new(NULL); gtk_label_set_angle (GTK_LABEL(label), -90.0); gtk_label_set_markup (GTK_LABEL (label), _("About")); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox1, label); logo_area = gtk_image_new(); logo = gdk_pixbuf_new_from_inline(-1, osmo_logo, FALSE, NULL); gtk_widget_show(logo_area); gtk_box_pack_start (GTK_BOX (vbox1), logo_area, FALSE, TRUE, 0); #ifndef REV sprintf(tmpbuf, "%s %s", _("version"), VERSION); #else sprintf(tmpbuf, "%s %d", _("SVN revision"), REV); #endif label = gtk_label_new(tmpbuf); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (vbox1), label, FALSE, TRUE, 4); gtk_image_set_from_pixbuf (GTK_IMAGE (logo_area), logo); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4); /*--------------------------------------------------------------------------*/ hbuttonbox = gtk_hbutton_box_new (); gtk_widget_show (hbuttonbox); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END); about_radiobutton = gui_image_label_radio_button(_("About"), osmo_stock_about); gtk_widget_show (about_radiobutton); gtk_button_set_relief (GTK_BUTTON (about_radiobutton), GTK_RELIEF_NONE); GTK_WIDGET_UNSET_FLAGS(about_radiobutton, GTK_CAN_FOCUS); gtk_radio_button_set_group (GTK_RADIO_BUTTON (about_radiobutton), radiobutton_group); radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (about_radiobutton)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (about_radiobutton), TRUE); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (about_radiobutton), FALSE); gtk_container_add (GTK_CONTAINER (hbuttonbox), about_radiobutton); g_signal_connect (G_OBJECT (about_radiobutton), "released", G_CALLBACK(button_released_cb), NULL); help_radiobutton = gui_image_label_radio_button(_("Key shortcuts"), osmo_stock_help); gtk_widget_show (help_radiobutton); gtk_button_set_relief (GTK_BUTTON (help_radiobutton), GTK_RELIEF_NONE); GTK_WIDGET_UNSET_FLAGS(help_radiobutton, GTK_CAN_FOCUS); gtk_radio_button_set_group (GTK_RADIO_BUTTON (help_radiobutton), radiobutton_group); radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (help_radiobutton)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (help_radiobutton), FALSE); gtk_container_add (GTK_CONTAINER (hbuttonbox), help_radiobutton); g_signal_connect (G_OBJECT (help_radiobutton), "released", G_CALLBACK(button_released_cb), NULL); license_radiobutton = gui_image_label_radio_button(_("License"), osmo_stock_license); gtk_widget_show (license_radiobutton); gtk_button_set_relief (GTK_BUTTON (license_radiobutton), GTK_RELIEF_NONE); GTK_WIDGET_UNSET_FLAGS(license_radiobutton, GTK_CAN_FOCUS); gtk_radio_button_set_group (GTK_RADIO_BUTTON (license_radiobutton), radiobutton_group); radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (license_radiobutton)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (license_radiobutton), FALSE); gtk_container_add (GTK_CONTAINER (hbuttonbox), license_radiobutton); g_signal_connect (G_OBJECT (license_radiobutton), "released", G_CALLBACK(button_released_cb), NULL); /*--------------------------------------------------------------------------*/ hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox1), scrolled_window, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (scrolled_window); viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (viewport); gtk_container_set_border_width (GTK_CONTAINER (viewport), 0); gtk_container_add (GTK_CONTAINER (scrolled_window), viewport); entry_buffer = gtk_text_buffer_new (NULL); gtk_text_buffer_get_iter_at_offset (entry_buffer, &entry_iter, 0); gtk_text_buffer_create_tag (entry_buffer, "bold", "weight", PANGO_WEIGHT_ULTRABOLD, NULL); gtk_text_buffer_create_tag (entry_buffer, "big", "size", 16 * PANGO_SCALE, NULL); gtk_text_buffer_create_tag (entry_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL); gtk_text_buffer_create_tag (entry_buffer, "center", "justification", GTK_JUSTIFY_CENTER, NULL); gtk_text_buffer_get_iter_at_offset (entry_buffer, &entry_iter, 0); about_textview = gtk_text_view_new_with_buffer (entry_buffer); gtk_container_set_border_width (GTK_CONTAINER (about_textview), 1); gtk_text_view_set_editable(GTK_TEXT_VIEW (about_textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (about_textview), FALSE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (about_textview), GTK_WRAP_WORD); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(about_textview), 2); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(about_textview), 6); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(about_textview), 6); gtk_widget_show (about_textview); gtk_container_add (GTK_CONTAINER (viewport), about_textview); gui_url_setup(&about_links_list, &about_link_index, about_textview); display_about(); }
static void prefs_custom_header_create(void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *ok_btn; GtkWidget *cancel_btn; GtkWidget *confirm_area; GtkWidget *vbox1; GtkWidget *table1; GtkWidget *hdr_label; GtkWidget *hdr_combo; GtkWidget *val_label; GtkWidget *val_entry; GtkWidget *val_btn; GtkWidget *reg_hbox; GtkWidget *btn_hbox; GtkWidget *arrow; GtkWidget *add_btn; GtkWidget *del_btn; GtkWidget *preview; GtkWidget *ch_hbox; GtkWidget *ch_scrolledwin; GtkWidget *list_view; GtkWidget *btn_vbox; GtkWidget *up_btn; GtkWidget *down_btn; debug_print("Creating custom header setting window...\n"); window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_customheader"); gtk_container_set_border_width (GTK_CONTAINER (window), 8); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW (window), TRUE); vbox = gtk_vbox_new (FALSE, 6); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (window), vbox); gtkut_stock_button_set_create(&confirm_area, &cancel_btn, GTK_STOCK_CANCEL, &ok_btn, GTK_STOCK_OK, NULL, NULL); gtk_widget_show (confirm_area); gtk_box_pack_end (GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default (ok_btn); gtk_window_set_title (GTK_WINDOW(window), _("Custom header configuration")); MANAGE_WINDOW_SIGNALS_CONNECT (window); g_signal_connect (G_OBJECT(window), "delete_event", G_CALLBACK(prefs_custom_header_deleted), NULL); g_signal_connect (G_OBJECT(window), "key_press_event", G_CALLBACK(prefs_custom_header_key_pressed), NULL); g_signal_connect (G_OBJECT(ok_btn), "clicked", G_CALLBACK(prefs_custom_header_ok), NULL); g_signal_connect (G_OBJECT(cancel_btn), "clicked", G_CALLBACK(prefs_custom_header_cancel), NULL); vbox1 = gtk_vbox_new (FALSE, VSPACING); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2); table1 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0); gtk_table_set_row_spacings (GTK_TABLE (table1), 8); gtk_table_set_col_spacings (GTK_TABLE (table1), 8); hdr_label = gtk_label_new (_("Header")); gtk_widget_show (hdr_label); gtk_table_attach (GTK_TABLE (table1), hdr_label, 0, 1, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (hdr_label), 0, 0.5); hdr_combo = combobox_text_new(TRUE, "User-Agent", "Face", "X-Face", "X-Operating-System", NULL); gtk_table_attach (GTK_TABLE (table1), hdr_combo, 0, 1, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0); gtk_widget_set_size_request (hdr_combo, 150, -1); val_label = gtk_label_new (_("Value")); gtk_widget_show (val_label); gtk_table_attach (GTK_TABLE (table1), val_label, 1, 2, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (val_label), 0, 0.5); val_entry = gtk_entry_new (); gtk_widget_show (val_entry); gtk_table_attach (GTK_TABLE (table1), val_entry, 1, 2, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0); gtk_widget_set_size_request (val_entry, 200, -1); val_btn = gtkut_get_browse_file_btn(_("Bro_wse")); gtk_widget_show (val_btn); gtk_table_attach (GTK_TABLE (table1), val_btn, 2, 3, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0); g_signal_connect (G_OBJECT (val_btn), "clicked", G_CALLBACK (prefs_custom_header_val_from_file_cb), NULL); /* add / delete */ reg_hbox = gtk_hbox_new (FALSE, 4); gtk_widget_show (reg_hbox); gtk_box_pack_start (GTK_BOX (vbox1), reg_hbox, FALSE, FALSE, 0); arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT); gtk_widget_show (arrow); gtk_box_pack_start (GTK_BOX (reg_hbox), arrow, FALSE, FALSE, 0); gtk_widget_set_size_request (arrow, -1, 16); btn_hbox = gtk_hbox_new (TRUE, 4); gtk_widget_show (btn_hbox); gtk_box_pack_start (GTK_BOX (reg_hbox), btn_hbox, FALSE, FALSE, 0); add_btn = gtk_button_new_from_stock (GTK_STOCK_ADD); gtk_widget_show (add_btn); gtk_box_pack_start (GTK_BOX (btn_hbox), add_btn, FALSE, TRUE, 0); g_signal_connect (G_OBJECT (add_btn), "clicked", G_CALLBACK (prefs_custom_header_add_cb), NULL); del_btn = gtk_button_new_from_stock (GTK_STOCK_DELETE); gtk_widget_show (del_btn); gtk_box_pack_start (GTK_BOX (btn_hbox), del_btn, FALSE, TRUE, 0); g_signal_connect (G_OBJECT (del_btn), "clicked", G_CALLBACK (prefs_custom_header_delete_cb), NULL); ch_hbox = gtk_hbox_new (FALSE, 8); gtk_widget_show (ch_hbox); gtk_box_pack_start (GTK_BOX (vbox1), ch_hbox, TRUE, TRUE, 0); ch_scrolledwin = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (ch_scrolledwin, -1, 200); gtk_widget_show (ch_scrolledwin); gtk_box_pack_start (GTK_BOX (ch_hbox), ch_scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (ch_scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); list_view = prefs_custom_header_list_view_create(); gtk_widget_show (list_view); gtk_container_add (GTK_CONTAINER (ch_scrolledwin), list_view); btn_vbox = gtk_vbox_new (FALSE, 8); gtk_widget_show (btn_vbox); gtk_box_pack_start (GTK_BOX (ch_hbox), btn_vbox, FALSE, FALSE, 0); up_btn = gtk_button_new_from_stock (GTK_STOCK_GO_UP); gtk_widget_show (up_btn); gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (up_btn), "clicked", G_CALLBACK (prefs_custom_header_up), NULL); down_btn = gtk_button_new_from_stock (GTK_STOCK_GO_DOWN); gtk_widget_show (down_btn); gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (down_btn), "clicked", G_CALLBACK (prefs_custom_header_down), NULL); preview = gtk_image_new (); gtk_widget_show (preview); gtk_box_pack_start (GTK_BOX (btn_vbox), preview, FALSE, FALSE, 0); gtk_widget_show_all(window); customhdr.window = window; customhdr.ok_btn = ok_btn; customhdr.cancel_btn = cancel_btn; customhdr.preview = preview; customhdr.hdr_combo = hdr_combo; customhdr.hdr_entry = gtk_bin_get_child(GTK_BIN((hdr_combo))); customhdr.val_entry = val_entry; customhdr.list_view = list_view; }
bool loop(int argc, char** argv) { char home[256]; //NEED TO MAKE THIS DYNAMIC strcpy(home, getenv("HOME")); //parse the config file settings.parse_config(strcat(home, config_file)); //load the controls into list ElementList list(settings.card); list_ptr = &list; //reorder the controls to the order specified in the config file settings.reorder_list(&list); //set the scale list.set_scale((Element::scale_t)settings.scaling); //set the auto_mute list.set_auto_mute(settings.auto_mute); //initialize gtk gtk_init(&argc, &argv); //set up the tray_slider that goes in the tray if (settings.enable_tray_icon){ GtkWidget *tray_frame; tray_frame = gtk_alignment_new(0.5,0.0,0,0); settings.tray_slider = new retro_slider; settings.set_tray_slider(&list); settings.apply_to_tray_slider(settings.tray_slider); if (list.num_elems > 0){ settings.tray_slider->init(tray_frame, (void*)settings.tray_control, &Element::get_callback, &Element::set_callback, (settings.tray_control->values > 1)); } else { settings.tray_control = NULL; } //set up the small window that holds the tray_slider settings.slider_window = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_resizable(GTK_WINDOW(settings.slider_window), false); gtk_window_set_decorated(GTK_WINDOW(settings.slider_window), false); gtk_window_set_skip_taskbar_hint(GTK_WINDOW(settings.slider_window), true); gtk_window_set_skip_pager_hint(GTK_WINDOW(settings.slider_window), true); gtk_widget_set_usize(settings.slider_window, settings.tray_slider->width, settings.tray_slider->height); //don't want accidental closure of the slider window to destroy the window g_signal_connect(settings.slider_window, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); //want the widow to go away when it loses focus g_signal_connect(settings.slider_window, "focus-out-event", G_CALLBACK (gtk_widget_hide), NULL); gtk_container_add( GTK_CONTAINER(settings.slider_window), tray_frame ); //we want it hidden by default, but it must be shown at least once or else scrolling over the icon will cause a hang gtk_widget_show_all(settings.slider_window); gtk_widget_hide_all(settings.slider_window); //set up tray icon #if GTK_CHECK_VERSION(2,16,0) settings.tray_icon = gtk_status_icon_new(); gtk_status_icon_set_from_file(settings.tray_icon, VOL_MUTED_IMAGE); #else settings.tray_icon = GTK_WIDGET(egg_tray_icon_new("Retrovol Tray Icon")); //set the background color bool enable_tray_icon_background_color = settings.enable_tray_icon_background_color; GdkColor bg_color; char bg_color_str[8]; if (cmdline_enable_bg_color){ enable_tray_icon_background_color = true; strcpy(bg_color_str, cmdline_bg_color); } else if (settings.enable_tray_icon_background_color){ settings.nftoh(settings.tray_icon_background_color, bg_color_str); } if (enable_tray_icon_background_color){ if (gdk_color_parse(bg_color_str, &bg_color)){ GtkStyle *style = gtk_style_copy(gtk_widget_get_style(settings.tray_icon)); style->bg[GTK_STATE_NORMAL] = bg_color; gtk_widget_set_style(settings.tray_icon, style); } else { fprintf(stderr, _("Error: Failed to set background color to %s\n"), bg_color_str); } } //set up the images settings.tray_icon_image = gtk_image_new(); gtk_container_add( GTK_CONTAINER(settings.tray_icon), settings.tray_icon_image ); gtk_image_set_from_file(GTK_IMAGE(settings.tray_icon_image), VOL_MEDIUM_IMAGE); //set the event mask gtk_widget_set_events (settings.tray_icon, GDK_BUTTON_PRESS_MASK | GDK_SCROLL_MASK); #endif //signals g_signal_connect(G_OBJECT(settings.tray_icon), "button_press_event", G_CALLBACK (&tray_button_press_event_callback), settings.slider_window); if (settings.tray_control){ g_signal_connect(G_OBJECT(settings.tray_icon), "scroll_event", G_CALLBACK (&retro_slider::scroll_event_callback), settings.tray_slider); } #if GTK_CHECK_VERSION(2,16,0) //make icon visible gtk_status_icon_set_visible(settings.tray_icon, true); #else //handle situations where the icon's window dies, such as due to the tray itself exiting g_signal_connect(G_OBJECT(settings.tray_icon), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); //make icon visible gtk_widget_show_all(settings.tray_icon); #endif //set up the popup menu (the function checks if it should actually do anything) set_menu(); } //set up the window settings.main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); //gtk_window_set_position(GTK_WINDOW(settings.main_window), GTK_WIN_POS_CENTER); gtk_window_set_default_size(GTK_WINDOW(settings.main_window), settings.window_width, settings.window_height); gtk_window_set_title(GTK_WINDOW(settings.main_window), "Retrovol"); restore_posdim(); g_signal_connect(settings.main_window, "configure-event", G_CALLBACK (save_posdim), NULL); //if the tray icon is enabled, we want the window to hide rather than closing if (settings.enable_tray_icon){ g_signal_connect(settings.main_window, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); } //make the over_box, which will hold stuff like the menu, status bar, and the actual content in the middle GtkWidget *over_box; over_box = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(settings.main_window), over_box); //define the menu GtkItemFactoryEntry menu_items_1[] = { { (gchar*)_("/_File"), NULL, NULL, 0, (gchar*)"<Branch>" }, { (gchar*)_("/File/_Configure"), (gchar*)"<CTRL>C", G_CALLBACK(configure), 0, (gchar*)"<StockItem>", GTK_STOCK_EXECUTE }, { (gchar*)_("/File/_Quit"), (gchar*)"<CTRL>Q", G_CALLBACK(close_window), 0, (gchar*)"<StockItem>", GTK_STOCK_QUIT }, }; gint nmenu_items_1 = sizeof (menu_items_1) / sizeof (menu_items_1[0]); GtkItemFactoryEntry menu_items_2[] = { { (gchar*)_("/_File"), NULL, NULL, 0, (gchar*)"<Branch>" }, { (gchar*)_("/File/_Configure"), (gchar*)"<CTRL>C", G_CALLBACK(configure), 0, (gchar*)"<StockItem>", GTK_STOCK_EXECUTE }, { (gchar*)_("/File/_Exit completely"), (gchar*)"<CTRL>E", G_CALLBACK(gtk_main_quit), 0, (gchar*)"<StockItem>", GTK_STOCK_QUIT }, { (gchar*)_("/File/_Quit"), (gchar*)"<CTRL>Q", G_CALLBACK(close_window), 0, (gchar*)"<StockItem>", GTK_STOCK_QUIT }, }; gint nmenu_items_2 = sizeof (menu_items_2) / sizeof (menu_items_2[0]); GtkItemFactoryEntry *menu_items; gint nmenu_items; //if the tray menu is enabled, don't have the "Exit" entry in the main menu if (settings.enable_tray_menu){ menu_items = menu_items_1; nmenu_items = nmenu_items_1; } else { menu_items = menu_items_2; nmenu_items = nmenu_items_2; } //build the menu GtkWidget *menubar; menubar = get_menubar_menu(settings.main_window, menu_items, nmenu_items, "<RetrovolMain>"); gtk_box_pack_start(GTK_BOX(over_box), menubar, FALSE, TRUE, 0); //use a scrolled window GtkWidget *scrolled_window; scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(over_box), scrolled_window); //put the stuff into a viewport manually, so we can specify that it should have no shadow GtkWidget *viewport; viewport = gtk_viewport_new(NULL, NULL); gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE); gtk_container_add(GTK_CONTAINER(scrolled_window), viewport); //and create an Hbox to hold all the stuff GtkWidget *hbox; if (settings.vertical){ hbox = gtk_hbox_new(TRUE, 2); gtk_container_add(GTK_CONTAINER(viewport), hbox); } else { hbox = gtk_vbox_new(TRUE, 2); gtk_container_add(GTK_CONTAINER(viewport), hbox); } //add the sliders retro_slider *sliders = new retro_slider[list.num_items]; for(int i=0; i<list.num_items; i++){ //use a vbox w/ slider on top and label on bottom GtkWidget *vbox; if (settings.vertical){ vbox = gtk_vbox_new(FALSE, 2); } else { vbox = gtk_hbox_new(FALSE, 2); } gtk_box_pack_start(GTK_BOX(hbox), vbox, false, false, 0); if (strcmp(list.items[i]->type, "INTEGER") == 0){ //integers need sliders //the rslider pseudo-widget likes to be inside a container, lets use a GtkAlignment GtkWidget *frame; if (settings.vertical){ frame = gtk_alignment_new(0.5,0.0,0,0); gtk_box_pack_start(GTK_BOX(vbox), frame, false, false, 0); } else { frame = gtk_alignment_new(0.0,0.5,0,0); gtk_box_pack_end(GTK_BOX(vbox), frame, false, false, 0); } //make the slider and associate with a control settings.apply_to_slider(&sliders[i]); sliders[i].init(frame, (void*)list.items[i], &Element::get_callback, &Element::set_callback, (list.items[i]->values > 1)); } else if (strcmp(list.items[i]->type, "BOOLEAN") == 0){ //booleans need checkboxes GtkWidget *alignment; if (settings.vertical){ alignment = gtk_alignment_new(0.5,1.0,0,0); gtk_box_pack_start(GTK_BOX(vbox), alignment, true, true, 0); } else { alignment = gtk_alignment_new(1.0,0.5,0,0); gtk_box_pack_end(GTK_BOX(vbox), alignment, true, true, 0); } GtkWidget *chkbx; chkbx = gtk_check_button_new(); //set it to the current state gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chkbx), (bool)list.items[i]->get()); //bind to the toggle_checkbox function Element* ptr = list.items[i]; g_signal_connect(GTK_TOGGLE_BUTTON(chkbx), "toggled", G_CALLBACK (toggle_checkbox), ptr); g_signal_connect_after(GTK_TOGGLE_BUTTON(chkbx), "expose-event", G_CALLBACK (refresh_checkbox), ptr); gtk_container_add(GTK_CONTAINER(alignment), chkbx); } else if (strcmp(list.items[i]->type, "ENUMERATED") == 0){ GtkWidget *alignment; if (settings.vertical){ alignment = gtk_alignment_new(0.5,0.5,0,0); gtk_box_pack_start(GTK_BOX(vbox), alignment, true, true, 0); } else { alignment = gtk_alignment_new(1.0,0.5,0,0); gtk_box_pack_end(GTK_BOX(vbox), alignment, true, true, 0); } //insert a combobox with the different options GtkWidget *combo_box; combo_box=gtk_combo_box_new_text(); for(unsigned int n=0; n<list.items[i]->number_of_enums; n++){ gtk_combo_box_append_text(GTK_COMBO_BOX(combo_box), list.items[i]->enums[n]); } gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), list.items[i]->get()); //bind to the change_combo_box function g_signal_connect(GTK_COMBO_BOX(combo_box), "changed", G_CALLBACK (change_combo_box), list.items[i]); gtk_container_add(GTK_CONTAINER(alignment), combo_box); } //add a checkbox for sliders that are muteable if (list.items[i]->switch_id >= 0){ GtkWidget *alignment; if (settings.vertical){ alignment = gtk_alignment_new(0.5,1.0,0,0); gtk_box_pack_start(GTK_BOX(vbox), alignment, true, true, 0); } else { alignment = gtk_alignment_new(1.0,0.5,0,0); gtk_box_pack_end(GTK_BOX(vbox), alignment, true, true, 0); } GtkWidget *chkbx; chkbx = gtk_check_button_new(); //set it to the current state gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chkbx), (bool)list.elems[list.items[i]->switch_id].get()); //bind to the toggle_checkbox function g_signal_connect(GTK_TOGGLE_BUTTON(chkbx), "toggled", G_CALLBACK (toggle_checkbox), &(list.elems[list.items[i]->switch_id])); g_signal_connect_after(GTK_TOGGLE_BUTTON(chkbx), "expose-event", G_CALLBACK (refresh_checkbox), &(list.elems[list.items[i]->switch_id])); gtk_container_add(GTK_CONTAINER(alignment), chkbx); } //display the name of the control GtkWidget *alignment; char wrapped[256]; if (settings.vertical){ alignment = gtk_alignment_new(0.5,1.0,0,0); gtk_box_pack_end(GTK_BOX(vbox), alignment, false, false, 0); word_wrap(wrapped, list.items[i]->short_name); } else { alignment = gtk_alignment_new(1.0,0.5,0,0); gtk_box_pack_start(GTK_BOX(vbox), alignment, false, false, 0); strcpy(wrapped, list.items[i]->short_name); } GtkWidget *label; label = gtk_label_new(wrapped); gtk_container_add(GTK_CONTAINER(alignment), label); } //finish the window stuff if (!start_hidden){ gtk_widget_show_all(settings.main_window); } g_signal_connect(settings.main_window, "destroy", G_CALLBACK (gtk_main_quit), NULL); //add some periodic refreshment to keep the icon and window up-to-date #if GTK_CHECK_VERSION(2,14,0) int timeout = g_timeout_add_seconds(1, update, NULL); #else //this is less efficient than g_timeout_add_seconds() int timeout = g_timeout_add(1000, update, NULL); #endif //finished with gtk setup gtk_main(); //stop the timeout g_source_remove(timeout); //have the window shown again if it was open before we restarted if (settings.resume_main){ settings.resume_main = false; start_hidden = false; } else { start_hidden = true; } return(settings.restart); }
GtkWidget * pgd_text_create_widget (PopplerDocument *document) { PgdTextDemo *demo; GtkWidget *label; GtkWidget *vbox, *vbox2; GtkWidget *hbox, *page_selector, *area_hbox; GtkWidget *button; GtkWidget *swindow, *textview, *treeview; GtkTreeSelection *selection; GtkWidget *frame, *alignment, *table; GtkWidget *hpaned; GtkCellRenderer *renderer; gchar *str; gint n_pages; gint row = 0; demo = g_new0 (PgdTextDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_text_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("X1:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_x1 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_x1, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_x1, TRUE, TRUE, 0); gtk_widget_show (demo->area_x1); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Y1:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_y1 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_y1, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_y1, TRUE, TRUE, 0); gtk_widget_show (demo->area_y1); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("X2:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_x2 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_x2, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_x2, TRUE, TRUE, 0); gtk_widget_show (demo->area_x2); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Y2:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_y2 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_y2, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_y2, TRUE, TRUE, 0); gtk_widget_show (demo->area_y2); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); pgd_text_area_selector_setup (demo); button = gtk_button_new_with_label ("Get Text"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_text_get_text), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No text found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_paned_set_position (GTK_PANED (hpaned), 300); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model)); demo->treeview = treeview; renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_X1_COLUMN, "X1", renderer, "text", TEXT_X1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_Y1_COLUMN, "Y1", renderer, "text", TEXT_Y1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_X2_COLUMN, "X2", renderer, "text", TEXT_X2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_Y2_COLUMN, "Y2", renderer, "text", TEXT_Y2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_OFFSET_COLUMN, "Offset", renderer, "text", TEXT_OFFSET_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (selection, "changed", G_CALLBACK (pgd_text_selection_changed), (gpointer) demo); gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); /* Text attributes */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Text Attributes</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_widget_show (alignment); table = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (table), 6); gtk_grid_set_row_spacing (GTK_GRID (table), 6); demo->font_name = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Font Name:</b>", demo->font_name, &row); demo->font_size = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Font Size:</b>", demo->font_size, &row); demo->is_underlined = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Underlined:</b>", demo->is_underlined, &row); demo->text_color = gtk_image_new (); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Color:</b>", demo->text_color, &row); gtk_container_add (GTK_CONTAINER (alignment), table); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 12); gtk_widget_show (frame); gtk_paned_add1 (GTK_PANED (hpaned), vbox2); gtk_widget_show (vbox2); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->buffer = gtk_text_buffer_new (NULL); textview = gtk_text_view_new_with_buffer (demo->buffer); g_signal_connect (textview, "query-tooltip", G_CALLBACK (pgd_text_view_query_tooltip), demo); g_signal_connect (demo->buffer, "notify::has-selection", G_CALLBACK (pgd_text_buffer_selection_changed), textview); gtk_container_add (GTK_CONTAINER (swindow), textview); gtk_widget_show (textview); gtk_paned_add2 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_text_free, demo); return vbox; }
int main(int argc, char *argv[]) { GtkWidget *window; int i, j, k; count = 0; /*initiate gtk*/ gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "Spectrogram"); gtk_window_set_resizable(GTK_WINDOW(window), TRUE); gtk_container_set_border_width(GTK_CONTAINER(window), 2); image = gtk_image_new(); gtk_container_add(GTK_CONTAINER(window), image); g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL); gtk_widget_show_all(window); /*END*/ /*Initialize socket*/ sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) error1("ERROR opening socket"); bzero((char *) &serv_addr, sizeof(serv_addr)); port_num = 51717; serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_port = htons(port_num); if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) error1("ERROR on binding"); listen(sockfd,5); clilen = sizeof(cli_addr); newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen); if (newsockfd < 0) error1("ERROR on accept"); //First Header fprintf(stderr, "Reading header... "); n = read(newsockfd, &header, sizeof(struct fft_header)); if (n < 0) error1("ERROR reading from socket"); else if (n > 0) { printf("header.constSync is %X\n", header.constSync); if(header.constSync != 0xACFDFFBC) error1("ERROR reading from socket, incorrect header placement\n"); } else if( n == 0) { printf("Sender has closed connection\n"); exit(0); } //Initializing structures samp_rate = header.ptsPerFFT; CAMERA_WIDTH = samp_rate; rgbImage = malloc(sizeof(struct pixel) * (CAMERA_HEIGHT*CAMERA_WIDTH)); rgbImageTemp = malloc(sizeof(struct pixel) * (CAMERA_HEIGHT*CAMERA_WIDTH)); buffer = malloc(sizeof(float) * samp_rate); bufSize = sizeof(float)* samp_rate; length = (sizeof(struct fft_header) + sizeof(float)* samp_rate); size = length* 2 + 1; tempBuf = malloc(length); //First Data fprintf(stderr, "Reading data... "); n = read(newsockfd, (char *) buffer, header.ptsPerFFT * sizeof(float)); if (n < 0) error1("ERROR reading from socket"); else if( n == 0) { printf("Sender has closed connection\n"); exit(0); } /*End*/ //gtk initialization /*Initialize screen with color*/ for(j = 0; j < CAMERA_WIDTH; j++) { for(i = CAMERA_HEIGHT-1; i>=0 ; i--) { rgbImage[j+i*CAMERA_WIDTH].blue = BLUEMAC(0); rgbImage[j+i*CAMERA_WIDTH].red = REDMAC(0); rgbImage[j+i*CAMERA_WIDTH].green = GREENMAC(0); } } for(i = 0; i<CAMERA_WIDTH ; i++) { rgbImage[i].blue = BLUEMAC(buffer[i]); rgbImage[i].red = REDMAC(buffer[i]); rgbImage[i].green = GREENMAC(buffer[i]); } //loadeImage function loadImage(rgbImage); //call shift every 50msec gint func_ref = g_timeout_add(50, getData, NULL); gtk_main(); g_source_remove (func_ref); return 0; }
static GtkWidget * build_tab_label (NautilusNotebook *nb, NautilusWindowSlot *slot) { NautilusDragSlotProxyInfo *drag_info; GtkWidget *hbox, *label, *close_button, *image, *spinner, *icon; /* set hbox spacing and label padding (see below) so that there's an * equal amount of space around the label */ hbox = gtk_hbox_new (FALSE, 4); gtk_widget_show (hbox); /* setup load feedback */ spinner = ephy_spinner_new (); ephy_spinner_set_size (EPHY_SPINNER (spinner), GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0); /* setup site icon, empty by default */ icon = gtk_image_new (); gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0); /* don't show the icon */ /* setup label */ label = gtk_label_new (NULL); gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END); gtk_label_set_single_line_mode (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_misc_set_padding (GTK_MISC (label), 0, 0); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); /* setup close button */ close_button = gtk_button_new (); gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE); /* don't allow focus on the close button */ gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE); gtk_widget_set_name (close_button, "nautilus-tab-close-button"); image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_widget_set_tooltip_text (close_button, _("Close tab")); g_signal_connect_object (close_button, "clicked", G_CALLBACK (close_button_clicked_cb), slot, 0); gtk_container_add (GTK_CONTAINER (close_button), image); gtk_widget_show (image); gtk_box_pack_start (GTK_BOX (hbox), close_button, FALSE, FALSE, 0); gtk_widget_show (close_button); /* Set minimal size */ g_signal_connect (hbox, "style-set", G_CALLBACK (tab_label_style_set_cb), NULL); drag_info = g_new0 (NautilusDragSlotProxyInfo, 1); drag_info->target_slot = slot; g_object_set_data_full (G_OBJECT (hbox), "proxy-drag-info", drag_info, (GDestroyNotify) g_free); nautilus_drag_slot_proxy_init (hbox, drag_info); g_object_set_data (G_OBJECT (hbox), "label", label); g_object_set_data (G_OBJECT (hbox), "spinner", spinner); g_object_set_data (G_OBJECT (hbox), "icon", icon); g_object_set_data (G_OBJECT (hbox), "close-button", close_button); return hbox; }
static void tb_editor_set_item_values(TBEditorWidget *tbw, const gchar *action_name, GtkListStore *store, GtkTreeIter *iter) { gchar *icon = NULL; gchar *label = NULL; gchar *label_clean = NULL; GdkPixbuf *pix = NULL; GtkAction *action; action = gtk_action_group_get_action(marlin_view_window_get_actiongroup(tbw->mvw), action_name); if (action != NULL) { /*gtk_action_block_activate(action); log_printf (LOG_LEVEL_UNDEFINED, "blocked %s\n", action_name);*/ icon = katze_object_get_string(action, "icon-name"); if (icon == NULL) { icon = katze_object_get_string(action, "stock-id"); } label = katze_object_get_string(action, "label"); if (label != NULL) label_clean = katze_strip_mnemonics(label); } else label_clean = strdup(action_name); GtkIconTheme *icon_theme = gtk_icon_theme_get_default (); /*GtkIconInfo *icon_info = gtk_icon_theme_lookup_icon (icon_theme, icon, 16, GTK_ICON_LOOKUP_USE_BUILTIN | GTK_ICON_LOOKUP_GENERIC_FALLBACK | GTK_ICON_LOOKUP_FORCE_SIZE); gchar *test; test = gtk_icon_info_get_filename (icon_info); //log_printf (LOG_LEVEL_UNDEFINED, "action: %20s icon: %20s\n", action_name, icon); log_printf (LOG_LEVEL_UNDEFINED, "action: %20s icon: %20s test: %s\n", action_name, icon, test);*/ if (icon != NULL) { //GtkIconSize status_btn_size = gtk_icon_size_from_name ("16px"); GtkWidget *image = gtk_image_new (); //pix = gtk_widget_render_icon (image, icon, status_btn_size, NULL); pix = gtk_widget_render_icon (image, icon, GTK_ICON_SIZE_MENU, NULL); gtk_widget_destroy (image); if (pix==NULL && icon!=NULL) pix = gtk_icon_theme_load_icon (icon_theme, icon, 16, GTK_ICON_LOOKUP_USE_BUILTIN | GTK_ICON_LOOKUP_GENERIC_FALLBACK | GTK_ICON_LOOKUP_FORCE_SIZE, NULL); } gtk_list_store_set(store, iter, TB_EDITOR_COL_ACTION, action_name, TB_EDITOR_COL_LABEL, label_clean, //TB_EDITOR_COL_LABEL, action_name, TB_EDITOR_COL_ICON, pix, -1); g_free(icon); g_free(label); g_free(label_clean); }
static void _lib_import_single_image_callback(GtkWidget *widget, gpointer user_data) { GtkWidget *win = dt_ui_main_window(darktable.gui->ui); GtkWidget *filechooser = gtk_file_chooser_dialog_new( _("import image"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Open"), GTK_RESPONSE_ACCEPT, (char *)NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE); char *last_directory = dt_conf_get_string("ui_last/import_last_directory"); if(last_directory != NULL) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_directory); g_free(last_directory); } char *cp, **extensions, ext[1024]; GtkFileFilter *filter; filter = GTK_FILE_FILTER(gtk_file_filter_new()); extensions = g_strsplit(dt_supported_extensions, ",", 100); for(char **i = extensions; *i != NULL; i++) { snprintf(ext, sizeof(ext), "*.%s", *i); gtk_file_filter_add_pattern(filter, ext); gtk_file_filter_add_pattern(filter, cp = g_ascii_strup(ext, -1)); g_free(cp); } g_strfreev(extensions); gtk_file_filter_set_name(filter, _("supported images")); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter); filter = GTK_FILE_FILTER(gtk_file_filter_new()); gtk_file_filter_add_pattern(filter, "*"); gtk_file_filter_set_name(filter, _("all files")); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter); GtkWidget *preview = gtk_image_new(); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(filechooser), preview); g_signal_connect(filechooser, "update-preview", G_CALLBACK(_lib_import_update_preview), preview); dt_lib_import_metadata_t metadata; gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser), _lib_import_get_extra_widget(&metadata, FALSE)); if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT) { dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(filechooser))); _lib_import_evaluate_extra_widget(&metadata, FALSE); char *filename = NULL; dt_film_t film; GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(filechooser)); GSList *it = list; int id = 0; int filmid = 0; /* reset filter so that view isn't empty */ dt_view_filter_reset(darktable.view_manager, TRUE); while(it) { filename = (char *)it->data; gchar *directory = g_path_get_dirname((const gchar *)filename); filmid = dt_film_new(&film, directory); id = dt_image_import(filmid, filename, TRUE); if(!id) dt_control_log(_("error loading file `%s'"), filename); g_free(filename); g_free(directory); it = g_slist_next(it); } if(id) { dt_film_open(filmid); // make sure buffers are loaded (load full for testing) dt_mipmap_buffer_t buf; dt_mipmap_cache_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING, 'r'); gboolean loaded = (buf.buf != NULL); dt_mipmap_cache_release(darktable.mipmap_cache, &buf); if(!loaded) { dt_control_log(_("file has unknown format!")); } else { dt_control_set_mouse_over_id(id); dt_ctl_switch_mode_to(DT_DEVELOP); } } } gtk_widget_destroy(metadata.frame); gtk_widget_destroy(filechooser); gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui)); }
GtkWidget * scratch_tab_create() { GtkWidget *vbox = gtk_vbox_new(FALSE, 5); /* file list treeview */ filelist_treeview = gtk_tree_view_new (); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (filelist_treeview), TRUE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW (filelist_treeview), FALSE); GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(filelist_treeview)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT(filelist_treeview), "cursor-changed", G_CALLBACK (filelist_treeview_row_selected), NULL); filelist_treeview_sw = new_scrolled_window (NULL); gtk_container_add (GTK_CONTAINER (filelist_treeview_sw), filelist_treeview); /* add columns to the tree view */ GtkCellRenderer *renderer; GtkTreeViewColumn *col; int i; int col_count = sizeof (filelist_treeview_col_names) / sizeof (char *); for (i=0; i<col_count; i++) { renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (filelist_treeview_col_names[i], renderer, "text", i, NULL); if (i == 0) { gtk_tree_view_column_set_clickable(col, TRUE); gtk_tree_view_column_set_sort_order(col, GTK_SORT_DESCENDING); gtk_tree_view_column_set_sort_column_id(col, 0); gtk_tree_view_column_set_sort_indicator(col, TRUE); } else { gtk_tree_view_column_set_clickable(col, FALSE); } gtk_tree_view_append_column (GTK_TREE_VIEW(filelist_treeview), col); } filelist_store = gtk_list_store_new (col_count, G_TYPE_STRING, G_TYPE_STRING); GtkTreeSortable *sortable = GTK_TREE_SORTABLE(filelist_store); gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_DESCENDING); gtk_tree_view_set_model(GTK_TREE_VIEW(filelist_treeview), GTK_TREE_MODEL(filelist_store)); GtkWidget *hbox = gtk_hbox_new(TRUE, 5); GtkWidget *scratch_button = gtk_button_new_with_label("Scratch on map"); g_signal_connect (G_OBJECT (scratch_button), "clicked", G_CALLBACK (scratch_button_clicked), NULL); view_button = gtk_button_new_with_label("View"); g_signal_connect (G_OBJECT(view_button), "clicked", G_CALLBACK (view_button_clicked), NULL); delete_button = gtk_button_new_with_label("Delete"); g_signal_connect (G_OBJECT(delete_button), "clicked", G_CALLBACK (delete_button_clicked), NULL); gtk_container_add(GTK_CONTAINER(hbox), view_button); gtk_container_add(GTK_CONTAINER(hbox), delete_button); gtk_container_add(GTK_CONTAINER(hbox), scratch_button); gtk_box_pack_start(GTK_BOX(vbox), filelist_treeview_sw, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); /* populate files into filelist treeview */ GtkTreeIter iter; struct dirent *ep; char buf[256]; char *file_path = NULL; int len, ext_len = strlen(SCREENSHOT_FILE_EXT); char *fname; struct stat st; DIR *dp = opendir (g_context.screenshot_dir); if (dp == NULL) { if (stat(buf, &st) == 0) warn_dialog("unable to list screenshot files"); } else { while ((ep = readdir (dp))) { fname = ep->d_name; len = strlen(fname); if (ep->d_type == DT_REG && len > ext_len && (strncmp(&fname[len-ext_len], SCREENSHOT_FILE_EXT, ext_len) == 0)) { gtk_list_store_prepend (filelist_store, &iter); file_path = get_full_path(buf, sizeof(buf), fname); add_file_to_list(&iter, file_path, fname); } } closedir (dp); } notebook = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), FALSE); gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE); GtkWidget *label; label = gtk_label_new("screen shot list"); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label); GtkWidget *image_box = gtk_vbox_new(FALSE, 0); screenshot_label = gtk_label_new(""); screenshot_image = gtk_image_new(); gtk_box_pack_start(GTK_BOX(image_box), screenshot_label, FALSE, FALSE, 0); GtkWidget *sw = new_scrolled_window (screenshot_image); /* stretch */ gtk_box_pack_start(GTK_BOX(image_box), sw, TRUE, TRUE, 0); label = gtk_label_new("view screen shot"); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), image_box, label); return notebook; }
void update_sidepanel() { int i; for(i = 0; i < BUFFER_COUNT; i++) { if(icons[i] != NULL) { gtk_widget_hide(icons[i]); gtk_widget_destroy(icons[i]); gtk_widget_hide(icon_event_boxes[i]); gtk_widget_destroy(icon_event_boxes[i]); icons[i] = NULL; icon_event_boxes[i] = NULL; } } for(i = 0; i < BUFFER_COUNT; i++) { if(mdata[i] != NULL) { if(i == current_buffer) { GdkColor color; gdk_color_parse("red", &color); if(selected_buffer_frame != NULL) gtk_widget_destroy(selected_buffer_frame); selected_buffer_frame = gtk_frame_new(NULL); gtk_widget_modify_bg(selected_buffer_frame, GTK_STATE_NORMAL, &color); gtk_box_pack_start(GTK_BOX(list_vbox), selected_buffer_frame, FALSE, TRUE, 1); icons[i] = gtk_image_new(); icon_event_boxes[i] = gtk_event_box_new(); gtk_image_set_from_pixbuf(GTK_IMAGE(icons[i]), get_pixbuf_from_data(mdata[i], 0)); gtk_container_add(GTK_CONTAINER(selected_buffer_frame), icon_event_boxes[i]); gtk_container_add(GTK_CONTAINER(icon_event_boxes[i]), icons[i]); gtk_widget_show(icons[i]); gtk_widget_show(icon_event_boxes[i]); gtk_widget_show(selected_buffer_frame); g_signal_connect(G_OBJECT(icon_event_boxes[i]), "button_press_event", G_CALLBACK(buffer_callback), (gpointer *)(size_t)i); } else { icons[i] = gtk_image_new(); icon_event_boxes[i] = gtk_event_box_new(); gtk_image_set_from_pixbuf(GTK_IMAGE(icons[i]), get_pixbuf_from_data(mdata[i], 0)); gtk_box_pack_start(GTK_BOX(list_vbox), icon_event_boxes[i], FALSE, TRUE, 2); gtk_container_add(GTK_CONTAINER(icon_event_boxes[i]), icons[i]); gtk_widget_show(icons[i]); gtk_widget_show(icon_event_boxes[i]); g_signal_connect(G_OBJECT(icon_event_boxes[i]), "button_press_event", G_CALLBACK(buffer_callback), (gpointer *)(size_t)i); } } } }
static void egg_tray_icon_update_manager_window (EggTrayIcon *icon) { static GdkPixbuf *background_pixbuf; const gchar *window_manager=NULL; if (icon->manager_window != None) { GdkWindow *gdkwin; gdkwin = gdk_window_lookup (icon->manager_window); gdk_window_remove_filter (gdkwin, egg_tray_icon_manager_filter, icon); } XGrabServer (GDK_DISPLAY()); icon->manager_window = XGetSelectionOwner (GDK_DISPLAY(), icon->selection_atom); if (icon->manager_window != None) XSelectInput (GDK_DISPLAY(), icon->manager_window, StructureNotifyMask); XUngrabServer (GDK_DISPLAY()); XFlush (GDK_DISPLAY()); if (icon->manager_window == None) return; window_manager=gdk_x11_screen_get_window_manager_name (gdk_screen_get_default()); if ( !g_ascii_strcasecmp(window_manager, kde_window_manger) && kde_dock (icon)) { if ((background_pixbuf=kde_dock_background(icon)) !=NULL) { icon->box= gtk_fixed_new (); gtk_fixed_set_has_window(GTK_FIXED (icon->box),TRUE); gtk_container_add(GTK_CONTAINER(icon), icon->box); icon->image=gtk_image_new (); gtk_image_set_from_pixbuf(GTK_IMAGE(icon->image), icon->default_pix); icon->background =gtk_image_new (); gtk_image_set_from_pixbuf(GTK_IMAGE(icon->background), background_pixbuf); gtk_fixed_put (GTK_FIXED (icon->box), GTK_WIDGET(icon->background), 0, 0); gtk_fixed_put (GTK_FIXED (icon->box), GTK_WIDGET(icon->image), 0, 0); gtk_widget_show (icon->background); gtk_widget_show (icon->image); gtk_widget_show(icon->box); icon->ready=TRUE; } } else { icon->box=gtk_event_box_new (); gtk_container_add(GTK_CONTAINER(icon), icon->box); icon->image=gtk_image_new (); gtk_image_set_from_pixbuf(GTK_IMAGE(icon->image),icon->default_pix); gtk_container_add(GTK_CONTAINER(icon->box), icon->image); gtk_widget_show (icon->image); gtk_widget_show(icon->box); GdkWindow *gdkwin; gdkwin = gdk_window_lookup (icon->manager_window); gdk_window_add_filter (gdkwin, egg_tray_icon_manager_filter, icon); /* Send a request that we'd like to dock */ egg_tray_icon_send_dock_request (icon); } }
int main(int argc, char ** argv) { GtkWidget * vbox; GtkWidget * hpaned; GtkWidget * sc_win, * sc_buffer; GtkWidget * menu_bar; GtkWidget * file_menu, * file_item, * open_item, * save_item, * quit_item, * exp_img_item, * save_raw_data_item; GtkWidget * generate_menu, * generate_item, * mandelbrot_item, * julia_item, * palette_item, * random_noise_item, * from_clipboard_item; GtkWidget * settings_menu, * settings_item; GtkWidget * zoom_box, * zoom_button; //init general colors = (color_t *)malloc(56 * sizeof(color_t)); memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *)); memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *)); memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *)); mdata[current_buffer] = (unsigned char *)malloc(128 * 128); char * templine = malloc(13); FILE * fcolors = fopen("colors", "r"); int i, r, g, b; for(i = 0; fgets(templine, 13, fcolors) == templine; i++) { sscanf(templine, "%i,%i,%i", &r, &g, &b); color_t color = {r, g, b}; colors[i] = color; } free(templine); fclose(fcolors); save_colors(colors, "colors.bin"); //load_colors(colors, "colors.bin"); srand(time(NULL)); config = config_new(); //init gtk gtk_init(&argc, &argv); //window window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER); g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL); //vbox #ifdef GTK2 vbox = gtk_vbox_new(FALSE, 0); #else vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif gtk_container_add(GTK_CONTAINER (window), vbox); gtk_widget_show(vbox); //////menu_bar menu_bar = gtk_menu_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0); gtk_widget_show(menu_bar); ////////file_menu file_menu = gtk_menu_new(); //////////open_item open_item = gtk_menu_item_new_with_label("Open"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), open_item); gtk_widget_show(open_item); g_signal_connect_swapped (open_item, "activate", G_CALLBACK (button_click), (gpointer) "button.open"); //////////save_item save_item = gtk_menu_item_new_with_label("Save"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_item); gtk_widget_show(save_item); g_signal_connect_swapped (save_item, "activate", G_CALLBACK (button_click), (gpointer) "button.save"); //////////save_raw_data_item save_raw_data_item = gtk_menu_item_new_with_label("Save Raw Map"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_raw_data_item); gtk_widget_show(save_raw_data_item); g_signal_connect_swapped (save_raw_data_item, "activate", G_CALLBACK (button_click), (gpointer) "button.save_rm"); //////////exp_img_item exp_img_item = gtk_menu_item_new_with_label("Export Image"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), exp_img_item); gtk_widget_show(exp_img_item); g_signal_connect_swapped(exp_img_item, "activate", G_CALLBACK (button_click), (gpointer) "button.exp_img"); //////////quit_item quit_item = gtk_menu_item_new_with_label("Quit"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), quit_item); gtk_widget_show(quit_item); g_signal_connect_swapped (quit_item, "activate", G_CALLBACK(kill_window), (gpointer)"button.quit"); /////////file_item file_item = gtk_menu_item_new_with_label("File"); gtk_widget_show(file_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item); ////////generate_menu generate_menu = gtk_menu_new(); //////////mandelbrot_item mandelbrot_item = gtk_menu_item_new_with_label("Mandelbrot"); gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), mandelbrot_item); gtk_widget_show(mandelbrot_item); g_signal_connect_swapped(mandelbrot_item, "activate", G_CALLBACK(button_click), (gpointer) "button.mandelbrot"); //////////julia_item julia_item = gtk_menu_item_new_with_label("Julia"); gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), julia_item); gtk_widget_show(julia_item); g_signal_connect_swapped(julia_item, "activate", G_CALLBACK (button_click), (gpointer) "button.julia"); //////////palette_item palette_item = gtk_menu_item_new_with_label("Palette"); gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), palette_item); gtk_widget_show(palette_item); g_signal_connect_swapped(palette_item, "activate", G_CALLBACK(button_click), (gpointer)"button.palette"); //////////random_noise_item random_noise_item = gtk_menu_item_new_with_label("Random Noise"); gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), random_noise_item); gtk_widget_show(random_noise_item); g_signal_connect_swapped(random_noise_item, "activate", G_CALLBACK(button_click), (gpointer)"button.random_noise"); //////////from_clipboard_item from_clipboard_item = gtk_menu_item_new_with_label("From Clipboard"); gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), from_clipboard_item); gtk_widget_show(from_clipboard_item); g_signal_connect_swapped(from_clipboard_item, "activate", G_CALLBACK(button_click), (gpointer)"button.from_clipboard"); /////////generate_item generate_item = gtk_menu_item_new_with_label("Generate"); gtk_widget_show(generate_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item); ////////settings_menu settings_menu = gtk_menu_new(); ////////settings_item settings_item = gtk_menu_item_new_with_label("Settings"); gtk_widget_show(settings_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item); //////////FSD_checkbox FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox); gtk_widget_show(FSD_checkbox); //drop_down_menu init_drop_down_menu(); //hpaned #ifdef GTK2 hpaned = gtk_hpaned_new(); #else hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL); #endif gtk_widget_set_size_request (hpaned, 220, -1); gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show(hpaned); ////sc_buffer sc_buffer = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_buffer, 128 + 32, 512); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512); #endif gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE); gtk_widget_show(sc_buffer); //////list_vbox #ifdef GTK2 list_vbox = gtk_vbox_new(FALSE, 0); #else list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox); gtk_widget_show(list_vbox); ////sc_win sc_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4); gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); #endif gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE); gtk_widget_show(sc_win); //////image dimage = gdk_pixbuf_new_from_file("start.png", NULL); image = gtk_image_new(); gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image); gtk_widget_show(image); ////zoom_box #ifdef GTK2 zoom_box = gtk_hbox_new(FALSE, 0); #else zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #endif gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0); gtk_widget_show(zoom_box); //////zoom_button (+) zoom_button = gtk_button_new_with_label("+"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp"); gtk_widget_show(zoom_button); //////zoom_button (|) zoom_button = gtk_button_new_with_label("|"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome"); gtk_widget_show(zoom_button); //////zoom_button (-) zoom_button = gtk_button_new_with_label("-"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm"); gtk_widget_show(zoom_button); //icon gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico")); //display window gtk_widget_show (window); gtk_main(); //clean up free(colors); for(i = 0; i < BUFFER_COUNT; i++) free(mdata[i]); config_free(config); return 0; }
static gboolean avatar_image_button_press_event (GtkWidget *widget, GdkEventButton *event) { EmpathyAvatarImagePriv *priv; GtkWidget *popup; GtkWidget *frame; GtkWidget *image; gint x, y; gint popup_width, popup_height; gint width, height; GdkPixbuf *pixbuf; GtkAllocation allocation; priv = GET_PRIV (widget); if (priv->popup) { gtk_widget_destroy (priv->popup); priv->popup = NULL; } if (event->button != 1 || event->type != GDK_BUTTON_PRESS || !priv->pixbuf) { return FALSE; } popup_width = gdk_pixbuf_get_width (priv->pixbuf); popup_height = gdk_pixbuf_get_height (priv->pixbuf); gtk_widget_get_allocation (priv->image, &allocation); width = allocation.width; height = allocation.height; /* Don't show a popup if the popup is smaller then the currently avatar * image. */ if (popup_height <= height && popup_width <= width) { return TRUE; } pixbuf = tpaw_pixbuf_scale_down_if_necessary (priv->pixbuf, MAX_LARGE); popup_width = gdk_pixbuf_get_width (pixbuf); popup_height = gdk_pixbuf_get_height (pixbuf); popup = gtk_window_new (GTK_WINDOW_POPUP); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_container_add (GTK_CONTAINER (popup), frame); image = gtk_image_new (); gtk_container_add (GTK_CONTAINER (frame), image); gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf); g_object_unref (pixbuf); gdk_window_get_origin (gtk_widget_get_window (priv->image), &x, &y); x = x - (popup_width - width) / 2; y = y - (popup_height - height) / 2; gtk_window_move (GTK_WINDOW (popup), x, y); priv->popup = popup; gtk_widget_show_all (popup); return TRUE; }
void pidgin_log_show_contact(PurpleContact *contact) { struct log_viewer_hash_t *ht; PurpleBlistNode *child; PidginLogViewer *lv = NULL; GList *logs = NULL; GdkPixbuf *pixbuf; GtkWidget *image; const char *name = NULL; char *title; int total_log_size = 0; g_return_if_fail(contact != NULL); ht = g_new0(struct log_viewer_hash_t, 1); ht->type = PURPLE_LOG_IM; ht->contact = contact; if (log_viewers == NULL) { log_viewers = g_hash_table_new(log_viewer_hash, log_viewer_equal); } else if ((lv = g_hash_table_lookup(log_viewers, ht))) { gtk_window_present(GTK_WINDOW(lv->window)); g_free(ht); return; } for (child = contact->node.child ; child ; child = child->next) { if (!PURPLE_BLIST_NODE_IS_BUDDY(child)) continue; logs = g_list_concat(purple_log_get_logs(PURPLE_LOG_IM, ((PurpleBuddy *)child)->name, ((PurpleBuddy *)child)->account), logs); total_log_size += purple_log_get_total_size(PURPLE_LOG_IM, ((PurpleBuddy *)child)->name, ((PurpleBuddy *)child)->account); } logs = g_list_sort(logs, purple_log_compare); image = gtk_image_new(); pixbuf = gtk_widget_render_icon(image, PIDGIN_STOCK_STATUS_PERSON, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL), "GtkWindow"); if (pixbuf) { gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf); g_object_unref(pixbuf); } else { gtk_widget_destroy(image); image = NULL; } if (contact->alias != NULL) name = contact->alias; else if (contact->priority != NULL) name = purple_buddy_get_contact_alias(contact->priority); /* This will happen if the contact doesn't have an alias, * and none of the contact's buddies are online. * There is probably a better way to deal with this. */ if (name == NULL) { if (contact->node.child != NULL && PURPLE_BLIST_NODE_IS_BUDDY(contact->node.child)) name = purple_buddy_get_contact_alias((PurpleBuddy *) contact->node.child); if (name == NULL) name = ""; } title = g_strdup_printf(_("Conversations with %s"), name); display_log_viewer(ht, logs, title, image, total_log_size); g_free(title); }
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase) { wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase); GSList* radioGroup; switch ( tool->GetStyle() ) { case wxTOOL_STYLE_BUTTON: switch (tool->GetKind()) { case wxITEM_CHECK: tool->m_item = gtk_toggle_tool_button_new(); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; case wxITEM_RADIO: radioGroup = GetRadioGroup(pos); if (radioGroup) { // this is the first button in the radio button group, // it will be toggled automatically by GTK so bring the // internal flag in sync tool->Toggle(true); } tool->m_item = gtk_radio_tool_button_new(radioGroup); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; default: wxFAIL_MSG("unknown toolbar child type"); // fall through case wxITEM_DROPDOWN: case wxITEM_NORMAL: tool->m_item = gtk_tool_button_new(NULL, ""); g_signal_connect(tool->m_item, "clicked", G_CALLBACK(item_clicked), tool); break; } if (!HasFlag(wxTB_NOICONS)) { GtkWidget* image = gtk_image_new(); gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(tool->m_item), image); tool->SetImage(); gtk_widget_show(image); g_signal_connect(image, "expose_event", G_CALLBACK(image_expose_event), tool); } if (!tool->GetLabel().empty()) { gtk_tool_button_set_label( GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel())); // needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT gtk_tool_item_set_is_important(tool->m_item, true); } if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty()) { #if GTK_CHECK_VERSION(2, 12, 0) if (!gtk_check_version(2, 12, 0)) { gtk_tool_item_set_tooltip_text(tool->m_item, wxGTK_CONV(tool->GetShortHelp())); } else #endif { gtk_tool_item_set_tooltip(tool->m_item, m_tooltips, wxGTK_CONV(tool->GetShortHelp()), ""); } } g_signal_connect(GTK_BIN(tool->m_item)->child, "button_press_event", G_CALLBACK(button_press_event), tool); g_signal_connect(tool->m_item, "enter_notify_event", G_CALLBACK(enter_notify_event), tool); g_signal_connect(tool->m_item, "leave_notify_event", G_CALLBACK(enter_notify_event), tool); if (tool->GetKind() == wxITEM_DROPDOWN) tool->CreateDropDown(); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_SEPARATOR: tool->m_item = gtk_separator_tool_item_new(); if ( tool->IsStretchable() ) { gtk_separator_tool_item_set_draw ( GTK_SEPARATOR_TOOL_ITEM(tool->m_item), FALSE ); gtk_tool_item_set_expand(tool->m_item, TRUE); } gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_CONTROL: wxWindow* control = tool->GetControl(); if (control->m_widget->parent == NULL) AddChildGTK(control); tool->m_item = GTK_TOOL_ITEM(control->m_widget->parent->parent); if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos)) { g_object_ref(tool->m_item); gtk_container_remove( GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item)); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); g_object_unref(tool->m_item); } // Inserted items "slide" into place using an animated effect that // causes multiple size events on the item. Must set size request // to keep item size from getting permanently set too small by the // first of these size events. const wxSize size = control->GetSize(); gtk_widget_set_size_request(control->m_widget, size.x, size.y); break; } gtk_widget_show(GTK_WIDGET(tool->m_item)); InvalidateBestSize(); return true; }
void makeGUI() { GtkWidget *seperator; GtkWidget* vertbox; /** * Create the window and the main containter for all the widgets (topbox) **/ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(window), 5); topbox = gtk_vbox_new(FALSE, 0); /* * Build the left side of the panel first */ image = gtk_image_new(); gtk_widget_set_size_request(image, 320, 240); horbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(topbox), horbox, TRUE, TRUE, 0); vertbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(horbox), vertbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vertbox), image, TRUE, FALSE, 0); gtk_widget_show(vertbox); gtk_widget_show(image); if (options) { GtkWidget* frame; frame = gtk_frame_new("Wallpaper Settings"); optionBox = gtk_combo_box_new_text (); gtk_combo_box_append_text (GTK_COMBO_BOX (optionBox), "Scale To Fit"); gtk_combo_box_append_text (GTK_COMBO_BOX (optionBox), "Center"); gtk_combo_box_append_text (GTK_COMBO_BOX (optionBox), "Tile"); gtk_combo_box_set_active (GTK_COMBO_BOX (optionBox), 0); g_signal_connect (G_OBJECT (GTK_COMBO_BOX (optionBox)), "changed", G_CALLBACK (setOption), NULL); gtk_widget_show(optionBox); gtk_container_set_border_width (GTK_CONTAINER (frame), 2); gtk_container_add (GTK_CONTAINER (frame), optionBox); gtk_widget_show(frame); gtk_box_pack_start(GTK_BOX(vertbox), frame, TRUE, TRUE, 0); seperator = gtk_hseparator_new(); gtk_widget_show(seperator); } /** * Seperate the two sides, just for fun **/ seperator = gtk_vseparator_new(); gtk_widget_show(seperator); gtk_box_pack_start(GTK_BOX(horbox), seperator, TRUE, TRUE, 2); /** * Now make the right side of the panel. * This is where the list of wallpapers go (selectbox) * It is embed in a scrollable area, so the window isn't * twenty meters long **/ scrollable = gtk_scrolled_window_new (NULL, NULL); createTreeList(); gtk_widget_set_size_request(scrollable, 250, 240); gtk_container_add(GTK_CONTAINER(scrollable), selectBox); gtk_box_pack_start(GTK_BOX(horbox), scrollable, TRUE, TRUE, 0); gtk_widget_show(selectBox); gtk_widget_show(scrollable); gtk_widget_show(horbox); /* * Foo! */ horbox = gtk_hbox_new(TRUE, 0); seperator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(topbox), seperator, TRUE, TRUE, 2); gtk_widget_show(seperator); gtk_box_pack_start(GTK_BOX(topbox), horbox, FALSE, TRUE, 2); button = gtk_button_new_from_stock("gtk-apply"); gtk_box_pack_start(GTK_BOX(horbox), button, FALSE, TRUE, 10); gtk_widget_show(button); gtk_widget_show(horbox); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(delete_event), NULL); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(setWallpaper), "2"); button = gtk_button_new_from_stock("gtk-cancel"); gtk_box_pack_end(GTK_BOX(horbox), button, FALSE, TRUE, 10); gtk_widget_show(button); g_signal_connect_swapped (G_OBJECT (button), "clicked", G_CALLBACK (delete_event), G_OBJECT (window)); gtk_container_add(GTK_CONTAINER(window), topbox); gtk_widget_show(topbox); gtk_window_set_title (GTK_WINDOW (window), "CWallpaper Setter"); gtk_widget_show(window); gtk_widget_grab_focus(GTK_WIDGET(selectBox)); buildList(); return; }
/** * Cette fonction est la boucle principale du programme. * Elle permet de rassembler toutes les autres fonctions dans un contenu reflétant * le fonctionnement du programme. Pour comprendre le fonctionnement d'un programme, * lire le main() devrait suffire. * Dans notre cas en revanche ce n'est pas tout à fait exact, car gtk implique * une execution évènementielle, c'est à dire une éxécution basée sur les * évènements. Le programme ne se lit donc plus du haut vers le bas, mais en * fonction des évènements liés à des fonctions dites de callback, dans le fichier * libGUI.c. */ int main(int argc, char ** argv) { // Commençons par charger les préférences, si elles existent. On ouvre le fichier // en lecture pour charger la structure préférences : fichierPreferences = fopen(".olonoPrefs", "rb"); if (fichierPreferences == NULL) erreur("Pas de fichier de préférences trouvé\n"); else { // On lit 1 élément de donnée de longueur preferences depuis le fichier // fPreferences pour le stocker dans la variable prefs (de type preferences) fread(&prefs,sizeof(preferences),1,fichierPreferences); /// INIT 2 : Préférences globales (from file) couleurDepart = prefs.couleurDepart; allowIA = prefs.allowIA; couleurIA = prefs.couleurIA; affJouable = prefs.affJouable; taillePlateau = prefs.taillePlateau; if (args.verbose) ecrire("Chargement de :\n\t couleurDepart: %d, allowIA : %d\n\t couleurIA : %d, taillePlateau: %d",couleurDepart,allowIA,couleurIA,taillePlateau); } /* On initialise les arguments à leur valeur par défaut */ args.taillePlateau = 0; args.verbose = 0; args.Tore = 0; /* This is where the magic should happen | Attention, instant magique ... */ argp_parse (&argp, argc, argv, 0, 0, &args); /// INIT 3 : Préférences globales (from) if (args.taillePlateau != 0) if (atoi((char*) args.taillePlateau) <= 25 && atoi((char*) args.taillePlateau) >= 4) taillePlateau = atoi((char*) args.taillePlateau); /// Les 3 priorités d'initialisation étant terminées, on peut désormais // assigner la couleur de départ du jeton : jeton = couleurDepart; /// ######################################################################## /// /// ### On commence les choses sérieuses ici (cad le main) ################# /// /// ######################################################################## /// gint i=0,j=0,n=0; CASE caseActuelle[625]; wOlono = g_malloc(sizeof(window)); plateau = createPlateau(); initPlateau(plateau); tronc = initHistorique(plateau,couleurDepart); /// ######################################################################## /// /// ### On fait chauffer l'Interface Graphique ############################# /// /// ######################################################################## /// GladeXML *xml; /* Initialisation de la lib GTK+ */ gtk_init(&argc, &argv); /* load the interface and complete it with the variable pieces */ xml = glade_xml_new(DATADIR "/" GLADEDIR "/" GLADEFILE, NULL, NULL); /* connect the signals in the interface */ glade_xml_signal_autoconnect(xml); /* // timer up*/ /* wOlono->pIAClock = g_timer_new();*/ /* g_timer_start(wOlono->pIAClock);*/ // get the main Window wOlono->pWindow = glade_xml_get_widget(xml, "olonoWindow"); gtk_window_set_title(GTK_WINDOW (wOlono->pWindow), "OloNO v" VERSION); // get checkBoxes, and set their values wOlono->pCheckAllowIA = glade_xml_get_widget(xml, "allowIA"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckAllowIA),allowIA); wOlono->pCheckiaIsBlack = glade_xml_get_widget(xml, "iaIsBlack"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckiaIsBlack),couleurIA); wOlono->pCheckAffJouable = glade_xml_get_widget(xml, "showPossibleMoves"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckAffJouable),affJouable); wOlono->pCheckCouleurDeb = glade_xml_get_widget(xml, "whiteStart"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (wOlono->pCheckCouleurDeb),!couleurDepart); // also get the spin button and set the default value : wOlono->pSpinTT = glade_xml_get_widget(xml, "taillePlateau"); gtk_spin_button_set_value(GTK_SPIN_BUTTON (wOlono->pSpinTT),taillePlateau); // why not speak to the prefs window too ? wOlono->pPrefWindow = glade_xml_get_widget(xml, "olonoPreferences"); // get the status bar : wOlono->pStatusBar = glade_xml_get_widget(xml, "barreDesTaches"); // creating context ids : wOlono->contextId01 = gtk_statusbar_get_context_id(GTK_STATUSBAR(wOlono->pStatusBar), "MsgTour"); wOlono->contextId02 = gtk_statusbar_get_context_id(GTK_STATUSBAR(wOlono->pStatusBar), "MsgScore"); // creating first blank message for contextId01 : gtk_statusbar_push (GTK_STATUSBAR (wOlono->pStatusBar), GPOINTER_TO_INT(wOlono->contextId01),"Bienvenue - Youkoso"); // On s'occupe de charger les images en mémoire : wOlono->imgVide = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGVIDE,&wOlono->gerror); wOlono->imgBlanche = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGBLANCHE,&wOlono->gerror); wOlono->imgNoire = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGNOIRE,&wOlono->gerror); wOlono->imgJoker = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGJOKER,&wOlono->gerror); // Puis on créé les dérivées transparentes : wOlono->imgTransBlanche = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGTBLANCHE,&wOlono->gerror); wOlono->imgTransNoire = gdk_pixbuf_new_from_file(DATADIR "/" IMGDIR "/" IMGTNOIRE,&wOlono->gerror); // set the plateau. wOlono->pPlateau = gtk_table_new(taillePlateau,taillePlateau,TRUE); for (i=0;i<taillePlateau;i++) { for (j=0;j<taillePlateau;j++) { n=i*taillePlateau+j; wOlono->pImage[n] = gtk_image_new(); wOlono->pEvent[n] = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (wOlono->pEvent[n]), wOlono->pImage[n]); // Important : On place le gtk_event_box au dessus sinon on peut pas // recevoir des évènements, puisqu'il est caché par l'image. gtk_event_box_set_above_child (GTK_EVENT_BOX (wOlono->pEvent[n]),1); // On rempli caseActuelle : caseActuelle[n].x = i; caseActuelle[n].y = j; // On connecte chaque signal à la fonction callback : g_signal_connect (G_OBJECT (wOlono->pEvent[n]), "button_press_event", G_CALLBACK (on_case_clic), &caseActuelle[n]); gtk_table_attach_defaults (GTK_TABLE (wOlono->pPlateau), wOlono->pEvent[n], i, i+1, j, j+1); } } /* Rafraichit le plateau (fait concorder celui en mémoire et celui affiché) */ refreshBoard(plateau); wOlono->pContainer = glade_xml_get_widget(xml, "cadreAspect"); gtk_container_add(GTK_CONTAINER(wOlono->pContainer), wOlono->pPlateau); /* For all the abandonned widgets ie plateau */ gtk_widget_show_all (wOlono->pPlateau); /* start the event loop */ gtk_main(); return 0; }
void wxAnyButton::DoSetBitmap(const wxBitmap& bitmap, State which) { switch ( which ) { case State_Normal: if ( DontShowLabel() ) { // we only have the bitmap in this button, never remove it but // do invalidate the best size when the bitmap (and presumably // its size) changes InvalidateBestSize(); } // normal image is special: setting it enables images for the button and // resetting it to nothing disables all of them else { GtkWidget *image = gtk_button_get_image(GTK_BUTTON(m_widget)); if ( image && !bitmap.IsOk() ) { gtk_container_remove(GTK_CONTAINER(m_widget), image); } else if ( !image && bitmap.IsOk() ) { image = gtk_image_new(); gtk_button_set_image(GTK_BUTTON(m_widget), image); } else // image presence or absence didn't change { // don't invalidate best size below break; } InvalidateBestSize(); } break; case State_Pressed: if ( bitmap.IsOk() ) { if ( !m_bitmaps[which].IsOk() ) { // we need to install the callbacks to be notified about // the button pressed state change g_signal_connect ( m_widget, "pressed", G_CALLBACK(wxgtk_button_press_callback), this ); g_signal_connect ( m_widget, "released", G_CALLBACK(wxgtk_button_released_callback), this ); } } else // no valid bitmap { if ( m_bitmaps[which].IsOk() ) { // we don't need to be notified about the button pressed // state changes any more g_signal_handlers_disconnect_by_func ( m_widget, (gpointer)wxgtk_button_press_callback, this ); g_signal_handlers_disconnect_by_func ( m_widget, (gpointer)wxgtk_button_released_callback, this ); // also make sure we don't remain stuck in pressed state if ( m_isPressed ) { m_isPressed = false; GTKUpdateBitmap(); } } } break; case State_Current: // the logic here is the same as above for State_Pressed: we need // to connect the handlers if we must be notified about the changes // in the button current state and we disconnect them when/if we // don't need them any more if ( bitmap.IsOk() ) { if ( !m_bitmaps[which].IsOk() ) { g_signal_connect ( m_widget, "enter", G_CALLBACK(wxgtk_button_enter_callback), this ); g_signal_connect ( m_widget, "leave", G_CALLBACK(wxgtk_button_leave_callback), this ); } } else // no valid bitmap { if ( m_bitmaps[which].IsOk() ) { g_signal_handlers_disconnect_by_func ( m_widget, (gpointer)wxgtk_button_enter_callback, this ); g_signal_handlers_disconnect_by_func ( m_widget, (gpointer)wxgtk_button_leave_callback, this ); if ( m_isCurrent ) { m_isCurrent = false; GTKUpdateBitmap(); } } } break; case State_Focused: if ( bitmap.IsOk() ) { Connect(wxEVT_SET_FOCUS, wxFocusEventHandler(wxAnyButton::GTKOnFocus)); Connect(wxEVT_KILL_FOCUS, wxFocusEventHandler(wxAnyButton::GTKOnFocus)); } else // no valid focused bitmap { Disconnect(wxEVT_SET_FOCUS, wxFocusEventHandler(wxAnyButton::GTKOnFocus)); Disconnect(wxEVT_KILL_FOCUS, wxFocusEventHandler(wxAnyButton::GTKOnFocus)); } break; default: // no callbacks to connect/disconnect ; } m_bitmaps[which] = bitmap; // update the bitmap immediately if necessary, otherwise it will be done // when the bitmap for the corresponding state is needed the next time by // GTKUpdateBitmap() if ( bitmap.IsOk() && which == GTKGetCurrentState() ) { GTKDoShowBitmap(bitmap); } }