static void fit_param_row_create(FitControls *controls, gint i, GtkTable *table, gint row) { FitParamControl *cntrl; cntrl = &g_array_index(controls->param, FitParamControl, i); /* Fix */ cntrl->fix = gtk_check_button_new(); gtk_table_attach(table, cntrl->fix, 0, 1, row, row+1, 0, 0, 0, 0); g_object_set_data(G_OBJECT(cntrl->fix), "id", GINT_TO_POINTER(i + 1)); gtk_widget_show(cntrl->fix); g_signal_connect(cntrl->fix, "toggled", G_CALLBACK(fix_changed), controls); /* Name */ cntrl->name = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(cntrl->name), 1.0, 0.5); gtk_table_attach(table, cntrl->name, 1, 2, row, row+1, GTK_FILL, 0, 0, 0); gtk_widget_show(cntrl->name); /* Equals */ cntrl->equals = gtk_label_new("="); gtk_table_attach(table, cntrl->equals, 2, 3, row, row+1, 0, 0, 0, 0); gtk_widget_show(cntrl->equals); /* Value */ cntrl->value = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(cntrl->value), 1.0, 0.5); gtk_table_attach(table, cntrl->value, 3, 4, row, row+1, GTK_FILL, 0, 0, 0); gtk_widget_show(cntrl->value); cntrl->value_unit = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(cntrl->value_unit), 0.0, 0.5); gtk_table_attach(table, cntrl->value_unit, 4, 5, row, row+1, GTK_FILL, 0, 0, 0); gtk_widget_show(cntrl->value_unit); /* Plus-minus */ cntrl->pm = gtk_label_new("±"); gtk_table_attach(table, cntrl->pm, 5, 6, row, row+1, 0, 0, 0, 0); gtk_widget_show(cntrl->pm); /* Error */ cntrl->error = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(cntrl->error), 1.0, 0.5); gtk_table_attach(table, cntrl->error, 6, 7, row, row+1, GTK_FILL, 0, 0, 0); gtk_widget_show(cntrl->error); cntrl->error_unit = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(cntrl->error_unit), 0.0, 0.5); gtk_table_attach(table, cntrl->error_unit, 7, 8, row, row+1, GTK_FILL, 0, 0, 0); gtk_widget_show(cntrl->error_unit); /* Copy */ cntrl->copy = gtk_button_new_with_label("→"); gtk_button_set_relief(GTK_BUTTON(cntrl->copy), GTK_RELIEF_NONE); gtk_table_attach(table, cntrl->copy, 8, 9, row, row+1, 0, 0, 0, 0); g_object_set_data(G_OBJECT(cntrl->copy), "id", GINT_TO_POINTER(i + 1)); gtk_widget_show(cntrl->copy); g_signal_connect(cntrl->copy, "clicked", G_CALLBACK(copy_param), controls); /* Initial */ cntrl->init = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(cntrl->init), 12); gtk_table_attach(table, cntrl->init, 9, 10, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); g_object_set_data(G_OBJECT(cntrl->init), "id", GINT_TO_POINTER(i + 1)); gtk_widget_show(cntrl->init); g_signal_connect(cntrl->init, "activate", G_CALLBACK(param_initial_activate), controls); gwy_widget_set_activate_on_unfocus(cntrl->init, TRUE); }
void xkb_layout_choose (GtkBuilder * dialog) { GtkBuilder *chooser_dialog; chooser_dialog = gtk_builder_new (); gtk_builder_add_from_file (chooser_dialog, MATECC_UI_DIR "/mate-keyboard-properties-layout-chooser.ui", NULL); GtkWidget *chooser = CWID ("xkb_layout_chooser"); GtkWidget *lang_chooser = CWID ("xkb_languages_available"); GtkWidget *notebook = CWID ("choosers_nb"); GtkWidget *kbdraw = NULL; GtkWidget *toplevel = NULL; gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (WID ("keyboard_dialog"))); xkb_layout_chooser_available_layouts_fill (chooser_dialog, "xkb_countries_available", "xkb_country_variants_available", xkl_config_registry_foreach_country, (ConfigItemProcessFunc) xkb_layout_chooser_add_country_to_available_countries, G_CALLBACK (xkb_layout_chooser_available_country_changed)); xkb_layout_chooser_available_layouts_fill (chooser_dialog, "xkb_languages_available", "xkb_language_variants_available", xkl_config_registry_foreach_language, (ConfigItemProcessFunc) xkb_layout_chooser_add_language_to_available_languages, G_CALLBACK (xkb_layout_chooser_available_language_changed)); g_signal_connect_after (G_OBJECT (notebook), "switch_page", G_CALLBACK (xkb_layout_chooser_page_changed), chooser_dialog); gtk_combo_box_set_active (GTK_COMBO_BOX (CWID ("xkb_countries_available")), FALSE); if (gtk_tree_model_iter_n_children (gtk_combo_box_get_model (GTK_COMBO_BOX (lang_chooser)), NULL)) { gtk_combo_box_set_active (GTK_COMBO_BOX (CWID ("xkb_languages_available")), FALSE); } else { /* If language info is not available - remove the corresponding tab, pretend there is no notebook at all */ gtk_notebook_remove_page (GTK_NOTEBOOK (notebook), 1); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE); gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE); } #ifdef HAVE_X11_EXTENSIONS_XKB_H if (!strcmp (xkl_engine_get_backend_name (engine), "XKB")) { kbdraw = xkb_layout_preview_create_widget (chooser_dialog); g_object_set_data (G_OBJECT (chooser), "kbdraw", kbdraw); gtk_container_add (GTK_CONTAINER (CWID ("previewFrame")), kbdraw); gtk_widget_show_all (kbdraw); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (CWID ("hbtnBox")), CWID ("btnPrint"), TRUE); } else #endif { gtk_widget_hide_all (CWID ("vboxPreview")); gtk_widget_hide (CWID ("btnPrint")); } g_signal_connect (G_OBJECT (chooser), "response", G_CALLBACK (xkb_layout_chooser_response), chooser_dialog); toplevel = gtk_widget_get_toplevel (chooser); if (gtk_widget_is_toplevel (toplevel)) { GdkRectangle *rect = matekbd_preview_load_position (); if (rect != NULL) { gtk_window_move (GTK_WINDOW (toplevel), rect->x, rect->y); gtk_window_resize (GTK_WINDOW (toplevel), rect->width, rect->height); g_free (rect); } } xkb_layout_preview_update (chooser_dialog); gtk_dialog_run (GTK_DIALOG (chooser)); gtk_widget_destroy (chooser); }
static void * finch_request_fields(const char *title, const char *primary, const char *secondary, PurpleRequestFields *allfields, const char *ok, GCallback ok_cb, const char *cancel, GCallback cancel_cb, PurpleAccount *account, const char *who, PurpleConversation *conv, void *userdata) { GntWidget *window, *box; GList *grlist; GntWidget *screenname = NULL, *accountlist = NULL; window = setup_request_window(title, primary, secondary, PURPLE_REQUEST_FIELDS); /* This is how it's going to work: the request-groups are going to be * stacked vertically one after the other. A GntLine will be separating * the groups. */ box = gnt_vbox_new(FALSE); gnt_box_set_pad(GNT_BOX(box), 0); gnt_box_set_fill(GNT_BOX(box), TRUE); for (grlist = purple_request_fields_get_groups(allfields); grlist; grlist = grlist->next) { PurpleRequestFieldGroup *group = grlist->data; GList *fields = purple_request_field_group_get_fields(group); GntWidget *hbox; const char *title = purple_request_field_group_get_title(group); if (title) gnt_box_add_widget(GNT_BOX(box), gnt_label_new_with_format(title, GNT_TEXT_FLAG_BOLD)); for (; fields ; fields = fields->next) { /* XXX: Break each of the fields into a separate function? */ PurpleRequestField *field = fields->data; PurpleRequestFieldType type = purple_request_field_get_type(field); const char *label = purple_request_field_get_label(field); hbox = gnt_hbox_new(TRUE); /* hrm */ gnt_box_add_widget(GNT_BOX(box), hbox); if (type != PURPLE_REQUEST_FIELD_BOOLEAN && label) { GntWidget *l; if (purple_request_field_is_required(field)) l = gnt_label_new_with_format(label, GNT_TEXT_FLAG_UNDERLINE); else l = gnt_label_new(label); gnt_widget_set_size(l, 0, 1); gnt_box_add_widget(GNT_BOX(hbox), l); } if (type == PURPLE_REQUEST_FIELD_BOOLEAN) { FINCH_SET_DATA(field, create_boolean_field(field)); } else if (type == PURPLE_REQUEST_FIELD_STRING) { FINCH_SET_DATA(field, create_string_field(field, &screenname)); } else if (type == PURPLE_REQUEST_FIELD_INTEGER) { FINCH_SET_DATA(field, create_integer_field(field)); } else if (type == PURPLE_REQUEST_FIELD_CHOICE) { FINCH_SET_DATA(field, create_choice_field(field)); } else if (type == PURPLE_REQUEST_FIELD_LIST) { FINCH_SET_DATA(field, create_list_field(field)); } else if (type == PURPLE_REQUEST_FIELD_ACCOUNT) { accountlist = FINCH_SET_DATA(field, create_account_field(field)); } else { FINCH_SET_DATA(field, gnt_label_new_with_format(_("Not implemented yet."), GNT_TEXT_FLAG_BOLD)); } gnt_box_set_alignment(GNT_BOX(hbox), GNT_ALIGN_MID); gnt_box_add_widget(GNT_BOX(hbox), GNT_WIDGET(FINCH_GET_DATA(field))); } if (grlist->next) gnt_box_add_widget(GNT_BOX(box), gnt_hline_new()); } gnt_box_add_widget(GNT_BOX(window), box); box = setup_button_box(window, userdata, request_fields_cb, allfields, ok, ok_cb, cancel, cancel_cb, NULL); gnt_box_add_widget(GNT_BOX(window), box); setup_default_callback(window, cancel_cb, userdata); gnt_widget_show(window); if (screenname && accountlist) { g_signal_connect(screenname, "completion", G_CALLBACK(update_selected_account), accountlist); } g_object_set_data(G_OBJECT(window), "fields", allfields); return window; }
GtkWidget * create_applications_menu (const char *menu_file, const char *menu_path, gboolean always_show_image) { GMenuTree *tree; GtkWidget *menu; guint idle_id; GError *error = NULL; menu = create_empty_menu (); if (always_show_image) g_object_set_data (G_OBJECT (menu), "panel-menu-force-icon-for-categories", GINT_TO_POINTER (TRUE)); tree = gmenu_tree_new (menu_file, GMENU_TREE_FLAGS_SORT_DISPLAY_NAME); if (!gmenu_tree_load_sync (tree, &error)) { g_warning ("Failed to load applications: %s", error->message); g_clear_error (&error); return menu; } g_object_set_data_full (G_OBJECT (menu), "panel-menu-tree", g_object_ref (tree), (GDestroyNotify) g_object_unref); g_object_set_data_full (G_OBJECT (menu), "panel-menu-tree-path", g_strdup (menu_path ? menu_path : "/"), (GDestroyNotify) g_free); g_object_set_data (G_OBJECT (menu), "panel-menu-needs-loading", GUINT_TO_POINTER (TRUE)); g_signal_connect (menu, "show", G_CALLBACK (submenu_to_display), NULL); idle_id = g_idle_add_full (G_PRIORITY_LOW, submenu_to_display_in_idle, menu, NULL); g_object_set_data_full (G_OBJECT (menu), "panel-menu-idle-id", GUINT_TO_POINTER (idle_id), remove_submenu_to_display_idle); g_signal_connect (menu, "button_press_event", G_CALLBACK (menu_dummy_button_press_event), NULL); g_signal_connect (tree, "changed", G_CALLBACK (handle_gmenu_tree_changed), menu); g_signal_connect (menu, "destroy", G_CALLBACK (remove_gmenu_tree_monitor), tree); g_object_unref (tree); return menu; }
bool ClientHandler::OnJSDialog(CefRefPtr<CefBrowser> browser, const CefString& origin_url, const CefString& accept_lang, JSDialogType dialog_type, const CefString& message_text, const CefString& default_prompt_text, CefRefPtr<CefJSDialogCallback> callback, bool& suppress_message) { CEF_REQUIRE_UI_THREAD(); GtkButtonsType buttons = GTK_BUTTONS_NONE; GtkMessageType gtk_message_type = GTK_MESSAGE_OTHER; std::string title; switch (dialog_type) { case JSDIALOGTYPE_ALERT: buttons = GTK_BUTTONS_NONE; gtk_message_type = GTK_MESSAGE_WARNING; title = "JavaScript Alert"; break; case JSDIALOGTYPE_CONFIRM: buttons = GTK_BUTTONS_CANCEL; gtk_message_type = GTK_MESSAGE_QUESTION; title = "JavaScript Confirm"; break; case JSDIALOGTYPE_PROMPT: buttons = GTK_BUTTONS_CANCEL; gtk_message_type = GTK_MESSAGE_QUESTION; title = "JavaScript Prompt"; break; } js_dialog_callback_ = callback; if (!origin_url.empty()) { title += " - "; title += origin_url.ToString(); } GtkWidget* window = gtk_widget_get_ancestor( GTK_WIDGET(GetMainWindowHandle()), GTK_TYPE_WINDOW); gtk_dialog_ = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, gtk_message_type, buttons, "%s", message_text.ToString().c_str()); g_signal_connect(gtk_dialog_, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); gtk_window_set_title(GTK_WINDOW(gtk_dialog_), title.c_str()); GtkWidget* ok_button = gtk_dialog_add_button(GTK_DIALOG(gtk_dialog_), GTK_STOCK_OK, GTK_RESPONSE_OK); if (dialog_type != JSDIALOGTYPE_PROMPT) gtk_widget_grab_focus(ok_button); if (dialog_type == JSDIALOGTYPE_PROMPT) { GtkWidget* content_area = gtk_dialog_get_content_area(GTK_DIALOG(gtk_dialog_)); GtkWidget* text_box = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(text_box), default_prompt_text.ToString().c_str()); gtk_box_pack_start(GTK_BOX(content_area), text_box, TRUE, TRUE, 0); g_object_set_data(G_OBJECT(gtk_dialog_), kPromptTextId, text_box); gtk_entry_set_activates_default(GTK_ENTRY(text_box), TRUE); } gtk_dialog_set_default_response(GTK_DIALOG(gtk_dialog_), GTK_RESPONSE_OK); g_signal_connect(gtk_dialog_, "response", G_CALLBACK(OnDialogResponse), this); gtk_widget_show_all(GTK_WIDGET(gtk_dialog_)); return true; }
static void dev_set_probes(GtkAction *action, GtkWindow *parent) { (void)action; struct sr_device *device = g_object_get_data(G_OBJECT(parent), "device"); if (!device) return; GtkWidget *dialog = gtk_dialog_new_with_buttons("Configure Probes", parent, GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request(sw, 300, 200); GtkWidget *tv = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER(sw), tv); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), sw, TRUE, TRUE, 0); /* Populate list store with probe options */ GtkListStore *probes = gtk_list_store_new(MAX_PROBE, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_STRING, GTK_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(tv), GTK_TREE_MODEL(probes)); GtkTreeIter iter; GSList *p; int i; for (p = device->probes, i = 1; p; p = g_slist_next(p), i++) { struct sr_probe *probe = p->data; gtk_list_store_append(probes, &iter); gtk_list_store_set(probes, &iter, PROBE_NUMBER, i, PROBE_ENABLED, probe->enabled, PROBE_NAME, probe->name, PROBE_TRIGGER, probe->trigger, -1); } /* Save device with list so that property can be set by edited * handler. */ g_object_set_data(G_OBJECT(probes), "device", device); /* Add columns to the tree view */ GtkTreeViewColumn *col; col = gtk_tree_view_column_new_with_attributes("Probe", gtk_cell_renderer_text_new(), "text", PROBE_NUMBER, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col); GtkCellRenderer *cel = gtk_cell_renderer_toggle_new(); g_object_set(cel, "activatable", TRUE, NULL); g_signal_connect(cel, "toggled", G_CALLBACK(probe_toggled), probes); col = gtk_tree_view_column_new_with_attributes("En", cel, "active", PROBE_ENABLED, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col); cel = gtk_cell_renderer_text_new(); g_object_set(cel, "editable", TRUE, NULL); g_signal_connect(cel, "edited", G_CALLBACK(probe_named), probes); col = gtk_tree_view_column_new_with_attributes("Signal Name", cel, "text", PROBE_NAME, "sensitive", PROBE_ENABLED, NULL); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col); cel = gtk_cell_renderer_text_new(); g_object_set(cel, "editable", TRUE, NULL); g_signal_connect(cel, "edited", G_CALLBACK(probe_trigger_set), probes); col = gtk_tree_view_column_new_with_attributes("Trigger", cel, "text", PROBE_TRIGGER, "sensitive", PROBE_ENABLED, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col); gtk_widget_show_all(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); }
static void exo_toolbars_editor_update (ExoToolbarsEditor *editor) { GtkAction *action; GtkWidget *image; GtkWidget *item; GList *children; GList *actions; GList *lp; gchar *stock; gchar *text; gint height; gint width = 4; gint x = 0; gint y = 0; if (editor->priv->finalizing) return; /* remove all existing tool items */ children = gtk_container_get_children (GTK_CONTAINER (editor->priv->table)); for (lp = children; lp != NULL; lp = lp->next) gtk_container_remove (GTK_CONTAINER (editor->priv->table), lp->data); g_list_free (children); if (editor->priv->model == NULL || editor->priv->ui_manager == NULL) return; gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE); actions = exo_toolbars_editor_get_actions (editor, editor->priv->model); height = g_list_length (actions) / width + 1; gtk_table_resize (GTK_TABLE (editor->priv->table), height, width); for (lp = actions; lp != NULL; lp = lp->next) { action = lp->data; g_object_get (G_OBJECT (action), "short-label", &text, "stock-id", &stock, NULL); if (G_UNLIKELY (stock == NULL)) stock = g_strdup (GTK_STOCK_DND); image = gtk_image_new_from_icon_name (stock, GTK_ICON_SIZE_LARGE_TOOLBAR); item = exo_toolbars_editor_create_item (editor, image, text, GDK_ACTION_MOVE); g_object_set_data (G_OBJECT (item), I_("gtk-action"), action); gtk_table_attach_defaults (GTK_TABLE (editor->priv->table), item, x, x + 1, y, y + 1); g_free (stock); g_free (text); if (++x >= width) { x= 0; ++y; } } g_list_free (actions); image = _exo_toolbars_new_separator_image (); item = exo_toolbars_editor_create_item (editor, image, _("Separator"), GDK_ACTION_COPY); gtk_table_attach_defaults (GTK_TABLE (editor->priv->table), item, x, x + 1, y, y + 1); return; }
static void add_address_row (CEPageIP4 *page, const gchar *address, const gchar *network, const gchar *gateway) { GtkWidget *row; GtkWidget *row_grid; GtkWidget *widget; GtkWidget *label; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); row_grid = gtk_grid_new (); label = gtk_label_new (_("Address")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 1, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 1, 1, 1); label = gtk_label_new (_("Netmask")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 2, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "network", widget); gtk_entry_set_text (GTK_ENTRY (widget), network); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 2, 1, 1); label = gtk_label_new (_("Gateway")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 3, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "gateway", widget); gtk_entry_set_text (GTK_ENTRY (widget), gateway); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 3, 1, 1); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete Address")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_grid_attach (GTK_GRID (row_grid), delete_button, 3, 2, 1, 1); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_grid_set_row_spacing (GTK_GRID (row_grid), 10); gtk_widget_set_margin_start (row_grid, 10); gtk_widget_set_margin_end (row_grid, 10); gtk_widget_set_margin_top (row_grid, 10); gtk_widget_set_margin_bottom (row_grid, 10); gtk_widget_set_halign (row_grid, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_grid); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->address_list), row); update_row_sensitivity (page, page->address_list); }
static void add_route_row (CEPageIP4 *page, const gchar *address, const gchar *netmask, const gchar *gateway, gint metric) { GtkWidget *row; GtkWidget *row_grid; GtkWidget *label; GtkWidget *widget; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); row_grid = gtk_grid_new (); label = gtk_label_new (_("Address")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 1, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 1, 1, 1); label = gtk_label_new (_("Netmask")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 2, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "netmask", widget); gtk_entry_set_text (GTK_ENTRY (widget), netmask); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 2, 1, 1); label = gtk_label_new (_("Gateway")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 3, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "gateway", widget); gtk_entry_set_text (GTK_ENTRY (widget), gateway); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 3, 1, 1); /* Translators: Please see https://en.wikipedia.org/wiki/Metrics_(networking) */ label = gtk_label_new (C_("network parameters", "Metric")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 4, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "metric", widget); if (metric > 0) { gchar *s = g_strdup_printf ("%d", metric); gtk_entry_set_text (GTK_ENTRY (widget), s); g_free (s); } gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 4, 1, 1); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete Route")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_widget_set_halign (delete_button, GTK_ALIGN_CENTER); gtk_widget_set_valign (delete_button, GTK_ALIGN_CENTER); gtk_grid_attach (GTK_GRID (row_grid), delete_button, 3, 1, 1, 4); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_grid_set_row_spacing (GTK_GRID (row_grid), 10); gtk_widget_set_margin_start (row_grid, 10); gtk_widget_set_margin_end (row_grid, 10); gtk_widget_set_margin_top (row_grid, 10); gtk_widget_set_margin_bottom (row_grid, 10); gtk_widget_set_halign (row_grid, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_grid); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->routes_list), row); update_row_sensitivity (page, page->routes_list); }
static void close_mkrcp( GtkWidget *widget, gpointer data ) { g_return_if_fail(data != NULL); g_object_set_data(G_OBJECT(data), "mkrcp_dialog", NULL); }
MetaWindowMenu* meta_window_menu_new (MetaFrames *frames, MetaMenuOp ops, MetaMenuOp insensitive, Window client_xwindow, unsigned long active_workspace, int n_workspaces, MetaWindowMenuFunc func, gpointer data) { int i; MetaWindowMenu *menu; /* FIXME: Modifications to 'ops' should happen in meta_window_show_menu */ if (n_workspaces < 2) ops &= ~(META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES); else if (n_workspaces == 2) /* #151183: If we only have two workspaces, disable the menu listing them. */ ops &= ~(META_MENU_OP_WORKSPACES); menu = g_new (MetaWindowMenu, 1); menu->frames = frames; menu->client_xwindow = client_xwindow; menu->func = func; menu->data = data; menu->ops = ops; menu->insensitive = insensitive; menu->menu = gtk_menu_new (); gtk_menu_set_screen (GTK_MENU (menu->menu), gtk_widget_get_screen (GTK_WIDGET (frames))); for (i = 0; i < (int) G_N_ELEMENTS (menuitems); i++) { MenuItem menuitem = menuitems[i]; if (ops & menuitem.op || menuitem.op == 0) { GtkWidget *mi; MenuData *md; unsigned int key; MetaVirtualModifier mods; mi = menu_item_new (&menuitem, -1); /* Set the activeness of radiobuttons. */ switch (menuitem.op) { case META_MENU_OP_STICK: gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), active_workspace == 0xFFFFFFFF); break; case META_MENU_OP_UNSTICK: gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), active_workspace != 0xFFFFFFFF); break; default: break; } if (menuitem.type == MENU_ITEM_WORKSPACE_LIST) { if (ops & META_MENU_OP_WORKSPACES) { Display *display; Window xroot; GdkScreen *screen; GdkWindow *window; GtkWidget *submenu; int j; MenuItem to_another_workspace = { 0, MENU_ITEM_NORMAL, NULL, FALSE, N_("Move to Another _Workspace") }; meta_verbose ("Creating %d-workspace menu current space %lu\n", n_workspaces, active_workspace); window = gtk_widget_get_window (GTK_WIDGET (frames)); display = GDK_WINDOW_XDISPLAY (window); screen = gdk_window_get_screen (window); xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen)); submenu = gtk_menu_new (); g_assert (mi==NULL); mi = menu_item_new (&to_another_workspace, -1); gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), submenu); for (j = 0; j < n_workspaces; j++) { char *label; MenuData *md; unsigned int key; MetaVirtualModifier mods; MenuItem moveitem; GtkWidget *submi; meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES, j + 1, &key, &mods); label = get_workspace_name_with_accel (display, xroot, j); moveitem.type = MENU_ITEM_NORMAL; moveitem.op = META_MENU_OP_WORKSPACES; moveitem.label = label; submi = menu_item_new (&moveitem, j + 1); g_free (label); if ((active_workspace == (unsigned)j) && (ops & META_MENU_OP_UNSTICK)) gtk_widget_set_sensitive (submi, FALSE); md = g_new (MenuData, 1); md->menu = menu; md->op = META_MENU_OP_WORKSPACES; g_object_set_data (G_OBJECT (submi), "workspace", GINT_TO_POINTER (j)); g_signal_connect_data (G_OBJECT (submi), "activate", G_CALLBACK (activate_cb), md, (GClosureNotify) g_free, 0); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), submi); gtk_widget_show (submi); } } else meta_verbose ("not creating workspace menu\n"); } else if (menuitem.type != MENU_ITEM_SEPARATOR) { meta_core_get_menu_accelerator (menuitems[i].op, -1, &key, &mods); if (insensitive & menuitem.op) gtk_widget_set_sensitive (mi, FALSE); md = g_new (MenuData, 1); md->menu = menu; md->op = menuitem.op; g_signal_connect_data (G_OBJECT (mi), "activate", G_CALLBACK (activate_cb), md, (GClosureNotify) g_free, 0); } if (mi) { gtk_menu_shell_append (GTK_MENU_SHELL (menu->menu), mi); gtk_widget_show (mi); } } } g_signal_connect (menu->menu, "selection_done", G_CALLBACK (menu_closed), menu); return menu; }
GtkWidget *bar_new(LayoutWindow *lw) { BarData *bd; GtkWidget *box; GtkWidget *scrolled; GtkWidget *tbar; GtkWidget *add_box; bd = g_new0(BarData, 1); bd->lw = lw; bd->widget = gtk_vbox_new(FALSE, PREF_PAD_GAP); g_object_set_data(G_OBJECT(bd->widget), "bar_data", bd); g_signal_connect(G_OBJECT(bd->widget), "destroy", G_CALLBACK(bar_destroy), bd); g_signal_connect(G_OBJECT(bd->widget), "size-allocate", G_CALLBACK(bar_size_allocate), bd); g_signal_connect(G_OBJECT(bd->widget), "button_release_event", G_CALLBACK(bar_menu_cb), bd); bd->width = SIDEBAR_DEFAULT_WIDTH; gtk_widget_set_size_request(bd->widget, bd->width, -1); box = gtk_hbox_new(FALSE, 0); bd->label_file_name = gtk_label_new(""); gtk_label_set_ellipsize(GTK_LABEL(bd->label_file_name), PANGO_ELLIPSIZE_END); gtk_label_set_selectable(GTK_LABEL(bd->label_file_name), TRUE); gtk_misc_set_alignment(GTK_MISC(bd->label_file_name), 0.5, 0.5); gtk_box_pack_start(GTK_BOX(box), bd->label_file_name, TRUE, TRUE, 0); gtk_widget_show(bd->label_file_name); gtk_box_pack_start(GTK_BOX(bd->widget), box, FALSE, FALSE, 0); gtk_widget_show(box); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(bd->widget), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); bd->vbox = gtk_vbox_new(FALSE, 0); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), bd->vbox); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_bin_get_child(GTK_BIN(scrolled))), GTK_SHADOW_NONE); add_box = gtk_vbox_new(FALSE, 0); gtk_box_pack_end(GTK_BOX(bd->widget), add_box, FALSE, FALSE, 0); tbar = pref_toolbar_new(add_box, GTK_TOOLBAR_ICONS); bd->add_button = pref_toolbar_button(tbar, GTK_STOCK_ADD, NULL, FALSE, _("Add Pane"), G_CALLBACK(bar_menu_add_cb), bd); gtk_widget_show(add_box); #ifdef HAVE_LIBCHAMPLAIN_GTK g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN(scrolled))), "unrealize", G_CALLBACK(bar_unrealize_clutter_fix_cb), NULL); #endif gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_NONE); gtk_widget_show(bd->vbox); return bd->widget; }
int dt_gui_gtk_init(dt_gui_gtk_t *gui, int argc, char *argv[]) { // unset gtk rc from kde: char gtkrc[PATH_MAX], path[PATH_MAX], datadir[PATH_MAX], configdir[PATH_MAX]; dt_loc_get_datadir(datadir, PATH_MAX); dt_loc_get_user_config_dir(configdir, PATH_MAX); g_snprintf(gtkrc, PATH_MAX, "%s/darktable.gtkrc", configdir); if (!g_file_test(gtkrc, G_FILE_TEST_EXISTS)) g_snprintf(gtkrc, PATH_MAX, "%s/darktable.gtkrc", datadir); if (g_file_test(gtkrc, G_FILE_TEST_EXISTS)) (void)setenv("GTK2_RC_FILES", gtkrc, 1); else fprintf(stderr, "[gtk_init] could not found darktable.gtkrc"); /* lets zero mem */ memset(gui,0,sizeof(dt_gui_gtk_t)); #if GLIB_MAJOR_VERSION <= 2 #if GLIB_MINOR_VERSION < 31 if (!g_thread_supported ()) g_thread_init(NULL); #endif #endif gdk_threads_init(); gdk_threads_enter(); gtk_init (&argc, &argv); GtkWidget *widget; gui->ui = dt_ui_initialize(argc,argv); gui->pixmap = NULL; gui->center_tooltip = 0; gui->presets_popup_menu = NULL; if(g_file_test(gtkrc, G_FILE_TEST_EXISTS)) gtk_rc_parse (gtkrc); // Initializing the shortcut groups darktable.control->accelerators = gtk_accel_group_new(); darktable.control->accelerator_list = NULL; // Connecting the callback to update keyboard accels for key_pressed g_signal_connect(G_OBJECT(gtk_accel_map_get()), "changed", G_CALLBACK(key_accel_changed), NULL); // Initializing widgets init_widgets(); // Adding the global shortcut group to the main window gtk_window_add_accel_group(GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)), darktable.control->accelerators); // get the screen resolution gui->dpi = gdk_screen_get_resolution(gtk_widget_get_screen(GTK_WIDGET(dt_ui_main_window(darktable.gui->ui)))); // set constant width from conf key int panel_width = dt_conf_get_int("panel_width"); if(panel_width < 20 || panel_width > 500) { // fix for unset/insane values. panel_width = 300; dt_conf_set_int("panel_width", panel_width); } // dt_gui_background_jobs_init(); /* Have the delete event (window close) end the program */ dt_loc_get_datadir(datadir, PATH_MAX); snprintf(path, PATH_MAX, "%s/icons", datadir); gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), path); widget = dt_ui_center(darktable.gui->ui); g_signal_connect (G_OBJECT (widget), "key-press-event", G_CALLBACK (key_pressed), NULL); g_signal_connect (G_OBJECT (widget), "configure-event", G_CALLBACK (configure), NULL); g_signal_connect (G_OBJECT (widget), "expose-event", G_CALLBACK (expose), NULL); g_signal_connect (G_OBJECT (widget), "motion-notify-event", G_CALLBACK (mouse_moved), NULL); g_signal_connect (G_OBJECT (widget), "leave-notify-event", G_CALLBACK (center_leave), NULL); g_signal_connect (G_OBJECT (widget), "enter-notify-event", G_CALLBACK (center_enter), NULL); g_signal_connect (G_OBJECT (widget), "button-press-event", G_CALLBACK (button_pressed), NULL); g_signal_connect (G_OBJECT (widget), "button-release-event", G_CALLBACK (button_released), NULL); g_signal_connect (G_OBJECT (widget), "scroll-event", G_CALLBACK (scrolled), NULL); // TODO: left, right, top, bottom: //leave-notify-event widget = darktable.gui->widgets.left_border; g_signal_connect (G_OBJECT (widget), "expose-event", G_CALLBACK (expose_borders), (gpointer)0); g_signal_connect (G_OBJECT (widget), "button-press-event", G_CALLBACK (borders_button_pressed), darktable.gui->ui); g_signal_connect (G_OBJECT (widget), "scroll-event", G_CALLBACK (borders_scrolled), (gpointer)0); g_object_set_data(G_OBJECT (widget), "border", (gpointer)0); widget = darktable.gui->widgets.right_border; g_signal_connect (G_OBJECT (widget), "expose-event", G_CALLBACK (expose_borders), (gpointer)1); g_signal_connect (G_OBJECT (widget), "button-press-event", G_CALLBACK (borders_button_pressed), darktable.gui->ui); g_signal_connect (G_OBJECT (widget), "scroll-event", G_CALLBACK (borders_scrolled), (gpointer)1); g_object_set_data(G_OBJECT (widget), "border", (gpointer)1); widget = darktable.gui->widgets.top_border; g_signal_connect (G_OBJECT (widget), "expose-event", G_CALLBACK (expose_borders), (gpointer)2); g_signal_connect (G_OBJECT (widget), "button-press-event", G_CALLBACK (borders_button_pressed), darktable.gui->ui); g_signal_connect (G_OBJECT (widget), "scroll-event", G_CALLBACK (borders_scrolled), (gpointer)2); g_object_set_data(G_OBJECT (widget), "border", (gpointer)2); widget = darktable.gui->widgets.bottom_border; g_signal_connect (G_OBJECT (widget), "expose-event", G_CALLBACK (expose_borders), (gpointer)3); g_signal_connect (G_OBJECT (widget), "button-press-event", G_CALLBACK (borders_button_pressed), darktable.gui->ui); g_signal_connect (G_OBJECT (widget), "scroll-event", G_CALLBACK (borders_scrolled), (gpointer)3); g_object_set_data(G_OBJECT (widget), "border", (gpointer)3); dt_gui_presets_init(); widget = dt_ui_center(darktable.gui->ui); GTK_WIDGET_UNSET_FLAGS (widget, GTK_DOUBLE_BUFFERED); // GTK_WIDGET_SET_FLAGS (widget, GTK_DOUBLE_BUFFERED); GTK_WIDGET_SET_FLAGS (widget, GTK_APP_PAINTABLE); // TODO: make this work as: libgnomeui testgnome.c /* GtkContainer *box = GTK_CONTAINER(darktable.gui->widgets.plugins_vbox); GtkScrolledWindow *swin = GTK_SCROLLED_WINDOW(darktable.gui-> widgets.right_scrolled_window); gtk_container_set_focus_vadjustment (box, gtk_scrolled_window_get_vadjustment (swin)); */ dt_ctl_get_display_profile(widget, &darktable.control->xprofile_data, &darktable.control->xprofile_size); // register keys for view switching dt_accel_register_global(NC_("accel", "capture view"), GDK_t, 0); dt_accel_register_global(NC_("accel", "lighttable view"), GDK_l, 0); dt_accel_register_global(NC_("accel", "darkroom view"), GDK_d, 0); dt_accel_connect_global( "capture view", g_cclosure_new(G_CALLBACK(_gui_switch_view_key_accel_callback), (gpointer)DT_GUI_VIEW_SWITCH_TO_TETHERING, NULL)); dt_accel_connect_global( "lighttable view", g_cclosure_new(G_CALLBACK(_gui_switch_view_key_accel_callback), (gpointer)DT_GUI_VIEW_SWITCH_TO_LIBRARY, NULL)); dt_accel_connect_global( "darkroom view", g_cclosure_new(G_CALLBACK(_gui_switch_view_key_accel_callback), (gpointer)DT_GUI_VIEW_SWITCH_TO_DARKROOM, NULL)); // register_keys for applying styles init_styles_key_accels(); connect_styles_key_accels(); // register ctrl-q to quit: dt_accel_register_global(NC_("accel", "quit"), GDK_q, GDK_CONTROL_MASK); dt_accel_connect_global( "quit", g_cclosure_new(G_CALLBACK(quit_callback), NULL, NULL)); // Contrast and brightness accelerators dt_accel_register_global(NC_("accel", "increase brightness"), GDK_F10, 0); dt_accel_register_global(NC_("accel", "decrease brightness"), GDK_F9, 0); dt_accel_register_global(NC_("accel", "increase contrast"), GDK_F8, 0); dt_accel_register_global(NC_("accel", "decrease contrast"), GDK_F7, 0); dt_accel_connect_global( "increase brightness", g_cclosure_new(G_CALLBACK(brightness_key_accel_callback), (gpointer)1, NULL)); dt_accel_connect_global( "decrease brightness", g_cclosure_new(G_CALLBACK(brightness_key_accel_callback), (gpointer)0, NULL)); dt_accel_connect_global( "increase contrast", g_cclosure_new(G_CALLBACK(contrast_key_accel_callback), (gpointer)1, NULL)); dt_accel_connect_global( "decrease contrast", g_cclosure_new(G_CALLBACK(contrast_key_accel_callback), (gpointer)0, NULL)); // Full-screen accelerators dt_accel_register_global(NC_("accel", "toggle fullscreen"), GDK_F11, 0); dt_accel_register_global(NC_("accel", "leave fullscreen"), GDK_Escape, 0); dt_accel_connect_global( "toggle fullscreen", g_cclosure_new(G_CALLBACK(fullscreen_key_accel_callback), (gpointer)1, NULL)); dt_accel_connect_global( "leave fullscreen", g_cclosure_new(G_CALLBACK(fullscreen_key_accel_callback), (gpointer)0, NULL)); // Side-border hide/show dt_accel_register_global(NC_("accel", "toggle side borders"), GDK_Tab, 0); // toggle view of header dt_accel_register_global(NC_("accel", "toggle header"), GDK_h, GDK_CONTROL_MASK); // View-switch dt_accel_register_global(NC_("accel", "switch view"), GDK_period, 0); dt_accel_connect_global( "switch view", g_cclosure_new(G_CALLBACK(view_switch_key_accel_callback), NULL, NULL)); darktable.gui->reset = 0; for(int i=0; i<3; i++) darktable.gui->bgcolor[i] = 0.1333; /* apply contrast to theme */ dt_gui_contrast_init (); return 0; }
static GtkWidget * quit_close_all_dialog_new (Gimp *gimp, gboolean do_quit) { GimpContainer *images; GimpContext *context; GimpMessageBox *box; GtkWidget *dialog; GtkWidget *label; GtkWidget *button; GtkWidget *view; GtkWidget *dnd_widget; gint rows; gint view_size; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); /* FIXME: need container of dirty images */ images = gimp_displays_get_dirty_images (gimp); context = gimp_context_new (gimp, "close-all-dialog", gimp_get_user_context (gimp)); g_return_val_if_fail (images != NULL, NULL); dialog = gimp_message_dialog_new (do_quit ? _("Quit GIMP") : _("Close All Images"), GIMP_STOCK_WARNING, NULL, 0, gimp_standard_help_func, do_quit ? GIMP_HELP_FILE_QUIT : GIMP_HELP_FILE_CLOSE_ALL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); g_object_set_data_full (G_OBJECT (dialog), "dirty-images", images, (GDestroyNotify) g_object_unref); g_object_set_data_full (G_OBJECT (dialog), "dirty-images-context", context, (GDestroyNotify) g_object_unref); g_signal_connect (dialog, "response", G_CALLBACK (quit_close_all_dialog_response), gimp); box = GIMP_MESSAGE_DIALOG (dialog)->box; button = gtk_dialog_add_button (GTK_DIALOG (dialog), "", GTK_RESPONSE_OK); g_object_set_data (G_OBJECT (box), "ok-button", button); g_object_set_data (G_OBJECT (box), "do-quit", GINT_TO_POINTER (do_quit)); g_signal_connect_object (images, "add", G_CALLBACK (quit_close_all_dialog_container_changed), box, 0); g_signal_connect_object (images, "remove", G_CALLBACK (quit_close_all_dialog_container_changed), box, 0); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); view_size = gimp->config->layer_preview_size; rows = CLAMP (gimp_container_get_n_children (images), 3, 6); view = gimp_container_tree_view_new (images, context, view_size, 1); gimp_container_box_set_size_request (GIMP_CONTAINER_BOX (view), -1, rows * (view_size + 2)); gtk_box_pack_start (GTK_BOX (box), view, TRUE, TRUE, 0); gtk_widget_show (view); g_signal_connect (view, "activate-item", G_CALLBACK (quit_close_all_dialog_image_activated), gimp); dnd_widget = gimp_container_view_get_dnd_widget (GIMP_CONTAINER_VIEW (view)); gimp_dnd_xds_source_add (dnd_widget, (GimpDndDragViewableFunc) gimp_dnd_get_drag_data, NULL); if (do_quit) label = gtk_label_new (_("If you quit GIMP now, " "these changes will be lost.")); else label = gtk_label_new (_("If you close these images now, " "changes will be lost.")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); g_object_set_data (G_OBJECT (box), "lost-label", label); quit_close_all_dialog_container_changed (images, NULL, GIMP_MESSAGE_DIALOG (dialog)->box); return dialog; }
void termit_append_tab_with_details(const struct TabInfo* ti) { struct TermitTab* pTab = g_malloc0(sizeof(struct TermitTab)); termit_style_copy(&pTab->style, &configs.style); if (ti->name) { pTab->tab_name = gtk_label_new(ti->name); pTab->custom_tab_name = TRUE; } else { gchar* label_text = g_strdup_printf("%s %d", configs.default_tab_name, termit.tab_max_number++); pTab->tab_name = gtk_label_new(label_text); g_free(label_text); pTab->custom_tab_name = FALSE; } pTab->encoding = (ti->encoding) ? g_strdup(ti->encoding) : g_strdup(configs.default_encoding); pTab->bksp_binding = ti->bksp_binding; pTab->delete_binding = ti->delete_binding; pTab->hbox = gtk_hbox_new(FALSE, 0); pTab->vte = vte_terminal_new(); vte_terminal_set_scrollback_lines(VTE_TERMINAL(pTab->vte), configs.scrollback_lines); if (configs.default_word_chars) vte_terminal_set_word_chars(VTE_TERMINAL(pTab->vte), configs.default_word_chars); vte_terminal_set_mouse_autohide(VTE_TERMINAL(pTab->vte), TRUE); vte_terminal_set_backspace_binding(VTE_TERMINAL(pTab->vte), pTab->bksp_binding); vte_terminal_set_delete_binding(VTE_TERMINAL(pTab->vte), pTab->delete_binding); #ifdef TERMIT_ENABLE_SEARCH vte_terminal_search_set_wrap_around(VTE_TERMINAL(pTab->vte), TRUE); #endif // TERMIT_ENABLE_SEARCH /* parse command */ gchar **cmd_argv; GError *cmd_err = NULL; gchar *cmd_path = NULL; gchar *cmd_file = NULL; pTab->command = (ti->command) ? g_strdup(ti->command) : g_strdup(configs.default_command); if (!g_shell_parse_argv(pTab->command, NULL, &cmd_argv, &cmd_err)) { ERROR("%s", _("Cannot parse command. Creating tab with shell")); g_error_free(cmd_err); } else { cmd_path = g_find_program_in_path(cmd_argv[0]); cmd_file = g_path_get_basename(cmd_argv[0]); } TRACE("command=%s cmd_path=%s cmd_file=%s", pTab->command, cmd_path, cmd_file); if (cmd_path && cmd_file) { g_free(cmd_argv[0]); cmd_argv[0] = g_strdup(cmd_path); #if VTE_CHECK_VERSION(0, 26, 0) > 0 if (vte_terminal_fork_command_full(VTE_TERMINAL(pTab->vte), VTE_PTY_DEFAULT, ti->working_dir, cmd_argv, NULL, 0, NULL, NULL, &pTab->pid, &cmd_err) != TRUE) { ERROR("failed to open tab: %s", cmd_err->message); g_error_free(cmd_err); } #else pTab->pid = vte_terminal_fork_command(VTE_TERMINAL(pTab->vte), cmd_path, cmd_argv, NULL, ti->working_dir, TRUE, TRUE, TRUE); #endif // version >= 0.26 } else { g_free(pTab->command); pTab->command = g_strdup(configs.default_command); gchar* argv[] = {pTab->command, NULL}; TRACE("defaults: cmd=%s working_dir=%s", pTab->command, ti->working_dir); /* default tab */ #if VTE_CHECK_VERSION(0, 26, 0) > 0 if (vte_terminal_fork_command_full(VTE_TERMINAL(pTab->vte), VTE_PTY_DEFAULT, ti->working_dir, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, &pTab->pid, &cmd_err) != TRUE) { ERROR("failed to open tab: %s", cmd_err->message); g_error_free(cmd_err); } #else pTab->pid = vte_terminal_fork_command(VTE_TERMINAL(pTab->vte), pTab->command, NULL, NULL, ti->working_dir, TRUE, TRUE, TRUE); #endif // version >= 0.26 } g_strfreev(cmd_argv); g_free(cmd_path); g_free(cmd_file); g_signal_connect(G_OBJECT(pTab->vte), "beep", G_CALLBACK(termit_on_beep), pTab); g_signal_connect(G_OBJECT(pTab->vte), "focus-in-event", G_CALLBACK(termit_on_focus), pTab); g_signal_connect(G_OBJECT(pTab->vte), "window-title-changed", G_CALLBACK(termit_on_tab_title_changed), NULL); g_signal_connect(G_OBJECT(pTab->vte), "child-exited", G_CALLBACK(termit_on_child_exited), NULL); // g_signal_connect(G_OBJECT(pTab->vte), "eof", G_CALLBACK(termit_eof), NULL); g_signal_connect_swapped(G_OBJECT(pTab->vte), "button-press-event", G_CALLBACK(termit_on_popup), NULL); vte_terminal_set_encoding(VTE_TERMINAL(pTab->vte), pTab->encoding); pTab->matches = g_array_new(FALSE, TRUE, sizeof(struct Match)); termit_tab_add_matches(pTab, configs.matches); termit_tab_set_transparency(pTab, pTab->style.transparency); vte_terminal_set_font(VTE_TERMINAL(pTab->vte), pTab->style.font); gint index = gtk_notebook_append_page(GTK_NOTEBOOK(termit.notebook), pTab->hbox, pTab->tab_name); if (index == -1) { ERROR("%s", _("Cannot create a new tab")); return; } if (configs.fill_tabbar) { GValue val = {}; g_value_init(&val, G_TYPE_BOOLEAN); g_value_set_boolean(&val, TRUE); gtk_container_child_set_property(GTK_CONTAINER(termit.notebook), pTab->hbox, "tab-expand", &val); gtk_container_child_set_property(GTK_CONTAINER(termit.notebook), pTab->hbox, "tab-fill", &val); } termit_tab_set_audible_bell(pTab, configs.audible_bell); termit_tab_set_visible_bell(pTab, configs.visible_bell); pTab->scrollbar = gtk_vscrollbar_new(vte_terminal_get_adjustment(VTE_TERMINAL(pTab->vte))); gtk_box_pack_start(GTK_BOX(pTab->hbox), pTab->vte, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(pTab->hbox), pTab->scrollbar, FALSE, FALSE, 0); GtkWidget* tabWidget = gtk_notebook_get_nth_page(GTK_NOTEBOOK(termit.notebook), index); if (!tabWidget) { ERROR("tabWidget is NULL"); return; } g_object_set_data(G_OBJECT(tabWidget), TERMIT_TAB_DATA, pTab); if (index == 0) { // there is no "switch-page" signal on the first page termit_set_statusbar_message(index); } pTab->scrollbar_is_shown = configs.show_scrollbar; gtk_widget_show_all(termit.notebook); if (pTab->style.image_file == NULL) { vte_terminal_set_background_image(VTE_TERMINAL(pTab->vte), NULL); } else { vte_terminal_set_background_image_file(VTE_TERMINAL(pTab->vte), pTab->style.image_file); } termit_tab_apply_colors(pTab); gtk_notebook_set_current_page(GTK_NOTEBOOK(termit.notebook), index); gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(termit.notebook), pTab->hbox, TRUE); gtk_window_set_focus(GTK_WINDOW(termit.main_window), pTab->vte); termit_check_single_tab(); termit_hide_scrollbars(); }
/* returns a parent widget to pack the contents of the page into */ GtkWidget *gtkui_page_new(char *title, void (*callback)(void), void (*detacher)(GtkWidget *)) { GtkWidget *parent, *label; GtkWidget *hbox, *button, *image; /* a container to hold the close button and tab label */ hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox); /* the label for the tab title */ label = gtk_label_new(title); gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); gtk_widget_show(label); /* the close button */ button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); gtk_widget_set_size_request(button, 20, 20); gtk_widget_show(button); /* an image for the button */ image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_container_add(GTK_CONTAINER (button), image); gtk_widget_show(image); /* a parent to pack the contents into */ parent = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(parent), GTK_SHADOW_NONE); gtk_widget_show(parent); if(!notebook && notebook_frame) { gtk_container_remove(GTK_CONTAINER (notebook_frame), gtk_bin_get_child(GTK_BIN (notebook_frame))); notebook = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_notebook_set_scrollable(GTK_NOTEBOOK (notebook), TRUE); gtk_container_add(GTK_CONTAINER (notebook_frame), notebook); gtk_widget_show(notebook); #if GTK_MINOR_VERSION == 2 g_signal_connect(G_OBJECT (notebook), "switch-page", G_CALLBACK(gtkui_page_defocus_tabs), NULL); #endif gtkui_create_tab_menu(); } gtk_notebook_append_page(GTK_NOTEBOOK(notebook), parent, hbox); /* attach callback to destroy the tab/page */ g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK(gtkui_page_close), parent); /* attach callback to do specific clean-up */ if(callback) g_object_set_data(G_OBJECT (parent), "destroy", callback); if(detacher) g_object_set_data(G_OBJECT (parent), "detach", detacher); gtkui_page_present(parent); return(parent); }
static void dev_set_options(GtkAction *action, GtkWindow *parent) { (void)action; struct sr_device *device = g_object_get_data(G_OBJECT(parent), "device"); if (!device) return; GtkWidget *dialog = gtk_dialog_new_with_buttons("Device Properties", parent, GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request(sw, 300, 200); GtkWidget *tv = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER(sw), tv); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), sw, TRUE, TRUE, 0); /* Populate list store with config options */ GtkListStore *props = gtk_list_store_new(MAX_DEV_PROP, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN); gtk_tree_view_set_model(GTK_TREE_VIEW(tv), GTK_TREE_MODEL(props)); int *capabilities = device->plugin->get_capabilities(); int cap; GtkTreeIter iter; for (cap = 0; capabilities[cap]; cap++) { struct sr_hwcap_option *hwo; if (!(hwo = sr_find_hwcap_option(capabilities[cap]))) continue; gtk_list_store_append(props, &iter); gtk_list_store_set(props, &iter, DEV_PROP_CAPABILITY, capabilities[cap], DEV_PROP_TYPE, hwo->type, DEV_PROP_SHORTNAME, hwo->shortname, DEV_PROP_DESCRIPTION, hwo->description, DEV_PROP_IS_TEXT, hwo->type != SR_T_BOOL, -1); } /* Popup tooltop containing description if mouse hovers */ gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(tv), DEV_PROP_DESCRIPTION); /* Save device with list so that property can be set by edited * handler. */ g_object_set_data(G_OBJECT(props), "device", device); /* Add columns to the tree view */ GtkTreeViewColumn *col; col = gtk_tree_view_column_new_with_attributes("Property", gtk_cell_renderer_text_new(), "text", DEV_PROP_SHORTNAME, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col); /* We pack both a text and toggle renderer. Only one will be visible. * depending on type. */ GtkCellRenderer *cel = gtk_cell_renderer_text_new(); g_object_set(cel, "editable", TRUE, NULL); g_signal_connect(cel, "edited", G_CALLBACK(prop_edited), props); col = gtk_tree_view_column_new_with_attributes("Value", cel, "text", DEV_PROP_TEXTVALUE, "visible", DEV_PROP_IS_TEXT, NULL); cel = gtk_cell_renderer_toggle_new(); g_signal_connect(cel, "toggled", G_CALLBACK(prop_toggled), props); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(col), cel, TRUE); gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(col), cel, dev_prop_bool_data_func, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col); gtk_widget_show_all(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); }
/* * display the interface selection dialog */ static void gtkui_unified_sniff(void) { GList *iface_list; const char *iface_desc = NULL; char err[100]; GtkWidget *iface_combo; pcap_if_t *dev; GtkWidget *dialog, *label, *hbox, *image; DEBUG_MSG("gtk_unified_sniff"); dialog = gtk_dialog_new_with_buttons(EC_PROGRAM" Input", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, 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); label = gtk_label_new ("Network interface : "); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); /* make a list of network interfaces */ iface_list = NULL; for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { iface_list = g_list_append(iface_list, dev->description); } /* make a drop down box and assign the list to it */ iface_combo = gtk_combo_new(); gtk_combo_set_popdown_strings (GTK_COMBO (iface_combo), iface_list); gtk_box_pack_start (GTK_BOX (hbox), iface_combo, FALSE, FALSE, 0); /* hitting Enter in the drop down box clicks OK */ g_object_set_data(G_OBJECT (GTK_COMBO (iface_combo)->entry), "dialog", dialog); g_signal_connect(G_OBJECT (GTK_COMBO (iface_combo)->entry), "activate", G_CALLBACK (gtkui_dialog_enter), NULL); /* list is stored in the widget, can safely free this copy */ g_list_free(iface_list); /* render the contents of the dialog */ gtk_widget_show_all (hbox); /* show the dialog itself and become interactive */ if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { iface_desc = gtk_entry_get_text(GTK_ENTRY (GTK_COMBO (iface_combo)->entry)); for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { if(!strncmp(dev->description, iface_desc, IFACE_LEN)) { SAFE_FREE(GBL_OPTIONS->iface); SAFE_CALLOC(GBL_OPTIONS->iface, IFACE_LEN, sizeof(char)); strncpy(GBL_OPTIONS->iface, dev->name, IFACE_LEN); break; } } /* if no match in list */ if(GBL_OPTIONS->iface == NULL) { snprintf(err, 100, "Invalid interface: %s", iface_desc); gtkui_error(err); gtk_widget_destroy(dialog); return; } /* exit setup iterface */ gtk_widget_destroy(dialog); gtk_main_quit(); return; } gtk_widget_destroy(dialog); }
void save_as_file(GtkButton *button) { /** Save the current editor content as the choosen file. **/ #ifdef DEBUG DEBUG_FUNC_MARK #endif GtkWidget *file_chooser = gtk_file_chooser_dialog_new( _("Save as file"), GTK_WINDOW(gui->main_window), GTK_FILE_CHOOSER_ACTION_SAVE, _("Cancel"), GTK_RESPONSE_CANCEL, _("Save as"), GTK_RESPONSE_ACCEPT, NULL) ; /** Retrieve the stored filepath: **/ gpointer stored_filepath = g_object_get_data(G_OBJECT(current_editor.current_buffer), "filepath") ; /** Storing last opened file folder. **/ if (open_file_dirname != NULL) { g_free(open_file_dirname) ; } open_file_dirname = g_strdup(g_path_get_dirname(stored_filepath)) ; gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), open_file_dirname ); gint res; GtkFileChooser *chooser; chooser = GTK_FILE_CHOOSER(file_chooser); gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE); res = gtk_dialog_run(GTK_DIALOG(file_chooser)) ; if (res == GTK_RESPONSE_ACCEPT) { char *filepath ; filepath = gtk_file_chooser_get_filename(chooser); /** Getting current editor content **/ GtkTextIter iter_start, iter_end ; GError *error = NULL ; gtk_text_buffer_get_start_iter(current_editor.current_buffer, &iter_start); gtk_text_buffer_get_end_iter(current_editor.current_buffer, &iter_end); gchar *file_content = gtk_text_buffer_get_text(current_editor.current_buffer, &iter_start, &iter_end, FALSE) ; if (! g_file_set_contents(filepath, file_content, -1, &error) ) { /** Failed to save editor content as file, display an error message and return. **/ char *msg = g_strdup_printf(_("Failed to save file:\n%s"), filepath) ; display_message_dialog(_("Cannot save file !!!"), msg, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE) ; free(msg) ; return ; } /** Mark the TextBuffer as not modfied. **/ gtk_text_buffer_set_modified(current_editor.current_buffer, FALSE) ; /** Only useful if the content type has changed like a new file saved as a *.c file. **/ GtkSourceLanguage *source_language = NULL ; GtkSourceLanguageManager *source_language_manager = gtk_source_language_manager_get_default(); gboolean result_uncertain ; gchar *content_type ; content_type = g_content_type_guess( g_path_get_basename(filepath), (const guchar *) file_content, strlen(file_content), &result_uncertain) ; if (content_type && source_language_manager) { source_language = gtk_source_language_manager_guess_language(source_language_manager, g_path_get_basename(filepath), content_type); if (source_language) { set_syntax_highlight_radio(gtk_source_language_get_id(source_language)) ; gtk_source_buffer_set_language(GTK_SOURCE_BUFFER(current_editor.current_buffer), source_language) ; g_object_set_data(G_OBJECT(current_editor.current_textview), "lang_id", (char *) gtk_source_language_get_id(source_language)) ; } g_free(content_type) ; } /** Update the notebook label tab **/ GtkWidget *notebook_tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(gui->editor_notebook), current_editor.current_notebook_page); /** The tab contains an mimetype icon, the filename and the page closing button. **/ GList *tab_compound_list = gtk_container_get_children(GTK_CONTAINER(notebook_tab)) ; tab_compound_list = g_list_first(tab_compound_list) ; while (tab_compound_list->data != NULL) { /** We iterate over the notebook tab component **/ if (g_object_get_data(G_OBJECT(tab_compound_list->data), "tab_filename_widget")) { /** Set the new filename in the tab. **/ gtk_label_set_text(GTK_LABEL(tab_compound_list->data), g_path_get_basename(filepath)) ; } if (g_object_get_data(G_OBJECT(tab_compound_list->data), "tab_icon") && source_language) { uint8_t c ; for ( c=0 ; ; c++) { if (gtk_source_language_get_mime_types(source_language) == NULL) { break ; } char *mimetype = gtk_source_language_get_mime_types(source_language)[c] ; if (mimetype == NULL) { /** don't find an specific mimetype for this new file extension use default icon. **/ g_object_set(G_OBJECT(tab_compound_list->data),"file", PATH_TO_MIMETYPE_ICON "unknown.png", NULL) ; break ; } /** We search for an image filename ending with the corresponding mimetype: **/ char *ptr = strchr(mimetype, '/') ; if (ptr != NULL) { /** Simply pointer arithmetic to exchange the '/' (used in mimetypes) and the '-' (used in the images names) character **/ mimetype[ptr - mimetype] = '-' ; gchar *filepath = g_strdup_printf("%s%s.png", PATH_TO_MIMETYPE_ICON, mimetype) ; if ( g_file_test(filepath, G_FILE_TEST_EXISTS) ) { /** We found an corresponding image for this mimetype. **/ g_object_set(G_OBJECT(tab_compound_list->data),"file", filepath, NULL) ; free(filepath) ; break ; } free(filepath) ; } } } if (tab_compound_list->next == NULL) { break ; } tab_compound_list = tab_compound_list->next ; } g_free(file_content) ; /** Storing filepath for further saving operations. **/ g_object_set_data(G_OBJECT(current_editor.current_buffer), "filepath", filepath) ; /** setting the base filename in the bottom bar. **/ gtk_label_set_text(GTK_LABEL(gui->bottom_bar->filename_label), g_path_get_basename(filepath)) ; if (settings.rm_trailing_spaces) { /** Deleting trailing spaces. **/ char *trailing_spaces_deleting ; trailing_spaces_deleting = g_strdup_printf("sed -i 's/[[:space:]]$//' '%s'", (char *) filepath) ; int ret ; if ((ret = system(trailing_spaces_deleting)) == -1) { g_warning( _("Removing trailing space failure:\n%s\n"), trailing_spaces_deleting) ; } free(trailing_spaces_deleting) ; } File_Editor *file_editor = (File_Editor *) g_object_get_data(G_OBJECT(current_editor.current_textview), "file_editor") ; gtk_notebook_set_menu_label_text(GTK_NOTEBOOK(gui->editor_notebook), file_editor->scrolled_window, g_path_get_basename(filepath) ) ; #ifdef RELOADING_FUNC /** Update Last modification timestamp. **/ File_Editor *file_editor = (File_Editor *) g_object_get_data(G_OBJECT(current_editor.current_textview), "file_editor") ; g_stat(filepath, &file_editor->file_info) ; #endif } /** @NOTE: the filepath must not be free because it is set as data from the file_editor->buffer for further use. **/ gtk_widget_destroy(file_chooser); }
static void window_actions_display_opened (GdkDisplayManager *manager, GdkDisplay *display, GimpActionGroup *group) { GimpRadioActionEntry *entries; const gchar *help_id; const gchar *group_name; GSList *radio_group; gint n_screens; gint i; help_id = g_object_get_data (G_OBJECT (group), "change-to-screen-help-id"); group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group)); n_screens = gdk_display_get_n_screens (display); entries = g_new0 (GimpRadioActionEntry, n_screens); for (i = 0; i < n_screens; i++) { GdkScreen *screen = gdk_display_get_screen (display, i); gchar *screen_name; screen_name = gdk_screen_make_display_name (screen); entries[i].name = g_strdup_printf ("%s-move-to-screen-%s", group_name, screen_name); entries[i].stock_id = GIMP_STOCK_MOVE_TO_SCREEN; entries[i].label = g_strdup_printf (_("Screen %s"), screen_name); entries[i].accelerator = NULL; entries[i].tooltip = g_strdup_printf (_("Move this window to " "screen %s"), screen_name); entries[i].value = g_quark_from_string (screen_name); entries[i].help_id = help_id; g_free (screen_name); } radio_group = g_object_get_data (G_OBJECT (group), "change-to-screen-radio-group"); radio_group = gimp_action_group_add_radio_actions (group, NULL, entries, n_screens, radio_group, 0, G_CALLBACK (window_move_to_screen_cmd_callback)); g_object_set_data (G_OBJECT (group), "change-to-screen-radio-group", radio_group); for (i = 0; i < n_screens; i++) { GdkScreen *screen = gdk_display_get_screen (display, i); GtkAction *action; action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), entries[i].name); if (action) g_object_set_data (G_OBJECT (action), "screen", screen); g_free ((gchar *) entries[i].name); g_free ((gchar *) entries[i].tooltip); g_free ((gchar *) entries[i].label); } g_free (entries); g_signal_connect_object (display, "closed", G_CALLBACK (window_actions_display_closed), G_OBJECT (group), 0); }
int view_orb(GtkWidget* Parent,int argc, char **argv) { GtkWidget* vboxwin; GtkWidget* hboxwin; GtkWidget* handleBoxColorMapGrid; GtkWidget* handleBoxColorMapContours; GtkWidget* handleBoxColorMapPlanesMapped; static gboolean first = TRUE; init_dipole(); if(!first) { if(PrincipalWindow) { gtk_widget_hide(GTK_WIDGET(PrincipalWindow)); gtk_widget_show(GTK_WIDGET(PrincipalWindow)); /* if(argc>1) read_any_file(argv[1]);*/ return 0; } } /* initialisation */ initialise_global_orbitals_variables(); read_opengl_file(); /* Create new top level window. */ PrincipalWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(PrincipalWindow), _("Gabedit : Orbitals/Density/Vibration")); gtk_container_set_reallocate_redraws (GTK_CONTAINER (PrincipalWindow), TRUE); gtk_window_set_default_size (GTK_WINDOW(PrincipalWindow),(gint)(ScreenWidth*0.5),(gint)(ScreenHeight*0.69)); gtk_container_set_border_width(GTK_CONTAINER(PrincipalWindow), 1); init_child(PrincipalWindow,gtk_widget_destroy," Draw Dens. Orb. "); /* g_signal_connect(G_OBJECT(PrincipalWindow),"delete_event",(GCallback)close_window_orb,NULL);*/ g_signal_connect(G_OBJECT(PrincipalWindow), "delete-event",G_CALLBACK(gtk_widget_hide_on_delete), NULL); gtk_window_set_transient_for(GTK_WINDOW(PrincipalWindow),GTK_WINDOW(Parent)); vboxwin = create_vbox(PrincipalWindow); gtk_widget_realize(PrincipalWindow); hboxwin = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX(vboxwin), hboxwin, TRUE, TRUE, 2); gtk_widget_show (hboxwin); if (!NewGLArea(hboxwin)) return 0; create_status_bar_orb(vboxwin); create_status_progress_bar_orb(vboxwin); handleBoxColorMapGrid = create_color_map_show(vboxwin,NULL," Grid "); g_object_set_data(G_OBJECT(PrincipalWindow), "HandleboxColorMapGrid ", handleBoxColorMapGrid); handleBoxColorMapContours = create_color_map_show(vboxwin,NULL, "Contours "); g_object_set_data(G_OBJECT(PrincipalWindow), "HandleboxColorMapContours", handleBoxColorMapContours); handleBoxColorMapPlanesMapped = create_color_map_show(vboxwin,NULL," Planes colorcoded"); g_object_set_data(G_OBJECT(PrincipalWindow), "HandleboxColorMapPlanesMapped", handleBoxColorMapPlanesMapped); set_icone(PrincipalWindow); gtk_widget_show(GTK_WIDGET(PrincipalWindow)); color_map_hide(handleBoxColorMapGrid); color_map_hide(handleBoxColorMapContours); color_map_hide(handleBoxColorMapPlanesMapped); /* if(argc>1) read_any_file(argv[1]);*/ first = FALSE; gtk_window_move(GTK_WINDOW(PrincipalWindow),0,0); InitializeAll(); /*printCoefZlm();*/ return 0; }
static void anjuta_docman_page_init (AnjutaDocman *docman, IAnjutaDocument *doc, GFile* file, AnjutaDocmanPage *page) { GtkWidget *close_button; GtkWidget *close_pixmap; GtkWidget *label, *menu_label; GtkWidget *box, *menu_box; GtkWidget *event_hbox; GtkWidget *event_box; gint h, w; GdkColor color; const gchar *filename; gchar *ruri; g_return_if_fail (IANJUTA_IS_DOCUMENT (doc)); gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h); close_pixmap = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_widget_show (close_pixmap); /* setup close button, zero out {x,y} thickness to get smallest possible size */ close_button = gtk_button_new(); gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE); gtk_container_add(GTK_CONTAINER(close_button), close_pixmap); gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE); gtk_widget_set_name (close_button, "anjuta-tab-close-button"); gtk_widget_set_size_request (close_button, w, h); gtk_widget_set_tooltip_text (close_button, _("Close file")); filename = ianjuta_document_get_filename (doc, NULL); label = gtk_label_new (filename); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_widget_show (label); menu_label = gtk_label_new (filename); gtk_misc_set_alignment (GTK_MISC (menu_label), 0.0, 0.5); gtk_widget_show (menu_label); menu_box = gtk_hbox_new(FALSE, 2); color.red = 0; color.green = 0; color.blue = 0; gtk_widget_modify_fg (close_button, GTK_STATE_NORMAL, &color); gtk_widget_modify_fg (close_button, GTK_STATE_INSENSITIVE, &color); gtk_widget_modify_fg (close_button, GTK_STATE_ACTIVE, &color); gtk_widget_modify_fg (close_button, GTK_STATE_PRELIGHT, &color); gtk_widget_modify_fg (close_button, GTK_STATE_SELECTED, &color); gtk_widget_show(close_button); box = gtk_hbox_new (FALSE, 2); /* create our layout/event boxes */ event_box = gtk_event_box_new(); gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE); event_hbox = gtk_hbox_new (FALSE, 2); page->menu_icon = gtk_image_new(); page->mime_icon = gtk_image_new(); gtk_box_pack_start (GTK_BOX (event_hbox), page->mime_icon, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (menu_box), page->menu_icon, FALSE, FALSE, 0); if (file != NULL) { GdkPixbuf* pixbuf = anjuta_docman_get_pixbuf_for_file (file); if (pixbuf != NULL) { gtk_image_set_from_pixbuf (GTK_IMAGE (page->menu_icon), pixbuf); gtk_image_set_from_pixbuf (GTK_IMAGE (page->mime_icon), pixbuf); g_object_unref (pixbuf); } ruri = g_file_get_parse_name (file); if (ruri != NULL) { /* set the tab-tooltip */ gchar *tip; tip = g_markup_printf_escaped ("<b>%s</b> %s", _("Path:"), ruri); gtk_widget_set_tooltip_markup (event_box, tip); g_free (ruri); g_free (tip); } } gtk_box_pack_start (GTK_BOX (event_hbox), label, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (event_hbox), close_button, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (event_box), event_hbox); /* setup the data hierarchy */ g_object_set_data (G_OBJECT (box), "event_box", event_box); /* pack our top-level layout box */ gtk_box_pack_start (GTK_BOX (box), event_box, TRUE, TRUE, 0); /* show the widgets of the tab */ gtk_widget_show_all(box); /* menu box */ gtk_box_pack_start (GTK_BOX (menu_box), menu_label, TRUE, TRUE, 0); gtk_widget_show_all (menu_box); /* main box */ g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (on_notebook_page_close_button_click), docman); g_signal_connect (G_OBJECT (close_button), "enter", G_CALLBACK (on_notebook_page_close_button_enter), page); g_signal_connect (G_OBJECT (close_button), "leave", G_CALLBACK (on_notebook_page_close_button_leave), page); g_signal_connect (G_OBJECT (box), "button-press-event", G_CALLBACK (on_notebook_tab_btnpress), docman); g_signal_connect (G_OBJECT (box), "button-release-event", G_CALLBACK (on_notebook_tab_btnrelease), docman); g_signal_connect (G_OBJECT (box), "event", G_CALLBACK (on_notebook_tab_double_click), docman); page->widget = GTK_WIDGET (doc); /* this is the notebook-page child widget */ page->doc = doc; page->box = box; page->close_image = close_pixmap; page->close_button = close_button; page->label = label; page->menu_box = menu_box; page->menu_label = menu_label; gtk_widget_show_all (page->widget); }
static void gcal_toolbar_set_overview_mode (GcalToolbar *toolbar) { GcalToolbarPrivate *priv; GtkStyleContext *context; GtkWidget *button; g_return_if_fail (GCAL_IS_TOOLBAR (toolbar)); priv = toolbar->priv; /* add */ if (priv->add_button == NULL) { priv->add_button = gtk_button_new_with_label (_("New Event")); g_object_ref_sink (priv->add_button); gtk_widget_set_size_request (priv->add_button, 100, -1); context = gtk_widget_get_style_context (priv->add_button); gtk_style_context_add_class (context, "suggested-action"); g_signal_connect (priv->add_button, "clicked", G_CALLBACK (gcal_toolbar_add_event), toolbar); } gtk_container_add (GTK_CONTAINER (priv->left_item), priv->add_button); gtk_widget_show_all (priv->add_button); /* views_box */ if (priv->views_box == NULL) { priv->views_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); g_object_ref_sink (priv->views_box); gtk_widget_set_hexpand (priv->views_box, TRUE); context = gtk_widget_get_style_context (priv->views_box); gtk_style_context_add_class (context, "linked"); /* day */ button = gtk_toggle_button_new_with_label (_("Day")); gtk_widget_set_size_request (button, 80, -1); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->views_box), button); g_object_set_data (G_OBJECT (button), "view-type", GUINT_TO_POINTER (GCAL_WINDOW_VIEW_DAY)); g_signal_connect (button, "toggled", G_CALLBACK (gcal_toolbar_view_changed), toolbar); /* week */ button = gtk_toggle_button_new_with_label (_("Week")); gtk_widget_set_size_request (button, 80, -1); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->views_box), button); g_object_set_data (G_OBJECT (button), "view-type", GUINT_TO_POINTER (GCAL_WINDOW_VIEW_WEEK)); g_signal_connect (button, "toggled", G_CALLBACK (gcal_toolbar_view_changed), toolbar); /* month */ button = gtk_toggle_button_new_with_label (_("Month")); gtk_widget_set_size_request (button, 80, -1); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->views_box), button); g_object_set_data (G_OBJECT (button), "view-type", GUINT_TO_POINTER (GCAL_WINDOW_VIEW_MONTH)); g_signal_connect (button, "toggled", G_CALLBACK (gcal_toolbar_view_changed), toolbar); /* year */ button = gtk_toggle_button_new_with_label (_("Year")); gtk_widget_set_size_request (button, 80, -1); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->views_box), button); g_object_set_data (G_OBJECT (button), "view-type", GUINT_TO_POINTER (GCAL_WINDOW_VIEW_YEAR)); g_signal_connect (button, "toggled", G_CALLBACK (gcal_toolbar_view_changed), toolbar); /* list */ button = gtk_toggle_button_new_with_label (_("List")); gtk_widget_set_size_request (button, 80, -1); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->views_box), button); g_object_set_data (G_OBJECT (button), "view-type", GUINT_TO_POINTER (GCAL_WINDOW_VIEW_LIST)); g_signal_connect (button, "toggled", G_CALLBACK (gcal_toolbar_view_changed), toolbar); } gtk_container_add (GTK_CONTAINER (priv->central_item), priv->views_box); gtk_widget_show_all (priv->views_box); /* right_box */ if (priv->right_box == NULL) { priv->right_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); g_object_ref_sink (priv->right_box); gtk_widget_set_hexpand (priv->right_box, TRUE); gtk_box_set_spacing (GTK_BOX (priv->right_box), 6); /* sources_button */ priv->sources_button = gtk_toggle_button_new (); gtk_container_add ( GTK_CONTAINER (priv->sources_button), gtk_image_new_from_icon_name ("x-office-calendar-symbolic", GTK_ICON_SIZE_MENU)); context = gtk_widget_get_style_context (priv->sources_button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->right_box), priv->sources_button); g_signal_connect (priv->sources_button, "clicked", G_CALLBACK (gcal_toolbar_sources_shown), toolbar); /* search_button */ priv->search_button = gtk_button_new (); gtk_container_add ( GTK_CONTAINER (priv->search_button), gtk_image_new_from_icon_name ("folder-saved-search-symbolic", GTK_ICON_SIZE_MENU)); context = gtk_widget_get_style_context (priv->search_button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->right_box), priv->search_button); g_signal_connect (priv->search_button, "clicked", G_CALLBACK (gcal_toolbar_search_events), toolbar); } gtk_container_add (GTK_CONTAINER (priv->right_item), priv->right_box); gtk_widget_show_all (priv->sources_button); }
/*! \brief displays a live marker for the Y axis (horizontal Line) \param curve (MtxCurve *) pointer to curve */ void mtx_curve_set_y_marker_value (MtxCurve *curve, gfloat value) { MtxCurvePrivate *priv = NULL; gint i = 0; gfloat x = 0.0; gfloat y = 0.0; gfloat d1 = 0.0; gfloat d2 = 0.0; gboolean get_peak_cross = FALSE; g_return_if_fail (MTX_IS_CURVE (curve)); priv = MTX_CURVE_GET_PRIVATE(curve); #if GTK_MINOR_VERSION >= 18 if (!gtk_widget_is_sensitive(GTK_WIDGET(curve))) return; #else if (!GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(curve))) return; #endif if (priv->y_marker == value) return; /* IF marker is clamped beyond ranges, don't bother updating*/ if (((value < priv->lowest_y) && (priv->y_marker_clamp == LOW)) || ((value > priv->highest_y) && (priv->y_marker_clamp == HIGH))) return; /* Filter out jitter to within 1% */ if (fabs(value-priv->y_marker) < (fabs(priv->highest_y-priv->lowest_y)/100.0)) return; g_object_freeze_notify (G_OBJECT (curve)); if (value <priv->lowest_y) { priv->y_marker = priv->lowest_y; priv->y_marker_clamp = LOW; } else if (value > priv->highest_y) { priv->y_marker = priv->highest_y; priv->y_marker_clamp = HIGH; } else { priv->y_marker = value; priv->y_marker_clamp = NONE; } if (value > priv->peak_y_marker) { priv->peak_y_marker = value > priv->highest_y ? priv->highest_y:value; get_peak_cross = TRUE; if (priv->y_peak_timeout) { g_source_remove(priv->y_peak_timeout); priv->y_peak_timeout = -1; } } else { priv->y_draw_peak = TRUE; g_object_set_data(G_OBJECT(curve),"axis",GINT_TO_POINTER(_Y_)); if (priv->y_peak_timeout <= 0) priv->y_peak_timeout = g_timeout_add(5000,(GSourceFunc)cancel_peak,(gpointer)curve); } for (i = 0;i<priv->num_points - 1;i++) { if (value < priv->coords[0].y) { priv->x_at_y_marker = priv->coords[0].x; if (0 != priv->marker_proximity_vertex) { priv->marker_proximity_vertex = 0; g_signal_emit_by_name((gpointer)curve, "marker-proximity"); } } else if (value > priv->coords[priv->num_points-1].y) { priv->x_at_y_marker = priv->coords[priv->num_points-1].x; if (get_peak_cross) priv->peak_x_at_y_marker = priv->x_at_y_marker; if (priv->num_points-1 != priv->marker_proximity_vertex) { priv->marker_proximity_vertex = priv->num_points-1; g_signal_emit_by_name((gpointer)curve, "marker-proximity"); } } else if ((value > priv->coords[i].y) && (value < priv->coords[i+1].y)) { if (get_intersection(priv->coords[i].x,priv->coords[i].y,priv->coords[i+1].x,priv->coords[i+1].y,0,value,priv->w,value,&x,&y)) { priv->x_at_y_marker = x; if (get_peak_cross) priv->peak_x_at_y_marker = x; d1 = sqrt(pow((priv->coords[i].x-x),2)+ pow((priv->coords[i].y-value),2)); d2 = sqrt(pow((priv->coords[i+1].x-x),2)+ pow((priv->coords[i+1].y-value),2)); if (d1 < d2) { if (i != priv->marker_proximity_vertex) { priv->marker_proximity_vertex = i; g_signal_emit_by_name((gpointer)curve, "marker-proximity"); } } else { if (i+1 != priv->marker_proximity_vertex) { priv->marker_proximity_vertex = i+1; g_signal_emit_by_name((gpointer)curve, "marker-proximity"); } } } else printf("couldn't find intersection\n"); break; } } g_object_thaw_notify (G_OBJECT (curve)); mtx_curve_redraw(curve,FALSE); return; }
void bmd_add_columns (GtkTreeView *treeview, GtkTreeModel *items_model, GtkTreeModel *numbers_model) { GtkCellRenderer *renderer; // added for sorting GtkTreeViewColumn *column; /* number column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (bmd_cell_edited), items_model); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_NUMBER)); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Number", renderer, "text", COLUMN_ITEM_NUMBER, NULL); // added for sorting column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0); gtk_tree_view_column_set_sort_column_id (column, 0); /* title column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (bmd_cell_edited), items_model); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_TITLE)); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Title", renderer, "text", COLUMN_ITEM_TITLE, NULL); // added for sorting column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 1); gtk_tree_view_column_set_sort_column_id (column, 1); /* author column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (bmd_cell_edited), items_model); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_AUTHOR)); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Author", renderer, "text", COLUMN_ITEM_AUTHOR, NULL); // added for sorting column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 2); gtk_tree_view_column_set_sort_column_id (column, 2); /* pages column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (bmd_cell_edited), items_model); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_PAGES)); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Pages", renderer, "text", COLUMN_ITEM_PAGES, NULL); // added for sorting column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 3); gtk_tree_view_column_set_sort_column_id (column, 3); }
static gboolean nm_connection_editor_set_connection (NMConnectionEditor *editor, NMConnection *orig_connection, GError **error) { NMSettingConnection *s_con; const char *connection_type; const char *slave_type; gboolean success = FALSE; GSList *iter, *copy; g_return_val_if_fail (NM_IS_CONNECTION_EDITOR (editor), FALSE); g_return_val_if_fail (NM_IS_CONNECTION (orig_connection), FALSE); /* clean previous connection */ if (editor->connection) g_object_unref (editor->connection); editor->connection = nm_simple_connection_new_clone (orig_connection); editor->orig_connection = g_object_ref (orig_connection); nm_connection_editor_update_title (editor); /* Handle CA cert ignore stuff */ eap_method_ca_cert_ignore_load (editor->connection); s_con = nm_connection_get_setting_connection (editor->connection); g_assert (s_con); connection_type = nm_setting_connection_get_connection_type (s_con); if (!add_page (editor, ce_page_general_new, editor->connection, error)) goto out; if (!strcmp (connection_type, NM_SETTING_WIRED_SETTING_NAME)) { if (!add_page (editor, ce_page_ethernet_new, editor->connection, error)) goto out; if (!add_page (editor, ce_page_8021x_security_new, editor->connection, error)) goto out; if (!add_page (editor, ce_page_dcb_new, editor->connection, error)) goto out; } else if (!strcmp (connection_type, NM_SETTING_WIRELESS_SETTING_NAME)) { if (!add_page (editor, ce_page_wifi_new, editor->connection, error)) goto out; if (!add_page (editor, ce_page_wifi_security_new, editor->connection, error)) goto out; } else if (!strcmp (connection_type, NM_SETTING_VPN_SETTING_NAME)) { if (!add_page (editor, ce_page_vpn_new, editor->connection, error)) goto out; } else if (!strcmp (connection_type, NM_SETTING_IP_TUNNEL_SETTING_NAME)) { if (!add_page (editor, ce_page_ip_tunnel_new, editor->connection, error)) goto out; } else if (!strcmp (connection_type, NM_SETTING_PPPOE_SETTING_NAME)) { if (!add_page (editor, ce_page_dsl_new, editor->connection, error)) goto out; if (!add_page (editor, ce_page_ethernet_new, editor->connection, error)) goto out; if (!add_page (editor, ce_page_ppp_new, editor->connection, error)) goto out; } else if (!strcmp (connection_type, NM_SETTING_GSM_SETTING_NAME) || !strcmp (connection_type, NM_SETTING_CDMA_SETTING_NAME)) { if (!add_page (editor, ce_page_mobile_new, editor->connection, error)) goto out; if (!add_page (editor, ce_page_ppp_new, editor->connection, error)) goto out; } else if (!strcmp (connection_type, NM_SETTING_BLUETOOTH_SETTING_NAME)) { NMSettingBluetooth *s_bt = nm_connection_get_setting_bluetooth (editor->connection); const char *type = nm_setting_bluetooth_get_connection_type (s_bt); g_assert (type); if (!add_page (editor, ce_page_bluetooth_new, editor->connection, error)) goto out; if (!g_strcmp0 (type, "dun")) { if (!add_page (editor, ce_page_mobile_new, editor->connection, error)) goto out; if (!add_page (editor, ce_page_ppp_new, editor->connection, error)) goto out; } } else if (!strcmp (connection_type, NM_SETTING_INFINIBAND_SETTING_NAME)) { if (!add_page (editor, ce_page_infiniband_new, editor->connection, error)) goto out; } else if (!strcmp (connection_type, NM_SETTING_BOND_SETTING_NAME)) { if (!add_page (editor, ce_page_bond_new, editor->connection, error)) goto out; } else if (!strcmp (connection_type, NM_SETTING_TEAM_SETTING_NAME)) { if (!add_page (editor, ce_page_team_new, editor->connection, error)) goto out; } else if (!strcmp (connection_type, NM_SETTING_BRIDGE_SETTING_NAME)) { if (!add_page (editor, ce_page_bridge_new, editor->connection, error)) goto out; } else if (!strcmp (connection_type, NM_SETTING_VLAN_SETTING_NAME)) { if (!add_page (editor, ce_page_vlan_new, editor->connection, error)) goto out; } else { g_warning ("Unhandled setting type '%s'", connection_type); } slave_type = nm_setting_connection_get_slave_type (s_con); if (!g_strcmp0 (slave_type, NM_SETTING_TEAM_SETTING_NAME)) { if (!add_page (editor, ce_page_team_port_new, editor->connection, error)) goto out; } else if (!g_strcmp0 (slave_type, NM_SETTING_BRIDGE_SETTING_NAME)) { if (!add_page (editor, ce_page_bridge_port_new, editor->connection, error)) goto out; } if ( nm_connection_get_setting_ip4_config (editor->connection) && !add_page (editor, ce_page_ip4_new, editor->connection, error)) goto out; if ( nm_connection_get_setting_ip6_config (editor->connection) && !add_page (editor, ce_page_ip6_new, editor->connection, error)) goto out; /* After all pages are created, then kick off secrets requests that any * the pages may need to make; if they don't need any secrets, then let * them finish initialization. The list might get modified during the loop * which is why copy the list here. */ copy = g_slist_copy (editor->initializing_pages); for (iter = copy; iter; iter = g_slist_next (iter)) { CEPage *page = CE_PAGE (iter->data); const char *setting_name = g_object_get_data (G_OBJECT (page), SECRETS_TAG); if (!setting_name) { /* page doesn't need any secrets */ ce_page_complete_init (page, NULL, NULL, NULL); } else if (!NM_IS_REMOTE_CONNECTION (editor->orig_connection)) { /* We want to get secrets using ->orig_connection, since that's the * remote connection which can actually respond to secrets requests. * ->connection is a plain NMConnection copy of ->orig_connection * which is what gets changed when users modify anything. But when * creating or importing, ->orig_connection will be an NMConnection * since the new connection hasn't been added to NetworkManager yet. * So basically, skip requesting secrets if the connection can't * handle a secrets request. */ ce_page_complete_init (page, setting_name, NULL, NULL); } else { /* Page wants secrets, get them */ get_secrets_for_page (editor, page, setting_name); } g_object_set_data (G_OBJECT (page), SECRETS_TAG, NULL); } g_slist_free (copy); /* set the UI */ recheck_initialization (editor); success = TRUE; out: return success; }
/* * Create and display the column selection widgets. * Called as part of the creation of the Preferences notebook ( Edit ! Preferences ) */ GtkWidget * column_prefs_show(GtkWidget *prefs_window) { GtkWidget *main_vb, *bottom_hb, *column_l, *add_bt, *tb, *lb; GtkWidget *list_vb, *list_lb, *list_sc; GtkWidget *add_remove_vb; GtkWidget *props_fr, *props_hb; GList *clp; fmt_data *cfmt; gint i; gchar *fmt; gint cur_fmt; const gchar *column_titles[] = {"Title", "Field type"}; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *sel; GtkTreeIter iter; GtkTreeIter first_iter; gint first_row = TRUE; GtkTooltips *tooltips = gtk_tooltips_new(); /* Container for each row of widgets */ main_vb = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_widget_show(main_vb); list_vb = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (list_vb), 5); gtk_widget_show (list_vb); gtk_box_pack_start (GTK_BOX (main_vb), list_vb, TRUE, TRUE, 0); list_lb = gtk_label_new (("[The first list entry will be displayed as the leftmost column]")); gtk_widget_show (list_lb); gtk_box_pack_start (GTK_BOX (list_vb), list_lb, FALSE, FALSE, 0); list_sc = scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(list_sc), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(list_vb), list_sc); gtk_widget_show(list_sc); store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); column_row_deleted_handler_id = g_signal_connect(GTK_TREE_MODEL(store), "row-deleted", G_CALLBACK(column_dnd_row_deleted_cb), NULL); column_l = tree_view_new(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(column_l), TRUE); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(column_l), FALSE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(column_l), TRUE); gtk_tooltips_set_tip (tooltips, column_l, "Click on a title to change its name.\nDrag an item to change its order.", NULL); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK(column_title_changed_cb), GTK_TREE_MODEL(store)); column = gtk_tree_view_column_new_with_attributes(column_titles[0], renderer, "text", 0, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(column_l), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(column_titles[1], renderer, "text", 1, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(column_l), column); /* XXX - make this match the packet list prefs? */ sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(column_l)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); g_signal_connect(sel, "changed", G_CALLBACK(column_list_select_cb), NULL); gtk_container_add(GTK_CONTAINER(list_sc), column_l); gtk_widget_show(column_l); clp = g_list_first(prefs.col_list); while (clp) { cfmt = (fmt_data *) clp->data; cur_fmt = get_column_format_from_str(cfmt->fmt); if (cur_fmt == COL_CUSTOM) { fmt = g_strdup_printf("%s (%s)", col_format_desc(cur_fmt), cfmt->custom_field); } else { if (cfmt->custom_field) { /* Delete custom_field from previous changes */ g_free (cfmt->custom_field); cfmt->custom_field = NULL; } fmt = g_strdup_printf("%s", col_format_desc(cur_fmt)); } gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, cfmt->title, 1, fmt, 2, clp, -1); if (first_row) { first_iter = iter; first_row = FALSE; } clp = clp->next; g_free (fmt); } g_object_unref(G_OBJECT(store)); /* Bottom row: Add/remove buttons and properties */ bottom_hb = gtk_hbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX (main_vb), bottom_hb, FALSE, TRUE, 0); gtk_widget_show(bottom_hb); /* Add / remove buttons */ add_remove_vb = gtk_vbox_new (TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (add_remove_vb), 5); gtk_box_pack_start (GTK_BOX (bottom_hb), add_remove_vb, FALSE, FALSE, 0); gtk_widget_show(add_remove_vb); add_bt = gtk_button_new_from_stock(GTK_STOCK_ADD); g_signal_connect(add_bt, "clicked", G_CALLBACK(column_list_new_cb), column_l); gtk_box_pack_start (GTK_BOX (add_remove_vb), add_bt, FALSE, FALSE, 0); gtk_tooltips_set_tip (tooltips, add_bt, "Add a new column at the end of the list.", NULL); gtk_widget_show(add_bt); remove_bt = gtk_button_new_from_stock(GTK_STOCK_REMOVE); gtk_widget_set_sensitive(remove_bt, FALSE); g_signal_connect(remove_bt, "clicked", G_CALLBACK(column_list_delete_cb), column_l); gtk_box_pack_start (GTK_BOX (add_remove_vb), remove_bt, FALSE, FALSE, 0); gtk_tooltips_set_tip (tooltips, remove_bt, "Remove the selected column.", NULL); gtk_widget_show(remove_bt); /* properties frame */ props_fr = gtk_frame_new("Properties"); gtk_box_pack_start (GTK_BOX (bottom_hb), props_fr, TRUE, TRUE, 0); gtk_widget_show(props_fr); /* Column name entry and format selection */ tb = gtk_table_new(2, 2, FALSE); gtk_container_set_border_width(GTK_CONTAINER(tb), 5); gtk_container_add(GTK_CONTAINER(props_fr), tb); gtk_table_set_row_spacings(GTK_TABLE(tb), 10); gtk_table_set_col_spacings(GTK_TABLE(tb), 15); gtk_widget_show(tb); lb = gtk_label_new("Field type:"); gtk_misc_set_alignment(GTK_MISC(lb), 1.0f, 0.5f); gtk_table_attach_defaults(GTK_TABLE(tb), lb, 0, 1, 0, 1); gtk_tooltips_set_tip (tooltips, lb, "Select which packet information to present in the column.", NULL); gtk_widget_show(lb); props_hb = gtk_hbox_new(FALSE, 5); gtk_table_attach(GTK_TABLE(tb), props_hb, 1, 2, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); gtk_tooltips_set_tip (tooltips, props_hb, "Select which packet information to present in the column.", NULL); gtk_widget_show(props_hb); field_lb = gtk_label_new("Field name:"); gtk_misc_set_alignment(GTK_MISC(field_lb), 1.0f, 0.5f); gtk_table_attach_defaults(GTK_TABLE(tb), field_lb, 0, 1, 1, 2); gtk_widget_set_sensitive(field_lb, FALSE); gtk_tooltips_set_tip (tooltips, field_lb, "Field name used when field type is \"Custom\". " "This string has the same syntax as a display filter string.", NULL); gtk_widget_show(field_lb); field_te = gtk_entry_new(); g_object_set_data (G_OBJECT(field_te), E_FILT_FIELD_NAME_ONLY_KEY, ""); g_signal_connect(field_te, "changed", G_CALLBACK(filter_te_syntax_check_cb), NULL); /* XXX: column_field_changed_cb will be called for every character entered in the entry box. */ /* Consider Changing logic so that the field is "accepted" only when a return is entered ?? */ /* Also: entry shouldn't be accepted if it's not a valid filter ? */ column_field_changed_handler_id = g_signal_connect(field_te, "changed", G_CALLBACK(column_field_changed_cb), column_l); g_object_set_data(G_OBJECT(main_vb), E_FILT_AUTOCOMP_PTR_KEY, NULL); g_signal_connect(field_te, "key-press-event", G_CALLBACK (filter_string_te_key_pressed_cb), NULL); g_signal_connect(prefs_window, "key-press-event", G_CALLBACK (filter_parent_dlg_key_pressed_cb), NULL); colorize_filter_te_as_empty(field_te); gtk_table_attach_defaults(GTK_TABLE(tb), field_te, 1, 2, 1, 2); gtk_widget_set_sensitive(field_te, FALSE); gtk_tooltips_set_tip (tooltips, field_te, "Field name used when field type is \"Custom\". " "This string has the same syntax as a display filter string.", NULL); gtk_widget_show(field_te); fmt_cmb = gtk_combo_box_new_text(); for (i = 0; i < NUM_COL_FMTS; i++) gtk_combo_box_append_text(GTK_COMBO_BOX(fmt_cmb), col_format_desc(i)); column_menu_changed_handler_id = g_signal_connect(fmt_cmb, "changed", G_CALLBACK(column_menu_changed_cb), column_l); gtk_widget_set_sensitive(fmt_cmb, FALSE); gtk_box_pack_start(GTK_BOX(props_hb), fmt_cmb, FALSE, FALSE, 0); gtk_widget_show(fmt_cmb); /* select the first menu list row. */ /* Triggers call to column_list_select_cb(). */ gtk_tree_selection_select_iter(sel, &first_iter); return(main_vb); }
/** * gnome_gdk_pixbuf_new_from_uri: * @uri: the uri of an image * @width: The width the image should have or -1 to not constrain the width * @height: The height the image should have or -1 to not constrain the height * @preserve_aspect_ratio: %TRUE to preserve the image's aspect ratio * * Loads a GdkPixbuf from the image file @uri points to, scaling it to the * desired size. If you pass -1 for @width or @height then the value * specified in the file will be used. * * When preserving aspect ratio, if both height and width are set the size * is picked such that the scaled image fits in a width * height rectangle. * * Return value: The loaded pixbuf, or NULL on error * * Since: 2.14 **/ GdkPixbuf * gnome_gdk_pixbuf_new_from_uri_at_scale (const char *uri, gint width, gint height, gboolean preserve_aspect_ratio) { GnomeVFSResult result; char buffer[LOAD_BUFFER_SIZE]; GnomeVFSFileSize bytes_read; GdkPixbufLoader *loader; GdkPixbuf *pixbuf; GdkPixbufAnimation *animation; GdkPixbufAnimationIter *iter; gboolean has_frame; SizePrepareContext info; GFile *file; GFileInputStream *file_input_stream; g_return_val_if_fail (uri != NULL, NULL); file = g_file_new_for_uri (uri); file_input_stream = g_file_read (file, NULL, NULL); if (file_input_stream == NULL) { g_object_unref (file); return NULL; } loader = gdk_pixbuf_loader_new (); if (1 <= width || 1 <= height) { info.width = width; info.height = height; info.input_width = info.input_height = 0; info.preserve_aspect_ratio = preserve_aspect_ratio; g_signal_connect (loader, "size-prepared", G_CALLBACK (size_prepared_cb), &info); } has_frame = FALSE; result = GNOME_VFS_ERROR_GENERIC; while (!has_frame) { bytes_read = g_input_stream_read (G_INPUT_STREAM (file_input_stream), buffer, sizeof (buffer), NULL, NULL); if (bytes_read == -1) { break; } result = GNOME_VFS_OK; if (bytes_read == 0) { break; } if (!gdk_pixbuf_loader_write (loader, (unsigned char *)buffer, bytes_read, NULL)) { result = GNOME_VFS_ERROR_WRONG_FORMAT; break; } animation = gdk_pixbuf_loader_get_animation (loader); if (animation) { iter = gdk_pixbuf_animation_get_iter (animation, NULL); if (!gdk_pixbuf_animation_iter_on_currently_loading_frame (iter)) { has_frame = TRUE; } g_object_unref (iter); } } gdk_pixbuf_loader_close (loader, NULL); if (result != GNOME_VFS_OK) { g_object_unref (G_OBJECT (loader)); g_input_stream_close (G_INPUT_STREAM (file_input_stream), NULL, NULL); g_object_unref (file_input_stream); g_object_unref (file); return NULL; } g_input_stream_close (G_INPUT_STREAM (file_input_stream), NULL, NULL); g_object_unref (file_input_stream); g_object_unref (file); pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (pixbuf != NULL) { g_object_ref (G_OBJECT (pixbuf)); g_object_set_data (G_OBJECT (pixbuf), "gnome-original-width", GINT_TO_POINTER (info.input_width)); g_object_set_data (G_OBJECT (pixbuf), "gnome-original-height", GINT_TO_POINTER (info.input_height)); } g_object_unref (G_OBJECT (loader)); return pixbuf; }
static GtkWidget * create_emblem_widget_with_pixbuf (CajaEmblemSidebar *emblem_sidebar, const char *keyword, const char *display_name, GdkPixbuf *pixbuf) { GtkWidget *image, *event_box; GdkPixbuf *prelight_pixbuf; image = eel_labeled_image_new (display_name, pixbuf); eel_labeled_image_set_fixed_image_height (EEL_LABELED_IMAGE (image), STANDARD_EMBLEM_HEIGHT); eel_labeled_image_set_spacing (EEL_LABELED_IMAGE (image), EMBLEM_LABEL_SPACING); event_box = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (event_box), image); prelight_pixbuf = eel_create_spotlight_pixbuf (pixbuf); gtk_drag_source_set (event_box, GDK_BUTTON1_MASK, drag_types, G_N_ELEMENTS (drag_types), GDK_ACTION_COPY | GDK_ACTION_MOVE); gtk_drag_source_set_icon_pixbuf (event_box, pixbuf); g_signal_connect (event_box, "button_press_event", G_CALLBACK (caja_emblem_sidebar_button_press_cb), emblem_sidebar); g_signal_connect (event_box, "drag-data-get", G_CALLBACK (caja_emblem_sidebar_drag_data_get_cb), emblem_sidebar); g_signal_connect (event_box, "enter-notify-event", G_CALLBACK (caja_emblem_sidebar_enter_notify_cb), emblem_sidebar); g_signal_connect (event_box, "leave-notify-event", G_CALLBACK (caja_emblem_sidebar_leave_notify_cb), emblem_sidebar); g_object_set_data_full (G_OBJECT (event_box), "emblem-keyword", g_strdup (keyword), g_free); g_object_set_data_full (G_OBJECT (event_box), "emblem-display-name", g_strdup (display_name), g_free); g_object_set_data_full (G_OBJECT (event_box), "original-pixbuf", pixbuf, g_object_unref); g_object_set_data_full (G_OBJECT (event_box), "prelight-pixbuf", prelight_pixbuf, g_object_unref); g_object_set_data (G_OBJECT (event_box), "labeled-image", image); return event_box; }
static void fit_dialog(FitArgs *args) { GtkWidget *label, *dialog, *hbox, *hbox2, *table, *align, *expander, *scroll; GtkTable *table2; GwyGraphModel *gmodel; GwyGraphCurveModel *cmodel; GwyGraphArea *area; GwySelection *selection; GwySIUnit *siunit; FitControls controls; gint response, row; GString *report; gdouble xmin, xmax; controls.args = args; controls.in_update = TRUE; controls.param = g_array_new(FALSE, TRUE, sizeof(FitParamControl)); gmodel = gwy_graph_get_model(GWY_GRAPH(args->parent_graph)); gwy_graph_model_get_x_range(gmodel, &xmin, &xmax); g_object_get(gmodel, "si-unit-x", &siunit, NULL); args->abscissa_vf = gwy_si_unit_get_format_with_digits(siunit, GWY_SI_UNIT_FORMAT_VFMARKUP, MAX(fabs(xmin), fabs(xmax)), 4, NULL); g_object_unref(siunit); dialog = gtk_dialog_new_with_buttons(_("Fit FD Curve"), NULL, 0, NULL); controls.dialog = dialog; gtk_dialog_add_action_widget(GTK_DIALOG(dialog), gwy_stock_like_button_new(gwy_sgettext("verb|_Fit"), GTK_STOCK_EXECUTE), RESPONSE_FIT); gtk_dialog_add_button(GTK_DIALOG(dialog), gwy_sgettext("verb|_Estimate"), RESPONSE_ESTIMATE); gtk_dialog_add_button(GTK_DIALOG(dialog), _("_Plot Inits"), RESPONSE_PLOT); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_SAVE, RESPONSE_SAVE); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); gwy_help_add_to_graph_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); hbox = gtk_hbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 0); /* Graph */ args->graph_model = gwy_graph_model_new_alike(gmodel); controls.graph = gwy_graph_new(args->graph_model); g_object_unref(args->graph_model); gtk_widget_set_size_request(controls.graph, 400, 300); gwy_graph_enable_user_input(GWY_GRAPH(controls.graph), FALSE); gtk_box_pack_start(GTK_BOX(hbox), controls.graph, TRUE, TRUE, 0); gwy_graph_set_status(GWY_GRAPH(controls.graph), GWY_GRAPH_STATUS_XSEL); area = GWY_GRAPH_AREA(gwy_graph_get_area(GWY_GRAPH(controls.graph))); selection = gwy_graph_area_get_selection(area, GWY_GRAPH_STATUS_XSEL); gwy_selection_set_max_objects(selection, 1); g_signal_connect(selection, "changed", G_CALLBACK(graph_selected), &controls); gwy_graph_model_add_curve(controls.args->graph_model, gwy_graph_model_get_curve(gmodel, args->curve)); args->fitfunc = NULL; /* Controls */ align = gtk_alignment_new(0.0, 0.0, 0.0, 0.0); gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, FALSE, 0); g_signal_connect(align, "size-request", G_CALLBACK(grow_width), NULL); table = gtk_table_new(7, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 4); row = 0; /* Curve to fit */ label = gtk_label_new_with_mnemonic(_("_Graph curve:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_FILL, 0, 0, 0); controls.curve = curve_selector_new(gmodel, G_CALLBACK(curve_changed), &controls, args->curve); gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.curve); gtk_table_attach(GTK_TABLE(table), controls.curve, 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; /* Fitted function */ label = gtk_label_new_with_mnemonic(_("F_unction:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_FILL, 0, 0, 0); controls.function = function_selector_new(G_CALLBACK(function_changed), &controls, args->function_type); gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.function); gtk_table_attach(GTK_TABLE(table), controls.function, 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.formula = gtk_label_new("f(x) ="); gtk_misc_set_alignment(GTK_MISC(controls.formula), 0.0, 0.5); gtk_label_set_selectable(GTK_LABEL(controls.formula), TRUE); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), controls.formula); gtk_table_attach(GTK_TABLE(table), scroll, 0, 2, row, row+1, GTK_FILL, 0, 0, 8); row++; /* Parameters sought */ controls.param_table = gtk_table_new(1, 10, FALSE); table2 = GTK_TABLE(controls.param_table); gtk_table_set_row_spacing(table2, 0, 2); gtk_table_set_col_spacings(table2, 2); gtk_table_set_col_spacing(table2, 0, 6); gtk_table_set_col_spacing(table2, 4, 6); gtk_table_set_col_spacing(table2, 5, 6); gtk_table_set_col_spacing(table2, 7, 6); gtk_table_set_col_spacing(table2, 8, 6); gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(table2), 0, 2, row, row+1, GTK_FILL, 0, 0, 0); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; gtk_table_attach(table2, gwy_label_new_header(_("Fix")), 0, 1, 0, 1, GTK_FILL, 0, 0, 0); gtk_table_attach(table2, gwy_label_new_header(_("Parameter")), 1, 5, 0, 1, GTK_FILL, 0, 0, 0); gtk_table_attach(table2, gwy_label_new_header(_("Error")), 6, 8, 0, 1, GTK_FILL, 0, 0, 0); gtk_table_attach(table2, gwy_label_new_header(_("Initial")), 9, 10, 0, 1, GTK_FILL, 0, 0, 0); /* Make space for 4 parameters */ #if 0 for (i = 0; i < 4; i++) fit_param_row_create(&controls, i, table2, i+1); #endif /* Chi^2 */ label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("χ<sup>2</sup> result:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_FILL, 0, 0, 0); controls.chisq = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(controls.chisq), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), controls.chisq, 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; /* Correlation matrix */ expander = gtk_expander_new(NULL); gtk_expander_set_label_widget(GTK_EXPANDER(expander), gwy_label_new_header(_("Correlation Matrix"))); gtk_table_attach(GTK_TABLE(table), expander, 0, 2, row, row+1, GTK_FILL, 0, 0, 0); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; align = gtk_alignment_new(0.0, 0.5, 0.0, 0.0); gtk_container_add(GTK_CONTAINER(expander), align); row++; controls.covar = g_array_new(FALSE, TRUE, sizeof(GtkWidget*)); controls.covar_table = gtk_table_new(1, 1, TRUE); table2 = GTK_TABLE(controls.covar_table); gtk_table_set_col_spacings(table2, 6); gtk_table_set_row_spacings(table2, 2); gtk_container_add(GTK_CONTAINER(align), GTK_WIDGET(table2)); /* Fit area */ hbox2 = gtk_hbox_new(FALSE, 6); gtk_table_attach(GTK_TABLE(table), hbox2, 0, 2, row, row+1, GTK_FILL, 0, 0, 0); row++; label = gtk_label_new(_("Range:")); gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0); controls.from = gtk_entry_new(); g_object_set_data(G_OBJECT(controls.from), "id", (gpointer)"from"); gtk_entry_set_width_chars(GTK_ENTRY(controls.from), 8); gtk_box_pack_start(GTK_BOX(hbox2), controls.from, FALSE, FALSE, 0); g_signal_connect(controls.from, "activate", G_CALLBACK(range_changed), &controls); gwy_widget_set_activate_on_unfocus(controls.from, TRUE); label = gtk_label_new(gwy_sgettext("range|to")); gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0); controls.to = gtk_entry_new(); g_object_set_data(G_OBJECT(controls.to), "id", (gpointer)"to"); gtk_entry_set_width_chars(GTK_ENTRY(controls.to), 8); gtk_box_pack_start(GTK_BOX(hbox2), controls.to, FALSE, FALSE, 0); g_signal_connect(controls.to, "activate", G_CALLBACK(range_changed), &controls); gwy_widget_set_activate_on_unfocus(controls.to, TRUE); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), args->abscissa_vf->units); gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0); /* Auto-update */ hbox2 = gtk_hbox_new(FALSE, 6); gtk_table_attach(GTK_TABLE(table), hbox2, 0, 2, row, row+1, GTK_FILL, 0, 0, 0); row++; label = gtk_label_new(_("Instant:")); gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0); controls.auto_estimate = gtk_check_button_new_with_mnemonic(_("e_stimate")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.auto_estimate), args->auto_estimate); gtk_box_pack_start(GTK_BOX(hbox2), controls.auto_estimate, FALSE, FALSE, 0); g_signal_connect(controls.auto_estimate, "toggled", G_CALLBACK(auto_estimate_changed), &controls); controls.auto_plot = gtk_check_button_new_with_mnemonic(_("p_lot")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.auto_plot), args->auto_plot); gtk_box_pack_start(GTK_BOX(hbox2), controls.auto_plot, FALSE, FALSE, 0); g_signal_connect(controls.auto_plot, "toggled", G_CALLBACK(auto_plot_changed), &controls); function_changed(GTK_COMBO_BOX(controls.function), &controls); graph_selected(selection, -1, &controls); controls.in_update = FALSE; gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); fit_fetch_entry(&controls); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); fit_controls_free(&controls); return; break; case GTK_RESPONSE_OK: if (args->is_estimated) { cmodel = gwy_graph_model_get_curve(args->graph_model, 1); gwy_graph_model_add_curve(gmodel, cmodel); } gtk_widget_destroy(dialog); break; case RESPONSE_SAVE: report = create_fit_report(args); gwy_save_auxiliary_data(_("Save Fit Report"), GTK_WINDOW(dialog), -1, report->str); g_string_free(report, TRUE); break; case RESPONSE_ESTIMATE: fit_estimate(&controls); break; case RESPONSE_PLOT: fit_set_state(&controls, FALSE, TRUE); fit_plot_curve(args); break; case RESPONSE_FIT: fit_do(&controls); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); fit_controls_free(&controls); }