static void mimeview_show_mime_part(MimeView *mimeview, MimeInfo *partinfo) { TextView *textview = mimeview->textview; GtkTextBuffer *buffer; GtkTextIter iter; GtkTextChildAnchor *anchor; GtkWidget *vbbox; GtkWidget *button; gchar buf[BUFFSIZE]; if (!partinfo) return; textview_set_font(textview, NULL); textview_clear(textview); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview->text)); gtk_text_buffer_get_start_iter(buffer, &iter); gtk_text_buffer_insert(buffer, &iter, _("Select an action for the attached file:\n"), -1); if (partinfo->filename || partinfo->name) g_snprintf(buf, sizeof(buf), "[%s %s (%s)]\n\n", partinfo->filename ? partinfo->filename : partinfo->name, partinfo->content_type, to_human_readable(partinfo->content_size)); else g_snprintf(buf, sizeof(buf), "[%s (%s)]\n\n", partinfo->content_type, to_human_readable(partinfo->content_size)); gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, buf, -1, "mimepart", NULL); vbbox = gtk_vbutton_box_new(); gtk_box_set_spacing(GTK_BOX(vbbox), 5); button = gtk_button_new_from_stock(GTK_STOCK_OPEN); gtk_container_add(GTK_CONTAINER(vbbox), button); g_signal_connect(button, "clicked", G_CALLBACK(open_button_clicked), mimeview); button = gtk_button_new_with_mnemonic(_("Open _with...")); gtk_container_add(GTK_CONTAINER(vbbox), button); g_signal_connect(button, "clicked", G_CALLBACK(open_with_button_clicked), mimeview); button = gtk_button_new_with_mnemonic(_("_Display as text")); gtk_container_add(GTK_CONTAINER(vbbox), button); g_signal_connect(button, "clicked", G_CALLBACK(display_as_text_button_clicked), mimeview); button = gtk_button_new_with_mnemonic(_("_Save as...")); gtk_container_add(GTK_CONTAINER(vbbox), button); g_signal_connect(button, "clicked", G_CALLBACK(save_as_button_clicked), mimeview); gtk_widget_show_all(vbbox); anchor = gtk_text_buffer_create_child_anchor(buffer, &iter); gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(textview->text), vbbox, anchor); }
static void on_vbbox_dialog_ok (GtkWidget * widget, GbWidgetNewData * data) { GtkWidget *new_widget, *spinbutton, *window, *new_child; gint rows, i; window = gtk_widget_get_toplevel (widget); /* Only call callback if placeholder/fixed widget is still there */ if (gb_widget_can_finish_new (data)) { spinbutton = gtk_object_get_data (GTK_OBJECT (window), "rows"); g_return_if_fail (spinbutton != NULL); rows = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinbutton)); new_widget = gtk_vbutton_box_new (); for (i = 0; i < rows; i++) { new_child = gb_widget_new ("GtkButton", new_widget); GTK_WIDGET_SET_FLAGS (new_child, GTK_CAN_DEFAULT); gtk_container_add (GTK_CONTAINER (new_widget), new_child); } gb_widget_initialize (new_widget, data); (*data->callback) (new_widget, data); } gtk_widget_destroy (window); }
// // Constructor // CNewFilesBox::CNewFilesBox(void):CInfoBox("Process new frames"), m_Thread(NULL), m_StopThread(false), m_SuspendRq(false), m_Delay(false), m_OutFiles(0), m_ExitCode(0), m_State(STATE_STOP), m_Proc(NULL) { GtkWidget *hbox = gtk_hbox_new(FALSE, 8); gtk_container_set_border_width(GTK_CONTAINER(hbox), 4); gtk_box_pack_start(GTK_BOX(m_Box), hbox, FALSE, TRUE, 0); // Two text lines GtkWidget *vbox = gtk_vbox_new(TRUE, 8); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0); m_Line1 = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(m_Line1), 0, 0.5); gtk_box_pack_start(GTK_BOX(vbox), m_Line1, TRUE, TRUE, 0); m_Line2 = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(m_Line2), 0, 0.5); gtk_box_pack_start(GTK_BOX(vbox), m_Line2, TRUE, TRUE, 0); // Button box GtkWidget *bbox = gtk_vbutton_box_new(); gtk_box_pack_start(GTK_BOX(hbox), bbox, FALSE, TRUE, 0); m_CancelBtn = gtk_button_new_with_label("Cancel"); gtk_box_pack_start(GTK_BOX(bbox), m_CancelBtn, FALSE, TRUE, 0); g_signal_connect(m_CancelBtn, "clicked", G_CALLBACK(cancel_clicked), this); m_PauseBtn = gtk_button_new_with_label("Pause"); gtk_box_pack_start(GTK_BOX(bbox), m_PauseBtn, FALSE, TRUE, 0); g_signal_connect(m_PauseBtn, "clicked", G_CALLBACK(pause_clicked), this); m_Con = new CNFConsole(this); m_Queue = g_async_queue_new(); m_DataMutex = g_mutex_new(); m_Cond = g_cond_new(); }
GtkWidget * gtk_button_box_new (GtkOrientation orientation) { if (orientation == GTK_ORIENTATION_HORIZONTAL) return gtk_hbutton_box_new (); else return gtk_vbutton_box_new (); }
/* * Creates a new GtkWidget of class GtkVButtonBox, performing any specialized * initialization needed for the widget to work correctly in this environment. * If a dialog box is used to initialize the widget, return NULL from this * function, and call data->callback with your new widget when it is done. * If the widget needs a special destroy handler, add a signal here. */ GtkWidget * gb_vbutton_box_new (GbWidgetNewData * data) { GtkWidget *new_widget; if (data->action == GB_LOADING) { new_widget = gtk_vbutton_box_new (); return new_widget; } else { show_vbbox_dialog (data); return NULL; } }
static GtkWidget *create_app_window(void) { GtkWidget *window, *vbox, *parent, *widget; window = app_window_common(); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); /* tokencode frame */ parent = gtk_frame_new("Tokencode"); gtk_box_pack_start(GTK_BOX(vbox), parent, FALSE, FALSE, 0); widget = gtk_table_new(5, 3, TRUE); gtk_container_add(GTK_CONTAINER(parent), widget); parent = widget; gtk_table_attach_defaults(GTK_TABLE(parent), tokencode_text, 0, 3, 2, 3); /* progress bar */ progress_bar = gtk_progress_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), progress_bar, FALSE, FALSE, 0); widget = gtk_hseparator_new(); gtk_widget_set_size_request(widget, 200, 50); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); /* buttons */ parent = gtk_vbutton_box_new(); gtk_box_set_spacing(GTK_BOX(parent), 10); gtk_box_pack_start(GTK_BOX(vbox), parent, FALSE, FALSE, 0); widget = gtk_button_new_with_mnemonic("_Copy to clipboard"); g_signal_connect(widget, "clicked", G_CALLBACK(clipboard_callback), NULL); gtk_container_add(GTK_CONTAINER(parent), widget); widget = gtk_button_new_with_mnemonic("_Quit"); g_signal_connect_swapped(widget, "clicked", G_CALLBACK(gtk_main_quit), window); gtk_container_add(GTK_CONTAINER(parent), widget); return window; }
static void mimeview_show_signature_part(MimeView *mimeview, MimeInfo *partinfo) { TextView *textview = mimeview->textview; GtkTextBuffer *buffer; GtkTextIter iter; GtkTextChildAnchor *anchor; GtkWidget *vbbox; GtkWidget *button; if (!partinfo) return; textview_set_font(textview, NULL); textview_clear(textview); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview->text)); gtk_text_buffer_get_start_iter(buffer, &iter); if (partinfo->sigstatus_full) { gtk_text_buffer_insert (buffer, &iter, partinfo->sigstatus_full, -1); return; } gtk_text_buffer_insert (buffer, &iter, _("This signature has not been checked yet.\n\n"), -1); vbbox = gtk_vbutton_box_new(); gtk_box_set_spacing(GTK_BOX(vbbox), 5); if (rfc2015_is_available()) { button = gtk_button_new_with_mnemonic(_("_Check signature")); gtk_container_add(GTK_CONTAINER(vbbox), button); g_signal_connect(button, "clicked", G_CALLBACK(check_signature_button_clicked), mimeview); } gtk_widget_show_all(vbbox); anchor = gtk_text_buffer_create_child_anchor(buffer, &iter); gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(textview->text), vbbox, anchor); }
/**** VBUTTONBOX constructor ****/ int clip_GTK_VBUTTONBOXNEW(ClipMachine * ClipMachineMemory) { ClipVar *cv = _clip_spar(ClipMachineMemory, 1); GtkWidget *wid = NULL; C_widget *cwid; CHECKOPT(1, MAP_type_of_ClipVarType); wid = gtk_vbutton_box_new(); if (!wid) goto err; cwid = _register_widget(ClipMachineMemory, wid, cv); _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj); return 0; err: return 1; }
/* 用指定的参数创建一个按钮盒 */ GtkWidget *create_bbox( gint horizontal, char *title, gint spacing, gint child_w, gint child_h, gint layout ) { GtkWidget *frame; GtkWidget *bbox; GtkWidget *button; frame = gtk_frame_new (title); if (horizontal) bbox = gtk_hbutton_box_new (); else bbox = gtk_vbutton_box_new (); gtk_container_set_border_width (GTK_CONTAINER (bbox), 5); gtk_container_add (GTK_CONTAINER (frame), bbox); /* 设置按钮盒的外观 */ gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout); gtk_box_set_spacing (GTK_BOX (bbox), spacing); /*gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);*/ button = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_container_add (GTK_CONTAINER (bbox), button); button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); gtk_container_add (GTK_CONTAINER (bbox), button); button = gtk_button_new_from_stock (GTK_STOCK_HELP); gtk_container_add (GTK_CONTAINER (bbox), button); return frame; }
static void vnr_message_area_initialize(VnrMessageArea * msg_area) { msg_area->with_button = FALSE; msg_area->hbox = gtk_hbox_new(FALSE, 7); gtk_container_add(GTK_CONTAINER (msg_area), msg_area->hbox); gtk_container_set_border_width(GTK_CONTAINER (msg_area->hbox), 7); msg_area->image = gtk_image_new(); gtk_box_pack_start (GTK_BOX (msg_area->hbox), msg_area->image, FALSE, FALSE, 0); msg_area->message = gtk_label_new (NULL); gtk_label_set_line_wrap(GTK_LABEL (msg_area->message), TRUE); gtk_label_set_selectable(GTK_LABEL(msg_area->message), TRUE); gtk_box_pack_start (GTK_BOX (msg_area->hbox), msg_area->message, FALSE, FALSE, 0); msg_area->button_box = gtk_vbutton_box_new(); gtk_box_pack_end(GTK_BOX (msg_area->hbox), msg_area->button_box, FALSE, FALSE, 0); msg_area->user_button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(msg_area->button_box), msg_area->user_button); msg_area->cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); g_signal_connect(msg_area->cancel_button, "clicked", G_CALLBACK(cancel_button_cb), msg_area); gtk_container_add(GTK_CONTAINER(msg_area->button_box), msg_area->cancel_button); gtk_widget_hide_all(msg_area->hbox); gtk_widget_set_state(GTK_WIDGET(msg_area), GTK_STATE_SELECTED); gtk_widget_set_state(msg_area->button_box, GTK_STATE_NORMAL); msg_area->initialized = TRUE; }
/* create a dialog widget from scratch */ static void gm_audio_profiles_edit_init (GMAudioProfilesEdit *dialog) { GtkDialog *gdialog = GTK_DIALOG (dialog); GtkWidget *vbox; GtkWidget *label; GtkWidget *sw; GtkWidget *hbox; GtkWidget *bbox; GtkWidget *button; GtkTreeSelection *selection; /* dialog = gtk_dialog_new_with_buttons (_("Edit Profiles"), NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_HELP, GTK_RESPONSE_HELP, GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL); */ // FIXME: GTK_DIALOG_DESTROY_WITH_PARENT, dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog, GM_AUDIO_TYPE_PROFILES_EDIT, GMAudioProfilesEditPrivate); gtk_window_set_title (GTK_WINDOW (dialog), _("Edit MATE Audio Profiles")); gtk_window_set_default_size (GTK_WINDOW (dialog), 320, 240); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP, GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (gdialog)), 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_action_area (gdialog)), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_action_area (gdialog)), 6); g_signal_connect (GTK_DIALOG (dialog), "response", G_CALLBACK (on_gm_audio_profiles_edit_response), NULL); g_signal_connect (G_OBJECT (dialog), "destroy", G_CALLBACK (on_gm_audio_profiles_edit_destroy), NULL); vbox = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (gdialog)), vbox, TRUE, TRUE, 0); /* FIXME hbox = gtk_hbox_new (FALSE, PADDING); gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); app->manage_profiles_default_menu = profile_optionmenu_new (); g_signal_connect (G_OBJECT (app->manage_profiles_default_menu), "changed", G_CALLBACK (default_menu_changed), app); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (hbox), app->manage_profiles_default_menu, FALSE, FALSE, 0); */ hbox = gtk_hbox_new (FALSE, 6); label = gtk_label_new_with_mnemonic (_("_Profiles:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); dialog->priv->manage_profiles_list = create_profile_list (); g_signal_connect (G_OBJECT (dialog->priv->manage_profiles_list), "row_activated", G_CALLBACK (profile_activated_callback), NULL); sw = gtk_scrolled_window_new (NULL, NULL); /* FIXME terminal_util_set_labelled_by (GTK_WIDGET (dialog->priv->manage_profiles_list), GTK_LABEL (label)); */ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (sw), dialog->priv->manage_profiles_list); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); gtk_label_set_mnemonic_widget (GTK_LABEL (label), dialog->priv->manage_profiles_list); bbox = gtk_vbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START); gtk_box_set_spacing (GTK_BOX (bbox), 6); gtk_box_pack_end (GTK_BOX (hbox), bbox, FALSE, FALSE, 0); button = gtk_button_new_from_stock (GTK_STOCK_NEW); fix_button_align (button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (new_button_clicked), dialog); dialog->priv->new_button = button; /* terminal_util_set_atk_name_description (dialog->priv->new_button, NULL, _("Click to open new profile dialog")); */ gm_audio_profile_manage_register_stock (); button = gtk_button_new_from_stock (MANAGE_STOCK_EDIT); fix_button_align (button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (edit_button_clicked), dialog); gtk_widget_set_sensitive (button, FALSE); dialog->priv->edit_button = button; /* terminal_util_set_atk_name_description (app->manage_profiles_edit_button, NULL, _("Click to open edit profile dialog")); */ button = gtk_button_new_from_stock (GTK_STOCK_DELETE); fix_button_align (button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (delete_button_clicked), dialog); gtk_widget_set_sensitive (button, FALSE); dialog->priv->delete_button = button; /* terminal_util_set_atk_name_description (app->manage_profiles_delete_button, NULL, _("Click to delete selected profile")); */ gtk_widget_grab_focus (dialog->priv->manage_profiles_list); /* Monitor selection for sensitivity */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->manage_profiles_list)); selection_changed_callback (selection, dialog->priv); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (selection_changed_callback), dialog->priv); }
void Operator_manage(GtkWidget * UNUSED(widget), GtkWindow * parent) { GtkWidget * dialog; GtkWidget *hbox; GtkWidget * bbox; GtkWidget * sw; GtkTreeModel * model; GtkWidget *treeview; GtkWidget * button; GtkCellRenderer * renderer; GtkTreeViewColumn *column; /** Creation de la fenêtre principale */ dialog = gtk_dialog_new_with_buttons("Gestion des opérateurs", parent, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX (hbox), sw, TRUE, TRUE, 0); model = gtk_tree_model_sort_new_with_model(Operator_loadModel()); /* create tree view */ treeview = gtk_tree_view_new_with_model(model); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW (treeview), TRUE); gtk_tree_view_set_search_column(GTK_TREE_VIEW (treeview), 0); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Opérateur"); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", 0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_min_width(column, 300); gtk_tree_view_column_set_sort_column_id(column, 0); gtk_tree_view_column_set_alignment(column, 0.5); gtk_cell_renderer_set_alignment(renderer, 0, 0.5); gtk_tree_view_append_column(GTK_TREE_VIEW (treeview), column); gtk_widget_set_size_request(sw, 350, 400); gtk_widget_show(treeview); g_object_unref(model); gtk_container_add(GTK_CONTAINER (sw), treeview); bbox = gtk_vbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START); gtk_box_set_spacing(GTK_BOX (bbox), 5); gtk_box_pack_start(GTK_BOX (hbox), bbox, TRUE, TRUE, 0); gtk_widget_show(bbox); button = gtk_button_new_with_label("Ajouter"); g_signal_connect (button, "clicked", G_CALLBACK (Operator_add), treeview); gtk_container_add(GTK_CONTAINER (bbox), button); gtk_widget_show(button); button = gtk_button_new_with_label("Supprimer"); g_signal_connect (button, "clicked", G_CALLBACK (Operator_delete), treeview); gtk_container_add(GTK_CONTAINER (bbox), button); gtk_widget_show(button); button = gtk_button_new_with_label("Modifier"); g_signal_connect (button, "clicked", G_CALLBACK (Operator_modify), treeview); gtk_container_add(GTK_CONTAINER (bbox), button); gtk_widget_show_all(hbox); gtk_dialog_run(GTK_DIALOG (dialog)); gtk_widget_destroy(dialog); }
void ephy_permissions_dialog_add_tab (EphyPermissionsDialog *dialog, const char *type, const char *title) { EphyPermissionsDialogPrivate *priv = dialog->priv; GtkWidget *hbox, *view, *vbuttonbox, *button; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeView *treeview; GtkTreeViewColumn *column; GtkTreeSelection *selection; DialogTab *tab; tab = g_new0 (DialogTab, 1); tab->dialog = dialog; tab->type = g_strdup (type); tab->qtype = g_quark_from_string (type); tab->filled = FALSE; priv->tabs = g_list_prepend (priv->tabs, tab); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); g_object_set_data (G_OBJECT (hbox), TAB_DATA_KEY, tab); view = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view), GTK_POLICY_NEVER /* FIXME? */, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (view), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), view, TRUE, TRUE, 0); tab->store = store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); tab->model = GTK_TREE_MODEL (store); tab->treeview = treeview = GTK_TREE_VIEW (gtk_tree_view_new_with_model (tab->model)); g_object_unref (store); g_signal_connect (treeview, "key-press-event", G_CALLBACK (treeview_key_press_event_cb), tab); gtk_tree_view_set_headers_visible (treeview, TRUE); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (treeview, COL_HOST, _("Domain"), renderer, "text", COL_HOST, NULL); column = gtk_tree_view_get_column (treeview, COL_HOST); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_reorderable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sort_column_id (column, COL_HOST); gtk_tree_view_insert_column_with_attributes (treeview, COL_PERM, _("State"), renderer, "text", COL_PERM, NULL); column = gtk_tree_view_get_column (treeview, COL_PERM); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_reorderable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sort_column_id (column, COL_PERM); gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (treeview)); tab->selection = selection = gtk_tree_view_get_selection (treeview); gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); g_signal_connect (selection, "changed", G_CALLBACK (treeview_selection_changed_cb), tab); /* Button box */ vbuttonbox = gtk_vbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox), GTK_BUTTONBOX_START); gtk_box_pack_start (GTK_BOX (hbox), vbuttonbox, FALSE, FALSE, 0); /* Remove button */ tab->remove_button = button = gtk_button_new_from_stock (GTK_STOCK_REMOVE); g_signal_connect (button, "clicked", G_CALLBACK (remove_button_clicked_cb), tab); gtk_box_pack_start (GTK_BOX (vbuttonbox), button, FALSE, FALSE, 0); gtk_size_group_add_widget (priv->buttons_size_group, button); gtk_widget_show_all (hbox); /* And finally insert it in the notebook */ gtk_notebook_append_page (priv->notebook, hbox, gtk_label_new (title)); }
void exchange_delegates (ExchangeAccount *account, GtkWidget *parent) { GtkWidget *dialog_vbox1; GtkWidget *vbox2; GtkWidget *label3; GtkWidget *delegate_hbox; GtkWidget *delegates_table; GtkWidget *vbuttonbox1; GtkWidget *add_button; GtkWidget *edit_button; GtkWidget *remove_button; ExchangeDelegates *delegates; ExchangeDelegatesUser *user; GtkTreeViewColumn *column; GtkTreeIter iter; gint i; g_return_if_fail (GTK_IS_WIDGET (parent)); g_return_if_fail (EXCHANGE_IS_ACCOUNT (account)); delegates = g_new0 (ExchangeDelegates, 1); delegates->account = g_object_ref (account); delegates->dialog = gtk_dialog_new_with_buttons ( _("Delegates"), NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (delegates->dialog)); gtk_widget_show (dialog_vbox1); vbox2 = gtk_vbox_new (FALSE, 6); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox2, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox2), 6); label3 = gtk_label_new (_("These users will be able to send mail on your behalf\nand access your folders with the permissions you give them.")); gtk_widget_show (label3); gtk_box_pack_start (GTK_BOX (vbox2), label3, FALSE, FALSE, 0); delegate_hbox = gtk_hbox_new (FALSE, 6); gtk_widget_show (delegate_hbox); gtk_box_pack_start (GTK_BOX (vbox2), delegate_hbox, TRUE, TRUE, 0); delegates_table = gtk_tree_view_new (); gtk_widget_show (delegates_table); gtk_box_pack_start (GTK_BOX (delegate_hbox), delegates_table, TRUE, TRUE, 0); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (delegates_table), FALSE); vbuttonbox1 = gtk_vbutton_box_new (); gtk_widget_show (vbuttonbox1); gtk_box_pack_end (GTK_BOX (delegate_hbox), vbuttonbox1, FALSE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox1), GTK_BUTTONBOX_START); gtk_box_set_spacing (GTK_BOX (vbuttonbox1), 6); add_button = gtk_button_new_from_stock ("gtk-add"); gtk_widget_show (add_button); gtk_container_add (GTK_CONTAINER (vbuttonbox1), add_button); gtk_widget_set_can_default (add_button, TRUE); edit_button = gtk_button_new_with_mnemonic (_("_Edit")); gtk_widget_show (edit_button); gtk_container_add (GTK_CONTAINER (vbuttonbox1), edit_button); gtk_widget_set_can_default (edit_button, TRUE); remove_button = gtk_button_new_from_stock ("gtk-remove"); gtk_widget_show (remove_button); gtk_container_add (GTK_CONTAINER (vbuttonbox1), remove_button); gtk_widget_set_can_default (remove_button, TRUE); g_signal_connect (delegates->dialog, "response", G_CALLBACK (dialog_response), delegates); if (parent) gtk_window_set_transient_for (GTK_WINDOW (delegates->dialog), GTK_WINDOW (parent)); delegates->parent = parent; g_object_weak_ref (G_OBJECT (parent), parent_destroyed, delegates); /* Set up the buttons */ g_signal_connect (add_button, "clicked", G_CALLBACK (add_button_clicked_cb), delegates); g_signal_connect (edit_button, "clicked", G_CALLBACK (edit_button_clicked_cb), delegates); g_signal_connect (remove_button, "clicked", G_CALLBACK (remove_button_clicked_cb), delegates); /* Set up the table */ delegates->model = gtk_list_store_new (1, G_TYPE_STRING); delegates->table = delegates_table; column = gtk_tree_view_column_new_with_attributes ( _("Name"), gtk_cell_renderer_text_new (), "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (delegates->table), column); gtk_tree_view_set_model (GTK_TREE_VIEW (delegates->table), GTK_TREE_MODEL (delegates->model)); /* Get list of delegate users */ if (get_user_list (delegates)) { for (i = 0; i < delegates->users->len; i++) { user = delegates->users->pdata[i]; gtk_list_store_append (delegates->model, &iter); gtk_list_store_set (delegates->model, &iter, 0, user->display_name, -1); } g_signal_connect (delegates->table, "button_press_event", G_CALLBACK (table_click_cb), delegates); } else { gtk_widget_set_sensitive (add_button, FALSE); gtk_widget_set_sensitive (edit_button, FALSE); gtk_widget_set_sensitive (remove_button, FALSE); gtk_list_store_append (delegates->model, &iter); gtk_list_store_set (delegates->model, &iter, 0, _("Error reading delegates list."), -1); } gtk_widget_show (delegates->dialog); }
GtkWidget* create_windowPreferences (void) { GtkWidget *windowPreferences; GtkWidget *vboxPrefs; GtkWidget *hboxUserName; GtkWidget *labelUserName; GtkWidget *entryUserName; GtkWidget *hbuttonboxBtns; GtkWidget *buttonCancel; GtkWidget *buttonApply; GtkWidget *hbox1; GtkWidget *vbox2; GtkWidget *frameHabits; GtkWidget *hbox3; GtkWidget *vbox3; GtkWidget *treeviewHabits; GtkWidget *vbuttonboxHabits; GtkWidget *buttonAddHabit; GtkWidget *buttonRemoveHabit; GtkWidget *buttonEditHabit; GtkWidget *label11; windowPreferences = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (windowPreferences, "windowPreferences"); gtk_window_set_title (GTK_WINDOW (windowPreferences), "Preferences"); gtk_window_set_resizable (GTK_WINDOW (windowPreferences), FALSE); vboxPrefs = gtk_vbox_new (FALSE, 5); gtk_widget_set_name (vboxPrefs, "vboxPrefs"); gtk_widget_show (vboxPrefs); gtk_container_add (GTK_CONTAINER (windowPreferences), vboxPrefs); gtk_container_set_border_width (GTK_CONTAINER (vboxPrefs), 3); hboxUserName = gtk_hbox_new (FALSE, 5); gtk_widget_set_name (hboxUserName, "hboxUserName"); gtk_widget_show (hboxUserName); gtk_box_pack_start (GTK_BOX (vboxPrefs), hboxUserName, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hboxUserName), 3); labelUserName = gtk_label_new ("User name"); gtk_widget_set_name (labelUserName, "labelUserName"); gtk_widget_show (labelUserName); gtk_box_pack_start (GTK_BOX (hboxUserName), labelUserName, FALSE, FALSE, 0); entryUserName = gtk_entry_new (); gtk_widget_set_name (entryUserName, "entryUserName"); gtk_widget_show (entryUserName); gtk_box_pack_start (GTK_BOX (hboxUserName), entryUserName, FALSE, FALSE, 0); gtk_entry_set_max_length (GTK_ENTRY (entryUserName), 20); gtk_entry_set_width_chars (GTK_ENTRY (entryUserName), 21); hbuttonboxBtns = gtk_hbutton_box_new (); gtk_widget_set_name (hbuttonboxBtns, "hbuttonboxBtns"); gtk_widget_show (hbuttonboxBtns); gtk_box_pack_end (GTK_BOX (vboxPrefs), hbuttonboxBtns, FALSE, FALSE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonboxBtns), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (hbuttonboxBtns), 5); buttonCancel = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_set_name (buttonCancel, "buttonCancel"); gtk_widget_show (buttonCancel); gtk_container_add (GTK_CONTAINER (hbuttonboxBtns), buttonCancel); GTK_WIDGET_SET_FLAGS (buttonCancel, GTK_CAN_DEFAULT); buttonApply = gtk_button_new_from_stock ("gtk-apply"); gtk_widget_set_name (buttonApply, "buttonApply"); gtk_widget_show (buttonApply); gtk_container_add (GTK_CONTAINER (hbuttonboxBtns), buttonApply); GTK_WIDGET_SET_FLAGS (buttonApply, GTK_CAN_DEFAULT); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_set_name (hbox1, "hbox1"); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vboxPrefs), hbox1, TRUE, TRUE, 0); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_set_name (vbox2, "vbox2"); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0); frameHabits = gtk_frame_new (NULL); gtk_widget_set_name (frameHabits, "frameHabits"); gtk_widget_show (frameHabits); gtk_box_pack_start (GTK_BOX (vbox2), frameHabits, TRUE, TRUE, 0); hbox3 = gtk_hbox_new (FALSE, 5); gtk_widget_set_name (hbox3, "hbox3"); gtk_widget_show (hbox3); gtk_container_add (GTK_CONTAINER (frameHabits), hbox3); gtk_container_set_border_width (GTK_CONTAINER (hbox3), 5); vbox3 = gtk_vbox_new (FALSE, 0); gtk_widget_set_name (vbox3, "vbox3"); gtk_widget_show (vbox3); gtk_box_pack_start (GTK_BOX (hbox3), vbox3, TRUE, TRUE, 0); treeviewHabits = gtk_tree_view_new (); gtk_widget_set_name (treeviewHabits, "treeviewHabits"); gtk_widget_show (treeviewHabits); gtk_box_pack_start (GTK_BOX (vbox3), treeviewHabits, TRUE, TRUE, 0); vbuttonboxHabits = gtk_vbutton_box_new (); gtk_widget_set_name (vbuttonboxHabits, "vbuttonboxHabits"); gtk_widget_show (vbuttonboxHabits); gtk_box_pack_start (GTK_BOX (hbox3), vbuttonboxHabits, FALSE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonboxHabits), GTK_BUTTONBOX_START); buttonAddHabit = gtk_button_new_from_stock ("gtk-add"); gtk_widget_set_name (buttonAddHabit, "buttonAddHabit"); gtk_widget_show (buttonAddHabit); gtk_container_add (GTK_CONTAINER (vbuttonboxHabits), buttonAddHabit); GTK_WIDGET_SET_FLAGS (buttonAddHabit, GTK_CAN_DEFAULT); buttonRemoveHabit = gtk_button_new_from_stock ("gtk-remove"); gtk_widget_set_name (buttonRemoveHabit, "buttonRemoveHabit"); gtk_widget_show (buttonRemoveHabit); gtk_container_add (GTK_CONTAINER (vbuttonboxHabits), buttonRemoveHabit); gtk_widget_set_sensitive (buttonRemoveHabit, FALSE); GTK_WIDGET_SET_FLAGS (buttonRemoveHabit, GTK_CAN_DEFAULT); buttonEditHabit = gtk_button_new_from_stock ("gtk-properties"); gtk_widget_set_name (buttonEditHabit, "buttonEditHabit"); gtk_widget_show (buttonEditHabit); gtk_container_add (GTK_CONTAINER (vbuttonboxHabits), buttonEditHabit); gtk_widget_set_sensitive (buttonEditHabit, FALSE); GTK_WIDGET_SET_FLAGS (buttonEditHabit, GTK_CAN_DEFAULT); label11 = gtk_label_new ("Habits"); gtk_widget_set_name (label11, "label11"); gtk_widget_show (label11); gtk_frame_set_label_widget (GTK_FRAME (frameHabits), label11); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (windowPreferences, windowPreferences, "windowPreferences"); GLADE_HOOKUP_OBJECT (windowPreferences, vboxPrefs, "vboxPrefs"); GLADE_HOOKUP_OBJECT (windowPreferences, hboxUserName, "hboxUserName"); GLADE_HOOKUP_OBJECT (windowPreferences, labelUserName, "labelUserName"); GLADE_HOOKUP_OBJECT (windowPreferences, entryUserName, "entryUserName"); GLADE_HOOKUP_OBJECT (windowPreferences, hbuttonboxBtns, "hbuttonboxBtns"); GLADE_HOOKUP_OBJECT (windowPreferences, buttonCancel, "buttonCancel"); GLADE_HOOKUP_OBJECT (windowPreferences, buttonApply, "buttonApply"); GLADE_HOOKUP_OBJECT (windowPreferences, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (windowPreferences, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (windowPreferences, frameHabits, "frameHabits"); GLADE_HOOKUP_OBJECT (windowPreferences, hbox3, "hbox3"); GLADE_HOOKUP_OBJECT (windowPreferences, vbox3, "vbox3"); GLADE_HOOKUP_OBJECT (windowPreferences, treeviewHabits, "treeviewHabits"); GLADE_HOOKUP_OBJECT (windowPreferences, vbuttonboxHabits, "vbuttonboxHabits"); GLADE_HOOKUP_OBJECT (windowPreferences, buttonAddHabit, "buttonAddHabit"); GLADE_HOOKUP_OBJECT (windowPreferences, buttonRemoveHabit, "buttonRemoveHabit"); GLADE_HOOKUP_OBJECT (windowPreferences, buttonEditHabit, "buttonEditHabit"); GLADE_HOOKUP_OBJECT (windowPreferences, label11, "label11"); return windowPreferences; }
int main( int argc, char *argv[] ) { GtkWidget *window, *hbox, *vbox, *bbox, *checkbox, *text_view, *button; GtkWidget *radio1, *radio2, *rbbox, *frame; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW(window), 320, 240); /* It's a good idea to do this for all windows. */ g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL); hbox = gtk_hbox_new (FALSE, 0); my_vbox = my_vbox_new (FALSE, 0); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (hbox), my_vbox); /* Some widgets to test with MyVBox */ widget1 = gtk_hbutton_box_new (); button = gtk_button_new_from_stock (GTK_STOCK_SAVE); g_signal_connect (button, "clicked", G_CALLBACK (save_cb), "save"); gtk_container_add (GTK_CONTAINER (widget1), button); button = gtk_button_new_from_stock (GTK_STOCK_SAVE_AS); g_signal_connect (button, "clicked", G_CALLBACK (save_cb), "save as"); gtk_container_add (GTK_CONTAINER (widget1), button); widget2 = gtk_frame_new ("Text"); text_buffer = gtk_text_buffer_new (NULL); text_view = gtk_text_view_new_with_buffer (text_buffer); gtk_container_add (GTK_CONTAINER (widget2), text_view); widget3 = gtk_vbutton_box_new (); button = gtk_button_new_from_stock (GTK_STOCK_DELETE); g_signal_connect (button, "clicked", G_CALLBACK (delete_cb), NULL); gtk_container_add (GTK_CONTAINER (widget3), button); button = gtk_button_new_from_stock (GTK_STOCK_UNDELETE); g_signal_connect (button, "clicked", G_CALLBACK (undo_cb), NULL); gtk_container_add (GTK_CONTAINER (widget3), button); /* Show the widgets and attach them later */ gtk_widget_show_all (widget1); gtk_widget_show_all (widget2); gtk_widget_show_all (widget3); /* Add checkboxes to the vbox */ bbox = gtk_vbutton_box_new (); checkbox = gtk_check_button_new_with_label ("Save"); g_signal_connect (checkbox, "toggled", G_CALLBACK (button_cb), GINT_TO_POINTER (1)); gtk_container_add (GTK_CONTAINER (bbox), checkbox); checkbox = gtk_check_button_new_with_label ("Text"); g_signal_connect (checkbox, "toggled", G_CALLBACK (button_cb), GINT_TO_POINTER (2)); gtk_container_add (GTK_CONTAINER (bbox), checkbox); checkbox = gtk_check_button_new_with_label ("Edit"); g_signal_connect (checkbox, "toggled", G_CALLBACK (button_cb), GINT_TO_POINTER (4)); gtk_container_add (GTK_CONTAINER (bbox), checkbox); /* Add radio buttons to select the animation style */ frame = gtk_frame_new ("Animation mode"); rbbox = gtk_hbutton_box_new (); radio1 = gtk_radio_button_new_with_label (NULL, "Move"); g_signal_connect (radio1, "toggled", G_CALLBACK (select_animation_cb), "move"); gtk_container_add (GTK_CONTAINER (rbbox), radio1); radio2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1), "Resize"); g_signal_connect (radio2, "toggled", G_CALLBACK (select_animation_cb), "resize"); gtk_container_add (GTK_CONTAINER (rbbox), radio2); gtk_container_add (GTK_CONTAINER (frame), rbbox); gtk_container_add (GTK_CONTAINER (bbox), frame); gtk_container_add (GTK_CONTAINER (vbox), bbox); /* Add vbox to the hbox */ gtk_container_add (GTK_CONTAINER (hbox), vbox); gtk_container_add (GTK_CONTAINER (window), hbox); gtk_widget_show_all (window); gtk_main (); return 0; }
static void create_adapter(adapter_data *adapter) { GHashTable *hash = NULL; GValue *value; DBusGProxy *default_proxy; const gchar *name; gboolean powered, discoverable; guint timeout; GtkWidget *mainbox; GtkWidget *vbox; GtkWidget *alignment; GtkWidget *table; GtkWidget *label; GtkWidget *image; GtkWidget *button; GtkWidget *entry; GtkWidget *buttonbox; int page_num; dbus_g_proxy_call(adapter->proxy, "GetProperties", NULL, G_TYPE_INVALID, dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &hash, G_TYPE_INVALID); if (hash != NULL) { value = g_hash_table_lookup(hash, "Name"); name = value ? g_value_get_string(value) : NULL; value = g_hash_table_lookup(hash, "Powered"); powered = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "Discoverable"); discoverable = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "DiscoverableTimeout"); timeout = value ? g_value_get_uint(value) : 0; } else { name = NULL; powered = FALSE; discoverable = FALSE; timeout = 0; } adapter->powered = powered; adapter->discoverable = discoverable; adapter->timeout_value = timeout; default_proxy = bluetooth_client_get_default_adapter (client); if (default_proxy != NULL) { adapter->is_default = g_str_equal (dbus_g_proxy_get_path (default_proxy), dbus_g_proxy_get_path (adapter->proxy)); g_object_unref (default_proxy); } mainbox = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12); page_num = gtk_notebook_prepend_page(GTK_NOTEBOOK(adapter->notebook), mainbox, NULL); adapter->child = mainbox; vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, TRUE, 0); /* The discoverable checkbox */ button = gtk_check_button_new_with_mnemonic (_("Make computer _visible")); if (powered == FALSE) discoverable = FALSE; if (discoverable != FALSE && timeout == 0) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); else if (discoverable == FALSE) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE); } gtk_widget_set_sensitive (button, adapter->powered); adapter->button_discoverable = button; adapter->signal_discoverable = g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(discoverable_changed_cb), adapter); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); /* The friendly name */ vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); label = create_label(_("Friendly name")); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(entry), 248); gtk_widget_set_size_request(entry, 240, -1); gtk_container_add (GTK_CONTAINER (alignment), entry); if (name != NULL) gtk_entry_set_text(GTK_ENTRY(entry), name); adapter->entry = entry; adapter->name_vbox = vbox; g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(name_callback), adapter); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(focus_callback), adapter); gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered); /* The known devices */ table = gtk_table_new(2, 2, FALSE); gtk_box_pack_start(GTK_BOX(mainbox), table, TRUE, TRUE, 0); label = create_label(_("Devices")); gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 6); /* Note that this will only ever show the devices on the default * adapter, this is on purpose */ adapter->chooser = bluetooth_chooser_new (NULL); g_object_set (adapter->chooser, "show-searching", FALSE, "show-device-type", FALSE, "show-device-category", FALSE, "show-pairing", TRUE, "show-connected", TRUE, "device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED, NULL); g_signal_connect (adapter->chooser, "notify::device-selected", G_CALLBACK(device_selected_cb), adapter); gtk_table_attach(GTK_TABLE(table), adapter->chooser, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); adapter->devices_table = table; buttonbox = gtk_vbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_START); gtk_box_set_spacing(GTK_BOX(buttonbox), 6); gtk_box_set_homogeneous(GTK_BOX(buttonbox), FALSE); gtk_table_attach(GTK_TABLE(table), buttonbox, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 6, 6); button = gtk_button_new_with_mnemonic(_("Set up _new device...")); image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wizard_callback), adapter); button = gtk_button_new_with_label(_("Disconnect")); image = gtk_image_new_from_stock(GTK_STOCK_DISCONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(disconnect_callback), adapter); adapter->button_disconnect = button; button = gtk_button_new_with_mnemonic(_("_Remove")); image = gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remove_callback), adapter); adapter->button_delete = button; gtk_widget_set_sensitive (adapter->devices_table, adapter->powered); g_object_set_data(G_OBJECT(mainbox), "adapter", adapter); gtk_widget_show_all(mainbox); if (adapter->is_default != FALSE) gtk_notebook_set_current_page (GTK_NOTEBOOK (adapter->notebook), page_num); }
CEmoticonDlg::CEmoticonDlg(CWidget* parent) : m_IsModified(false) // : CDialog( parent, _("Emoticons"), true ) { m_Widget = gtk_dialog_new_with_buttons(_("Emoticons"), GTK_WINDOW(parent->m_Widget), GtkDialogFlags(GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT), _("Send"), GTK_RESPONSE_OK, GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL); gtk_dialog_set_default_response(GTK_DIALOG(m_Widget), GTK_RESPONSE_OK ); gtk_window_set_type_hint (GTK_WINDOW (m_Widget), GDK_WINDOW_TYPE_HINT_DIALOG); PostCreate(); GtkWidget *vbox; GtkWidget *hbox; GtkWidget *emoticon_list_scrl; GtkWidget *emoticon_list; GtkWidget *vbtn_box; GtkWidget *add_btn; GtkWidget *edit_btn; GtkWidget *remove_btn; GtkWidget *up_btn; GtkWidget *down_btn; vbox = GTK_DIALOG (m_Widget)->vbox; gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox); gtk_box_pack_end (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); emoticon_list_scrl = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (emoticon_list_scrl); gtk_box_pack_start (GTK_BOX (hbox), emoticon_list_scrl, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (emoticon_list_scrl), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (emoticon_list_scrl), GTK_SHADOW_IN); vbtn_box = gtk_vbutton_box_new (); gtk_widget_show (vbtn_box); gtk_box_pack_start (GTK_BOX (hbox), vbtn_box, FALSE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbtn_box), GTK_BUTTONBOX_START); add_btn = gtk_button_new_from_stock ("gtk-add"); gtk_widget_show (add_btn); gtk_container_add (GTK_CONTAINER (vbtn_box), add_btn); GTK_WIDGET_SET_FLAGS (add_btn, GTK_CAN_DEFAULT); edit_btn = gtk_button_new_from_stock ("gtk-edit"); gtk_widget_show (edit_btn); gtk_container_add (GTK_CONTAINER (vbtn_box), edit_btn); GTK_WIDGET_SET_FLAGS (edit_btn, GTK_CAN_DEFAULT); remove_btn = gtk_button_new_from_stock ("gtk-remove"); gtk_widget_show (remove_btn); gtk_container_add (GTK_CONTAINER (vbtn_box), remove_btn); GTK_WIDGET_SET_FLAGS (remove_btn, GTK_CAN_DEFAULT); up_btn = gtk_button_new_from_stock ("gtk-go-up"); gtk_widget_show (up_btn); gtk_container_add (GTK_CONTAINER (vbtn_box), up_btn); GTK_WIDGET_SET_FLAGS (up_btn, GTK_CAN_DEFAULT); down_btn = gtk_button_new_from_stock ("gtk-go-down"); gtk_widget_show (down_btn); gtk_container_add (GTK_CONTAINER (vbtn_box), down_btn); GTK_WIDGET_SET_FLAGS (down_btn, GTK_CAN_DEFAULT); g_signal_connect ((gpointer) add_btn, "clicked", G_CALLBACK (CEmoticonDlg::OnAdd), this); g_signal_connect ((gpointer) edit_btn, "clicked", G_CALLBACK (CEmoticonDlg::OnEdit), this); g_signal_connect ((gpointer) remove_btn, "clicked", G_CALLBACK (CEmoticonDlg::OnRemove), this); g_signal_connect ((gpointer) up_btn, "clicked", G_CALLBACK (CEmoticonDlg::OnUp), this); g_signal_connect ((gpointer) down_btn, "clicked", G_CALLBACK (CEmoticonDlg::OnDown), this); gtk_window_set_default_size((GtkWindow*)m_Widget, 512, 400); m_List = new CListBox; emoticon_list = m_List->m_Widget; gtk_widget_show (emoticon_list); gtk_container_add (GTK_CONTAINER (emoticon_list_scrl), emoticon_list); g_signal_connect(G_OBJECT(m_Widget), "response", G_CALLBACK(CDialog::OnResponse), this); g_signal_connect(G_OBJECT(m_List->m_Widget), "row-activated", G_CALLBACK(CEmoticonDlg::OnListRowActivated), this ); LoadEmoticons(); }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *hbox1; GtkWidget *scrolledwindow1; GtkWidget *treeview1; GtkWidget *vbuttonbox1; GtkWidget *buttonDeleteAll; GtkWidget *buttonDelete; GtkWidget *buttonRunAll; GtkWidget *buttonRun; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Jobs")); gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow1); gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow1, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_SHADOW_IN); treeview1 = gtk_tree_view_new (); gtk_widget_show (treeview1); gtk_container_add (GTK_CONTAINER (scrolledwindow1), treeview1); //gtk_widget_set_size_request (treeview1, 300, -1); vbuttonbox1 = gtk_vbutton_box_new (); gtk_widget_show (vbuttonbox1); gtk_box_pack_start (GTK_BOX (hbox1), vbuttonbox1, FALSE, FALSE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox1), GTK_BUTTONBOX_START); buttonDeleteAll = gtk_button_new_with_mnemonic (QT_TR_NOOP("Delete All Jobs")); gtk_widget_show (buttonDeleteAll); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonDeleteAll); GTK_WIDGET_SET_FLAGS (buttonDeleteAll, GTK_CAN_DEFAULT); buttonDelete = gtk_button_new_with_mnemonic (QT_TR_NOOP("Delete Job")); gtk_widget_show (buttonDelete); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonDelete); GTK_WIDGET_SET_FLAGS (buttonDelete, GTK_CAN_DEFAULT); buttonRunAll = gtk_button_new_with_mnemonic (QT_TR_NOOP("Run all jobs")); gtk_widget_show (buttonRunAll); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonRunAll); GTK_WIDGET_SET_FLAGS (buttonRunAll, GTK_CAN_DEFAULT); buttonRun = gtk_button_new_with_mnemonic (QT_TR_NOOP("Run Job")); gtk_widget_show (buttonRun); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonRun); GTK_WIDGET_SET_FLAGS (buttonRun, GTK_CAN_DEFAULT); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow1, "scrolledwindow1"); GLADE_HOOKUP_OBJECT (dialog1, treeview1, "treeview1"); GLADE_HOOKUP_OBJECT (dialog1, vbuttonbox1, "vbuttonbox1"); GLADE_HOOKUP_OBJECT (dialog1, buttonDeleteAll, "buttonDeleteAll"); GLADE_HOOKUP_OBJECT (dialog1, buttonDelete, "buttonDelete"); GLADE_HOOKUP_OBJECT (dialog1, buttonRunAll, "buttonRunAll"); GLADE_HOOKUP_OBJECT (dialog1, buttonRun, "buttonRun"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
int main (int argc, char **argv) { GtkWidget *control_window; GtkWidget *vbbox; GtkWidget *button; GtkWidget *dialog; GtkWidget *prop_editor; GtkFileSystem *file_system; GtkFileFilter *filter; GtkWidget *preview_vbox; GtkWidget *extra; gtk_init (&argc, &argv); #ifdef USE_GNOME_VFS file_system = gtk_file_system_gnome_vfs_new (); #else file_system = gtk_file_system_unix_new (); #endif dialog = g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG, "action", GTK_FILE_CHOOSER_ACTION_OPEN, "file-system", file_system, "title", "Select a file", NULL); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); g_signal_connect (dialog, "selection-changed", G_CALLBACK (print_selected), NULL); g_signal_connect (dialog, "current-folder-changed", G_CALLBACK (print_current_folder), NULL); g_signal_connect (dialog, "response", G_CALLBACK (response_cb), NULL); /* Filters */ filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, "All Files"); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, "No backup files"); gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_DISPLAY_NAME, no_backup_files_filter, NULL, NULL); gtk_file_filter_add_mime_type (filter, "image/png"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); /* Make this filter the default */ gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, "PNG and JPEG"); gtk_file_filter_add_mime_type (filter, "image/jpeg"); gtk_file_filter_add_mime_type (filter, "image/png"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); /* Preview widget */ preview_vbox = gtk_vbox_new (0, FALSE); gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), preview_vbox); preview_label = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (preview_vbox), preview_label, TRUE, TRUE, 0); gtk_misc_set_padding (GTK_MISC (preview_label), 6, 6); preview_image = gtk_image_new (); gtk_box_pack_start (GTK_BOX (preview_vbox), preview_image, TRUE, TRUE, 0); gtk_misc_set_padding (GTK_MISC (preview_image), 6, 6); update_preview_cb (GTK_FILE_CHOOSER (dialog)); g_signal_connect (dialog, "update-preview", G_CALLBACK (update_preview_cb), NULL); /* Extra widget */ extra = gtk_check_button_new_with_mnemonic ("Lar_t whoever asks about this button"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (extra), TRUE); gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), extra); /* Shortcuts */ gtk_file_chooser_add_shortcut_folder_uri (GTK_FILE_CHOOSER (dialog), "file:///usr/share/pixmaps", NULL); /* Done with the dialog */ gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 400); /* show_all() to reveal bugs in composite widget handling */ gtk_widget_show_all (dialog); /* Extra controls for manipulating the test environment */ prop_editor = create_prop_editor (G_OBJECT (dialog), GTK_TYPE_FILE_CHOOSER); control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); vbbox = gtk_vbutton_box_new (); gtk_container_add (GTK_CONTAINER (control_window), vbbox); button = gtk_button_new_with_mnemonic ("_Select all"); gtk_container_add (GTK_CONTAINER (vbbox), button); g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_file_chooser_select_all), dialog); button = gtk_button_new_with_mnemonic ("_Unselect all"); gtk_container_add (GTK_CONTAINER (vbbox), button); g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_file_chooser_unselect_all), dialog); gtk_widget_show_all (control_window); gtk_main (); return 0; }
void addressbook_edit_person_page_attrib_ldap(PersonEditDlg *dialog, gint pageNum, gchar *pageLbl) { GtkWidget *combo_box; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *vboxl; GtkWidget *vboxb; GtkWidget *vbuttonbox; GtkWidget *buttonDel; GtkWidget *buttonMod; GtkWidget *buttonAdd; GtkWidget *table; GtkWidget *label; GtkWidget *clist_swin; GtkWidget *clist; GtkWidget *entry_value; gint top; personEditDlg = dialog; gchar *titles[ATTRIB_N_COLS]; gint i; titles[ATTRIB_COL_NAME] = N_("Name"); titles[ATTRIB_COL_VALUE] = N_("Value"); vbox = gtk_vbox_new(FALSE, 8); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(personEditDlg->notebook), vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), BORDER_WIDTH); label = gtk_label_new_with_mnemonic(pageLbl); gtk_widget_show(label); gtk_notebook_set_tab_label( GTK_NOTEBOOK(personEditDlg->notebook), gtk_notebook_get_nth_page(GTK_NOTEBOOK(personEditDlg->notebook), pageNum), label); /* Split into two areas */ hbox = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(vbox), hbox); /* Attribute list */ vboxl = gtk_vbox_new(FALSE, 4); gtk_container_add(GTK_CONTAINER(hbox), vboxl); gtk_container_set_border_width(GTK_CONTAINER(vboxl), 4); clist_swin = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(vboxl), clist_swin); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); clist = gtk_cmclist_new_with_titles(ATTRIB_N_COLS, titles); gtk_container_add(GTK_CONTAINER(clist_swin), clist); gtk_cmclist_set_selection_mode(GTK_CMCLIST(clist), GTK_SELECTION_BROWSE); gtk_cmclist_set_column_width(GTK_CMCLIST(clist), ATTRIB_COL_NAME, ATTRIB_COL_WIDTH_NAME); gtk_cmclist_set_column_width(GTK_CMCLIST(clist), ATTRIB_COL_VALUE, ATTRIB_COL_WIDTH_VALUE); gtk_cmclist_set_compare_func(GTK_CMCLIST(clist), edit_person_attrib_compare_func); gtk_cmclist_set_auto_sort(GTK_CMCLIST(clist), TRUE); for (i = 0; i < ATTRIB_N_COLS; i++) gtkut_widget_set_can_focus(GTK_CMCLIST(clist)->column[i].button, FALSE); /* Data entry area */ table = gtk_table_new(4, 2, FALSE); gtk_box_pack_start(GTK_BOX(vboxl), table, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_table_set_row_spacings(GTK_TABLE(table), 4); gtk_table_set_col_spacings(GTK_TABLE(table), 4); /* First row */ top = 0; label = gtk_label_new(N_("Name")); gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gchar **attribute = (gchar **) ATTRIBUTE; combo_box = gtk_combo_box_new_text(); while (*attribute) { if (!strcmp(*attribute, "jpegPhoto")) { attribute++; continue; } gtk_combo_box_append_text(GTK_COMBO_BOX(combo_box), *attribute++); } gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), 0); gtk_table_attach(GTK_TABLE(table), combo_box, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0); /* Next row */ ++top; label = gtk_label_new(N_("Value")); gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); entry_value = gtk_entry_new(); gtk_table_attach(GTK_TABLE(table), entry_value, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0); /* Button box */ vboxb = gtk_vbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(hbox), vboxb, FALSE, FALSE, 2); vbuttonbox = gtk_vbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(vbuttonbox), GTK_BUTTONBOX_START); gtk_box_set_spacing(GTK_BOX(vbuttonbox), 8); gtk_container_set_border_width(GTK_CONTAINER(vbuttonbox), 4); gtk_container_add(GTK_CONTAINER(vboxb), vbuttonbox); /* Buttons */ buttonDel = gtk_button_new_from_stock(GTK_STOCK_DELETE); gtk_container_add(GTK_CONTAINER(vbuttonbox), buttonDel); buttonMod = gtk_button_new_from_stock(GTK_STOCK_SAVE); gtk_container_add(GTK_CONTAINER(vbuttonbox), buttonMod); buttonAdd = gtk_button_new_from_stock(GTK_STOCK_ADD); gtk_container_add(GTK_CONTAINER(vbuttonbox), buttonAdd); gtk_widget_set_sensitive(buttonDel,FALSE); gtk_widget_set_sensitive(buttonMod,FALSE); gtk_widget_set_sensitive(buttonAdd,FALSE); gtk_widget_show_all(vbox); /* Event handlers */ g_signal_connect(G_OBJECT(clist), "select_row", G_CALLBACK( edit_person_attrib_list_selected), NULL); g_signal_connect(G_OBJECT(buttonDel), "clicked", G_CALLBACK(edit_person_attrib_delete), NULL); g_signal_connect(G_OBJECT(buttonMod), "clicked", G_CALLBACK(edit_person_attrib_modify), NULL); g_signal_connect(G_OBJECT(buttonAdd), "clicked", G_CALLBACK(edit_person_attrib_add), NULL); g_signal_connect(G_OBJECT(combo_box), "changed", G_CALLBACK(edit_person_entry_att_changed), NULL); g_signal_connect(G_OBJECT(entry_value), "key_press_event", G_CALLBACK(edit_person_entry_att_pressed), NULL); g_signal_connect(G_OBJECT(combo_box), "changed", G_CALLBACK(edit_person_combo_box_changed), clist); personEditDlg->clist_attrib = clist; personEditDlg->entry_atname = combo_box; personEditDlg->entry_atvalue = entry_value; personEditDlg->attrib_add = buttonAdd; personEditDlg->attrib_del = buttonDel; personEditDlg->attrib_mod = buttonMod; }
int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *hbox, *vbox; GtkWidget *vbox2, *bbox; GtkWidget *button; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkWidget *swindow; GtkTreeModel *sample_model; gint i; gtk_init (&argc, &argv); /* First initialize all the models for signal purposes */ left_tree_model = (GtkTreeModel *) gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); sample_model = (GtkTreeModel *) gtk_list_store_new (1, G_TYPE_STRING); sample_tree_view_top = gtk_tree_view_new_with_model (sample_model); sample_tree_view_bottom = gtk_tree_view_new_with_model (sample_model); top_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_top)); bottom_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_bottom)); top_right_tree_view = gtk_tree_view_new_with_model (top_right_tree_model); bottom_right_tree_view = gtk_tree_view_new_with_model (bottom_right_tree_model); for (i = 0; i < 10; i++) { GtkTreeIter iter; gchar *string = g_strdup_printf ("%d", i); gtk_list_store_append (GTK_LIST_STORE (sample_model), &iter); gtk_list_store_set (GTK_LIST_STORE (sample_model), &iter, 0, string, -1); g_free (string); } /* Set up the test windows. */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_default_size (GTK_WINDOW (window), 300, 300); gtk_window_set_title (GTK_WINDOW (window), "Top Window"); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (window), swindow); gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_top); gtk_widget_show_all (window); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_default_size (GTK_WINDOW (window), 300, 300); gtk_window_set_title (GTK_WINDOW (window), "Bottom Window"); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (window), swindow); gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_bottom); gtk_widget_show_all (window); /* Set up the main window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_default_size (GTK_WINDOW (window), 500, 300); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); gtk_container_add (GTK_CONTAINER (window), vbox); hbox = gtk_hbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); /* Left Pane */ cell = gtk_cell_renderer_text_new (); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); left_tree_view = gtk_tree_view_new_with_model (left_tree_model); gtk_container_add (GTK_CONTAINER (swindow), left_tree_view); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (left_tree_view), -1, "Unattached Columns", cell, "text", 0, NULL); cell = gtk_cell_renderer_toggle_new (); g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), left_tree_view); column = gtk_tree_view_column_new_with_attributes ("Visible", cell, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (left_tree_view), column); gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), swindow, TRUE, TRUE, 0); /* Middle Pane */ vbox2 = gtk_vbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0); bbox = gtk_vbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD); gtk_box_pack_start (GTK_BOX (vbox2), bbox, TRUE, TRUE, 0); button = gtk_button_new_with_mnemonic ("<< (_Q)"); gtk_widget_set_sensitive (button, FALSE); g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), top_right_tree_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (top_right_tree_view)), "changed", G_CALLBACK (selection_changed), button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_mnemonic (">> (_W)"); gtk_widget_set_sensitive (button, FALSE); g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), top_right_tree_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)), "changed", G_CALLBACK (selection_changed), button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); bbox = gtk_vbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD); gtk_box_pack_start (GTK_BOX (vbox2), bbox, TRUE, TRUE, 0); button = gtk_button_new_with_mnemonic ("<< (_E)"); gtk_widget_set_sensitive (button, FALSE); g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), bottom_right_tree_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (bottom_right_tree_view)), "changed", G_CALLBACK (selection_changed), button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_mnemonic (">> (_R)"); gtk_widget_set_sensitive (button, FALSE); g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), bottom_right_tree_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)), "changed", G_CALLBACK (selection_changed), button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); /* Right Pane */ vbox2 = gtk_vbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (top_right_tree_view), FALSE); cell = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (top_right_tree_view), -1, NULL, cell, "text", 0, NULL); cell = gtk_cell_renderer_toggle_new (); g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), top_right_tree_view); column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL); gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (top_right_tree_view), column); gtk_container_add (GTK_CONTAINER (swindow), top_right_tree_view); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (bottom_right_tree_view), FALSE); cell = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (bottom_right_tree_view), -1, NULL, cell, "text", 0, NULL); cell = gtk_cell_renderer_toggle_new (); g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), bottom_right_tree_view); column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL); gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (bottom_right_tree_view), column); gtk_container_add (GTK_CONTAINER (swindow), bottom_right_tree_view); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); /* Drag and Drop */ gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (left_tree_view), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (left_tree_view), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (top_right_tree_view), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (top_right_tree_view), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (bottom_right_tree_view), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (bottom_right_tree_view), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), FALSE, FALSE, 0); hbox = gtk_hbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_mnemonic ("_Add new Column"); g_signal_connect (button, "clicked", G_CALLBACK (add_clicked), left_tree_model); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show_all (window); gtk_main (); return 0; }
void FLAC_XMMS__configure(void) { GtkWidget *title_frame, *title_tag_vbox, *title_tag_label; GtkWidget *replaygain_frame, *resolution_frame, *output_vbox, *resolution_normal_frame, *resolution_replaygain_frame; GtkWidget *replaygain_vbox, *resolution_hbox, *resolution_normal_vbox, *resolution_replaygain_vbox; GtkWidget *resolution_replaygain_noise_shaping_vbox; GtkWidget *resolution_replaygain_bps_out_vbox; GtkWidget *label, *hbox; GtkWidget *bbox, *ok, *cancel; GList *list; GtkWidget *streaming_vbox; GtkWidget *streaming_buf_frame, *streaming_buf_hbox; GtkWidget *streaming_size_box, *streaming_size_label, *streaming_size_spin; GtkWidget *streaming_pre_box, *streaming_pre_label, *streaming_pre_spin; GtkWidget *streaming_proxy_frame, *streaming_proxy_vbox; GtkWidget *streaming_proxy_port_label, *streaming_proxy_host_label; GtkWidget *streaming_save_frame, *streaming_save_vbox; GtkWidget *streaming_save_label, *streaming_save_browse; #ifdef FLAC_ICECAST GtkWidget *streaming_cast_frame, *streaming_cast_vbox; #endif char *temp; if (flac_configurewin != NULL) { gdk_window_raise(flac_configurewin->window); return; } flac_configurewin = gtk_window_new(GTK_WINDOW_DIALOG); gtk_signal_connect(GTK_OBJECT(flac_configurewin), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &flac_configurewin); gtk_signal_connect(GTK_OBJECT(flac_configurewin), "destroy", GTK_SIGNAL_FUNC(configure_destroy), &flac_configurewin); gtk_window_set_title(GTK_WINDOW(flac_configurewin), _("Flac Configuration")); gtk_window_set_policy(GTK_WINDOW(flac_configurewin), FALSE, FALSE, FALSE); gtk_container_border_width(GTK_CONTAINER(flac_configurewin), 10); vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(flac_configurewin), vbox); notebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0); /* Title config.. */ title_frame = gtk_frame_new(_("Tag Handling")); gtk_container_border_width(GTK_CONTAINER(title_frame), 5); title_tag_vbox = gtk_vbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(title_tag_vbox), 5); gtk_container_add(GTK_CONTAINER(title_frame), title_tag_vbox); /* Convert Char Set */ convert_char_set = gtk_check_button_new_with_label(_("Convert Character Set")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(convert_char_set), flac_cfg.title.convert_char_set); gtk_signal_connect(GTK_OBJECT(convert_char_set), "clicked", convert_char_set_cb, NULL); gtk_box_pack_start(GTK_BOX(title_tag_vbox), convert_char_set, FALSE, FALSE, 0); /* Combo boxes... */ hbox = gtk_hbox_new(FALSE,4); gtk_container_add(GTK_CONTAINER(title_tag_vbox),hbox); label = gtk_label_new(_("Convert character set from :")); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); fileCharacterSetEntry = gtk_combo_new(); gtk_box_pack_start(GTK_BOX(hbox),fileCharacterSetEntry,TRUE,TRUE,0); label = gtk_label_new (_("to :")); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); userCharacterSetEntry = gtk_combo_new(); gtk_box_pack_start(GTK_BOX(hbox),userCharacterSetEntry,TRUE,TRUE,0); gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(fileCharacterSetEntry)->entry),FALSE); gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(userCharacterSetEntry)->entry),FALSE); gtk_combo_set_value_in_list(GTK_COMBO(fileCharacterSetEntry),TRUE,FALSE); gtk_combo_set_value_in_list(GTK_COMBO(userCharacterSetEntry),TRUE,FALSE); list = Charset_Create_List(); gtk_combo_set_popdown_strings(GTK_COMBO(fileCharacterSetEntry),Charset_Create_List_UTF8_Only()); gtk_combo_set_popdown_strings(GTK_COMBO(userCharacterSetEntry),list); gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(userCharacterSetEntry)->entry),Charset_Get_Title_From_Name(flac_cfg.title.user_char_set)); gtk_widget_set_sensitive(fileCharacterSetEntry, FALSE); gtk_widget_set_sensitive(userCharacterSetEntry, flac_cfg.title.convert_char_set); /* Override Tagging Format */ title_tag_override = gtk_check_button_new_with_label(_("Override generic titles")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(title_tag_override), flac_cfg.title.tag_override); gtk_signal_connect(GTK_OBJECT(title_tag_override), "clicked", title_tag_override_cb, NULL); gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_tag_override, FALSE, FALSE, 0); title_tag_box = gtk_hbox_new(FALSE, 5); gtk_widget_set_sensitive(title_tag_box, flac_cfg.title.tag_override); gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_tag_box, FALSE, FALSE, 0); title_tag_label = gtk_label_new(_("Title format:")); gtk_box_pack_start(GTK_BOX(title_tag_box), title_tag_label, FALSE, FALSE, 0); title_tag_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(title_tag_entry), flac_cfg.title.tag_format); gtk_box_pack_start(GTK_BOX(title_tag_box), title_tag_entry, TRUE, TRUE, 0); title_desc = xmms_titlestring_descriptions("pafFetnygc", 2); gtk_widget_set_sensitive(title_desc, flac_cfg.title.tag_override); gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_desc, FALSE, FALSE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), title_frame, gtk_label_new(_("Title"))); /* Output config.. */ output_vbox = gtk_vbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(output_vbox), 5); /* replaygain */ replaygain_frame = gtk_frame_new(_("ReplayGain")); gtk_container_border_width(GTK_CONTAINER(replaygain_frame), 5); gtk_box_pack_start(GTK_BOX(output_vbox), replaygain_frame, TRUE, TRUE, 0); replaygain_vbox = gtk_vbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(replaygain_vbox), 5); gtk_container_add(GTK_CONTAINER(replaygain_frame), replaygain_vbox); replaygain_enable = gtk_check_button_new_with_label(_("Enable ReplayGain processing")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_enable), flac_cfg.output.replaygain.enable); gtk_signal_connect(GTK_OBJECT(replaygain_enable), "clicked", replaygain_enable_cb, NULL); gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_enable, FALSE, FALSE, 0); replaygain_album_mode = gtk_check_button_new_with_label(_("Album mode")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_album_mode), flac_cfg.output.replaygain.album_mode); gtk_signal_connect(GTK_OBJECT(replaygain_album_mode), "clicked", replaygain_album_mode_cb, NULL); gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_album_mode, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE,3); gtk_container_add(GTK_CONTAINER(replaygain_vbox),hbox); label = gtk_label_new(_("Preamp:")); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); replaygain_preamp = gtk_adjustment_new(flac_cfg.output.replaygain.preamp, -24.0, +24.0, 1.0, 6.0, 0.0); gtk_signal_connect(GTK_OBJECT(replaygain_preamp), "value-changed", replaygain_preamp_cb, NULL); replaygain_preamp_hscale = gtk_hscale_new(GTK_ADJUSTMENT(replaygain_preamp)); gtk_scale_set_draw_value(GTK_SCALE(replaygain_preamp_hscale), FALSE); gtk_box_pack_start(GTK_BOX(hbox),replaygain_preamp_hscale,TRUE,TRUE,0); replaygain_preamp_label = gtk_label_new(_("0 dB")); gtk_box_pack_start(GTK_BOX(hbox),replaygain_preamp_label,FALSE,FALSE,0); gtk_adjustment_value_changed(GTK_ADJUSTMENT(replaygain_preamp)); replaygain_hard_limit = gtk_check_button_new_with_label(_("6dB hard limiting")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_hard_limit), flac_cfg.output.replaygain.hard_limit); gtk_signal_connect(GTK_OBJECT(replaygain_hard_limit), "clicked", replaygain_hard_limit_cb, NULL); gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_hard_limit, FALSE, FALSE, 0); replaygain_enable_cb(replaygain_enable, NULL); /* resolution */ resolution_frame = gtk_frame_new(_("Resolution")); gtk_container_border_width(GTK_CONTAINER(resolution_frame), 5); gtk_box_pack_start(GTK_BOX(output_vbox), resolution_frame, TRUE, TRUE, 0); resolution_hbox = gtk_hbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(resolution_hbox), 5); gtk_container_add(GTK_CONTAINER(resolution_frame), resolution_hbox); resolution_normal_frame = gtk_frame_new(_("Without ReplayGain")); gtk_container_border_width(GTK_CONTAINER(resolution_normal_frame), 5); gtk_box_pack_start(GTK_BOX(resolution_hbox), resolution_normal_frame, TRUE, TRUE, 0); resolution_normal_vbox = gtk_vbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(resolution_normal_vbox), 5); gtk_container_add(GTK_CONTAINER(resolution_normal_frame), resolution_normal_vbox); resolution_normal_dither_24_to_16 = gtk_check_button_new_with_label(_("Dither 24bps to 16bps")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_normal_dither_24_to_16), flac_cfg.output.resolution.normal.dither_24_to_16); gtk_signal_connect(GTK_OBJECT(resolution_normal_dither_24_to_16), "clicked", resolution_normal_dither_24_to_16_cb, NULL); gtk_box_pack_start(GTK_BOX(resolution_normal_vbox), resolution_normal_dither_24_to_16, FALSE, FALSE, 0); resolution_replaygain_frame = gtk_frame_new(_("With ReplayGain")); gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_frame), 5); gtk_box_pack_start(GTK_BOX(resolution_hbox), resolution_replaygain_frame, TRUE, TRUE, 0); resolution_replaygain_vbox = gtk_vbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_vbox), 5); gtk_container_add(GTK_CONTAINER(resolution_replaygain_frame), resolution_replaygain_vbox); resolution_replaygain_dither = gtk_check_button_new_with_label(_("Enable dithering")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_dither), flac_cfg.output.resolution.replaygain.dither); gtk_signal_connect(GTK_OBJECT(resolution_replaygain_dither), "clicked", resolution_replaygain_dither_cb, NULL); gtk_box_pack_start(GTK_BOX(resolution_replaygain_vbox), resolution_replaygain_dither, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(hbox), 5); gtk_box_pack_start(GTK_BOX(resolution_replaygain_vbox), hbox, TRUE, TRUE, 0); resolution_replaygain_noise_shaping_frame = gtk_frame_new(_("Noise shaping")); gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_noise_shaping_frame), 5); gtk_box_pack_start(GTK_BOX(hbox), resolution_replaygain_noise_shaping_frame, TRUE, TRUE, 0); resolution_replaygain_noise_shaping_vbox = gtk_vbutton_box_new(); gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), 5); gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_frame), resolution_replaygain_noise_shaping_vbox); resolution_replaygain_noise_shaping_radio_none = gtk_radio_button_new_with_label(NULL, _("none")); if(flac_cfg.output.resolution.replaygain.noise_shaping == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_none), TRUE); gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_none), "clicked", resolution_replaygain_noise_shaping_cb, NULL); gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_none); resolution_replaygain_noise_shaping_radio_low = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("low")); if(flac_cfg.output.resolution.replaygain.noise_shaping == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_low), TRUE); gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_low), "clicked", resolution_replaygain_noise_shaping_cb, NULL); gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_low); resolution_replaygain_noise_shaping_radio_medium = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("medium")); if(flac_cfg.output.resolution.replaygain.noise_shaping == 2) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_medium), TRUE); gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_medium), "clicked", resolution_replaygain_noise_shaping_cb, NULL); gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_medium); resolution_replaygain_noise_shaping_radio_high = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("high")); if(flac_cfg.output.resolution.replaygain.noise_shaping == 3) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_high), TRUE); gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_high), "clicked", resolution_replaygain_noise_shaping_cb, NULL); gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_high); resolution_replaygain_bps_out_frame = gtk_frame_new(_("Dither to")); gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_bps_out_frame), 5); gtk_box_pack_start(GTK_BOX(hbox), resolution_replaygain_bps_out_frame, FALSE, FALSE, 0); resolution_replaygain_bps_out_vbox = gtk_vbutton_box_new(); gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), 0); gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_frame), resolution_replaygain_bps_out_vbox); resolution_replaygain_bps_out_radio_16bps = gtk_radio_button_new_with_label(NULL, _("16 bps")); if(flac_cfg.output.resolution.replaygain.bps_out == 16) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_16bps), TRUE); gtk_signal_connect(GTK_OBJECT(resolution_replaygain_bps_out_radio_16bps), "clicked", resolution_replaygain_bps_out_cb, NULL); gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), resolution_replaygain_bps_out_radio_16bps); resolution_replaygain_bps_out_radio_24bps = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_bps_out_radio_16bps), _("24 bps")); if(flac_cfg.output.resolution.replaygain.bps_out == 24) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_24bps), TRUE); gtk_signal_connect(GTK_OBJECT(resolution_replaygain_bps_out_radio_24bps), "clicked", resolution_replaygain_bps_out_cb, NULL); gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), resolution_replaygain_bps_out_radio_24bps); resolution_replaygain_dither_cb(resolution_replaygain_dither, NULL); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), output_vbox, gtk_label_new(_("Output"))); /* Streaming */ streaming_vbox = gtk_vbox_new(FALSE, 0); streaming_buf_frame = gtk_frame_new(_("Buffering:")); gtk_container_set_border_width(GTK_CONTAINER(streaming_buf_frame), 5); gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_buf_frame, FALSE, FALSE, 0); streaming_buf_hbox = gtk_hbox_new(TRUE, 5); gtk_container_set_border_width(GTK_CONTAINER(streaming_buf_hbox), 5); gtk_container_add(GTK_CONTAINER(streaming_buf_frame), streaming_buf_hbox); streaming_size_box = gtk_hbox_new(FALSE, 5); /*gtk_table_attach_defaults(GTK_TABLE(streaming_buf_table),streaming_size_box,0,1,0,1); */ gtk_box_pack_start(GTK_BOX(streaming_buf_hbox), streaming_size_box, TRUE, TRUE, 0); streaming_size_label = gtk_label_new(_("Buffer size (kb):")); gtk_box_pack_start(GTK_BOX(streaming_size_box), streaming_size_label, FALSE, FALSE, 0); streaming_size_adj = gtk_adjustment_new(flac_cfg.stream.http_buffer_size, 4, 4096, 4, 4, 4); streaming_size_spin = gtk_spin_button_new(GTK_ADJUSTMENT(streaming_size_adj), 8, 0); gtk_widget_set_usize(streaming_size_spin, 60, -1); gtk_box_pack_start(GTK_BOX(streaming_size_box), streaming_size_spin, FALSE, FALSE, 0); streaming_pre_box = gtk_hbox_new(FALSE, 5); /*gtk_table_attach_defaults(GTK_TABLE(streaming_buf_table),streaming_pre_box,1,2,0,1); */ gtk_box_pack_start(GTK_BOX(streaming_buf_hbox), streaming_pre_box, TRUE, TRUE, 0); streaming_pre_label = gtk_label_new(_("Pre-buffer (percent):")); gtk_box_pack_start(GTK_BOX(streaming_pre_box), streaming_pre_label, FALSE, FALSE, 0); streaming_pre_adj = gtk_adjustment_new(flac_cfg.stream.http_prebuffer, 0, 90, 1, 1, 1); streaming_pre_spin = gtk_spin_button_new(GTK_ADJUSTMENT(streaming_pre_adj), 1, 0); gtk_widget_set_usize(streaming_pre_spin, 60, -1); gtk_box_pack_start(GTK_BOX(streaming_pre_box), streaming_pre_spin, FALSE, FALSE, 0); /* * Proxy config. */ streaming_proxy_frame = gtk_frame_new(_("Proxy:")); gtk_container_set_border_width(GTK_CONTAINER(streaming_proxy_frame), 5); gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_proxy_frame, FALSE, FALSE, 0); streaming_proxy_vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(streaming_proxy_vbox), 5); gtk_container_add(GTK_CONTAINER(streaming_proxy_frame), streaming_proxy_vbox); streaming_proxy_use = gtk_check_button_new_with_label(_("Use proxy")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_proxy_use), flac_cfg.stream.use_proxy); gtk_signal_connect(GTK_OBJECT(streaming_proxy_use), "clicked", GTK_SIGNAL_FUNC(proxy_use_cb), NULL); gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_use, FALSE, FALSE, 0); streaming_proxy_hbox = gtk_hbox_new(FALSE, 5); gtk_widget_set_sensitive(streaming_proxy_hbox, flac_cfg.stream.use_proxy); gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_hbox, FALSE, FALSE, 0); streaming_proxy_host_label = gtk_label_new(_("Host:")); gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_host_label, FALSE, FALSE, 0); streaming_proxy_host_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(streaming_proxy_host_entry), flac_cfg.stream.proxy_host); gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_host_entry, TRUE, TRUE, 0); streaming_proxy_port_label = gtk_label_new(_("Port:")); gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_port_label, FALSE, FALSE, 0); streaming_proxy_port_entry = gtk_entry_new(); gtk_widget_set_usize(streaming_proxy_port_entry, 50, -1); temp = g_strdup_printf("%d", flac_cfg.stream.proxy_port); gtk_entry_set_text(GTK_ENTRY(streaming_proxy_port_entry), temp); g_free(temp); gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_port_entry, FALSE, FALSE, 0); streaming_proxy_auth_use = gtk_check_button_new_with_label(_("Use authentication")); gtk_widget_set_sensitive(streaming_proxy_auth_use, flac_cfg.stream.use_proxy); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use), flac_cfg.stream.proxy_use_auth); gtk_signal_connect(GTK_OBJECT(streaming_proxy_auth_use), "clicked", GTK_SIGNAL_FUNC(proxy_auth_use_cb), NULL); gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_auth_use, FALSE, FALSE, 0); streaming_proxy_auth_hbox = gtk_hbox_new(FALSE, 5); gtk_widget_set_sensitive(streaming_proxy_auth_hbox, flac_cfg.stream.use_proxy && flac_cfg.stream.proxy_use_auth); gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_auth_hbox, FALSE, FALSE, 0); streaming_proxy_auth_user_label = gtk_label_new(_("Username:"******"Password:"******"Save stream to disk:")); gtk_container_set_border_width(GTK_CONTAINER(streaming_save_frame), 5); gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_save_frame, FALSE, FALSE, 0); streaming_save_vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(streaming_save_vbox), 5); gtk_container_add(GTK_CONTAINER(streaming_save_frame), streaming_save_vbox); streaming_save_use = gtk_check_button_new_with_label(_("Save stream to disk")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_save_use), flac_cfg.stream.save_http_stream); gtk_signal_connect(GTK_OBJECT(streaming_save_use), "clicked", GTK_SIGNAL_FUNC(streaming_save_use_cb), NULL); gtk_box_pack_start(GTK_BOX(streaming_save_vbox), streaming_save_use, FALSE, FALSE, 0); streaming_save_hbox = gtk_hbox_new(FALSE, 5); gtk_widget_set_sensitive(streaming_save_hbox, flac_cfg.stream.save_http_stream); gtk_box_pack_start(GTK_BOX(streaming_save_vbox), streaming_save_hbox, FALSE, FALSE, 0); streaming_save_label = gtk_label_new(_("Path:")); gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_label, FALSE, FALSE, 0); streaming_save_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(streaming_save_entry), flac_cfg.stream.save_http_path); gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_entry, TRUE, TRUE, 0); streaming_save_browse = gtk_button_new_with_label(_("Browse")); gtk_signal_connect(GTK_OBJECT(streaming_save_browse), "clicked", GTK_SIGNAL_FUNC(streaming_save_browse_cb), NULL); gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_browse, FALSE, FALSE, 0); #ifdef FLAC_ICECAST streaming_cast_frame = gtk_frame_new(_("SHOUT/Icecast:")); gtk_container_set_border_width(GTK_CONTAINER(streaming_cast_frame), 5); gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_cast_frame, FALSE, FALSE, 0); streaming_cast_vbox = gtk_vbox_new(5, FALSE); gtk_container_add(GTK_CONTAINER(streaming_cast_frame), streaming_cast_vbox); streaming_cast_title = gtk_check_button_new_with_label(_("Enable SHOUT/Icecast title streaming")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_cast_title), flac_cfg.stream.cast_title_streaming); gtk_box_pack_start(GTK_BOX(streaming_cast_vbox), streaming_cast_title, FALSE, FALSE, 0); streaming_udp_title = gtk_check_button_new_with_label(_("Enable Icecast Metadata UDP Channel")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_udp_title), flac_cfg.stream.use_udp_channel); gtk_box_pack_start(GTK_BOX(streaming_cast_vbox), streaming_udp_title, FALSE, FALSE, 0); #endif gtk_notebook_append_page(GTK_NOTEBOOK(notebook), streaming_vbox, gtk_label_new(_("Streaming"))); /* Buttons */ bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); ok = gtk_button_new_with_label(_("Ok")); gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(flac_configurewin_ok), NULL); GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0); gtk_widget_grab_default(ok); cancel = gtk_button_new_with_label(_("Cancel")); gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(flac_configurewin)); GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0); gtk_widget_show_all(flac_configurewin); }
int main( int argc,char *argv[]) { /* GtkWidget es el tipo de almancenamiento para los widgets */ GtkWidget *window; GtkWidget *title; GtkWidget *option1; GtkWidget *option2; GtkWidget *box; /* Esto se llama en todas las aplicaciones del GTK. Los argumentos se leen * de la linea de comandos y son filtrados y devueltos a la aplicación. */ gtk_init (&argc, &argv); /* Crea una nueva ventana */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); /* Crea una caja con botones */ box = gtk_vbutton_box_new (); /* Esto empaqueta la caja en la ventana (un contenedor gtk) */ gtk_container_add (GTK_CONTAINER (window), box); /* Crear una nueva etiqueta */ title = gtk_label_new ("BIENVENIDO A AGENDA ELECTRONICA\n"); gtk_misc_set_alignment (GTK_MISC (title), 0.5, 0); /* Empaqueta el título en la caja */ gtk_box_pack_start (GTK_BOX(box), title, FALSE, FALSE, 0); /* Mostrar el título */ gtk_widget_show (title); gtk_widget_set_usize (GTK_WIDGET (window), 400, 300); gtk_window_set_title (GTK_WINDOW (window), "Agenda Electronica"); /* Define la anchura del borde de la ventana. */ gtk_container_border_width (GTK_CONTAINER (window), 60); /* Crea cuatro ventanas para las etiquetas */ option1 = gtk_button_new_with_label ("Acceder a la agenda de usuario."); option2 = gtk_button_new_with_label ("Salir de la aplicacion."); /* Esto empaqueta los cuatro botones en la caja (un contenedor gtk) */ gtk_container_add (GTK_CONTAINER (box), option1); gtk_container_add (GTK_CONTAINER (box), option2); /* Aquí se conecta el evento "destroy" a un manejador de señal. * Este evento se produce cuando se llama a gtk_widget_destroy() en la ventana */ gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(closeAppWindow), NULL); /* Conecta el evento "clicked" al manejador de evento clickButton1 */ gtk_signal_connect (GTK_OBJECT (option1), "clicked", GTK_SIGNAL_FUNC(clickButton1), NULL); /* Conecta el evento "clicked" al manejador de evento clickButton2 */ gtk_signal_connect (GTK_OBJECT (option2), "clicked", GTK_SIGNAL_FUNC(clickButton2), NULL); /* Muestra los botones */ gtk_widget_show (option1); gtk_widget_show (option2); /* y la caja */ gtk_widget_show (box); gtk_widget_set_uposition( window, 400, 200 ); /* y la ventana */ gtk_widget_show (window); /* Todas las aplicaciones GTK deben tener un gtk_main(). El control termina * aquí y espera a que ocurran eventos (como una pulsación de tecla o ratón) */ gtk_main (); return(0); }
static void create_bus_layout_dialog (bus_layout_D *dialog) { GtkWidget *tblMain = NULL, *frm = NULL, *img = NULL, *tbl = NULL, *align = NULL, *bbox = NULL ; dialog->dialog = gtk_dialog_new () ; gtk_window_set_title (GTK_WINDOW (dialog->dialog), _("Bus Layout")) ; gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), TRUE) ; gtk_window_set_default_size (GTK_WINDOW (dialog->dialog), 300, 200) ; tblMain = gtk_table_new (1, 2, FALSE) ; gtk_widget_show (tblMain) ; gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog->dialog)->vbox), tblMain, TRUE, TRUE, 0) ; gtk_container_set_border_width (GTK_CONTAINER (tblMain), 2) ; frm = gtk_frame_new (_("Cells And Buses")) ; gtk_widget_show (frm) ; gtk_table_attach (GTK_TABLE (tblMain), frm, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 2, 2) ; gtk_container_set_border_width (GTK_CONTAINER (frm), 2) ; dialog->sw = gtk_scrolled_window_new (NULL, NULL) ; gtk_widget_show (dialog->sw) ; gtk_container_add (GTK_CONTAINER (frm), dialog->sw) ; gtk_container_set_border_width (GTK_CONTAINER (dialog->sw), 2) ; gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->sw), GTK_SHADOW_IN) ; gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC) ; dialog->tview = create_bus_layout_tree_view (FALSE, NULL, GTK_SELECTION_MULTIPLE) ; gtk_widget_show (dialog->tview) ; gtk_container_add (GTK_CONTAINER (dialog->sw), dialog->tview) ; gtk_tree_selection_set_select_function (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview)), (GtkTreeSelectionFunc)select_cell_row_p, NULL, NULL) ; align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0) ; gtk_widget_show (align) ; gtk_table_attach (GTK_TABLE (tblMain), align, 1, 2, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 2, 2) ; gtk_container_set_border_width (GTK_CONTAINER (align), 2) ; tbl = gtk_table_new (3, 1, FALSE) ; gtk_widget_show (tbl) ; gtk_container_add (GTK_CONTAINER (align), tbl) ; gtk_container_set_border_width (GTK_CONTAINER (tbl), 2) ; bbox = gtk_vbutton_box_new () ; gtk_widget_show (bbox) ; gtk_table_attach (GTK_TABLE (tbl), bbox, 0, 1, 0, 1, (GtkAttachOptions)(0), (GtkAttachOptions)(0), 2, 2) ; gtk_container_set_border_width (GTK_CONTAINER (bbox), 2) ; // gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), gtk_vbutton_box_get_spacing_default ()) ; dialog->btnCreateBus = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON), _("Create Bus"), FALSE) ; gtk_widget_show (dialog->btnCreateBus) ; gtk_widget_show (img) ; gtk_box_pack_start (GTK_BOX (bbox), dialog->btnCreateBus, FALSE, TRUE, 0) ; dialog->btnDeleteBus = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON), _("Delete Bus"), FALSE) ; gtk_widget_show (dialog->btnDeleteBus) ; gtk_widget_show (img) ; gtk_box_pack_start (GTK_BOX (bbox), dialog->btnDeleteBus, FALSE, TRUE, 0) ; dialog->btnMoveBusUp = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON), _("Move Bus Up"), FALSE) ; gtk_widget_show (dialog->btnMoveBusUp) ; gtk_widget_show (img) ; gtk_box_pack_start (GTK_BOX (bbox), dialog->btnMoveBusUp, FALSE, TRUE, 0) ; dialog->btnMoveBusDown = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON), _("Move Bus Down"), FALSE) ; gtk_widget_show (dialog->btnMoveBusDown) ; gtk_widget_show (img) ; gtk_box_pack_start (GTK_BOX (bbox), dialog->btnMoveBusDown, FALSE, TRUE, 0) ; dialog->btnMoveCellsUp = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON), _("Make Cell(s) More Significant"), FALSE) ; gtk_widget_show (dialog->btnMoveCellsUp) ; gtk_widget_show (img) ; gtk_box_pack_start (GTK_BOX (bbox), dialog->btnMoveCellsUp, FALSE, TRUE, 0) ; dialog->btnMoveCellsDown = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON), _("Make Cell(s) Less Significant"), FALSE) ; gtk_widget_show (dialog->btnMoveCellsDown) ; gtk_widget_show (img) ; gtk_box_pack_start (GTK_BOX (bbox), dialog->btnMoveCellsDown, FALSE, TRUE, 0) ; dialog->lblBusName = gtk_label_new (_("Bus Name:")) ; gtk_widget_show (dialog->lblBusName) ; gtk_table_attach (GTK_TABLE (tbl), dialog->lblBusName, 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 2, 2) ; gtk_label_set_justify (GTK_LABEL (dialog->lblBusName), GTK_JUSTIFY_LEFT) ; gtk_misc_set_alignment (GTK_MISC (dialog->lblBusName), 0.0, 1.0) ; dialog->txtBusName = g_object_new (GTK_TYPE_ENTRY, "text", _("Untitled Bus"), NULL) ; gtk_widget_show (dialog->txtBusName) ; gtk_table_attach (GTK_TABLE (tbl), dialog->txtBusName, 0, 1, 2, 3, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 2, 2) ; gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL) ; gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), GTK_STOCK_OK, GTK_RESPONSE_OK) ; gtk_dialog_set_default_response (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK) ; g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview))), "changed", (GCallback)tree_view_selection_changed, dialog) ; g_signal_connect (G_OBJECT (dialog->btnCreateBus), "clicked", (GCallback)create_bus_button_clicked, dialog) ; g_signal_connect (G_OBJECT (dialog->btnDeleteBus), "clicked", (GCallback)delete_bus_button_clicked, dialog) ; g_signal_connect (G_OBJECT (dialog->btnMoveCellsUp), "clicked", (GCallback)raise_bus_cell_position, dialog) ; g_signal_connect (G_OBJECT (dialog->btnMoveCellsDown), "clicked", (GCallback)lower_bus_cell_position, dialog) ; g_signal_connect (G_OBJECT (dialog->btnMoveBusUp), "clicked", (GCallback)raise_bus_position, dialog) ; g_signal_connect (G_OBJECT (dialog->btnMoveBusDown), "clicked", (GCallback)lower_bus_position, dialog) ; g_signal_connect (G_OBJECT (dialog->txtBusName), "changed", (GCallback)bus_name_changed, dialog) ; g_signal_connect (G_OBJECT (dialog->txtBusName), "insert-text", (GCallback)entry_insert_text, dialog) ; g_signal_connect (G_OBJECT (dialog->txtBusName), "delete-text", (GCallback)entry_delete_text, dialog) ; }
static void asgtk_image_view_make_parts (ASGtkImageView * iv, Bool horizontal) { iv->frame = gtk_aspect_frame_new (NULL, 0.5, 0.5, 1.0, TRUE); gtk_frame_set_shadow_type (GTK_FRAME (iv->frame), GTK_SHADOW_NONE); gtk_widget_show (iv->frame); colorize_gtk_widget (iv->frame, get_colorschemed_style_normal ()); iv->scrolled_window = ASGTK_SCROLLED_WINDOW (GTK_POLICY_NEVER, GTK_POLICY_NEVER, GTK_SHADOW_NONE); ASGTK_CONTAINER_ADD (iv->frame, iv->scrolled_window); if (!get_flags (iv->flags, ASGTK_IMAGE_VIEW_SCALE_TO_VIEW | ASGTK_IMAGE_VIEW_TILE_TO_VIEW)) { gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (iv->scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); } colorize_gtk_widget (GTK_WIDGET (iv->scrolled_window), get_colorschemed_style_normal ()); iv->view = gtk_image_new_from_pixbuf (NULL); gtk_widget_show (GTK_WIDGET (iv->view)); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (iv->scrolled_window), GTK_WIDGET (iv->view)); colorize_gtk_widget (GTK_WIDGET (iv->view), get_colorschemed_style_normal ()); g_signal_connect ((gpointer) iv->scrolled_window, "size-allocate", G_CALLBACK (asgtk_imview_view_size_alloc), iv); iv->details_label = gtk_label_new (NO_IMAGE_TEXT); gtk_widget_show (iv->details_label); iv->details_frame = gtk_frame_new (NULL); gtk_widget_show (iv->details_frame); gtk_container_set_border_width (GTK_CONTAINER (iv->details_frame), 1); gtk_frame_set_shadow_type (GTK_FRAME (iv->details_frame), GTK_SHADOW_IN); colorize_gtk_widget (iv->details_frame, get_colorschemed_style_normal ()); iv->tools_hbox = horizontal ? gtk_vbox_new (FALSE, 0) : gtk_hbutton_box_new (); gtk_container_set_border_width (GTK_CONTAINER (iv->tools_hbox), 0); if (GTK_IS_BUTTON_BOX (iv->tools_hbox)) gtk_button_box_set_layout (GTK_BUTTON_BOX (iv->tools_hbox), GTK_BUTTONBOX_END /*SPREAD*/); gtk_widget_show (iv->tools_hbox); iv->details_hbox = horizontal ? gtk_vbutton_box_new () : gtk_hbutton_box_new (); gtk_container_set_border_width (GTK_CONTAINER (iv->details_hbox), 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (iv->details_hbox), GTK_BUTTONBOX_EDGE); gtk_widget_show (iv->details_hbox); gtk_container_add (GTK_CONTAINER (iv->details_frame), iv->details_hbox); gtk_box_pack_end (GTK_BOX (iv->details_hbox), iv->details_label, TRUE, TRUE, 0); }
void GUI::setup_left_box(){ // create label GtkWidget * cpu_frame; cpu_frame = gtk_frame_new ("CPU"); // create cpu box GtkWidget * cpu_box; cpu_box = gtk_vbox_new (FALSE, 0); /* IC REGISTER */ // ic box GtkWidget * ic_box; ic_box = gtk_hbox_new (FALSE, 0); // ic label GtkWidget * ic_label; ic_label = gtk_label_new ("IC"); gtk_widget_set_usize (ic_label, 80, 28); // create ic this->ic_buffer = gtk_entry_buffer_new (NULL, -1); this->ic = gtk_entry_new_with_buffer (this->ic_buffer); gtk_entry_set_editable (GTK_ENTRY(this->ic), FALSE); gtk_widget_set_can_focus (this->ic, FALSE); // add content to ic_box gtk_box_pack_start (GTK_BOX (ic_box), ic_label, FALSE, FALSE, 20); gtk_box_pack_start (GTK_BOX (ic_box), this->ic, FALSE, FALSE, 5); /* ST REGISTER */ // st box GtkWidget * st_box; st_box = gtk_hbox_new (FALSE, 0); // ic label GtkWidget * st_label; st_label = gtk_label_new ("ST"); gtk_widget_set_usize (st_label, 80, 28); // create ic this->st_buffer = gtk_entry_buffer_new (NULL, -1); this->st = gtk_entry_new_with_buffer (this->st_buffer); gtk_entry_set_editable (GTK_ENTRY(this->st), FALSE); gtk_widget_set_can_focus (this->st, FALSE); // add content to ic_box gtk_box_pack_start (GTK_BOX (st_box), st_label, FALSE, FALSE, 20); gtk_box_pack_end (GTK_BOX (st_box), this->st, FALSE, FALSE, 5); // add ic_box to cpu box gtk_box_pack_start (GTK_BOX (cpu_box), ic_box, FALSE, FALSE, 5); gtk_box_pack_end (GTK_BOX (cpu_box), st_box, FALSE, FALSE, 5); // put cpu_box in cpu_frame gtk_container_add (GTK_CONTAINER (cpu_frame), cpu_box); // left top box GtkWidget * left_top_box; left_top_box = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (left_top_box), cpu_frame, FALSE, FALSE, 0); this->left_box = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (this->left_box), left_top_box, FALSE, FALSE, 0); // CHANNELS // channels frame GtkWidget * channels_frame; channels_frame = gtk_frame_new ("CHANNELS"); GtkWidget * channels_vbox; channels_vbox = gtk_vbox_new (FALSE, 5); // keyboard GtkWidget * kb_box; kb_box = gtk_hbox_new (FALSE, 0); GtkWidget * kb_label; kb_label = gtk_label_new ("KEYBOARD"); gtk_widget_set_usize (kb_label, 80, 28); this->keyboard_channel = gtk_entry_new (); gtk_entry_set_editable (GTK_ENTRY(this->keyboard_channel), FALSE); gtk_widget_set_can_focus (this->keyboard_channel, FALSE); gtk_box_pack_start (GTK_BOX (kb_box), kb_label, FALSE, FALSE, 20); gtk_box_pack_end (GTK_BOX (kb_box), this->keyboard_channel, FALSE, FALSE, 5); gtk_box_pack_start (GTK_BOX (channels_vbox ), kb_box, FALSE, FALSE, 0); // monitor GtkWidget * mn_box; mn_box = gtk_hbox_new (FALSE, 0); GtkWidget * mn_label; mn_label = gtk_label_new ("MONITOR"); gtk_widget_set_usize (mn_label, 80, 28); this->monitor_channel = gtk_entry_new (); gtk_entry_set_editable (GTK_ENTRY(this->monitor_channel), FALSE); gtk_widget_set_can_focus (this->monitor_channel, FALSE); gtk_box_pack_start (GTK_BOX (mn_box), mn_label, FALSE, FALSE, 20); gtk_box_pack_end (GTK_BOX (mn_box), this->monitor_channel, FALSE, FALSE, 5); gtk_box_pack_start (GTK_BOX (channels_vbox), mn_box, FALSE, FALSE, 0); // hdd GtkWidget * hdd_box; hdd_box = gtk_hbox_new (FALSE, 0); GtkWidget * hdd_label; hdd_label = gtk_label_new ("HDD"); gtk_widget_set_usize (hdd_label, 80, 28); this->hdd_channel = gtk_entry_new (); gtk_entry_set_editable (GTK_ENTRY(this->hdd_channel), FALSE); gtk_widget_set_can_focus (this->hdd_channel, FALSE); gtk_box_pack_start (GTK_BOX (hdd_box), hdd_label, FALSE, FALSE, 20); gtk_box_pack_end (GTK_BOX (hdd_box), this->hdd_channel, FALSE, FALSE, 5); gtk_box_pack_start (GTK_BOX (channels_vbox), hdd_box, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (channels_frame), channels_vbox); gtk_box_pack_start (GTK_BOX (this->left_box), channels_frame, FALSE, FALSE, 0); GtkWidget * control_buttons; control_buttons = gtk_vbutton_box_new (); this->rm_mem_show_button = gtk_button_new_with_label("Show RM memory"); g_signal_connect (this->rm_mem_show_button, "clicked", G_CALLBACK (GUI::rm_mem_show_button_clicked), gpointer(this)); gtk_box_pack_start (GTK_BOX (control_buttons), this->rm_mem_show_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (this->left_box), control_buttons, FALSE, FALSE, 0); }
void prefs_dialog_open(SensorsApplet *sensors_applet) { gchar *header_text; PrefsDialog *prefs_dialog; DisplayMode display_mode; g_assert(sensors_applet->prefs_dialog == NULL); /* while prefs dialog is open, stop the updating of sensors so * we don't get any race conditions due to concurrent updates * of the labels, values and icons linked lists etc. */ if (sensors_applet->timeout_id != 0) { if (g_source_remove(sensors_applet->timeout_id)) { sensors_applet->timeout_id = 0; } } sensors_applet->prefs_dialog = g_new0(PrefsDialog, 1); prefs_dialog = sensors_applet->prefs_dialog; prefs_dialog->sensors_applet = sensors_applet; prefs_dialog->dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(_("Sensors Applet Preferences"), NULL, GTK_DIALOG_MODAL, GTK_STOCK_HELP, GTK_RESPONSE_HELP, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL)); g_object_set(prefs_dialog->dialog, "border-width", 12, "default-width", 480, "default-height", 350, NULL); gtk_box_set_homogeneous(GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)), FALSE); gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)), 5); g_signal_connect(prefs_dialog->dialog, "response", G_CALLBACK(prefs_dialog_response), sensors_applet); g_signal_connect_swapped(prefs_dialog->dialog, "delete-event", G_CALLBACK(prefs_dialog_close), sensors_applet); g_signal_connect_swapped(prefs_dialog->dialog, "destroy", G_CALLBACK(prefs_dialog_close), sensors_applet); /* if no SensorsList's have been created, this is because we haven't been able to access any sensors */ if (sensors_applet->sensors == NULL) { GtkWidget *label; label = gtk_label_new(_("No sensors found!")); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)), label, TRUE, TRUE, 0); return; } header_text = g_markup_printf_escaped("<b>%s</b>", _("Display")); prefs_dialog->display_header = g_object_new(GTK_TYPE_LABEL, "use-markup", TRUE, "label", header_text, "xalign", 0.0, NULL); g_free(header_text); prefs_dialog->display_mode_combo_box = GTK_COMBO_BOX(gtk_combo_box_text_new()); gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("label with value")); gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("icon with value")); gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("value only")); gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("icon only")); gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("graph only")); display_mode = g_settings_get_int(sensors_applet->settings, DISPLAY_MODE); gtk_combo_box_set_active(prefs_dialog->display_mode_combo_box, display_mode); g_signal_connect(prefs_dialog->display_mode_combo_box, "changed", G_CALLBACK(prefs_dialog_display_mode_changed), prefs_dialog); /* use spaces in label to indent */ prefs_dialog->display_mode_label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "label", _("_Display sensors in panel as"), "mnemonic-widget", prefs_dialog->display_mode_combo_box, "xalign", 0.0, NULL); prefs_dialog->layout_mode_combo_box = GTK_COMBO_BOX(gtk_combo_box_text_new()); gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_combo_box), (display_mode != DISPLAY_ICON) && (display_mode != DISPLAY_VALUE) && (display_mode != DISPLAY_GRAPH)); gtk_combo_box_text_append_text(prefs_dialog->layout_mode_combo_box, _("beside labels / icons")); gtk_combo_box_text_append_text(prefs_dialog->layout_mode_combo_box, _("below labels / icons")); gtk_combo_box_set_active(prefs_dialog->layout_mode_combo_box, g_settings_get_int(sensors_applet->settings, LAYOUT_MODE)); g_signal_connect(prefs_dialog->layout_mode_combo_box, "changed", G_CALLBACK(prefs_dialog_layout_mode_changed), prefs_dialog); prefs_dialog->layout_mode_label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "label", _("Preferred _position of sensor values"), "mnemonic-widget", prefs_dialog->layout_mode_combo_box, "xalign", 0.0, NULL); gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_label), (display_mode != DISPLAY_ICON) && (display_mode != DISPLAY_VALUE) && (display_mode != DISPLAY_GRAPH)); prefs_dialog->temperature_scale_combo_box = GTK_COMBO_BOX(gtk_combo_box_text_new()); gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Kelvin")); gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Celsius")); gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Fahrenheit")); gtk_combo_box_set_active(prefs_dialog->temperature_scale_combo_box, g_settings_get_int(sensors_applet->settings, TEMPERATURE_SCALE)); g_signal_connect(prefs_dialog->temperature_scale_combo_box, "changed", G_CALLBACK(prefs_dialog_temperature_scale_changed), prefs_dialog); prefs_dialog->temperature_scale_label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "label", _("_Temperature scale"), "mnemonic-widget", prefs_dialog->temperature_scale_combo_box, "xalign", 0.0, NULL); prefs_dialog->graph_size_adjust = g_object_new(GTK_TYPE_ADJUSTMENT, "value", (gdouble)g_settings_get_int(sensors_applet->settings, GRAPH_SIZE), "lower", 1.0, "upper", 100.0, "step-increment", 1.0, "page-increment", 10.0, "page-size", 0.0, NULL); prefs_dialog->graph_size_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON, "adjustment", prefs_dialog->graph_size_adjust, "climb-rate", 1.0, "digits", 0, "value", (gdouble)g_settings_get_int(sensors_applet->settings, GRAPH_SIZE), "width-chars", 4, NULL); gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_spinbutton), (display_mode == DISPLAY_GRAPH)); prefs_dialog->graph_size_label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "label", _("Graph _size (pixels)"), "mnemonic-widget", prefs_dialog->graph_size_spinbutton, "xalign", 0.0, NULL); gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_label), (display_mode == DISPLAY_GRAPH)); g_signal_connect(prefs_dialog->graph_size_spinbutton, "value-changed", G_CALLBACK(prefs_dialog_graph_size_changed), prefs_dialog); header_text = g_markup_printf_escaped("<b>%s</b>", _("Update")); prefs_dialog->update_header = g_object_new(GTK_TYPE_LABEL, "use-markup", TRUE, "label", header_text, "xalign", 0.0, NULL); g_free(header_text); prefs_dialog->timeout_adjust = g_object_new(GTK_TYPE_ADJUSTMENT, "value", 2.0, "lower", 1.5, "upper", 10.0, "step-increment", 0.5, "page-increment", 1.0, "page-size", 0.0, NULL); prefs_dialog->timeout_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON, "adjustment", prefs_dialog->timeout_adjust, "climb-rate", 0.5, "digits", 1, "value", (gdouble) g_settings_get_int(sensors_applet->settings, TIMEOUT) / 1000.0, "width-chars", 4, NULL); prefs_dialog->timeout_label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "label", _("Update _interval (secs)"), "mnemonic-widget", prefs_dialog->timeout_spinbutton, "xalign", 0.0, NULL); g_signal_connect(prefs_dialog->timeout_spinbutton, "value-changed", G_CALLBACK(prefs_dialog_timeout_changed), prefs_dialog); #ifdef HAVE_LIBNOTIFY header_text = g_markup_printf_escaped("<b>%s</b>", _("Notifications")); prefs_dialog->notifications_header = g_object_new(GTK_TYPE_LABEL, "use-markup", TRUE, "label", header_text, "xalign", 0.0, NULL); g_free(header_text); prefs_dialog->display_notifications = g_object_new(GTK_TYPE_CHECK_BUTTON, "use-underline", TRUE, "label", _("Display _notifications"), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs_dialog->display_notifications), g_settings_get_boolean(sensors_applet->settings, DISPLAY_NOTIFICATIONS)); g_signal_connect(prefs_dialog->display_notifications, "toggled", G_CALLBACK(prefs_dialog_display_notifications_toggled), prefs_dialog); #endif /* SIZE AND LAYOUT */ /* keep all widgets same size */ prefs_dialog->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); gtk_size_group_add_widget(prefs_dialog->size_group, GTK_WIDGET(prefs_dialog->display_mode_combo_box)); gtk_size_group_add_widget(prefs_dialog->size_group, GTK_WIDGET(prefs_dialog->layout_mode_combo_box)); gtk_size_group_add_widget(prefs_dialog->size_group, GTK_WIDGET(prefs_dialog->temperature_scale_combo_box)); gtk_size_group_add_widget(prefs_dialog->size_group, GTK_WIDGET(prefs_dialog->timeout_spinbutton)); g_object_unref(prefs_dialog->size_group); prefs_dialog->globals_table = g_object_new(GTK_TYPE_TABLE, "homogeneous", FALSE, "n-columns", 3, #ifdef HAVE_LIBNOTIFY "n-rows", 9, #else "n-rows", 7, #endif "row-spacing", 6, "column-spacing", 12, NULL); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->display_header), 0, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->display_mode_label), 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->display_mode_combo_box), 2, 3, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->layout_mode_label), 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->layout_mode_combo_box), 2, 3, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->graph_size_label), 1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->graph_size_spinbutton), 2, 3, 3, 4, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->temperature_scale_label), 1, 2, 4, 5, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->temperature_scale_combo_box), 2, 3, 4, 5, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->update_header), 0, 2, 5, 6, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->timeout_label), 1, 2, 6, 7, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->timeout_spinbutton), 2, 3, 6, 7, GTK_FILL, GTK_FILL, 0, 0); #ifdef HAVE_LIBNOTIFY gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->notifications_header), 0, 2, 7, 8, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(prefs_dialog->globals_table, GTK_WIDGET(prefs_dialog->display_notifications), 1, 2, 8, 9, GTK_FILL, GTK_FILL, 0, 0); #endif prefs_dialog->view = g_object_new(GTK_TYPE_TREE_VIEW, "model", GTK_TREE_MODEL(sensors_applet->sensors), "rules-hint", TRUE, "reorderable", FALSE, "enable-search", TRUE, "search-column", LABEL_COLUMN, NULL); /* get double clicks on rows - do same as configure sensor * button clicks */ g_signal_connect(prefs_dialog->view, "row-activated", G_CALLBACK(prefs_dialog_row_activated), prefs_dialog); prefs_dialog->id_renderer = gtk_cell_renderer_text_new(); prefs_dialog->label_renderer = gtk_cell_renderer_text_new(); g_object_set(prefs_dialog->label_renderer, "editable", TRUE, NULL); g_signal_connect(prefs_dialog->label_renderer, "edited", G_CALLBACK(prefs_dialog_sensor_name_changed), prefs_dialog); prefs_dialog->enable_renderer = gtk_cell_renderer_toggle_new(); g_signal_connect(prefs_dialog->enable_renderer, "toggled", G_CALLBACK(prefs_dialog_sensor_toggled), prefs_dialog); prefs_dialog->icon_renderer = gtk_cell_renderer_pixbuf_new(); prefs_dialog->id_column = gtk_tree_view_column_new_with_attributes(_("Sensor"), prefs_dialog->id_renderer, "text", ID_COLUMN, NULL); gtk_tree_view_column_set_min_width(prefs_dialog->id_column, 90); prefs_dialog->label_column = gtk_tree_view_column_new_with_attributes(_("Label"), prefs_dialog->label_renderer, "text", LABEL_COLUMN, "visible", VISIBLE_COLUMN, NULL); gtk_tree_view_column_set_min_width(prefs_dialog->label_column, 100); /* create the tooltip */ gtk_widget_set_tooltip_text(GTK_WIDGET(prefs_dialog->view), _("Labels can be edited directly by clicking on them.")); prefs_dialog->enable_column = gtk_tree_view_column_new_with_attributes(_("Enabled"), prefs_dialog->enable_renderer, "active", ENABLE_COLUMN, "visible", VISIBLE_COLUMN, NULL); prefs_dialog->icon_column = gtk_tree_view_column_new_with_attributes(_("Icon"), prefs_dialog->icon_renderer, "pixbuf", ICON_PIXBUF_COLUMN, "visible", VISIBLE_COLUMN, NULL); gtk_tree_view_append_column(prefs_dialog->view, prefs_dialog->id_column); gtk_tree_view_append_column(prefs_dialog->view, prefs_dialog->icon_column); gtk_tree_view_append_column(prefs_dialog->view, prefs_dialog->label_column); gtk_tree_view_append_column(prefs_dialog->view, prefs_dialog->enable_column); gtk_tree_view_columns_autosize(prefs_dialog->view); prefs_dialog->scrolled_window = g_object_new(GTK_TYPE_SCROLLED_WINDOW, "hadjustment", NULL, "height-request", 200, "hscrollbar-policy", GTK_POLICY_AUTOMATIC, "vadjustment",NULL, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL); gtk_container_add(GTK_CONTAINER(prefs_dialog->scrolled_window), GTK_WIDGET(prefs_dialog->view)); /* GtkTree Selection */ sensors_applet->selection = gtk_tree_view_get_selection(prefs_dialog->view); /* allow user to only select one row at a time at most */ gtk_tree_selection_set_mode(sensors_applet->selection, GTK_SELECTION_SINGLE); /* when selection is changed, make sure sensor_config button is activated */ /* Create buttons for user to interact with sensors tree */ prefs_dialog->sensor_up_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_GO_UP)); gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE); g_signal_connect(prefs_dialog->sensor_up_button, "clicked", G_CALLBACK(prefs_dialog_sensor_up_button_clicked), prefs_dialog); prefs_dialog->sensor_down_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_GO_DOWN)); gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE); g_signal_connect(prefs_dialog->sensor_down_button, "clicked", G_CALLBACK(prefs_dialog_sensor_down_button_clicked), prefs_dialog); prefs_dialog->buttons_box = GTK_VBUTTON_BOX(gtk_vbutton_box_new()); gtk_button_box_set_layout(GTK_BUTTON_BOX(prefs_dialog->buttons_box), GTK_BUTTONBOX_SPREAD); gtk_box_pack_start(GTK_BOX(prefs_dialog->buttons_box), GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(prefs_dialog->buttons_box), GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE, FALSE, 0); prefs_dialog->sensors_hbox = g_object_new(GTK_TYPE_HBOX, "border-width", 5, "homogeneous", FALSE, "spacing", 5, NULL); gtk_box_pack_start(prefs_dialog->sensors_hbox, GTK_WIDGET(prefs_dialog->scrolled_window), TRUE, TRUE, 0); /* make sure window takes * up most of room */ gtk_box_pack_start(prefs_dialog->sensors_hbox, GTK_WIDGET(prefs_dialog->buttons_box), FALSE, FALSE, 0); /* Sensor Config button */ /* initially make button insensitive until user selects a row from the sensors tree */ prefs_dialog->sensor_config_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_PROPERTIES)); g_object_set(prefs_dialog->sensor_config_button, "sensitive", FALSE, NULL); g_signal_connect(sensors_applet->selection, "changed", G_CALLBACK(prefs_dialog_selection_changed), prefs_dialog); /* pass selection to signal handler so we can give user a sensors_applet->prefs_dialog with the selected rows alarm value and enable */ g_signal_connect(prefs_dialog->sensor_config_button, "clicked", G_CALLBACK(prefs_dialog_sensor_config_button_clicked), prefs_dialog); prefs_dialog->sensor_config_hbox = g_object_new(GTK_TYPE_HBOX, "border-width", 5, "homogeneous", FALSE, "spacing", 0, NULL); gtk_box_pack_end(prefs_dialog->sensor_config_hbox, GTK_WIDGET(prefs_dialog->sensor_config_button), FALSE, FALSE, 0); /* pack sensors_vbox */ prefs_dialog->sensors_vbox = g_object_new(GTK_TYPE_VBOX, "border-width", 5, "homogeneous", FALSE, "spacing", 0, NULL); gtk_box_pack_start(prefs_dialog->sensors_vbox, GTK_WIDGET(prefs_dialog->sensors_hbox), TRUE, TRUE, 0); gtk_box_pack_start(prefs_dialog->sensors_vbox, GTK_WIDGET(prefs_dialog->sensor_config_hbox), FALSE, FALSE, 0); prefs_dialog->globals_alignment = g_object_new(GTK_TYPE_ALIGNMENT, "xalign", 0.5, "yalign", 0.0, "top-padding", 12, "left-padding", 12, "bottom-padding", 12, "right-padding", 12, NULL); gtk_container_add(GTK_CONTAINER(prefs_dialog->globals_alignment), GTK_WIDGET(prefs_dialog->globals_table)); prefs_dialog->notebook = g_object_new(GTK_TYPE_NOTEBOOK, NULL); gtk_notebook_append_page(prefs_dialog->notebook, GTK_WIDGET(prefs_dialog->globals_alignment), gtk_label_new(_("General Options"))); gtk_notebook_append_page(prefs_dialog->notebook, GTK_WIDGET(prefs_dialog->sensors_vbox), gtk_label_new(_("Sensors"))); /* pack notebook into prefs_dialog */ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)), GTK_WIDGET(prefs_dialog->notebook), TRUE, TRUE, 0); gtk_widget_show_all(GTK_WIDGET(prefs_dialog->dialog)); }
void create_configure_dialog(void) { GtkWidget *config_dialog; GtkWidget *main_widget; GtkWidget *cpu_hbox; GtkWidget *cpu_frame; GtkWidget *cpuframe_vbox; GtkWidget *cpuclock_hbox; GtkWidget *baseclock_combo; GtkWidget *rate_combo; GtkWidget *times_label; GtkWidget *realclock_label; GtkWidget *confirm_widget; GtkWidget *ok_button; GtkWidget *cancel_button; GtkWidget *arch_frame; GtkWidget *arch_hbox; GtkWidget *arch_radiobutton[NELEMENTS(architecture)]; GtkWidget *sound_frame; GtkWidget *soundframe_vbox; GtkWidget *soundrate_hbox; GtkWidget *rate_label; GtkWidget *rate_radiobutton[NELEMENTS(samplingrate)]; GtkWidget *soundbuffer_hbox; GtkWidget *buffer_label; GtkWidget *ms_label; gchar buf[8]; int i; uninstall_idle_process(); config_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(config_dialog), "Configure"); gtk_window_set_position(GTK_WINDOW(config_dialog), GTK_WIN_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(config_dialog), TRUE); gtk_window_set_resizable(GTK_WINDOW(config_dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER(config_dialog), 5); g_signal_connect(GTK_OBJECT(config_dialog), "destroy", G_CALLBACK(dialog_destroy), NULL); main_widget = gtk_vbox_new(FALSE, 0); gtk_widget_show(main_widget); gtk_container_add(GTK_CONTAINER(config_dialog), main_widget); /* CPU column */ cpu_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(cpu_hbox); gtk_box_pack_start(GTK_BOX(main_widget), cpu_hbox, TRUE, TRUE, 0); /* * CPU frame */ cpu_frame = gtk_frame_new("CPU"); gtk_widget_show(cpu_frame); gtk_box_pack_start(GTK_BOX(cpu_hbox), cpu_frame, TRUE, TRUE, 0); cpuframe_vbox = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(cpuframe_vbox), 5); gtk_widget_show(cpuframe_vbox); gtk_container_add(GTK_CONTAINER(cpu_frame), cpuframe_vbox); /* cpu clock */ cpuclock_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(cpuclock_hbox); gtk_box_pack_start(GTK_BOX(cpuframe_vbox),cpuclock_hbox, TRUE, TRUE, 2); baseclock_combo = gtk_combo_box_entry_new_text(); gtk_widget_show(baseclock_combo); gtk_box_pack_start(GTK_BOX(cpuclock_hbox), baseclock_combo, TRUE, FALSE, 0); gtk_widget_set_size_request(baseclock_combo, 96, -1); for (i = 0; i < NELEMENTS(baseclock_str); i++) { gtk_combo_box_append_text(GTK_COMBO_BOX(baseclock_combo), baseclock_str[i]); } baseclock_entry = GTK_BIN(baseclock_combo)->child; gtk_widget_show(baseclock_entry); gtk_editable_set_editable(GTK_EDITABLE(baseclock_entry), FALSE); switch (np2cfg.baseclock) { default: np2cfg.baseclock = PCBASECLOCK25; sysmng_update(SYS_UPDATECFG|SYS_UPDATECLOCK); /*FALLTHROUGH*/ case PCBASECLOCK25: gtk_entry_set_text(GTK_ENTRY(baseclock_entry),baseclock_str[1]); break; case PCBASECLOCK20: gtk_entry_set_text(GTK_ENTRY(baseclock_entry),baseclock_str[0]); break; } times_label = gtk_label_new("x"); gtk_widget_show(times_label); gtk_box_pack_start(GTK_BOX(cpuclock_hbox), times_label, TRUE, FALSE, 0); gtk_misc_set_padding(GTK_MISC(times_label), 5, 0); rate_combo = gtk_combo_box_entry_new_text(); gtk_widget_show(rate_combo); gtk_box_pack_start(GTK_BOX(cpuclock_hbox), rate_combo, TRUE, FALSE, 0); gtk_widget_set_size_request(rate_combo, 48, -1); for (i = 0; i < NELEMENTS(clockmult_str); i++) { gtk_combo_box_append_text(GTK_COMBO_BOX(rate_combo), clockmult_str[i]); } clockmult_entry = GTK_BIN(rate_combo)->child; gtk_widget_show(clockmult_entry); gtk_editable_set_editable(GTK_EDITABLE(clockmult_entry), FALSE); switch (np2cfg.multiple) { case 1: case 2: case 4: case 5: case 6: case 8: case 10: case 12: case 16: case 20: g_snprintf(buf, sizeof(buf), "%d", np2cfg.multiple); gtk_entry_set_text(GTK_ENTRY(clockmult_entry), buf); break; default: gtk_entry_set_text(GTK_ENTRY(clockmult_entry), "4"); break; } /* calculated cpu clock */ realclock_label = gtk_label_new("MHz"); gtk_widget_show(realclock_label); gtk_box_pack_start(GTK_BOX(cpuframe_vbox), realclock_label, FALSE, FALSE, 2); gtk_misc_set_alignment(GTK_MISC(realclock_label), 1.0, 0.5); g_signal_connect(GTK_OBJECT(baseclock_entry), "changed", G_CALLBACK(clock_changed), (gpointer)realclock_label); g_signal_connect(GTK_OBJECT(clockmult_entry), "changed", G_CALLBACK(clock_changed), (gpointer)realclock_label); clock_changed(NULL, realclock_label); /* OK, Cancel button base widget */ confirm_widget = gtk_vbutton_box_new(); gtk_widget_show(confirm_widget); gtk_box_pack_start(GTK_BOX(cpu_hbox), confirm_widget, TRUE, TRUE, 0); gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_widget), GTK_BUTTONBOX_END); //gtk_button_box_set_spacing(GTK_BUTTON_BOX(confirm_widget), 0); /* * Architecture frame */ arch_frame = gtk_frame_new("Architecture"); gtk_widget_show(arch_frame); gtk_box_pack_start(GTK_BOX(main_widget), arch_frame, TRUE, TRUE, 0); /* architecture */ arch_hbox = gtk_hbox_new(TRUE, 0); gtk_widget_show(arch_hbox); gtk_container_add(GTK_CONTAINER(arch_frame), arch_hbox); for (i = 0; i < NELEMENTS(architecture); i++) { arch_radiobutton[i] = gtk_radio_button_new_with_label_from_widget(i > 0 ? GTK_RADIO_BUTTON(arch_radiobutton[i-1]) : NULL, architecture[i].label); gtk_widget_show(arch_radiobutton[i]); gtk_box_pack_start(GTK_BOX(arch_hbox), arch_radiobutton[i], FALSE, FALSE, 0); #if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18) gtk_widget_set_can_focus(arch_radiobutton[i], FALSE); #else GTK_WIDGET_UNSET_FLAGS(rate_radiobutton[i], GTK_CAN_FOCUS); #endif g_signal_connect(GTK_OBJECT(arch_radiobutton[i]), "clicked", G_CALLBACK(arch_radiobutton_clicked), (gpointer)architecture[i].arch); } for (i = 0; i < NELEMENTS(architecture); i++) { if (strcmp(np2cfg.model, architecture[i].arch) == 0) { break; } } if (i == NELEMENTS(architecture)) { i = 1; milstr_ncpy(np2cfg.model, "VX", sizeof(np2cfg.model)); sysmng_update(SYS_UPDATECFG); } g_signal_emit_by_name(GTK_OBJECT(arch_radiobutton[i]), "clicked"); /* * Sound frame */ sound_frame = gtk_frame_new("Sound"); gtk_widget_show(sound_frame); gtk_box_pack_start(GTK_BOX(main_widget), sound_frame, TRUE, TRUE, 0); soundframe_vbox = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(soundframe_vbox), 5); gtk_widget_show(soundframe_vbox); gtk_container_add(GTK_CONTAINER(sound_frame), soundframe_vbox); /* sampling rate */ soundrate_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(soundrate_hbox); gtk_box_pack_start(GTK_BOX(soundframe_vbox), soundrate_hbox, TRUE, TRUE, 2); rate_label = gtk_label_new("Sampling Rate"); gtk_widget_show(rate_label); gtk_box_pack_start(GTK_BOX(soundrate_hbox), rate_label, FALSE, TRUE, 3); gtk_widget_set_size_request(rate_label, 96, -1); for (i = 0; i < NELEMENTS(samplingrate); i++) { rate_radiobutton[i] = gtk_radio_button_new_with_label_from_widget((i > 0) ? GTK_RADIO_BUTTON(rate_radiobutton[i-1]) : NULL, samplingrate[i].label); gtk_widget_show(rate_radiobutton[i]); gtk_box_pack_start(GTK_BOX(soundrate_hbox), rate_radiobutton[i], FALSE, FALSE, 0); #if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18) gtk_widget_set_can_focus(rate_radiobutton[i], FALSE); #else GTK_WIDGET_UNSET_FLAGS(rate_radiobutton[i], GTK_CAN_FOCUS); #endif g_signal_connect(GTK_OBJECT(rate_radiobutton[i]), "clicked", G_CALLBACK(rate_radiobutton_clicked), GINT_TO_POINTER(samplingrate[i].rate)); } if (np2cfg.samplingrate == 11025) { i = 0; } else if (np2cfg.samplingrate == 22050) { i = 1; } else if (np2cfg.samplingrate == 44100) { i = 2; } else { i = 1; np2cfg.samplingrate = 22050; sysmng_update(SYS_UPDATECFG|SYS_UPDATERATE); } g_signal_emit_by_name(GTK_OBJECT(rate_radiobutton[i]), "clicked"); soundbuffer_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(soundbuffer_hbox); gtk_box_pack_start(GTK_BOX(soundframe_vbox), soundbuffer_hbox, TRUE, TRUE, 2); /* buffer size */ buffer_label = gtk_label_new("Buffer"); gtk_widget_show(buffer_label); gtk_box_pack_start(GTK_BOX(soundbuffer_hbox), buffer_label, FALSE, FALSE, 0); gtk_widget_set_size_request(buffer_label, 96, -1); buffer_entry = gtk_entry_new(); gtk_widget_show(buffer_entry); gtk_box_pack_start(GTK_BOX(soundbuffer_hbox), buffer_entry, FALSE, FALSE, 0); gtk_widget_set_size_request(buffer_entry, 48, -1); if (np2cfg.delayms >= 20 && np2cfg.delayms <= 1000) { g_snprintf(buf, sizeof(buf), "%d", np2cfg.delayms); gtk_entry_set_text(GTK_ENTRY(buffer_entry), buf); } else { gtk_entry_set_text(GTK_ENTRY(buffer_entry), "500"); np2cfg.delayms = 500; sysmng_update(SYS_UPDATECFG|SYS_UPDATESBUF); soundrenewal = 1; } ms_label = gtk_label_new(" ms"); gtk_widget_show(ms_label); gtk_box_pack_start(GTK_BOX(soundbuffer_hbox),ms_label, FALSE, FALSE, 0); #if defined(SUPPORT_RESUME) /* resume */ resume_checkbutton = gtk_check_button_new_with_label("Resume"); gtk_widget_show(resume_checkbutton); gtk_box_pack_start(GTK_BOX(main_widget), resume_checkbutton, FALSE, FALSE, 1); if (np2oscfg.resume) { g_signal_emit_by_name(GTK_OBJECT(resume_checkbutton), "clicked"); } #endif #if defined(GCC_CPU_ARCH_IA32) /* Disable MMX */ disablemmx_checkbutton = gtk_check_button_new_with_label("Disable MMX"); gtk_widget_show(disablemmx_checkbutton); gtk_box_pack_start(GTK_BOX(main_widget), disablemmx_checkbutton, FALSE, FALSE, 1); if (mmxflag & MMXFLAG_NOTSUPPORT) { gtk_widget_set_sensitive(disablemmx_checkbutton, FALSE); } else if (mmxflag & MMXFLAG_DISABLE) { g_signal_emit_by_name(GTK_OBJECT(disablemmx_checkbutton), "clicked"); } #endif /* * OK, Cancel button */ ok_button = gtk_button_new_from_stock(GTK_STOCK_OK); gtk_widget_show(ok_button); gtk_container_add(GTK_CONTAINER(confirm_widget), ok_button); #if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18) gtk_widget_set_can_default(ok_button, TRUE); gtk_widget_has_default(ok_button); #else GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT); GTK_WIDGET_SET_FLAGS(ok_button, GTK_HAS_DEFAULT); #endif g_signal_connect(GTK_OBJECT(ok_button), "clicked", G_CALLBACK(ok_button_clicked), (gpointer)config_dialog); gtk_widget_grab_default(ok_button); cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_widget_show(cancel_button); gtk_container_add(GTK_CONTAINER(confirm_widget), cancel_button); #if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18) gtk_widget_set_can_default(cancel_button, TRUE); #else GTK_WIDGET_SET_FLAGS(cancel_button, GTK_CAN_DEFAULT); #endif g_signal_connect_swapped(GTK_OBJECT(cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), GTK_OBJECT(config_dialog)); gtk_widget_show_all(config_dialog); }
GtkWidget* create_sheets_main_dialog (void) { GtkWidget *sheets_main_dialog; GtkWidget *dialog_vbox1; GtkWidget *table_sheets; GtkWidget *vbuttonbox; GtkWidget *button_copy; GtkWidget *button_copy_all; GtkWidget *button_move; GtkWidget *button_move_all; GtkWidget *optionmenu_right; GtkWidget *optionmenu_right_menu; GtkWidget *optionmenu_left; GtkWidget *optionmenu_left_menu; GtkWidget *glade_menuitem; GtkWidget *scrolledwindow_left; GtkWidget *scrolledwindow_right; GtkWidget *dialog_action_area1; GtkWidget *hbox1; GtkWidget *button_new; GtkWidget *button_move_up; GtkWidget *button_move_down; GtkWidget *button_edit; GtkWidget *button_remove; GtkWidget *button_apply; GtkWidget *button_revert; GtkWidget *button_close; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); sheets_main_dialog = gtk_dialog_new (); gtk_object_set_data (GTK_OBJECT (sheets_main_dialog), "sheets_main_dialog", sheets_main_dialog); gtk_window_set_title (GTK_WINDOW (sheets_main_dialog), _("Sheets and Objects")); gtk_window_set_role(GTK_WINDOW(sheets_main_dialog), "sheets_main_dialog"); gtk_window_set_default_size (GTK_WINDOW (sheets_main_dialog), 506, 261); gtk_window_set_resizable (GTK_WINDOW (sheets_main_dialog), TRUE); dialog_vbox1 = GTK_DIALOG (sheets_main_dialog)->vbox; gtk_object_set_data (GTK_OBJECT (sheets_main_dialog), "dialog_vbox1", dialog_vbox1); gtk_widget_show (dialog_vbox1); table_sheets = gtk_table_new (2, 3, FALSE); gtk_widget_ref (table_sheets); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "table_sheets", table_sheets, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (table_sheets); gtk_box_pack_start (GTK_BOX (dialog_vbox1), table_sheets, TRUE, TRUE, 0); vbuttonbox = gtk_vbutton_box_new (); gtk_widget_ref (vbuttonbox); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "vbuttonbox", vbuttonbox, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbuttonbox); gtk_table_attach (GTK_TABLE (table_sheets), vbuttonbox, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 17, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox), GTK_BUTTONBOX_SPREAD); button_copy = gtk_button_new_with_label (_("<- Copy")); gtk_widget_ref (button_copy); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_copy", button_copy, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_copy); gtk_container_add (GTK_CONTAINER (vbuttonbox), button_copy); gtk_widget_add_accelerator (button_copy, "clicked", accel_group, GDK_c, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); button_copy_all = gtk_button_new_with_label (_("<- Copy All")); gtk_widget_ref (button_copy_all); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_copy_all", button_copy_all, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_copy_all); gtk_container_add (GTK_CONTAINER (vbuttonbox), button_copy_all); button_move = gtk_button_new_with_label (_("<- Move")); gtk_widget_ref (button_move); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_move", button_move, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_move); gtk_container_add (GTK_CONTAINER (vbuttonbox), button_move); gtk_widget_add_accelerator (button_move, "clicked", accel_group, GDK_m, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); button_move_all = gtk_button_new_with_label (_("<- Move All")); gtk_widget_ref (button_move_all); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_move_all", button_move_all, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_move_all); gtk_container_add (GTK_CONTAINER (vbuttonbox), button_move_all); optionmenu_right = gtk_option_menu_new (); gtk_widget_ref (optionmenu_right); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "optionmenu_right", optionmenu_right, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (optionmenu_right); gtk_table_attach (GTK_TABLE (table_sheets), optionmenu_right, 2, 3, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); optionmenu_right_menu = gtk_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu_right), optionmenu_right_menu); optionmenu_left = gtk_option_menu_new (); gtk_widget_ref (optionmenu_left); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "optionmenu_left", optionmenu_left, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (optionmenu_left); gtk_table_attach (GTK_TABLE (table_sheets), optionmenu_left, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); optionmenu_left_menu = gtk_menu_new (); glade_menuitem = gtk_menu_item_new_with_label (""); gtk_widget_show (glade_menuitem); gtk_menu_append (GTK_MENU (optionmenu_left_menu), glade_menuitem); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu_left), optionmenu_left_menu); scrolledwindow_left = gtk_scrolled_window_new (NULL, NULL); gtk_widget_ref (scrolledwindow_left); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "scrolledwindow_left", scrolledwindow_left, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (scrolledwindow_left); gtk_table_attach (GTK_TABLE (table_sheets), scrolledwindow_left, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_left), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); scrolledwindow_right = gtk_scrolled_window_new (NULL, NULL); gtk_widget_ref (scrolledwindow_right); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "scrolledwindow_right", scrolledwindow_right, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (scrolledwindow_right); gtk_table_attach (GTK_TABLE (table_sheets), scrolledwindow_right, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_right), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); dialog_action_area1 = GTK_DIALOG (sheets_main_dialog)->action_area; gtk_object_set_data (GTK_OBJECT (sheets_main_dialog), "dialog_action_area1", dialog_action_area1); gtk_widget_show (dialog_action_area1); gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10); hbox1 = gtk_hbox_new (TRUE, 0); gtk_widget_ref (hbox1); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "hbox1", hbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbox1, TRUE, TRUE, 0); button_new = gtk_button_new_from_stock(GTK_STOCK_NEW); gtk_widget_ref (button_new); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_new", button_new, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_new); gtk_box_pack_start (GTK_BOX (hbox1), button_new, FALSE, TRUE, 0); gtk_widget_add_accelerator (button_new, "clicked", accel_group, GDK_n, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); button_move_up = gtk_button_new_from_stock (GTK_STOCK_GO_UP); gtk_widget_ref (button_move_up); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_move_up", button_move_up, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_move_up); gtk_box_pack_start (GTK_BOX (hbox1), button_move_up, FALSE, TRUE, 0); gtk_widget_add_accelerator (button_move_up, "clicked", accel_group, GDK_u, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); button_move_down = gtk_button_new_from_stock (GTK_STOCK_GO_DOWN); gtk_widget_ref (button_move_down); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_move_down", button_move_down, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_move_down); gtk_box_pack_start (GTK_BOX (hbox1), button_move_down, FALSE, TRUE, 0); gtk_widget_add_accelerator (button_move_down, "clicked", accel_group, GDK_d, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); button_edit = gtk_button_new(); /* _with_label (_("Edit")); */ { GtkWidget *label; label = gtk_label_new(_("Edit")); gtk_widget_ref(label); gtk_label_parse_uline(GTK_LABEL(label), _("_Edit")); gtk_container_add(GTK_CONTAINER(button_edit), label); gtk_widget_show(label); } gtk_widget_ref (button_edit); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_edit", button_edit, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_edit); gtk_box_pack_start (GTK_BOX (hbox1), button_edit, FALSE, TRUE, 0); gtk_widget_add_accelerator (button_edit, "clicked", accel_group, GDK_e, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); button_remove = gtk_button_new_from_stock(GTK_STOCK_REMOVE); gtk_widget_ref (button_remove); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_remove", button_remove, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_remove); gtk_box_pack_start (GTK_BOX (hbox1), button_remove, FALSE, TRUE, 0); gtk_widget_add_accelerator (button_remove, "clicked", accel_group, GDK_r, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); button_apply = gtk_button_new_from_stock(GTK_STOCK_APPLY); gtk_widget_ref (button_apply); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_apply", button_apply, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_apply); gtk_box_pack_start (GTK_BOX (hbox1), button_apply, FALSE, TRUE, 0); gtk_widget_set_sensitive (button_apply, FALSE); button_revert = gtk_button_new_with_label(_("Revert")); gtk_widget_ref (button_revert); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_revert", button_revert, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_revert); gtk_box_pack_start (GTK_BOX (hbox1), button_revert, FALSE, TRUE, 0); gtk_widget_set_sensitive (button_revert, FALSE); button_close = gtk_button_new_from_stock(GTK_STOCK_CLOSE); gtk_widget_ref (button_close); gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_close", button_close, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button_close); gtk_box_pack_start (GTK_BOX (hbox1), button_close, FALSE, TRUE, 0); g_signal_connect (GTK_OBJECT (sheets_main_dialog), "delete_event", G_CALLBACK (on_sheets_main_dialog_delete_event), NULL); g_signal_connect (GTK_OBJECT (button_copy), "clicked", G_CALLBACK (on_sheets_dialog_button_copy_clicked), NULL); g_signal_connect (GTK_OBJECT (button_copy_all), "clicked", G_CALLBACK (on_sheets_dialog_button_copy_all_clicked), NULL); g_signal_connect (GTK_OBJECT (button_move), "clicked", G_CALLBACK (on_sheets_dialog_button_move_clicked), NULL); g_signal_connect (GTK_OBJECT (button_move_all), "clicked", G_CALLBACK (on_sheets_dialog_button_move_all_clicked), NULL); g_signal_connect (GTK_OBJECT (button_new), "clicked", G_CALLBACK (on_sheets_dialog_button_new_clicked), NULL); g_signal_connect (GTK_OBJECT (button_move_up), "clicked", G_CALLBACK (on_sheets_dialog_button_move_up_clicked), NULL); g_signal_connect (GTK_OBJECT (button_move_down), "clicked", G_CALLBACK (on_sheets_dialog_button_move_down_clicked), NULL); g_signal_connect (GTK_OBJECT (button_edit), "clicked", G_CALLBACK (on_sheets_dialog_button_edit_clicked), NULL); g_signal_connect (GTK_OBJECT (button_remove), "clicked", G_CALLBACK (on_sheets_dialog_button_remove_clicked), NULL); g_signal_connect (GTK_OBJECT (button_apply), "clicked", G_CALLBACK (on_sheets_dialog_button_apply_clicked), NULL); g_signal_connect (GTK_OBJECT (button_revert), "clicked", G_CALLBACK (on_sheets_dialog_button_revert_clicked), NULL); g_signal_connect (GTK_OBJECT (button_close), "clicked", G_CALLBACK (on_sheets_dialog_button_close_clicked), NULL); gtk_window_add_accel_group (GTK_WINDOW (sheets_main_dialog), accel_group); persistence_register_window(GTK_WINDOW(sheets_main_dialog)); return sheets_main_dialog; }