JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkWindow_gtk_1window_1set_1default ( JNIEnv* env, jclass cls, jlong _self, jlong _defaultWidget ) { GtkWindow* self; GtkWidget* defaultWidget; // convert parameter self self = (GtkWindow*) _self; // convert parameter defaultWidget defaultWidget = (GtkWidget*) _defaultWidget; // call function gtk_window_set_default(self, defaultWidget); // cleanup parameter self // cleanup parameter defaultWidget }
void html_diag_finish(Thtml_diag * dg, GCallback ok_func) { GtkWidget *align, *hbox; align = gtk_alignment_new(0.5, 1.0, 1.0, 0.0); gtk_alignment_set_padding(GTK_ALIGNMENT(align), 12, 0, 0, 0); #if GTK_CHECK_VERSION(3,0,0) hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); #else hbox = gtk_hbutton_box_new(); #endif gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbox), 12); gtk_container_add(GTK_CONTAINER(align), hbox); dg->obut = bf_stock_ok_button(ok_func, dg); dg->cbut = bf_stock_cancel_button(G_CALLBACK(html_diag_cancel_clicked_cb), dg); gtk_box_pack_start(GTK_BOX(hbox), dg->cbut, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), dg->obut, FALSE, FALSE, 0); gtk_window_set_default(GTK_WINDOW(dg->dialog), dg->obut); gtk_box_pack_start(GTK_BOX(dg->vbox), align, FALSE, FALSE, 0); gtk_widget_show_all(GTK_WIDGET(dg->dialog)); }
static void contacts_edit_pane_hide (ContactsData *data) { GtkWidget *widget; GtkWindow *window; /* All changed are instant-apply, so just remove the edit components * and switch back to main view. */ window = GTK_WINDOW (data->ui->main_window); widget = data->ui->edit_table; gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback)contacts_remove_edit_widgets_cb, widget); if ((widget = data->ui->contact_menu)) gtk_widget_hide (widget); if ((widget = data->ui->contacts_menu)) gtk_widget_show (widget); widget = data->ui->main_notebook; gtk_notebook_set_current_page (GTK_NOTEBOOK (widget), 0); gtk_window_set_title (window, _("Contacts")); contacts_set_available_options (data, TRUE, TRUE, TRUE); if (data->ui->edit_button) gtk_window_set_default (window, data->ui->edit_button); if ((widget = data->ui->search_entry) && GTK_WIDGET_VISIBLE (widget)) gtk_window_set_focus (window, data->ui->search_entry); }
void empathy_contact_information_dialog_show (EmpathyContact *contact, GtkWindow *parent) { GtkWidget *dialog; GtkWidget *button; GtkWidget *contact_widget; GList *l; g_return_if_fail (EMPATHY_IS_CONTACT (contact)); l = g_list_find_custom (information_dialogs, contact, (GCompareFunc) contact_dialogs_find); if (l) { gtk_window_present (GTK_WINDOW (l->data)); return; } /* Create dialog */ dialog = gtk_dialog_new (); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_title (GTK_WINDOW (dialog), empathy_contact_get_name (contact)); /* Close button */ button = gtk_button_new_with_label (GTK_STOCK_CLOSE); gtk_button_set_use_stock (GTK_BUTTON (button), TRUE); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, GTK_RESPONSE_CLOSE); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_window_set_default (GTK_WINDOW (dialog), button); gtk_widget_show (button); /* Contact info widget */ contact_widget = empathy_contact_widget_new (contact, EMPATHY_CONTACT_WIDGET_SHOW_LOCATION | EMPATHY_CONTACT_WIDGET_EDIT_NONE); gtk_container_set_border_width (GTK_CONTAINER (contact_widget), 8); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), contact_widget, TRUE, TRUE, 0); gtk_widget_show (contact_widget); g_object_set_data (G_OBJECT (dialog), "contact_widget", contact_widget); information_dialogs = g_list_prepend (information_dialogs, dialog); g_signal_connect (dialog, "response", G_CALLBACK (contact_dialogs_response_cb), &information_dialogs); if (parent) { gtk_window_set_transient_for (GTK_WINDOW (dialog), parent); } gtk_widget_show (dialog); }
GtkWidget * applet_mobile_password_dialog_new (NMDevice *device, NMConnection *connection, GtkEntry **out_secret_entry) { GtkDialog *dialog; GtkWidget *w; GtkBox *box; char *dev_str; NMSettingConnection *s_con; char *tmp; const char *id; dialog = GTK_DIALOG (gtk_dialog_new ()); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_window_set_title (GTK_WINDOW (dialog), _("Mobile broadband network password")); w = gtk_dialog_add_button (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT); w = gtk_dialog_add_button (dialog, GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default (GTK_WINDOW (dialog), w); s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); id = nm_setting_connection_get_id (s_con); g_assert (id); tmp = g_strdup_printf (_("A password is required to connect to '%s'."), id); w = gtk_label_new (tmp); g_free (tmp); gtk_box_pack_start (GTK_BOX (dialog->vbox), w, TRUE, TRUE, 0); dev_str = g_strdup_printf ("<b>%s</b>", utils_get_device_description (device)); w = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (w), dev_str); g_free (dev_str); gtk_box_pack_start (GTK_BOX (dialog->vbox), w, TRUE, TRUE, 0); w = gtk_alignment_new (0.5, 0.5, 0, 1.0); gtk_box_pack_start (GTK_BOX (dialog->vbox), w, TRUE, TRUE, 0); box = GTK_BOX (gtk_hbox_new (FALSE, 6)); gtk_container_set_border_width (GTK_CONTAINER (box), 6); gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (box)); gtk_box_pack_start (box, gtk_label_new (_("Password:")), FALSE, FALSE, 0); w = gtk_entry_new (); *out_secret_entry = GTK_ENTRY (w); gtk_entry_set_activates_default (GTK_ENTRY (w), TRUE); gtk_box_pack_start (box, w, FALSE, FALSE, 0); gtk_widget_show_all (dialog->vbox); return GTK_WIDGET (dialog); }
void empathy_contact_personal_dialog_show (GtkWindow *parent) { GtkWidget *button; GtkWidget *contact_widget; if (personal_dialog) { gtk_window_present (GTK_WINDOW (personal_dialog)); return; } /* Create dialog */ personal_dialog = gtk_dialog_new (); gtk_dialog_set_has_separator (GTK_DIALOG (personal_dialog), FALSE); gtk_window_set_resizable (GTK_WINDOW (personal_dialog), FALSE); gtk_window_set_title (GTK_WINDOW (personal_dialog), _("Personal Information")); /* Close button */ button = gtk_button_new_with_label (GTK_STOCK_CLOSE); gtk_button_set_use_stock (GTK_BUTTON (button), TRUE); gtk_dialog_add_action_widget (GTK_DIALOG (personal_dialog), button, GTK_RESPONSE_CLOSE); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_window_set_default (GTK_WINDOW (personal_dialog), button); gtk_widget_show (button); /* Contact info widget */ contact_widget = empathy_contact_widget_new (NULL, EMPATHY_CONTACT_WIDGET_EDIT_ACCOUNT | EMPATHY_CONTACT_WIDGET_EDIT_ALIAS | EMPATHY_CONTACT_WIDGET_EDIT_AVATAR); gtk_container_set_border_width (GTK_CONTAINER (contact_widget), 8); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (personal_dialog)->vbox), contact_widget, TRUE, TRUE, 0); empathy_contact_widget_set_account_filter (contact_widget, empathy_account_chooser_filter_is_connected, NULL); gtk_widget_show (contact_widget); g_signal_connect (personal_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_object_add_weak_pointer (G_OBJECT (personal_dialog), (gpointer) &personal_dialog); if (parent) { gtk_window_set_transient_for (GTK_WINDOW (personal_dialog), parent); } gtk_widget_show (personal_dialog); }
void gui_set_state(const enum gui_state_e state) { g_assert(GUI_STATE_IS_VALID(state)); gui_priv.state = state; if (gui_get_view() == GUI_VIEW_TEXT) return; const bool busy = (state == GUI_STATE_BUSY); gtk_widget_set_visible(GTK_WIDGET(gui.button_hash), !busy); gtk_widget_set_visible(GTK_WIDGET(gui.button_stop), busy); gtk_progress_bar_set_fraction(gui.progressbar, 0.0); gtk_widget_set_visible(GTK_WIDGET(gui.progressbar), busy); gtk_widget_set_sensitive(GTK_WIDGET(gui.hbox_input), !busy); gtk_widget_set_sensitive(GTK_WIDGET(gui.hbox_output), !busy); gtk_widget_set_sensitive(GTK_WIDGET(gui.toolbar), !busy); gtk_widget_set_sensitive(GTK_WIDGET(gui.treeview), !busy); gtk_widget_set_sensitive(GTK_WIDGET(gui.radiomenuitem_text), !busy); gtk_widget_set_sensitive(GTK_WIDGET(gui.radiomenuitem_file), !busy); gtk_widget_set_sensitive(GTK_WIDGET(gui.radiomenuitem_file_list), !busy); gtk_widget_set_sensitive(GTK_WIDGET(gui.dialog_table), !busy); gtk_widget_set_sensitive(GTK_WIDGET(gui.dialog_combobox), !busy); if (busy) { gtk_window_set_default(gui.window, GTK_WIDGET(gui.button_stop)); gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_save_as), false); } else { gtk_window_set_default(gui.window, GTK_WIDGET(gui.button_hash)); // User may already have menu open, so make sure save_as gets updated g_signal_emit_by_name(gui.menuitem_file, "activate"); } }
extern void usage_popup(GtkAction *action, gpointer user_data) { GtkWidget *table = gtk_table_new(1, 1, FALSE); GtkWidget *label = NULL; GtkWidget *popup = gtk_dialog_new_with_buttons( "Usage", GTK_WINDOW(user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); char *help_msg = "sview can be used to view and modify many of SLURM's\n" "records.\n\n" "Tabs are used to select the data type to work with.\n" "Right click on the tab to select it. Left click on\n" "the tab to control the fields of the table to be\n" "displayed. Those fields can then be re-ordered or used\n" "for sorting the records.\n\n" "Left click on a record to see the compute nodes\n" "associated with it. Right click on a record to modify\n" "it. The colored boxes represent compute nodes associated\n" "with each job, partition, etc. and may also selected\n" "with right and left buttons.\n\n" "Select 'Option' then 'Admin mode' to enable editing\n" "of the records.\n"; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_window_set_default_size(GTK_WINDOW(popup), 200, 50); label = gtk_label_new(help_msg); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), table, FALSE, FALSE, 0); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); gtk_widget_show_all(popup); (void) gtk_dialog_run (GTK_DIALOG(popup)); gtk_widget_destroy(popup); return; }
static GtkWidget * ask_for_pin (GtkEntry **out_secret_entry) { GtkDialog *dialog; GtkWidget *w = NULL, *ok_button = NULL; GtkBox *box = NULL, *vbox = NULL; dialog = GTK_DIALOG (gtk_dialog_new ()); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_window_set_title (GTK_WINDOW (dialog), _("PIN code required")); ok_button = gtk_dialog_add_button (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT); ok_button = gtk_dialog_add_button (dialog, GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default (GTK_WINDOW (dialog), ok_button); vbox = GTK_BOX (gtk_dialog_get_content_area (dialog)); w = gtk_label_new (_("PIN code is needed for the mobile broadband device")); gtk_box_pack_start (vbox, w, TRUE, TRUE, 0); w = gtk_alignment_new (0.5, 0.5, 0, 1.0); gtk_box_pack_start (vbox, w, TRUE, TRUE, 0); #if GTK_CHECK_VERSION(3,1,6) box = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6)); #else box = GTK_BOX (gtk_hbox_new (FALSE, 6)); #endif gtk_container_set_border_width (GTK_CONTAINER (box), 6); gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (box)); gtk_box_pack_start (box, gtk_label_new ("PIN:"), FALSE, FALSE, 0); w = gtk_entry_new (); *out_secret_entry = GTK_ENTRY (w); gtk_entry_set_max_length (GTK_ENTRY (w), 8); gtk_entry_set_width_chars (GTK_ENTRY (w), 8); gtk_entry_set_activates_default (GTK_ENTRY (w), TRUE); gtk_entry_set_visibility (GTK_ENTRY (w), FALSE); gtk_box_pack_start (box, w, FALSE, FALSE, 0); g_signal_connect (w, "changed", G_CALLBACK (pin_entry_changed), ok_button); pin_entry_changed (GTK_EDITABLE (w), ok_button); gtk_widget_show_all (GTK_WIDGET (vbox)); return GTK_WIDGET (dialog); }
void html_diag_finish(Thtml_diag *dg, GtkSignalFunc ok_func) { GtkWidget *hbox; gtk_box_pack_start(GTK_BOX(dg->vbox), gtk_hseparator_new(), FALSE, FALSE, 12); hbox = gtk_hbutton_box_new(); gtk_hbutton_box_set_layout_default(GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbox), 12); dg->obut = bf_stock_ok_button(ok_func, dg); dg->cbut = bf_stock_cancel_button(G_CALLBACK(html_diag_cancel_clicked_cb), dg); gtk_box_pack_start(GTK_BOX(hbox),dg->cbut , FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox),dg->obut , FALSE, FALSE, 0); gtk_window_set_default(GTK_WINDOW(dg->dialog), dg->obut); gtk_box_pack_start(GTK_BOX(dg->vbox), hbox, FALSE, FALSE, 0); gtk_widget_show_all(GTK_WIDGET(dg->dialog)); }
static void thunar_location_dialog_init (ThunarLocationDialog *location_dialog) { GtkWidget *cancel_button; GtkWidget *open_button; GtkWidget *hbox; GtkWidget *label; gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (location_dialog)->vbox), 2); gtk_container_set_border_width (GTK_CONTAINER (location_dialog), 5); gtk_dialog_set_has_separator (GTK_DIALOG (location_dialog), FALSE); gtk_window_set_default_size (GTK_WINDOW (location_dialog), 350, -1); gtk_window_set_title (GTK_WINDOW (location_dialog), _("Open Location")); cancel_button = gtk_dialog_add_button (GTK_DIALOG (location_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); open_button = gtk_dialog_add_button (GTK_DIALOG (location_dialog), GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT); gtk_window_set_default (GTK_WINDOW (location_dialog), open_button); hbox = g_object_new (GTK_TYPE_HBOX, "border-width", 5, "spacing", 12, NULL); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (location_dialog)->vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("_Location:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); location_dialog->entry = thunar_path_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (location_dialog->entry), TRUE); gtk_box_pack_start (GTK_BOX (hbox), location_dialog->entry, TRUE, TRUE, 0); thunar_gtk_label_set_a11y_relation (GTK_LABEL (label), location_dialog->entry); gtk_label_set_mnemonic_widget (GTK_LABEL (label), location_dialog->entry); gtk_widget_show (location_dialog->entry); /* the "Open" button is only sensitive if a valid file is entered */ exo_binding_new_full (G_OBJECT (location_dialog->entry), "current-file", G_OBJECT (open_button), "sensitive", transform_object_to_boolean, NULL, NULL); }
static void gw_addvocabularywindow_constructed (GObject *object) { //Declarations GwAddVocabularyWindow *window; GwAddVocabularyWindowPrivate *priv; //Chain the parent class { G_OBJECT_CLASS (gw_addvocabularywindow_parent_class)->constructed (object); } //Initializations window = GW_ADDVOCABULARYWINDOW (object); priv = window->priv; //Set up the gtkbuilder links priv->kanji_entry = GTK_ENTRY (gw_window_get_object (GW_WINDOW (window), "kanji_entry")); priv->furigana_entry = GTK_ENTRY (gw_window_get_object (GW_WINDOW (window), "furigana_entry")); priv->definitions_textview = GTK_TEXT_VIEW (gw_window_get_object (GW_WINDOW (window), "definitions_textview")); priv->cancel_button = GTK_BUTTON (gw_window_get_object (GW_WINDOW (window), "cancel_button")); priv->add_button = GTK_BUTTON (gw_window_get_object (GW_WINDOW (window), "add_button")); priv->vocabulary_list_combobox = GTK_COMBO_BOX (gw_window_get_object (GW_WINDOW (window), "vocabulary_list_combobox")); //Set up the gtk window gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_default_size (GTK_WINDOW (window), 500, 250); gtk_window_set_icon_name (GTK_WINDOW (window), "gwaei"); gtk_window_set_title (GTK_WINDOW (window), gettext("Add Vocabulary Word...")); gtk_window_set_resizable (GTK_WINDOW (window), TRUE); gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), TRUE); gtk_window_set_skip_pager_hint (GTK_WINDOW (window), TRUE); gtk_window_set_destroy_with_parent (GTK_WINDOW (window), FALSE); gtk_window_set_modal (GTK_WINDOW (window), TRUE); gtk_window_set_default (GTK_WINDOW (window), GTK_WIDGET (priv->add_button)); gw_addvocabularywindow_init_accelerators (window); gw_addvocabularywindow_init_combobox (window); gw_window_unload_xml (GW_WINDOW (window)); }
extern void about_popup(GtkAction *action, gpointer user_data) { GtkWidget *table = gtk_table_new(1, 1, FALSE); GtkWidget *label = NULL; GtkWidget *popup = gtk_dialog_new_with_buttons( "About", GTK_WINDOW(user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); char *version = NULL; version = xstrdup_printf("SLURM Version: %s", SLURM_VERSION_STRING); label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_window_set_default_size(GTK_WINDOW(popup), 200, 50); label = gtk_label_new(version); xfree(version); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), table, FALSE, FALSE, 0); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); gtk_widget_show_all(popup); (void) gtk_dialog_run (GTK_DIALOG(popup)); gtk_widget_destroy(popup); return; }
static void empathy_individual_edit_dialog_init ( EmpathyIndividualEditDialog *dialog) { GtkWidget *button; EmpathyIndividualEditDialogPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE ( dialog, EMPATHY_TYPE_INDIVIDUAL_EDIT_DIALOG, EmpathyIndividualEditDialogPriv); dialog->priv = priv; priv->individual = NULL; gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_title (GTK_WINDOW (dialog), _("Edit Contact Information")); /* Individual widget */ priv->individual_widget = empathy_individual_widget_new (priv->individual, EMPATHY_INDIVIDUAL_WIDGET_EDIT_ALIAS | EMPATHY_INDIVIDUAL_WIDGET_EDIT_GROUPS | EMPATHY_INDIVIDUAL_WIDGET_EDIT_FAVOURITE); gtk_container_set_border_width (GTK_CONTAINER (priv->individual_widget), 8); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area ( GTK_DIALOG (dialog))), priv->individual_widget, TRUE, TRUE, 0); gtk_widget_show (priv->individual_widget); /* Close button */ button = gtk_button_new_with_label (GTK_STOCK_CLOSE); gtk_button_set_use_stock (GTK_BUTTON (button), TRUE); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, GTK_RESPONSE_CLOSE); gtk_widget_set_can_default (button, TRUE); gtk_window_set_default (GTK_WINDOW (dialog), button); gtk_widget_show (button); g_signal_connect (dialog, "response", G_CALLBACK (individual_dialogs_response_cb), &edit_dialogs); }
/* ****************************************************************** * */ gint create_route_cb (GtkWidget * widget, guint datum) { GtkWidget *window; gchar *tabeltitel1[] = { "#", _("Waypoint"), _("Latitude"), _("Longitude"), _("Distance"), NULL }; GtkWidget *scrwindow, *vbox, *button, *button3, *hbox, *hbox_displays, *l1; gint i, j; gchar *text[5], text0[20], text1[20], text2[20], text3[20]; GtkTooltips *tooltips; route.edit = TRUE; window = gtk_dialog_new (); routewindow = window; /* gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, TRUE); */ gtk_window_set_title (GTK_WINDOW (window), _("Define route")); gtk_window_set_default_size (GTK_WINDOW (window), 320, 320); myroutelist = gtk_clist_new_with_titles (5, tabeltitel1); gtk_signal_connect (GTK_OBJECT (GTK_CLIST (myroutelist)), "select-row", GTK_SIGNAL_FUNC (setroutetarget), GTK_OBJECT (myroutelist)); select_route_button = gtk_button_new_with_label (_("Start route")); gtk_widget_set_sensitive (select_route_button, FALSE); GTK_WIDGET_SET_FLAGS (select_route_button, GTK_CAN_DEFAULT); gtk_signal_connect (GTK_OBJECT (select_route_button), "clicked", GTK_SIGNAL_FUNC (do_route_cb), 0); gtk_window_set_default (GTK_WINDOW (window), select_route_button); create_route2_button = gtk_button_new_with_label (_("Take all WP as route")); GTK_WIDGET_SET_FLAGS (create_route2_button, GTK_CAN_DEFAULT); gtk_signal_connect (GTK_OBJECT (create_route2_button), "clicked", GTK_SIGNAL_FUNC (insertallroutepoints), 0); button = gtk_button_new_with_label (_("Abort route")); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (sel_routecancel_cb), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC (sel_routeclose_cb), GTK_OBJECT (window)); /* button3 = gtk_button_new_with_label (_("Close")); */ button3 = gtk_button_new_from_stock (GTK_STOCK_CLOSE); GTK_WIDGET_SET_FLAGS (button3, GTK_CAN_DEFAULT); gtk_signal_connect_object (GTK_OBJECT (button3), "clicked", GTK_SIGNAL_FUNC (sel_routeclose_cb), GTK_OBJECT (window)); /* Font �ndern falls PDA-Mode und Touchscreen */ if (local_config.guimode == GUI_PDA) { if (onemousebutton) { /* Change default font throughout the widget */ PangoFontDescription *font_desc; font_desc = pango_font_description_from_string ("Sans 10"); gtk_widget_modify_font (myroutelist, font_desc); pango_font_description_free (font_desc); } } gtk_clist_set_column_justification (GTK_CLIST (myroutelist), 4, GTK_JUSTIFY_RIGHT); gtk_clist_set_column_justification (GTK_CLIST (myroutelist), 0, GTK_JUSTIFY_RIGHT); gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 0, TRUE); gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 1, TRUE); gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 2, TRUE); gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 3, TRUE); gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 4, TRUE); scrwindow = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrwindow), myroutelist); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrwindow), (GtkPolicyType) GTK_POLICY_AUTOMATIC, (GtkPolicyType) GTK_POLICY_AUTOMATIC); vbox = gtk_vbox_new (FALSE, 2); /* gtk_container_add (GTK_CONTAINER (window), vbox); */ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (vbox), scrwindow, TRUE, TRUE, 2); hbox = gtk_hbox_new (TRUE, 2); hbox_displays = gtk_hbox_new (TRUE, 2); if (!route.active) l1 = gtk_label_new (_ ("Click on waypoints list\nto add waypoints")); else l1 = gtk_label_new (_ ("Click on list item\nto select next waypoint")); gtk_box_pack_start (GTK_BOX (vbox), l1, FALSE, FALSE, 2); /* gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2); */ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), hbox, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), select_route_button, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), create_route2_button, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox_displays, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (hbox), button3, TRUE, TRUE, 2); gtk_widget_set_sensitive (create_route_button, FALSE); if (route.active) { gtk_widget_set_sensitive (select_route_button, FALSE); gtk_clist_clear (GTK_CLIST (myroutelist)); for (i = 0; i < route.items; i++) { (routelist + i)->dist = calcdist ((routelist + i)->lon, (routelist + i)->lat); text[1] = (routelist + i)->name; g_snprintf (text0, sizeof (text0), "%d", i + 1); g_snprintf (text1, sizeof (text1), "%8.5f", (routelist + i)->lat); g_snprintf (text2, sizeof (text2), "%8.5f", (routelist + i)->lon); g_snprintf (text3, sizeof (text3), "%9.3f", (routelist + i)->dist); text[0] = text0; text[2] = text1; text[3] = text2; text[4] = text3; j = gtk_clist_append (GTK_CLIST (myroutelist), (gchar **) text); gtk_clist_set_foreground (GTK_CLIST (myroutelist), j, &colors.black); } } else route.items = 0; tooltips = gtk_tooltips_new (); gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), create_route2_button, _ ("Create a route from all waypoints. Sorted with order in file, not distance."), NULL); gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), select_route_button, _ ("Click here to start your journey. GpsDrive guides you through the waypoints in this list."), NULL); gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), button, _("Abort your journey"), NULL); gtk_widget_show_all (window); return TRUE; }
static void _setup_ui (OlPlayerChooser *window) { OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window); gtk_container_set_border_width (GTK_CONTAINER (window), WINDOW_BORDER_SIZE); /* Setup info widgets */ priv->info_label = GTK_LABEL (gtk_label_new (NULL)); gtk_label_set_line_wrap (priv->info_label, TRUE); gtk_misc_set_alignment (GTK_MISC (priv->info_label), 0.0, 0.0); priv->info_icon = GTK_IMAGE (gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG)); GtkWidget *info_box = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (info_box), GTK_WIDGET (priv->info_icon), FALSE, /* expand */ FALSE, /* fill */ 0); gtk_box_pack_start (GTK_BOX (info_box), GTK_WIDGET (priv->info_label), TRUE, /* expand */ TRUE, /* fill */ 0); /* Setup app choosers */ priv->page_button_panel = GTK_BOX (gtk_hbox_new (FALSE, 0)); priv->chooser_panel = GTK_BOX (gtk_hbox_new (FALSE, 0)); _new_page (window, _("Supported players")); _new_page (window, _("All players")); _set_apps_to_page (window, ALL_CHOOSER_INDEX, g_app_info_get_all_for_type ("audio/mp3")); GtkWidget *apps_frame = gtk_frame_new (_("Choose a player to launch")); GtkBox *page_vbox = GTK_BOX (gtk_vbox_new (FALSE, 0)); gtk_widget_show (GTK_WIDGET (page_vbox)); gtk_box_pack_start (page_vbox, GTK_WIDGET (priv->page_button_panel), FALSE, /* expand */ FALSE, /* fill */ 0); /* padding */ gtk_box_pack_end (page_vbox, GTK_WIDGET (priv->chooser_panel), FALSE, /* expand */ FALSE, /* fill */ 0); /* padding */ gtk_container_add (GTK_CONTAINER (apps_frame), GTK_WIDGET (page_vbox)); /* Setup custom command */ priv->custom_cmd_panel = GTK_BOX (gtk_hbox_new (FALSE, 5)); GtkWidget *cmd_label = gtk_label_new (_("Use command:")); GtkWidget *cmd_entry = gtk_entry_new (); priv->cmd_entry = GTK_ENTRY (cmd_entry); gtk_entry_set_activates_default (priv->cmd_entry, TRUE); gtk_entry_set_completion (priv->cmd_entry, _new_bin_completion ()); GtkWidget *launch_button = gtk_button_new_with_label (_("Launch")); gtk_widget_set_can_default (launch_button, TRUE); gtk_window_set_default (GTK_WINDOW (window), launch_button); priv->launch_button = launch_button; g_signal_connect (launch_button, "clicked", G_CALLBACK (_launch_button_clicked_cb), window); gtk_box_pack_start (priv->custom_cmd_panel, cmd_label, FALSE, TRUE, 0); gtk_box_pack_start (priv->custom_cmd_panel, cmd_entry, TRUE, TRUE, 0); gtk_box_pack_start (priv->custom_cmd_panel, launch_button, FALSE, TRUE, 0); GtkWidget *final_hbox = gtk_hbox_new (FALSE, 0); GtkWidget *remember_button = gtk_check_button_new_with_label (_("Remember my choice")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (remember_button), TRUE); priv->remember_button = remember_button; gtk_box_pack_start (GTK_BOX (final_hbox), remember_button, FALSE, TRUE, 0); /* Setup the whole dialog */ GtkWidget *vbox = gtk_dialog_get_content_area (GTK_DIALOG (window)); gtk_box_set_spacing (GTK_BOX (vbox), 10); gtk_box_pack_start (GTK_BOX (vbox), info_box, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), apps_frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (priv->custom_cmd_panel), FALSE, TRUE, 0); gtk_box_pack_end (GTK_BOX (vbox), final_hbox, FALSE, TRUE, 0); gtk_widget_show (vbox); gtk_widget_show_all (info_box); gtk_widget_show (apps_frame); gtk_widget_show_all (GTK_WIDGET (priv->page_button_panel)); gtk_widget_show (GTK_WIDGET (priv->chooser_panel)); gtk_widget_show_all (GTK_WIDGET (priv->custom_cmd_panel)); gtk_widget_show_all (GTK_WIDGET (final_hbox)); gtk_dialog_add_button (GTK_DIALOG (window), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_window_set_title (GTK_WINDOW (window), _("Choose a player to launch")); gtk_window_set_resizable (GTK_WINDOW (window), FALSE); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); }
static void _admin_resv(GtkTreeModel *model, GtkTreeIter *iter, char *type) { resv_desc_msg_t *resv_msg = xmalloc(sizeof(resv_desc_msg_t)); reservation_name_msg_t resv_name_msg; char *resvid = NULL; char tmp_char[100]; char *temp = NULL; int edit_type = 0; int response = 0; GtkWidget *label = NULL; GtkWidget *entry = NULL; GtkWidget *popup = gtk_dialog_new_with_buttons( type, GTK_WINDOW(main_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); gtk_window_set_transient_for(GTK_WINDOW(popup), NULL); gtk_tree_model_get(model, iter, SORTID_NAME, &resvid, -1); slurm_init_resv_desc_msg(resv_msg); memset(&resv_name_msg, 0, sizeof(reservation_name_msg_t)); resv_msg->name = xstrdup(resvid); if (!strcasecmp("Remove Reservation", type)) { resv_name_msg.name = resvid; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_YES, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); snprintf(tmp_char, sizeof(tmp_char), "Are you sure you want to remove " "reservation %s?", resvid); label = gtk_label_new(tmp_char); edit_type = EDIT_REMOVE; } else { label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_window_set_default_size(GTK_WINDOW(popup), 200, 400); snprintf(tmp_char, sizeof(tmp_char), "Editing reservation %s think before you type", resvid); label = gtk_label_new(tmp_char); edit_type = EDIT_EDIT; entry = _admin_full_edit_resv(resv_msg, model, iter); } gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), label, FALSE, FALSE, 0); if (entry) gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), entry, TRUE, TRUE, 0); gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { switch(edit_type) { case EDIT_REMOVE: if (slurm_delete_reservation(&resv_name_msg) == SLURM_SUCCESS) { temp = g_strdup_printf( "Reservation %s removed successfully", resvid); } else { temp = g_strdup_printf( "Problem removing reservation %s.", resvid); } display_edit_note(temp); g_free(temp); break; case EDIT_EDIT: if (got_edit_signal) goto end_it; if (!global_send_update_msg) { temp = g_strdup_printf("No change detected."); } else if (slurm_update_reservation(resv_msg) == SLURM_SUCCESS) { temp = g_strdup_printf( "Reservation %s updated successfully", resvid); } else { temp = g_strdup_printf( "Problem updating reservation %s.", resvid); } display_edit_note(temp); g_free(temp); break; default: break; } } end_it: g_free(resvid); global_entry_changed = 0; slurm_free_resv_desc_msg(resv_msg); gtk_widget_destroy(popup); if (got_edit_signal) { type = got_edit_signal; got_edit_signal = NULL; _admin_resv(model, iter, type); xfree(type); } return; }
static void _admin_front_end(GtkTreeModel *model, GtkTreeIter *iter, char *type, char *node_list) { uint16_t state = (uint16_t) NO_VAL; update_front_end_msg_t front_end_update_msg; char *new_type = NULL, *reason = NULL; char tmp_char[100]; char *lower; int rc; GtkWidget *label = NULL; GtkWidget *entry = NULL; GtkWidget *popup = NULL; if (cluster_flags & CLUSTER_FLAG_FED) { display_fed_disabled_popup(type); global_entry_changed = 0; return; } popup = gtk_dialog_new_with_buttons( type, GTK_WINDOW(main_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); gtk_window_set_transient_for(GTK_WINDOW(popup), NULL); label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_YES, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); if (!strncasecmp("Drain", type, 5)) { new_type = "DRAIN"; reason = "\n\nPlease enter reason."; state = NODE_STATE_DRAIN; entry = create_entry(); } else if (!strncasecmp("Resume", type, 6)) { new_type = "RESUME"; reason = ""; state = NODE_RESUME; } snprintf(tmp_char, sizeof(tmp_char), "Are you sure you want to set state of front end node %s " "to %s?%s", node_list, new_type, reason); label = gtk_label_new(tmp_char); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), label, false, false, 0); if (entry) gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), entry, true, true, 0); gtk_widget_show_all(popup); rc = gtk_dialog_run (GTK_DIALOG(popup)); slurm_init_update_front_end_msg(&front_end_update_msg); if (rc == GTK_RESPONSE_OK) { front_end_update_msg.name = node_list; front_end_update_msg.node_state = state; if (entry) { front_end_update_msg.reason = xstrdup( gtk_entry_get_text(GTK_ENTRY(entry))); if (!front_end_update_msg.reason || !strlen(front_end_update_msg.reason)) { lower = g_strdup_printf( "You need a reason to do that."); display_edit_note(lower); g_free(lower); goto end_it; } rc = uid_from_string(getlogin(), &front_end_update_msg.reason_uid); if (rc < 0) front_end_update_msg.reason_uid = getuid(); } rc = slurm_update_front_end(&front_end_update_msg); if (rc == SLURM_SUCCESS) { lower = g_strdup_printf( "Nodes %s updated successfully.", node_list); display_edit_note(lower); g_free(lower); } else { lower = g_strdup_printf( "Problem updating nodes %s: %s", node_list, slurm_strerror(rc)); display_edit_note(lower); g_free(lower); } } end_it: global_entry_changed = 0; xfree(front_end_update_msg.reason); gtk_widget_destroy(popup); if (got_edit_signal) { type = got_edit_signal; got_edit_signal = NULL; _admin_front_end(model, iter, type, node_list); xfree(type); } return; }
GtkWidget *create_dir_browser(gchar * title, gchar * current_path, GtkSelectionMode mode, void (*handler) (gchar *)) { GtkWidget *window, *scroll_win, *tree, *vbox, *bbox, *ok, *cancel, *sep; gchar *root_text = "/", *node_text = "dummy"; gchar *currentdir, *pos, *tpath, *tpathnew; GtkCTreeNode *root_node, *node, *nextnode; DirNode *dirnode; gboolean leaf; #ifdef _GTK2 window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_modal(GTK_WINDOW(window), TRUE); // gtk_window_set_decorated(GTK_WINDOW(window), TRUE); #else window = gtk_window_new(GTK_WINDOW_DIALOG); #endif gtk_window_set_title(GTK_WINDOW(window), title); gtk_container_border_width(GTK_CONTAINER(window), 10); vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(window), vbox); scroll_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize(scroll_win, 250, 200); gtk_box_pack_start(GTK_BOX(vbox), scroll_win, TRUE, TRUE, 0); gtk_widget_show(scroll_win); gtk_widget_realize(window); if (!folder_pixmap) { folder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &folder_mask, NULL, folder); ofolder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &ofolder_mask, NULL, ofolder); } tree = gtk_ctree_new(1, 0); gtk_clist_set_column_auto_resize(GTK_CLIST(tree), 0, TRUE); gtk_clist_set_selection_mode(GTK_CLIST(tree), mode); gtk_ctree_set_line_style(GTK_CTREE(tree), GTK_CTREE_LINES_DOTTED); gtk_signal_connect(GTK_OBJECT(tree), "tree_expand", GTK_SIGNAL_FUNC(expand_cb), NULL); gtk_signal_connect(GTK_OBJECT(tree), "select_row", GTK_SIGNAL_FUNC(select_row_cb), NULL); gtk_container_add(GTK_CONTAINER(scroll_win), tree); gtk_object_set_user_data(GTK_OBJECT(tree), (gpointer) handler); root_node = gtk_ctree_insert_node(GTK_CTREE(tree), NULL, NULL, &root_text, 4, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, FALSE, FALSE); dirnode = g_malloc0(sizeof (DirNode)); dirnode->path = g_strdup("/"); gtk_ctree_node_set_row_data_full(GTK_CTREE(tree), root_node, dirnode, destroy_cb); node = gtk_ctree_insert_node(GTK_CTREE(tree), root_node, NULL, &node_text, 4, NULL, NULL, NULL, NULL, TRUE, TRUE); gtk_ctree_expand(GTK_CTREE(tree), root_node); gtk_widget_show(tree); sep = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0); gtk_widget_show(sep); bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); ok = gtk_button_new_with_label(tr("Ok")); gtk_object_set_user_data(GTK_OBJECT(ok), window); GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT); gtk_window_set_default(GTK_WINDOW(window), ok); gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(ok_clicked), tree); gtk_widget_show(ok); cancel = gtk_button_new_with_label(tr("Cancel")); GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0); gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window)); gtk_widget_show(cancel); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); gtk_widget_show(bbox); gtk_widget_show(vbox); if (current_path && *current_path) { currentdir = g_strdup(current_path); tpath = g_strdup("/"); pos = strtok(currentdir, "/"); node = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), NULL, "/", filetreeent_compare_func); do { tpathnew = g_strconcat(tpath, pos, "/", NULL); g_free(tpath); tpath = tpathnew; nextnode = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), node, tpath, filetreeent_compare_func); if (!nextnode) break; node = nextnode; pos = strtok(NULL, "/"); gtk_ctree_get_node_info(GTK_CTREE(tree), node, NULL, NULL, NULL, NULL, NULL, NULL, &leaf, NULL); if (!leaf && pos) gtk_ctree_expand(GTK_CTREE(tree), node); else { gtk_ctree_select(GTK_CTREE(tree), node); break; } } while (pos); g_free(tpath); g_free(currentdir); } else gtk_ctree_select(GTK_CTREE(tree), root_node); return window; }
static Tcolsel *colsel_dialog(Tbfwin *bfwin,const gchar *setcolor, gint modal, gint startpos, gint endpos) { Tcolsel *csd; GtkWidget *vbox, *hbox, *but; GdkColor gcolor; const gchar *this_color=setcolor; csd = g_new0(Tcolsel, 1); /* warning: bfwin might be NULL if this dialog is started by return_color() */ csd->bfwin = bfwin; csd->is_modal = modal; csd->startpos = startpos; csd->endpos = endpos; csd->returnval = setcolor ? g_strdup(setcolor) : g_strdup(""); DEBUG_MSG("colsel_dialog, malloced at %p, setcolor=%s\n", csd, setcolor); csd->win = window_full2(_("Bluefish: Select color"), GTK_WIN_POS_CENTER, 12, G_CALLBACK(colsel_destroy_lcb), csd, TRUE, bfwin?bfwin->main_window:NULL); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(csd->win), vbox); csd->csel = gtk_color_selection_new(); gtk_color_selection_set_has_opacity_control(GTK_COLOR_SELECTION(csd->csel), FALSE); if (this_color) { if (gdk_color_parse(this_color, &gcolor)) { gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(csd->csel), &gcolor); } else { this_color=NULL; } } gtk_color_selection_set_has_palette(GTK_COLOR_SELECTION(csd->csel), TRUE); gtk_box_pack_start(GTK_BOX(vbox), csd->csel, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 12); #if GTK_CHECK_VERSION(3,0,0) hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); #else hbox = gtk_hbutton_box_new(); #endif gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbox), 12); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); but = bf_stock_cancel_button(G_CALLBACK(colsel_cancel_clicked_lcb), csd); gtk_box_pack_start(GTK_BOX(hbox), but, TRUE, TRUE, 0); but = bf_stock_ok_button(G_CALLBACK(colsel_ok_clicked_lcb), csd); gtk_window_set_default(GTK_WINDOW(csd->win), but); gtk_box_pack_start(GTK_BOX(hbox), but, TRUE, TRUE, 0); if (bfwin && bfwin->session->colorlist) { GtkSettings* gtksettings; /* Note that this function can only be called when the GtkWidget is attached to a toplevel, since the settings object is specific to a particular GdkScreen. */ gtksettings = gtk_widget_get_settings(GTK_WIDGET(csd->csel)); if (gtksettings) { gchar *strings; DEBUG_MSG("pallette list=%d\n",g_list_length(bfwin->session->colorlist)); bfwin->session->colorlist = limit_stringlist(bfwin->session->colorlist, 20, TRUE); DEBUG_MSG("pallette list=%d\n",g_list_length(bfwin->session->colorlist)); strings = stringlist_to_string(bfwin->session->colorlist, ":"); strings[strlen(strings)-1] = '\0'; /* this property may contain max 20 colors, otherwise gtk will crash */ g_object_set(G_OBJECT(gtksettings), "gtk-color-palette", strings, NULL); g_free(strings); } /* DEBUG_MSG("colsel_dialog, setting palette from %s\n", strings); if (gtk_color_selection_palette_from_string(strings, &gcolorarr, &num)) { DEBUG_MSG("num=%d, gcolorarr=%p\n",num,gcolorarr); } else { DEBUG_MSG("hmm, failed to parse our string :(\n"); } */ } gtk_widget_show_all(csd->win); DEBUG_MSG("colsel_dialog, finished\n"); return csd; }
static void gdict_applet_build_window (GdictApplet *applet) { GdictAppletPrivate *priv = applet->priv; GtkWidget *window; GtkWidget *frame; GtkWidget *vbox; GtkWidget *bbox; GtkWidget *button; if (!priv->entry) { g_warning ("No entry widget defined"); return; } window = gdict_aligned_window_new (priv->toggle); g_signal_connect (window, "key-press-event", G_CALLBACK (window_key_press_event_cb), applet); g_signal_connect (window, "show", G_CALLBACK (window_show_cb), applet); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (window), frame); gtk_widget_show (frame); priv->frame = frame; vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); priv->defbox = gdict_defbox_new (); if (priv->context) gdict_defbox_set_context (GDICT_DEFBOX (priv->defbox), priv->context); gtk_box_pack_start (GTK_BOX (vbox), priv->defbox, TRUE, TRUE, 0); gtk_widget_show (priv->defbox); gtk_widget_set_can_focus (priv->defbox, TRUE); gtk_widget_set_can_default (priv->defbox, TRUE); bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (bbox), 6); gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 0); gtk_widget_show (bbox); button = gtk_button_new_from_stock (GTK_STOCK_CLEAR); gtk_widget_set_tooltip_text (button, _("Clear the definitions found")); set_atk_name_description (button, _("Clear definition"), _("Clear the text of the definition")); g_signal_connect (button, "clicked", G_CALLBACK (clear_cb), applet); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gtk_button_new_from_stock (GTK_STOCK_PRINT); gtk_widget_set_tooltip_text (button, _("Print the definitions found")); set_atk_name_description (button, _("Print definition"), _("Print the text of the definition")); g_signal_connect (button, "clicked", G_CALLBACK (print_cb), applet); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gtk_button_new_from_stock (GTK_STOCK_SAVE); gtk_widget_set_tooltip_text (button, _("Save the definitions found")); set_atk_name_description (button, _("Save definition"), _("Save the text of the definition to a file")); g_signal_connect (button, "clicked", G_CALLBACK (save_cb), applet); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_window_set_default (GTK_WINDOW (window), priv->defbox); priv->window = window; priv->is_window_showing = FALSE; }
void InternetGo (void) { if ((ifilestuff == 0) && (inet == 0)) { shost = gtk_entry_get_text (GTK_ENTRY (connectentry1)); theaddress = atoaddr (shost); iport = atoi (gtk_entry_get_text (GTK_ENTRY (connectentry2))); gtk_widget_destroy (connectwindow); iyesno = 0; bzero ((char *) &host_addr, sizeof (host_addr)); host_addr.sin_family = AF_INET; host_addr.sin_addr.s_addr = inet_addr (inet_ntoa (*theaddress)); host_addr.sin_port = htons (iport); if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) { Message ("Unable to open socket.", 3, 0); } itheerror = connect (sockfd, (struct sockaddr *) &host_addr, sizeof (host_addr)); if (itheerror < 0) { sprintf (serrortemp, "Unable to connect to host (%s).", strerror (errno)); Message (serrortemp, 3, 0); } else { fcntl (sockfd, F_SETFL, O_NONBLOCK); biscomputer = 0; sprintf (bplayername, "%s", "unknown"); wiscomputer = 0; sprintf (wplayername, "%s", "unknown"); StatusBar (); if (ichangestuff == 0) { Play ("open.mp3", 0); } internetwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (internetwindow), "Internet window"); gtk_signal_connect (GTK_OBJECT (internetwindow), "delete_event", GTK_SIGNAL_FUNC (CloseSocket), NULL); gtk_window_set_policy (GTK_WINDOW (internetwindow), 0, 0, 1); gtk_container_border_width (GTK_CONTAINER (internetwindow), 0); gtk_widget_realize (internetwindow); internetbox1 = gtk_vbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (internetbox1), 0); gtk_container_add (GTK_CONTAINER (internetwindow), internetbox1); gtk_widget_show (internetbox1); internetbox2 = gtk_hbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (internetbox2), 0); gtk_box_pack_start (GTK_BOX (internetbox1), internetbox2, TRUE, TRUE, 5); gtk_widget_show (internetbox2); internetbox3 = gtk_vbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (internetbox3), 0); gtk_box_pack_start (GTK_BOX (internetbox2), internetbox3, TRUE, TRUE, 0); gtk_widget_show (internetbox3); internettable1 = gtk_table_new (2, 1, FALSE); gtk_widget_show (internettable1); gtk_box_pack_start (GTK_BOX (internetbox3), internettable1, TRUE, TRUE, 0); internettable2 = gtk_table_new (2, 3, FALSE); gtk_widget_show (internettable2); gtk_box_pack_start (GTK_BOX (internetbox3), internettable2, TRUE, TRUE, 0); text = gtk_text_new (NULL, NULL); gtk_widget_set_usize (text, 535, 266); gtk_text_set_editable (GTK_TEXT (text), FALSE); gtk_table_attach (GTK_TABLE (internettable1), text, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0); gtk_widget_show (text); vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj); adj = (GTK_TEXT (text))->vadj; gtk_table_attach (GTK_TABLE (internettable1), vscrollbar, 1, 2, 0, 1, GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0); gtk_widget_show (vscrollbar); cmap = gdk_colormap_get_system (); color.red = 0xffff; color.green = 0; color.blue = 0; if (!gdk_color_alloc (cmap, &color)) { Message ("Could not allocate color.", 3, 0); } gtk_widget_realize (text); wrapcheck = gtk_check_button_new_with_label ("wrap"); gtk_table_attach (GTK_TABLE (internettable2), wrapcheck, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 5, 10); gtk_signal_connect (GTK_OBJECT (wrapcheck), "toggled", GTK_SIGNAL_FUNC (ToggleWrap), text); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wrapcheck), FALSE); gtk_widget_show (wrapcheck); internetentry = gtk_entry_new_with_max_length (50); gtk_signal_connect (GTK_OBJECT (internetentry), "activate", GTK_SIGNAL_FUNC (SendData), NULL); gtk_table_attach (GTK_TABLE (internettable2), internetentry, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 10); gtk_widget_grab_focus (internetentry); gtk_widget_show (internetentry); inetsep = gtk_hseparator_new (); gtk_table_attach (GTK_TABLE (internettable2), inetsep, 0, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (inetsep); inetbutton = gtk_button_new_with_label ("Disconnect"); gtk_signal_connect (GTK_OBJECT (inetbutton), "clicked", GTK_SIGNAL_FUNC (CloseSocket), NULL); GTK_WIDGET_SET_FLAGS (inetbutton, GTK_CAN_DEFAULT); gtk_window_set_default (GTK_WINDOW (internetwindow), inetbutton); gtk_table_attach (GTK_TABLE (internettable2), inetbutton, 0, 2, 2, 3, GTK_EXPAND | GTK_FILL, GTK_FILL, 2, 2); gtk_widget_show (inetbutton); gtk_widget_show (internetwindow); inet = 1; ReceiveData (); } } }
extern void change_refresh_popup(GtkAction *action, gpointer user_data) { GtkWidget *table = gtk_table_new(1, 2, FALSE); GtkWidget *label = NULL; GtkObject *adjustment = gtk_adjustment_new( working_sview_config.refresh_delay, 1, 10000, 5, 60, 0); GtkWidget *spin_button = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); GtkWidget *popup = gtk_dialog_new_with_buttons( "Refresh Interval", GTK_WINDOW (user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); GError *error = NULL; int response = 0; char *temp = NULL; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); label = gtk_label_new("Interval in Seconds "); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), table, FALSE, FALSE, 0); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), spin_button, 1, 2, 0, 1); gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { working_sview_config.refresh_delay = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(spin_button)); temp = g_strdup_printf("Refresh Interval set to %d seconds.", working_sview_config.refresh_delay); gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH); response = gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH, temp); g_free(temp); if (!g_thread_create(_refresh_thr, GINT_TO_POINTER(response), FALSE, &error)) { g_printerr ("Failed to create refresh thread: %s\n", error->message); } } gtk_widget_destroy(popup); return; }
extern void create_create_popup(GtkAction *action, gpointer user_data) { GtkWidget *popup = gtk_dialog_new_with_buttons( "Create", GTK_WINDOW(user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); int i, response = 0; GtkWidget *label = NULL; GtkWidget *entry = NULL; GtkTreeModel *model = NULL; GtkTreeIter iter; const gchar *name = gtk_action_get_name(action); sview_search_info_t sview_search_info; job_desc_msg_t *job_msg = NULL; submit_response_msg_t *slurm_alloc_msg = NULL; update_part_msg_t *part_msg = NULL; resv_desc_msg_t *resv_msg = NULL; char *res_name, *temp; sview_search_info.gchar_data = NULL; sview_search_info.int_data = NO_VAL; sview_search_info.int_data2 = NO_VAL; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_window_set_default_size(GTK_WINDOW(popup), 400, 600); if (!strcmp(name, "batch_job")) { sview_search_info.search_type = CREATE_BATCH_JOB; entry = create_entry(); label = gtk_label_new( "Batch job submission specifications\n\n" "Specify size (task and/or node count) plus the\n" "script. All other fields are optional.\n\n" "More fields will be made available later."); job_msg = xmalloc(sizeof(job_desc_msg_t)); slurm_init_job_desc_msg(job_msg); job_msg->group_id = getgid(); job_msg->user_id = getuid(); job_msg->work_dir = xmalloc(1024); if (!getcwd(job_msg->work_dir, 1024)) goto end_it; entry = create_job_entry(job_msg, model, &iter); } else if (!strcmp(name, "partition")) { sview_search_info.search_type = CREATE_PARTITION; entry = create_entry(); label = gtk_label_new( "Partition creation specifications\n\n" "Specify Name. All other fields are optional."); part_msg = xmalloc(sizeof(update_part_msg_t)); slurm_init_part_desc_msg(part_msg); entry = create_part_entry(part_msg, model, &iter); } else if (!strcmp(name, "reservation")) { sview_search_info.search_type = CREATE_RESERVATION; label = gtk_label_new( "Reservation creation specifications\n\n" "Specify Time_Start and either Duration or Time_End.\n" #ifdef HAVE_BG "Specify either Node_Count or Midplane_List.\n" #else "Specify either Node_Count or Node_List.\n" #endif "Specify either Accounts or Users.\n\n" "Supported Flags include: Maintenance, Overlap,\n" "Ignore_Jobs, Daily and Weekly, License_Only\n" "and Static_Alloc.\n" "All other fields are optional."); resv_msg = xmalloc(sizeof(resv_desc_msg_t)); slurm_init_resv_desc_msg(resv_msg); entry = create_resv_entry(resv_msg, model, &iter); } else { sview_search_info.search_type = 0; goto end_it; } gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), entry, TRUE, TRUE, 0); gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { if (!sview_search_info.search_type) goto end_it; switch(sview_search_info.search_type) { case CREATE_BATCH_JOB: response = slurm_submit_batch_job(job_msg, &slurm_alloc_msg); if (response == SLURM_SUCCESS) { temp = g_strdup_printf( "Job %u submitted", slurm_alloc_msg->job_id); } else { temp = g_strdup_printf( "Problem submitting job: %s", slurm_strerror(slurm_get_errno())); } display_edit_note(temp); g_free(temp); break; case CREATE_PARTITION: response = slurm_create_partition(part_msg); if (response == SLURM_SUCCESS) { temp = g_strdup_printf("Partition %s created", part_msg->name); } else { temp = g_strdup_printf( "Problem creating partition: %s", slurm_strerror(slurm_get_errno())); } display_edit_note(temp); g_free(temp); break; case CREATE_RESERVATION: res_name = slurm_create_reservation(resv_msg); if (res_name) { temp = g_strdup_printf( "Reservation %s created", res_name); free(res_name); } else { temp = g_strdup_printf( "Problem creating reservation: %s", slurm_strerror(slurm_get_errno())); } display_edit_note(temp); g_free(temp); break; default: break; } } end_it: gtk_widget_destroy(popup); if (slurm_alloc_msg) slurm_free_submit_response_response_msg(slurm_alloc_msg); if (job_msg) { for (i = 0; i < job_msg->argc; i++) xfree(job_msg->argv[i]); xfree(job_msg->argv); xfree(job_msg->name); xfree(job_msg->script); xfree(job_msg->work_dir); xfree(job_msg); } xfree(part_msg); if (resv_msg) slurm_free_resv_desc_msg(resv_msg); return; }
void Internet (void) { if ((ifilestuff == 0) && ((biscomputer == 0) || (wiscomputer == 0)) && (iyesno == 0) && (inet == 0)) { connectwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (connectwindow), "Internet play"); gtk_signal_connect (GTK_OBJECT (connectwindow), "delete_event", GTK_SIGNAL_FUNC (DestroyConnect), NULL); gtk_window_set_policy (GTK_WINDOW (connectwindow), 0, 0, 1); gtk_container_border_width (GTK_CONTAINER (connectwindow), 0); gtk_widget_realize (connectwindow); connectbox1 = gtk_vbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (connectbox1), 0); gtk_container_add (GTK_CONTAINER (connectwindow), connectbox1); gtk_widget_show (connectbox1); connectbox2 = gtk_hbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (connectbox2), 0); gtk_box_pack_start (GTK_BOX (connectbox1), connectbox2, FALSE, FALSE, 0); gtk_widget_show (connectbox2); connecttable1 = gtk_table_new (2, 4, FALSE); gtk_box_pack_start (GTK_BOX (connectbox2), connecttable1, TRUE, TRUE, 0); gtk_widget_show (connecttable1); entrylabel1 = gtk_label_new ("host:"); gtk_label_set (GTK_LABEL (entrylabel1), "host:"); gtk_label_set_justify (GTK_LABEL (entrylabel1), GTK_JUSTIFY_CENTER); gtk_table_attach (GTK_TABLE (connecttable1), entrylabel1, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 10, 10); gtk_widget_show (entrylabel1); connectentry1 = gtk_entry_new_with_max_length (50); gtk_entry_set_text (GTK_ENTRY (connectentry1), "nngs.cosmic.org"); gtk_entry_select_region (GTK_ENTRY (connectentry1), 0, GTK_ENTRY (connectentry1)->text_length); gtk_table_attach (GTK_TABLE (connecttable1), connectentry1, 1, 2, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 10); gtk_widget_grab_focus (connectentry1); gtk_widget_show (connectentry1); entrylabel2 = gtk_label_new ("port:"); gtk_label_set (GTK_LABEL (entrylabel2), "port:"); gtk_label_set_justify (GTK_LABEL (entrylabel2), GTK_JUSTIFY_CENTER); gtk_table_attach (GTK_TABLE (connecttable1), entrylabel2, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 10, 10); gtk_widget_show (entrylabel2); connectentry2 = gtk_entry_new_with_max_length (5); gtk_entry_set_text (GTK_ENTRY (connectentry2), "9696"); gtk_table_attach (GTK_TABLE (connecttable1), connectentry2, 1, 2, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 10); gtk_widget_show (connectentry2); connectsep = gtk_hseparator_new (); gtk_table_attach (GTK_TABLE (connecttable1), connectsep, 0, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (connectsep); connectbutton = gtk_button_new_with_label ("Connect"); gtk_signal_connect (GTK_OBJECT (connectbutton), "clicked", GTK_SIGNAL_FUNC (InternetGo), NULL); GTK_WIDGET_SET_FLAGS (connectbutton, GTK_CAN_DEFAULT); gtk_window_set_default (GTK_WINDOW (connectwindow), connectbutton); gtk_table_attach (GTK_TABLE (connecttable1), connectbutton, 0, 2, 3, 4, GTK_FILL, GTK_FILL, 2, 2); gtk_widget_show (connectbutton); gtk_widget_show (connectwindow); iyesno = 1; } }
/** * dialog_init: * @state: * * Create the dialog (guru). * **/ static gboolean dialog_goto_init (GotoState *state) { GtkTable *table; GtkWidget *scrolled; GtkTreeViewColumn *column; table = GTK_TABLE (go_gtk_builder_get_widget (state->gui, "names")); state->goto_text = GTK_ENTRY (gtk_entry_new ()); gtk_table_attach (table, GTK_WIDGET (state->goto_text), 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, 0, 0, 0); g_signal_connect_after (G_OBJECT (state->goto_text), "changed", G_CALLBACK (cb_dialog_goto_update_sensitivity), state); state->spin_rows = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "spin-rows")); state->spin_cols = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "spin-columns")); /* Set-up treeview */ scrolled = go_gtk_builder_get_widget (state->gui, "scrolled"); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_ETCHED_IN); state->model = gtk_tree_store_new (NUM_COLMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER); state->treeview = GTK_TREE_VIEW ( gtk_tree_view_new_with_model (GTK_TREE_MODEL (state->model))); state->selection = gtk_tree_view_get_selection (state->treeview); gtk_tree_selection_set_mode (state->selection, GTK_SELECTION_BROWSE); g_signal_connect (state->selection, "changed", G_CALLBACK (cb_dialog_goto_selection_changed), state); column = gtk_tree_view_column_new_with_attributes (_("Sheet"), gtk_cell_renderer_text_new (), "text", SHEET_NAME, NULL); gtk_tree_view_column_set_sort_column_id (column, SHEET_NAME); gtk_tree_view_append_column (state->treeview, column); column = gtk_tree_view_column_new_with_attributes (_("Cell"), gtk_cell_renderer_text_new (), "text", ITEM_NAME, NULL); gtk_tree_view_column_set_sort_column_id (column, ITEM_NAME); gtk_tree_view_append_column (state->treeview, column); gtk_tree_view_set_headers_visible (state->treeview, TRUE); gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (state->treeview)); dialog_goto_load_names (state); /* Finished set-up of treeview */ /* Listen for sheet changes */ state->sheet_order_changed_listener = g_signal_connect (G_OBJECT (state->wb), "sheet_order_changed", G_CALLBACK (cb_sheet_order_changed), state); state->sheet_added_listener = g_signal_connect (G_OBJECT (state->wb), "sheet_added", G_CALLBACK (cb_sheet_added), state); state->sheet_deleted_listener = g_signal_connect (G_OBJECT (state->wb), "sheet_deleted", G_CALLBACK (cb_sheet_deleted), state); state->close_button = go_gtk_builder_get_widget (state->gui, "close_button"); g_signal_connect (G_OBJECT (state->close_button), "clicked", G_CALLBACK (cb_dialog_goto_close_clicked), state); state->go_button = go_gtk_builder_get_widget (state->gui, "go_button"); g_signal_connect (G_OBJECT (state->go_button), "clicked", G_CALLBACK (cb_dialog_goto_go_clicked), state); gtk_window_set_default (GTK_WINDOW (state->dialog), state->go_button); gnumeric_init_help_button ( go_gtk_builder_get_widget (state->gui, "help_button"), GNUMERIC_HELP_LINK_GOTO_CELL); dialog_goto_load_selection (state); wbc_gtk_attach_guru (state->wbcg, state->dialog); g_object_set_data_full (G_OBJECT (state->dialog), "state", state, (GDestroyNotify) cb_dialog_goto_free); return FALSE; }
extern void create_search_popup(GtkAction *action, gpointer user_data) { GtkWidget *popup = gtk_dialog_new_with_buttons( "Search", GTK_WINDOW(user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); int response = 0; GtkWidget *label = NULL; GtkWidget *entry = NULL; GtkTreeModel *model = NULL; GtkTreeIter iter; const gchar *name = gtk_action_get_name(action); sview_search_info_t sview_search_info; sview_search_info.gchar_data = NULL; sview_search_info.int_data = NO_VAL; sview_search_info.int_data2 = NO_VAL; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); if (!strcmp(name, "jobid")) { sview_search_info.search_type = SEARCH_JOB_ID; entry = create_entry(); label = gtk_label_new("Which job id?"); } else if (!strcmp(name, "user_jobs")) { sview_search_info.search_type = SEARCH_JOB_USER; entry = create_entry(); label = gtk_label_new("Which user?"); } else if (!strcmp(name, "state_jobs")) { display_data_t pulldown_display_data[] = { {G_TYPE_NONE, JOB_PENDING, "Pending", TRUE, -1}, {G_TYPE_NONE, JOB_CONFIGURING, "Configuring", TRUE, -1}, {G_TYPE_NONE, JOB_RUNNING, "Running", TRUE, -1}, {G_TYPE_NONE, JOB_SUSPENDED, "Suspended", TRUE, -1}, {G_TYPE_NONE, JOB_COMPLETE, "Complete", TRUE, -1}, {G_TYPE_NONE, JOB_CANCELLED, "Cancelled", TRUE, -1}, {G_TYPE_NONE, JOB_FAILED, "Failed", TRUE, -1}, {G_TYPE_NONE, JOB_TIMEOUT, "Timeout", TRUE, -1}, {G_TYPE_NONE, JOB_NODE_FAIL, "Node Failure", TRUE, -1}, {G_TYPE_NONE, JOB_PREEMPTED, "Preempted", TRUE, -1}, {G_TYPE_NONE, -1, NULL, FALSE, -1} }; sview_search_info.search_type = SEARCH_JOB_STATE; entry = create_pulldown_combo(pulldown_display_data, JOB_END); label = gtk_label_new("Which state?"); } else if (!strcmp(name, "partition_name")) { sview_search_info.search_type = SEARCH_PARTITION_NAME; entry = create_entry(); label = gtk_label_new("Which partition"); } else if (!strcmp(name, "partition_state")) { display_data_t pulldown_display_data[] = { {G_TYPE_NONE, PARTITION_UP, "Up", TRUE, -1}, {G_TYPE_NONE, PARTITION_DOWN, "Down", TRUE, -1}, {G_TYPE_NONE, PARTITION_INACTIVE, "Inactive", TRUE, -1}, {G_TYPE_NONE, PARTITION_DRAIN, "Drain", TRUE, -1}, {G_TYPE_NONE, -1, NULL, FALSE, -1} }; sview_search_info.search_type = SEARCH_PARTITION_STATE; entry = create_pulldown_combo(pulldown_display_data, 5); label = gtk_label_new("Which state?"); } else if (!strcmp(name, "node_name")) { sview_search_info.search_type = SEARCH_NODE_NAME; entry = create_entry(); if (cluster_flags & CLUSTER_FLAG_BG) label = gtk_label_new("Which Midplane(s)?\n" "(ranged or comma separated)"); else label = gtk_label_new("Which node(s)?\n" "(ranged or comma separated)"); } else if (!strcmp(name, "node_state")) { display_data_t pulldown_display_data[] = { {G_TYPE_NONE, NODE_STATE_DOWN, "Down", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_ALLOCATED | NODE_STATE_DRAIN, "Draining", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_IDLE | NODE_STATE_DRAIN, "Drained", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_IDLE, "Idle", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_ALLOCATED, "Allocated", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_ERROR, "Error", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_MIXED, "Mixed", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_COMPLETING, "Completing", TRUE, -1}, {G_TYPE_NONE, NODE_STATE_UNKNOWN, "Unknown", TRUE, -1}, {G_TYPE_NONE, -1, NULL, FALSE, -1} }; sview_search_info.search_type = SEARCH_NODE_STATE; entry = create_pulldown_combo(pulldown_display_data, PAGE_CNT); label = gtk_label_new("Which state?"); } else if ((cluster_flags & CLUSTER_FLAG_BG) && !strcmp(name, "bg_block_name")) { sview_search_info.search_type = SEARCH_BLOCK_NAME; entry = create_entry(); label = gtk_label_new("Which block?"); } else if ((cluster_flags & CLUSTER_FLAG_BG) && !strcmp(name, "bg_block_size")) { sview_search_info.search_type = SEARCH_BLOCK_SIZE; entry = create_entry(); label = gtk_label_new("Which block size?"); } else if (!strcmp(name, "bg_block_state")) { display_data_t pulldown_display_data[] = { {G_TYPE_NONE, BG_BLOCK_NAV, "Nav", TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_FREE, "Free", TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_BUSY, NULL, TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_BOOTING, "Booting", TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_REBOOTING, NULL, TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_INITED, "Inited", TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_ALLOCATED, NULL, TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_TERM, "Terminating", TRUE, -1}, {G_TYPE_NONE, BG_BLOCK_ERROR_FLAG, "Error", TRUE, -1}, {G_TYPE_NONE, -1, NULL, FALSE, -1} }; display_data_t *display_data = pulldown_display_data; while (display_data++) { if (display_data->id == -1) break; if (cluster_flags & CLUSTER_FLAG_BGL) { switch(display_data->id) { case BG_BLOCK_BUSY: display_data->name = "Busy"; break; } } else if (cluster_flags & CLUSTER_FLAG_BGP){ switch(display_data->id) { case BG_BLOCK_REBOOTING: display_data->name = "Rebooting"; break; } } else { switch(display_data->id) { case BG_BLOCK_ALLOCATED: display_data->name = "Allocated"; break; } } } sview_search_info.search_type = SEARCH_BLOCK_STATE; entry = create_pulldown_combo(pulldown_display_data, PAGE_CNT); label = gtk_label_new("Which state?"); } else if (!strcmp(name, "reservation_name")) { sview_search_info.search_type = SEARCH_RESERVATION_NAME; entry = create_entry(); label = gtk_label_new("Which reservation"); } else { sview_search_info.search_type = 0; goto end_it; } gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), entry, FALSE, FALSE, 0); gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { if (!sview_search_info.search_type) goto end_it; switch(sview_search_info.search_type) { case SEARCH_BLOCK_STATE: case SEARCH_JOB_STATE: case SEARCH_NODE_STATE: case SEARCH_PARTITION_STATE: if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(entry), &iter)) { g_print("nothing selected\n"); return; } model = gtk_combo_box_get_model(GTK_COMBO_BOX(entry)); if (!model) { g_print("nothing selected\n"); return; } gtk_tree_model_get(model, &iter, 0, &sview_search_info.int_data, -1); break; case SEARCH_JOB_ID: case SEARCH_JOB_USER: case SEARCH_BLOCK_NAME: case SEARCH_BLOCK_SIZE: case SEARCH_PARTITION_NAME: case SEARCH_NODE_NAME: case SEARCH_RESERVATION_NAME: sview_search_info.gchar_data = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry))); break; default: break; } _search_entry(&sview_search_info); } end_it: gtk_widget_destroy(popup); return; }
static GtkWidget *create_window(void) { // Basic window stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE); gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls stwidgets.hlayout = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout); // banner { GdkPixbuf *pixbuf = load_banner(); stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons stwidgets.vlayout = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0); // Tab control stwidgets.tabs = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4); // layout table of config page stwidgets.configtlayout = gtk_table_new(6, 3, FALSE); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout); // 3D video mode LabelText stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0); #ifdef POLYMER gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 0); #else gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 7); #endif // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL); } #ifdef POLYMER gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0); #else gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, (GtkAttachOptions)0, 4, 7); #endif // Fullscreen checkbox stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0); #ifdef POLYMER gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 0); #else gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 7); #endif stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0); #ifdef POLYMER // Polymer checkbox stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0); #endif // Input devices LabelText stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, (GtkAttachOptions)0, 4, 0); // Input devices combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.inputdevcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0); // Custom mod LabelText stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, (GtkAttachOptions)0, 4, 7); // Custom mod combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.custommodcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 7); // Empty horizontal layout stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, (GtkAttachOptions)0, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 4, 0); // Autoload checkbox stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, (GtkAttachOptions)0, 2, 2); // Always show config checkbox stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, (GtkAttachOptions)0, 2, 2); // Configuration tab stwidgets.configtab = gtk_label_new("Configuration"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab); // Game data layout stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4); // Game data field LabelText stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:"); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5); // Game data scrollable area stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_SHADOW_IN); // Game data list { GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); GtkCellRenderer *cell; GtkTreeViewColumn *col; gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING); stwidgets.gamelist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL); gtk_tree_view_column_set_expand(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL); gtk_tree_view_column_set_min_width(col, 64); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); } gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); // Game tab stwidgets.gametab = gtk_label_new("Game"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab); // Messages scrollable area stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area stwidgets.messagestext = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext); gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); // Messages tab stwidgets.messagestab = gtk_label_new("Messages"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab); // Dialogue box buttons layout stwidgets.buttons = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3); gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END); // Cancel button stwidgets.cancelbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton); GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT); stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign); stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout); stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0); stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel"); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0); // Start button stwidgets.startbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton); GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT); gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton); stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign); stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout); stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0); stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start"); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect((gpointer) stwidgets.startwin, "delete_event", G_CALLBACK(on_startwin_delete_event), NULL); g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed", G_CALLBACK(on_vmode3dcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled", G_CALLBACK(on_fullscreencheck_toggled), NULL); #ifdef POLYMER g_signal_connect((gpointer) stwidgets.polymercheck, "toggled", G_CALLBACK(on_polymercheck_toggled), NULL); #endif g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed", G_CALLBACK(on_inputdevcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.custommodcombo, "changed", G_CALLBACK(on_custommodcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled", G_CALLBACK(on_autoloadcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled", G_CALLBACK(on_alwaysshowcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked", G_CALLBACK(on_cancelbutton_clicked), NULL); g_signal_connect((gpointer) stwidgets.startbutton, "clicked", G_CALLBACK(on_startbutton_clicked), NULL); { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.gamelist)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); g_signal_connect((gpointer) sel, "changed", G_CALLBACK(on_gamelist_selection_changed), NULL); } // Associate labels with their controls gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist); return stwidgets.startwin; }
extern void change_grid_popup(GtkAction *action, gpointer user_data) { GtkWidget *table = gtk_table_new(1, 2, FALSE); GtkWidget *label; GtkObject *adjustment; GtkWidget *width_sb, *hori_sb, *vert_sb; int width = working_sview_config.grid_x_width, hori = working_sview_config.grid_hori, vert = working_sview_config.grid_vert; GtkWidget *popup = gtk_dialog_new_with_buttons( "Grid Properties", GTK_WINDOW (user_data), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, NULL); GError *error = NULL; int response = 0; char *temp = NULL; label = gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_window_set_default(GTK_WINDOW(popup), label); gtk_dialog_add_button(GTK_DIALOG(popup), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), table, FALSE, FALSE, 0); label = gtk_label_new("Nodes in row "); adjustment = gtk_adjustment_new(working_sview_config.grid_x_width, 1, 1000, 1, 60, 0); width_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), width_sb, 1, 2, 0, 1); label = gtk_label_new("Nodes before horizontal break "); adjustment = gtk_adjustment_new(working_sview_config.grid_hori, 1, 1000, 1, 60, 0); hori_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); gtk_table_attach_defaults(GTK_TABLE(table), hori_sb, 1, 2, 1, 2); label = gtk_label_new("Nodes before vertical break "); adjustment = gtk_adjustment_new(working_sview_config.grid_vert, 1, 1000, 1, 60, 0); vert_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3); gtk_table_attach_defaults(GTK_TABLE(table), vert_sb, 1, 2, 2, 3); /*TODO * do we care about this? label = gtk_label_new("Topology ordered "); adjustment = gtk_adjustment_new(working_sview_config.grid_topological, 1, 1000, 1, 60, 0); GtkWidget *gtbtton = gtk_check_button_new (); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4); gtk_table_attach_defaults(GTK_TABLE(table), gtbtton, 1, 2, 3, 4); gtk_toggle_button_set_active (>btton, working_sview_config.grid_topological); */ gtk_widget_show_all(popup); response = gtk_dialog_run (GTK_DIALOG(popup)); if (response == GTK_RESPONSE_OK) { working_sview_config.grid_x_width = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(width_sb)); working_sview_config.grid_hori = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(hori_sb)); working_sview_config.grid_vert = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(vert_sb)); memcpy(&default_sview_config, &working_sview_config, sizeof(sview_config_t)); if ((width == working_sview_config.grid_x_width) && (hori == working_sview_config.grid_hori) && (vert == working_sview_config.grid_vert)) { temp = g_strdup_printf("Grid: Nothing changed."); } else if (working_sview_config.grid_topological) { temp = g_strdup_printf("Grid: Invalid mode .." " switch to non-topology " "order first."); } else { bool refresh = 0; temp = g_strdup_printf( "Grid set to %d nodes breaks " "at %d H and %d V.", working_sview_config.grid_x_width, working_sview_config.grid_hori, working_sview_config.grid_vert); /* If the old width was wider than the * current we need to remake the list so the * table gets set up correctly, so destroy it * here and it will be remade in get_system_stats(). */ if ((width > working_sview_config.grid_x_width) && grid_button_list) { list_destroy(grid_button_list); grid_button_list = NULL; refresh = 1; } get_system_stats(main_grid_table); if (refresh) refresh_main(NULL, NULL); } gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH); response = gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), STATUS_REFRESH, temp); g_free(temp); if (!g_thread_create(_refresh_thr, GINT_TO_POINTER(response), FALSE, &error)) { g_printerr ("Failed to create refresh thread: %s\n", error->message); } } gtk_widget_destroy(popup); return; }
void fallback_dialog_show (Defaults* d, const gchar* sender, const gchar* app_name, int id, const gchar* title_text, const gchar* _body_message, gchar** actions) { GtkWidget* dialog; GtkWidget* hbox; GtkWidget* vbox; GtkWidget* title; GtkWidget* body; GtkWidget* image; gchar* body_message = NULL; gchar* new_body_message = NULL; guint gap = EM2PIXELS (defaults_get_margin_size (d), d); gboolean success = FALSE; GError* error = NULL; if (!IS_DEFAULTS (d) || !sender || !app_name || !title_text || !_body_message || !actions) return; DialogInfo* dialog_info = g_new0 (DialogInfo, 1); if (!dialog_info) return; dialog_info->id = id; dialog_info->sender = g_strdup(sender); dialog = gtk_dialog_new (); hbox = g_object_new (GTK_TYPE_HBOX, "spacing", gap, "border-width", 12, NULL); // We deliberately use the gtk-dialog-warning icon rather than // the specified one to discourage people from trying to use // the notification system as a way of showing custom alert // dialogs. image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); vbox = g_object_new (GTK_TYPE_VBOX, NULL); title = gtk_label_new (NULL); gtk_label_set_text (GTK_LABEL (title), title_text); gtk_label_set_line_wrap (GTK_LABEL (title), TRUE); body = gtk_label_new (NULL); body_message = filter_text (_body_message); if (body_message) { success = pango_parse_markup (body_message, -1, 0, NULL, &new_body_message, NULL, &error); if (error && !success) { g_warning ("fallback_dialog_show(): Got error \"%s\"\n", error->message); g_error_free (error); error = NULL; } } if (new_body_message) { gtk_label_set_text (GTK_LABEL (body), new_body_message); g_free (new_body_message); } else gtk_label_set_text (GTK_LABEL (body), body_message); g_free (body_message); gtk_label_set_line_wrap (GTK_LABEL (body), TRUE); gtk_misc_set_alignment (GTK_MISC (title), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), title, TRUE, TRUE, 0); gtk_misc_set_alignment (GTK_MISC (body), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), body, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (hbox), vbox); gtk_container_add (GTK_CONTAINER ( gtk_dialog_get_content_area ( GTK_DIALOG (dialog))), hbox); gtk_container_set_border_width (GTK_CONTAINER (dialog), 2); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_window_set_default_size (GTK_WINDOW (dialog), EM2PIXELS (defaults_get_bubble_width (d) * 1.2f, d), -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_title (GTK_WINDOW (dialog), app_name); gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE); // is it a bad notification with actions? if (actions[0] != NULL) add_pathological_action_buttons (dialog, actions); GtkButton *cancel = GTK_BUTTON ( gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL)); g_signal_connect_swapped (G_OBJECT (cancel), "button-release-event", G_CALLBACK (handle_close), dialog); gtk_widget_set_can_default(GTK_WIDGET(cancel), FALSE); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (handle_close), dialog); GtkButton *ok = GTK_BUTTON ( gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_OK)); g_object_set_data_full (G_OBJECT (ok), "_libnotify_action", g_strdup ("default"), g_free); g_signal_connect (G_OBJECT (ok), "button-release-event", G_CALLBACK (handle_response), dialog); gtk_widget_set_can_default(GTK_WIDGET(ok), FALSE); g_object_set_data (G_OBJECT (dialog), "_dialog_info", dialog_info); g_signal_connect (G_OBJECT (dialog), "button-release-event", G_CALLBACK (handle_response), dialog); gtk_window_set_focus (GTK_WINDOW (dialog), NULL); gtk_window_set_default (GTK_WINDOW (dialog), NULL); gtk_widget_show_all (dialog); }