static GtkWidget *create_blocks_combo(void) { GtkWidget *event_box; UnicodeBlock *block; if (blocks_combo) gtk_widget_destroy(blocks_combo); blocks_combo = gtk_combo_box_new_text(); block = unicode_blocks; while (block->name) { if (block->enabled) gtk_combo_box_append_text(GTK_COMBO_BOX(blocks_combo), block->name); block++; } gtk_combo_box_set_active(GTK_COMBO_BOX(blocks_combo), block_unicode_to_combo(training_block)); gtk_combo_box_set_focus_on_click(GTK_COMBO_BOX(blocks_combo), FALSE); g_signal_connect(G_OBJECT(blocks_combo), "changed", G_CALLBACK(blocks_combo_changed), NULL); /* Wrap ComboBox in an EventBox for tooltips */ event_box = gtk_event_box_new(); gtk_tooltips_set_tip(tooltips, event_box, "Select Unicode block to train", NULL); gtk_container_add(GTK_CONTAINER(event_box), blocks_combo); return event_box; }
int clip_GTK_COMBOBOXSETFOCUSONCLICK(ClipMachine * cm) { C_widget *ccmb = _fetch_cw_arg(cm); gboolean set = _clip_parl(cm, 2); CHECKCWID(ccmb,GTK_IS_COMBO_BOX); CHECKARG(2, LOGICAL_t); gtk_combo_box_set_focus_on_click(GTK_COMBO_BOX(ccmb->widget), set); return 0; err: return 1; }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_combo_box_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gchar *items; gboolean add_tearoffs, focus_on_click; items = gb_widget_input_text (data, Items); if (data->apply) { GtkTreeModel *model; gchar *pos = items; gchar *items_end = &items[strlen (items)]; /* Save a copy so it is easy to get out later. */ gtk_object_set_data_full (GTK_OBJECT (widget), Items, g_strdup (items), g_free); /* Clear the list. */ model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget)); gtk_list_store_clear (GTK_LIST_STORE (model)); /* Now add the items one at a time. */ while (pos < items_end) { gchar *item_end = strchr (pos, '\n'); if (item_end == NULL) item_end = items_end; *item_end = '\0'; gtk_combo_box_append_text (GTK_COMBO_BOX (widget), pos); if (item_end != items_end) *item_end = '\n'; pos = item_end + 1; } } if (data->action == GB_APPLYING) g_free (items); add_tearoffs = gb_widget_input_bool (data, AddTearoffs); if (data->apply) gtk_combo_box_set_add_tearoffs (GTK_COMBO_BOX (widget), add_tearoffs); focus_on_click = gb_widget_input_bool (data, FocusOnClick); if (data->apply) gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (widget), focus_on_click); }
void structGuiOptionMenu :: f_init (GuiForm parent, int left, int right, int top, int bottom, unsigned long flags) { d_shell = parent -> d_shell; d_parent = parent; d_options = Ordered_create (); #if gtk d_widget = gtk_combo_box_new_text (); gtk_widget_set_size_request (GTK_WIDGET (d_widget), right - left, bottom - top + 8); gtk_fixed_put (GTK_FIXED (parent -> d_widget), GTK_WIDGET (d_widget), left, top - 6); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (d_widget), false); GTK_WIDGET_UNSET_FLAGS (d_widget, GTK_CAN_DEFAULT); #elif cocoa d_widget = (GuiObject) [GuiCocoaOptionMenu alloc]; v_positionInForm (d_widget, left, right, top, bottom, parent); [(GuiCocoaOptionMenu *) d_widget setUserData: this]; [(NSTextField *) d_widget setBezelStyle: NSRoundedBezelStyle]; [(NSTextField *) d_widget setBordered: NO]; [(NSTextField *) d_widget setSelectable: NO]; #elif motif d_xmMenuBar = XmCreateMenuBar (parent -> d_widget, "UiOptionMenu", NULL, 0); XtVaSetValues (d_xmMenuBar, XmNx, left - 4, XmNy, top - 4 #if mac - 1 #endif , XmNwidth, right - left + 8, XmNheight, bottom - top + 8, NULL); d_xmCascadeButton = XmCreateCascadeButton (d_xmMenuBar, "choice", NULL, 0); d_widget = XmCreatePulldownMenu (d_xmMenuBar, "choice", NULL, 0); if (flags & GuiMenu_INSENSITIVE) XtSetSensitive (d_widget, False); XtVaSetValues (d_xmCascadeButton, XmNsubMenuId, d_widget, NULL); XtManageChild (d_xmCascadeButton); XtVaSetValues (d_xmMenuBar, XmNwidth, right - left + 8, NULL); // BUG: twice? XtVaSetValues (d_xmCascadeButton, XmNx, 4, XmNy, 4, XmNwidth, right - left, XmNheight, bottom - top, NULL); #endif #if gtk g_signal_connect (G_OBJECT (d_widget), "destroy", G_CALLBACK (_guiGtkOptionMenu_destroyCallback), this); #elif cocoa #elif motif XtAddCallback (d_widget, XmNdestroyCallback, _guiMotifOptionMenu_destroyCallback, this); #endif }
/* Setup combo sytle custom list */ static void setup_combo_customlist (GtkComboBox *combo, GreeterItemInfo *item) { GList *li; g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (combo_selected), item); /* Make sure that focus never leaves username/password entry */ gtk_combo_box_set_focus_on_click (combo, FALSE); if (strcmp (item->id, "session") == 0) { populate_session (G_OBJECT (combo)); /* * Do not select since the session_init will initialize the * value and cause the combo list to get set without needing * to do it here. */ } else if (strcmp (item->id, "language") == 0) { populate_language (G_OBJECT (combo)); /* Select first */ gtk_combo_box_set_active (combo, 0); } else { for (li = item->data.list.items; li != NULL; li = li->next) { GreeterItemListItem *litem = li->data; gtk_combo_box_append_text (combo, litem->text); } /* Select first */ gtk_combo_box_set_active (combo, 0); } }
static void connect_proxy (GtkAction *action, GtkWidget *proxy) { if (GTK_IS_TOOL_ITEM (proxy)) { GtkToolItem *item = GTK_TOOL_ITEM (proxy); CajaViewAsAction *vaction = CAJA_VIEW_AS_ACTION (action); CajaNavigationWindow *window = vaction->priv->window; GtkWidget *view_as_menu_vbox; GtkWidget *view_as_combo_box; /* Option menu for content view types; it's empty here, filled in when a uri is set. * Pack it into vbox so it doesn't grow vertically when location bar does. */ view_as_menu_vbox = gtk_vbox_new (FALSE, 4); gtk_widget_show (view_as_menu_vbox); gtk_container_set_border_width (GTK_CONTAINER (item), 4); gtk_container_add (GTK_CONTAINER (item), view_as_menu_vbox); view_as_combo_box = gtk_combo_box_new_text (); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (view_as_combo_box), FALSE); gtk_box_pack_end (GTK_BOX (view_as_menu_vbox), view_as_combo_box, TRUE, FALSE, 0); gtk_widget_show (view_as_combo_box); g_signal_connect_object (view_as_combo_box, "changed", G_CALLBACK (view_as_menu_switch_views_callback), window, 0); g_signal_connect (window, "view-as-changed", G_CALLBACK (view_as_changed_callback), view_as_combo_box); } (* GTK_ACTION_CLASS (parent_class)->connect_proxy) (action, proxy); }
void tasks_add_edit_dialog_show (gboolean tasks_edit_mode, GUI *appGUI) { GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *label; GtkWidget *select_date_button; GtkWidget *scrolledwindow; GtkWidget *hseparator; GtkWidget *hbuttonbox; GtkWidget *table; GtkWidget *cancel_button; gint win_xpos, win_ypos; gchar tmpbuf[BUFFER_SIZE]; appGUI->tsk->tasks_add_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (appGUI->tsk->tasks_add_window), 6); if(tasks_edit_mode == TRUE) { gtk_window_set_title (GTK_WINDOW (appGUI->tsk->tasks_add_window), _("Edit task")); } else { gtk_window_set_title (GTK_WINDOW (appGUI->tsk->tasks_add_window), _("Add task")); } gtk_window_set_default_size (GTK_WINDOW(appGUI->tsk->tasks_add_window), TASKS_ADD_EDIT_WINDOW_SIZE_X, TASKS_ADD_EDIT_WINDOW_SIZE_Y); gtk_window_set_position(GTK_WINDOW(appGUI->tsk->tasks_add_window), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_transient_for(GTK_WINDOW(appGUI->tsk->tasks_add_window), GTK_WINDOW(appGUI->main_window)); gtk_window_set_modal(GTK_WINDOW(appGUI->tsk->tasks_add_window), TRUE); g_signal_connect (G_OBJECT (appGUI->tsk->tasks_add_window), "key_press_event", G_CALLBACK (tasks_add_edit_key_press_cb), appGUI); g_signal_connect (G_OBJECT (appGUI->tsk->tasks_add_window), "delete_event", G_CALLBACK(tasks_add_edit_window_close_cb), appGUI); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (appGUI->tsk->tasks_add_window), vbox1); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0); table = gtk_table_new (4, 4, FALSE); gtk_widget_show (table); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_box_pack_start (GTK_BOX (vbox2), table, FALSE, FALSE, 4); sprintf(tmpbuf, "<b>%s:</b>", _("Summary")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); sprintf(tmpbuf, "<b>%s:</b>", _("Due date")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->tsk->summary_entry = gtk_entry_new (); gtk_widget_show (appGUI->tsk->summary_entry); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->summary_entry, 1, 4, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); appGUI->tsk->due_date_entry = gtk_entry_new (); gtk_widget_show (appGUI->tsk->due_date_entry); GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->due_date_entry, GTK_CAN_FOCUS); gtk_editable_set_editable (GTK_EDITABLE (appGUI->tsk->due_date_entry), FALSE); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->due_date_entry, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); select_date_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_SELECT_DATE); gtk_widget_show (select_date_button); GTK_WIDGET_UNSET_FLAGS(select_date_button, GTK_CAN_FOCUS); g_signal_connect(select_date_button, "clicked", G_CALLBACK(select_date_cb), appGUI); gtk_table_attach (GTK_TABLE (table), select_date_button, 2, 4, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); sprintf(tmpbuf, "<b>%s:</b>", _("Category")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->tsk->category_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->category_combobox); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->category_combobox), FALSE); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->category_combobox, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); create_category_combobox (GTK_COMBO_BOX (appGUI->tsk->category_combobox), appGUI->opt->tasks_category_store, TRUE); gtk_combo_box_set_active(GTK_COMBO_BOX(appGUI->tsk->category_combobox), gui_list_store_get_text_index (appGUI->opt->tasks_category_store, gtk_combo_box_get_active_text(GTK_COMBO_BOX(appGUI->tsk->cf_combobox)))); sprintf(tmpbuf, "<b>%s:</b>", _("Priority")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_table_attach (GTK_TABLE (table), label, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->tsk->priority_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->priority_combobox); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), _("Low")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), _("Medium")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), _("High")); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), FALSE); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->priority_combobox, 3, 4, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_combo_box_set_active (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), 1); sprintf(tmpbuf, "<b>%s:</b>", _("Description")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox2), scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); appGUI->tsk->desc_textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->desc_textview), GTK_WRAP_WORD); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->desc_textview), 4); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->desc_textview), 4); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->desc_textview), 4); gtk_widget_show (appGUI->tsk->desc_textview); gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->tsk->desc_textview); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4); hbuttonbox = gtk_hbutton_box_new (); gtk_widget_show (hbuttonbox); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox), 2); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (hbuttonbox), 16); if (config.default_stock_icons) { cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); } else { cancel_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_CANCEL); } gtk_widget_show (cancel_button); gtk_container_add (GTK_CONTAINER (hbuttonbox), cancel_button); g_signal_connect(cancel_button, "clicked", G_CALLBACK(button_tasks_add_edit_window_close_cb), appGUI); if (config.default_stock_icons) { appGUI->tsk->tasks_ok_button = gtk_button_new_from_stock (GTK_STOCK_OK); } else { appGUI->tsk->tasks_ok_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_OK); } gtk_widget_show (appGUI->tsk->tasks_ok_button); gtk_container_add (GTK_CONTAINER (hbuttonbox), appGUI->tsk->tasks_ok_button); g_signal_connect(appGUI->tsk->tasks_ok_button, "clicked", G_CALLBACK(tasks_item_entered_cb), appGUI); appGUI->tsk->tasks_edit_state = tasks_edit_mode; appGUI->tsk->tasks_accept_state = FALSE; gtk_entry_set_text (GTK_ENTRY(appGUI->tsk->due_date_entry), _("No date")); if (tasks_edit_mode == TRUE) { appGUI->tsk->tasks_accept_state = TRUE; fill_fields (appGUI->tsk->due_date_entry, appGUI->tsk->summary_entry, appGUI->tsk->desc_textview, appGUI); } gtk_widget_set_sensitive(appGUI->tsk->tasks_ok_button, appGUI->tsk->tasks_accept_state); gtk_window_get_position (GTK_WINDOW(appGUI->tsk->tasks_add_window), &win_xpos, &win_ypos); gtk_window_move (GTK_WINDOW (appGUI->tsk->tasks_add_window), win_xpos-TASKS_ADD_EDIT_WINDOW_SIZE_X/2, win_ypos-10); gtk_widget_show(appGUI->tsk->tasks_add_window); }
void gtkhtml_editor_private_constructed (GtkhtmlEditor *editor) { GtkhtmlEditorPrivate *priv = editor->priv; GtkHTML *html; GtkWidget *widget; GtkToolbar *toolbar; GtkToolItem *tool_item; /* Construct main window widgets. */ widget = gtkhtml_editor_get_managed_widget (editor, "/main-menu"); gtk_box_pack_start (GTK_BOX (editor->vbox), widget, FALSE, FALSE, 0); priv->main_menu = g_object_ref (widget); gtk_widget_show (widget); widget = gtkhtml_editor_get_managed_widget (editor, "/main-toolbar"); gtk_box_pack_start (GTK_BOX (editor->vbox), widget, FALSE, FALSE, 0); priv->main_toolbar = g_object_ref (widget); gtk_widget_show (widget); widget = gtkhtml_editor_get_managed_widget (editor, "/edit-toolbar"); gtk_toolbar_set_style (GTK_TOOLBAR (widget), GTK_TOOLBAR_BOTH_HORIZ); gtk_box_pack_start (GTK_BOX (editor->vbox), widget, FALSE, FALSE, 0); priv->edit_toolbar = g_object_ref (widget); gtk_widget_show (widget); widget = gtkhtml_editor_get_managed_widget (editor, "/html-toolbar"); gtk_toolbar_set_style (GTK_TOOLBAR (widget), GTK_TOOLBAR_BOTH_HORIZ); gtk_box_pack_start (GTK_BOX (editor->vbox), widget, FALSE, FALSE, 0); priv->html_toolbar = g_object_ref (widget); gtk_widget_show (widget); widget = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (editor->vbox), widget, TRUE, TRUE, 0); priv->scrolled_window = g_object_ref (widget); gtk_widget_show (widget); widget = GTK_WIDGET (gtkhtml_editor_get_html (editor)); gtk_container_add (GTK_CONTAINER (priv->scrolled_window), widget); gtk_widget_show (widget); /* Add some combo boxes to the "edit" toolbar. */ toolbar = GTK_TOOLBAR (priv->edit_toolbar); tool_item = gtk_tool_item_new (); widget = gtkhtml_combo_box_new_with_action ( GTK_RADIO_ACTION (ACTION (STYLE_NORMAL))); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (widget), FALSE); gtk_container_add (GTK_CONTAINER (tool_item), widget); gtk_widget_set_tooltip_text (widget, _("Paragraph Style")); gtk_toolbar_insert (toolbar, tool_item, 0); priv->style_combo_box = g_object_ref (widget); gtk_widget_show_all (GTK_WIDGET (tool_item)); tool_item = gtk_separator_tool_item_new (); gtk_toolbar_insert (toolbar, tool_item, 0); gtk_widget_show_all (GTK_WIDGET (tool_item)); tool_item = gtk_tool_item_new (); widget = gtkhtml_combo_box_new_with_action ( GTK_RADIO_ACTION (ACTION (MODE_HTML))); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (widget), FALSE); gtk_container_add (GTK_CONTAINER (tool_item), widget); gtk_widget_set_tooltip_text (widget, _("Editing Mode")); gtk_toolbar_insert (toolbar, tool_item, 0); priv->mode_combo_box = g_object_ref (widget); gtk_widget_show_all (GTK_WIDGET (tool_item)); /* Add some combo boxes to the "html" toolbar. */ toolbar = GTK_TOOLBAR (priv->html_toolbar); tool_item = gtk_tool_item_new (); widget = gtkhtml_color_combo_new (); gtk_container_add (GTK_CONTAINER (tool_item), widget); gtk_widget_set_tooltip_text (widget, _("Font Color")); gtk_toolbar_insert (toolbar, tool_item, 0); priv->color_combo_box = g_object_ref (widget); gtk_widget_show_all (GTK_WIDGET (tool_item)); tool_item = gtk_tool_item_new (); widget = gtkhtml_combo_box_new_with_action ( GTK_RADIO_ACTION (ACTION (SIZE_PLUS_ZERO))); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (widget), FALSE); gtk_container_add (GTK_CONTAINER (tool_item), widget); gtk_widget_set_tooltip_text (widget, _("Font Size")); gtk_toolbar_insert (toolbar, tool_item, 0); priv->size_combo_box = g_object_ref (widget); gtk_widget_show_all (GTK_WIDGET (tool_item)); /* Initialize painters (requires "edit_area"). */ html = gtkhtml_editor_get_html (editor); gtk_widget_ensure_style (GTK_WIDGET (html)); priv->html_painter = g_object_ref (html->engine->painter); priv->plain_painter = html_plain_painter_new (priv->edit_area, TRUE); /* Add input methods to the context menu. */ widget = gtkhtml_editor_get_managed_widget ( editor, "/context-menu/context-input-methods-menu"); widget = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget)); gtk_im_multicontext_append_menuitems ( GTK_IM_MULTICONTEXT (html->priv->im_context), GTK_MENU_SHELL (widget)); /* Configure color stuff. */ priv->palette = gtkhtml_color_palette_new (); priv->text_color = gtkhtml_color_state_new (); gtkhtml_color_state_set_default_label ( priv->text_color, _("Automatic")); gtkhtml_color_state_set_palette ( priv->text_color, priv->palette); /* Text color widgets share state. */ widget = priv->color_combo_box; gtkhtml_color_combo_set_state ( GTKHTML_COLOR_COMBO (widget), priv->text_color); widget = WIDGET (TEXT_PROPERTIES_COLOR_COMBO); gtkhtml_color_combo_set_state ( GTKHTML_COLOR_COMBO (widget), priv->text_color); /* These color widgets share a custom color palette. */ widget = WIDGET (CELL_PROPERTIES_COLOR_COMBO); gtkhtml_color_combo_set_palette ( GTKHTML_COLOR_COMBO (widget), priv->palette); widget = WIDGET (PAGE_PROPERTIES_BACKGROUND_COLOR_COMBO); gtkhtml_color_combo_set_palette ( GTKHTML_COLOR_COMBO (widget), priv->palette); widget = WIDGET (PAGE_PROPERTIES_LINK_COLOR_COMBO); gtkhtml_color_combo_set_palette ( GTKHTML_COLOR_COMBO (widget), priv->palette); widget = WIDGET (TABLE_PROPERTIES_COLOR_COMBO); gtkhtml_color_combo_set_palette ( GTKHTML_COLOR_COMBO (widget), priv->palette); }
void ical_events_browser (GUI *appGUI) { GtkWidget *vbox1; GtkWidget *hseparator; GtkWidget *hbuttonbox; GtkWidget *close_button; GtkTreeIter iter; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkWidget *scrolledwindow; GtkWidget *table; GtkWidget *label; gchar tmpbuf[BUFFER_SIZE]; gchar *ical_name; gint i, k; i = 0; while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(appGUI->opt->calendar_ical_files_store), &iter, NULL, i++)); if (i-1 == 0) { gui_create_dialog(GTK_MESSAGE_INFO, _("No calendars defined"), GTK_WINDOW(appGUI->cal->fullyear_window)); return; } appGUI->cal->events_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (appGUI->cal->events_window), _("iCalendar events")); gtk_window_set_position (GTK_WINDOW (appGUI->cal->events_window), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_default_size (GTK_WINDOW(appGUI->cal->events_window), 550, 650); gtk_window_set_modal (GTK_WINDOW (appGUI->cal->events_window), TRUE); g_signal_connect (G_OBJECT (appGUI->cal->events_window), "delete_event", G_CALLBACK(ical_events_window_close_cb), appGUI); gtk_window_set_transient_for(GTK_WINDOW(appGUI->cal->events_window), GTK_WINDOW(appGUI->cal->fullyear_window)); gtk_container_set_border_width (GTK_CONTAINER (appGUI->cal->events_window), 8); g_signal_connect (G_OBJECT (appGUI->cal->events_window), "key_press_event", G_CALLBACK (ical_events_key_press_cb), appGUI); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (appGUI->cal->events_window), vbox1); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); table = gtk_table_new (1, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 8); sprintf(tmpbuf, "<b>%s:</b>", _("Calendar")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); appGUI->cal->ical_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->cal->ical_combobox); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->cal->ical_combobox), FALSE); GTK_WIDGET_UNSET_FLAGS(appGUI->cal->ical_combobox, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (table), appGUI->cal->ical_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(appGUI->cal->ical_combobox, "changed", G_CALLBACK(calendar_selected_cb), appGUI); k = 0; while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(appGUI->opt->calendar_ical_files_store), &iter, NULL, k++)) { gtk_tree_model_get(GTK_TREE_MODEL(appGUI->opt->calendar_ical_files_store), &iter, ICAL_COLUMN_NAME, &ical_name, -1); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->ical_combobox), ical_name); g_free (ical_name); } appGUI->cal->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->cal->n_items_label); gtk_widget_set_size_request (appGUI->cal->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (table), appGUI->cal->n_items_label, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->cal->n_items_label), TRUE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->cal->ical_events_list_store = gtk_list_store_new(ICAL_EVENTS_NUM_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT); appGUI->cal->ical_events_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->cal->ical_events_list_store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->cal->ical_events_list), FALSE); gtk_widget_show (appGUI->cal->ical_events_list); GTK_WIDGET_SET_FLAGS (appGUI->cal->ical_events_list, GTK_CAN_DEFAULT); gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->cal->ical_events_list); /* create columns */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Date"), renderer, "text", I_COLUMN_DATE, "weight", I_COLUMN_FONT_WEIGHT, NULL); gtk_tree_view_column_set_visible (column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->ical_events_list), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Julian", renderer, "text", I_COLUMN_DATE_JULIAN, NULL); gtk_tree_view_column_set_visible (column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->ical_events_list), column); gtk_tree_view_column_set_sort_column_id (column, I_COLUMN_DATE_JULIAN); g_signal_emit_by_name(column, "clicked"); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes(_("Summary"), renderer, "text", I_COLUMN_SUMMARY, "weight", I_COLUMN_FONT_WEIGHT, NULL); gtk_tree_view_column_set_visible (column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->ical_events_list), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", I_COLUMN_FONT_WEIGHT, NULL); gtk_tree_view_column_set_visible (column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->ical_events_list), column); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4); hbuttonbox = gtk_hbutton_box_new (); gtk_widget_show (hbuttonbox); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (hbuttonbox), 4); if (config.default_stock_icons) { close_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); } else { close_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_CLOSE); } gtk_widget_show (close_button); g_signal_connect(close_button, "clicked", G_CALLBACK(button_ical_events_window_close_cb), appGUI); gtk_container_add(GTK_CONTAINER(hbuttonbox), close_button); gtk_widget_show(appGUI->cal->events_window); gtk_combo_box_set_active (GTK_COMBO_BOX (appGUI->cal->ical_combobox), 0); gtk_widget_grab_focus (close_button); }
static void mucharmap_mini_font_selection_init (MucharmapMiniFontSelection *fontsel) { GtkCellRenderer *renderer; GtkStyle *style; AtkObject *accessib; gtk_widget_ensure_style (GTK_WIDGET (fontsel)); style = gtk_widget_get_style (GTK_WIDGET (fontsel)); fontsel->font_desc = pango_font_description_copy (style->font_desc); fontsel->default_size = -1; fontsel->size_adj = gtk_adjustment_new (MIN_FONT_SIZE, MIN_FONT_SIZE, MAX_FONT_SIZE, 1, 8, 0); accessib = gtk_widget_get_accessible (GTK_WIDGET (fontsel)); atk_object_set_name (accessib, _("Font")); gtk_box_set_spacing (GTK_BOX (fontsel), 6); fontsel->family = gtk_combo_box_new (); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (fontsel->family), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (fontsel->family), renderer, "text", COL_FAMILIY, NULL); gtk_widget_show (fontsel->family); accessib = gtk_widget_get_accessible (fontsel->family); atk_object_set_name (accessib, _("Font Family")); fontsel->bold = gtk_toggle_button_new_with_mnemonic (GTK_STOCK_BOLD); gtk_button_set_use_stock (GTK_BUTTON (fontsel->bold), TRUE); gtk_widget_show (fontsel->bold); g_signal_connect (fontsel->bold, "toggled", G_CALLBACK (bold_toggled), fontsel); fontsel->italic = gtk_toggle_button_new_with_mnemonic (GTK_STOCK_ITALIC); gtk_button_set_use_stock (GTK_BUTTON (fontsel->italic), TRUE); gtk_widget_show (fontsel->italic); g_signal_connect (fontsel->italic, "toggled", G_CALLBACK (italic_toggled), fontsel); fontsel->size = gtk_spin_button_new (GTK_ADJUSTMENT (fontsel->size_adj), 0, 0); gtk_widget_show (fontsel->size); accessib = gtk_widget_get_accessible (fontsel->size); atk_object_set_name (accessib, _("Font Size")); g_signal_connect (fontsel->size_adj, "value-changed", G_CALLBACK (font_size_changed), fontsel); fill_font_families_combo (fontsel); gtk_combo_box_set_active (GTK_COMBO_BOX (fontsel->family), -1); g_signal_connect (fontsel->family, "changed", G_CALLBACK (family_combo_changed), fontsel); gtk_box_pack_start (GTK_BOX (fontsel), fontsel->family, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (fontsel), fontsel->bold, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (fontsel), fontsel->italic, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (fontsel), fontsel->size, FALSE, FALSE, 0); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (fontsel->family), FALSE); gtk_button_set_focus_on_click (GTK_BUTTON (fontsel->bold), FALSE); gtk_button_set_focus_on_click (GTK_BUTTON (fontsel->italic), FALSE); gtk_container_set_border_width (GTK_CONTAINER (fontsel), 6); gtk_widget_show_all (GTK_WIDGET (fontsel)); }
void init_stuff (int argc, char *argv[]) { GtkWidget *w; GList *dev_list; GdkDevice *device; GdkScreen *screen; int i, j; struct Brush *b; gboolean can_xinput, success; gchar *tmppath, *tmpfn; // create some data structures needed to populate the preferences ui.default_page.bg = g_new(struct Background, 1); // initialize config file names tmppath = g_build_filename(g_get_home_dir(), CONFIG_DIR, NULL); mkdir(tmppath, 0700); // safer (MRU data may be confidential) ui.mrufile = g_build_filename(tmppath, MRU_FILE, NULL); ui.configfile = g_build_filename(tmppath, CONFIG_FILE, NULL); g_free(tmppath); // initialize preferences init_config_default(); load_config_from_file(); ui.font_name = g_strdup(ui.default_font_name); ui.font_size = ui.default_font_size; ui.hiliter_alpha_mask = 0xffffff00 + (guint)(255*ui.hiliter_opacity); // we need an empty canvas prior to creating the journal structures canvas = GNOME_CANVAS (gnome_canvas_new_aa ()); // initialize data ui.default_page.bg->canvas_item = NULL; ui.layerbox_length = 0; if (argc > 2 || (argc == 2 && argv[1][0] == '-')) { printf(_("Invalid command line parameters.\n" "Usage: %s [filename.xoj]\n"), argv[0]); gtk_exit(0); } undo = NULL; redo = NULL; journal.pages = NULL; bgpdf.status = STATUS_NOT_INIT; new_journal(); ui.cur_item_type = ITEM_NONE; ui.cur_item = NULL; ui.cur_path.coords = NULL; ui.cur_path_storage_alloc = 0; ui.cur_path.ref_count = 1; ui.cur_widths = NULL; ui.cur_widths_storage_alloc = 0; ui.selection = NULL; ui.cursor = NULL; ui.pen_cursor_pix = ui.hiliter_cursor_pix = NULL; ui.cur_brush = &(ui.brushes[0][ui.toolno[0]]); for (j=0; j<=NUM_BUTTONS; j++) for (i=0; i < NUM_STROKE_TOOLS; i++) { b = &(ui.brushes[j][i]); b->tool_type = i; if (b->color_no>=0) { b->color_rgba = predef_colors_rgba[b->color_no]; if (i == TOOL_HIGHLIGHTER) { b->color_rgba &= ui.hiliter_alpha_mask; } } b->thickness = predef_thickness[i][b->thickness_no]; } for (i=0; i<NUM_STROKE_TOOLS; i++) g_memmove(ui.default_brushes+i, &(ui.brushes[0][i]), sizeof(struct Brush)); ui.cur_mapping = 0; ui.which_unswitch_button = 0; ui.in_proximity = FALSE; ui.warned_generate_fontconfig = FALSE; reset_recognizer(); // initialize various interface elements gtk_window_set_default_size(GTK_WINDOW (winMain), ui.window_default_width, ui.window_default_height); if (ui.maximize_at_start) gtk_window_maximize(GTK_WINDOW (winMain)); update_toolbar_and_menu(); update_font_button(); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("journalApplyAllPages")), ui.bg_apply_all_pages); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("journalNewPageKeepsBG")), ui.new_page_bg_from_pdf); if (ui.fullscreen) { gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), TRUE); gtk_toggle_tool_button_set_active( GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), TRUE); gtk_window_fullscreen(GTK_WINDOW(winMain)); } gtk_button_set_relief(GTK_BUTTON(GET_COMPONENT("buttonColorChooser")), GTK_RELIEF_NONE); allow_all_accels(); add_scroll_bindings(); // prevent interface items from stealing focus // glade doesn't properly handle can_focus, so manually set it gtk_combo_box_set_focus_on_click(GTK_COMBO_BOX(GET_COMPONENT("comboLayer")), FALSE); g_signal_connect(GET_COMPONENT("spinPageNo"), "activate", G_CALLBACK(handle_activate_signal), NULL); gtk_container_forall(GTK_CONTAINER(winMain), unset_flags, (gpointer)GTK_CAN_FOCUS); GTK_WIDGET_SET_FLAGS(GTK_WIDGET(canvas), GTK_CAN_FOCUS); GTK_WIDGET_SET_FLAGS(GTK_WIDGET(GET_COMPONENT("spinPageNo")), GTK_CAN_FOCUS); // install hooks on button/key/activation events to make the spinPageNo lose focus gtk_container_forall(GTK_CONTAINER(winMain), install_focus_hooks, NULL); // set up and initialize the canvas gtk_widget_show (GTK_WIDGET (canvas)); w = GET_COMPONENT("scrolledwindowMain"); gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (canvas)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_events (GTK_WIDGET (canvas), GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_PROXIMITY_IN_MASK | GDK_PROXIMITY_OUT_MASK); gnome_canvas_set_pixels_per_unit (canvas, ui.zoom); gnome_canvas_set_center_scroll_region (canvas, TRUE); gtk_layout_get_hadjustment(GTK_LAYOUT (canvas))->step_increment = ui.scrollbar_step_increment; gtk_layout_get_vadjustment(GTK_LAYOUT (canvas))->step_increment = ui.scrollbar_step_increment; // set up the page size and canvas size update_page_stuff(); g_signal_connect ((gpointer) canvas, "button_press_event", G_CALLBACK (on_canvas_button_press_event), NULL); g_signal_connect ((gpointer) canvas, "button_release_event", G_CALLBACK (on_canvas_button_release_event), NULL); g_signal_connect ((gpointer) canvas, "enter_notify_event", G_CALLBACK (on_canvas_enter_notify_event), NULL); g_signal_connect ((gpointer) canvas, "leave_notify_event", G_CALLBACK (on_canvas_leave_notify_event), NULL); g_signal_connect ((gpointer) canvas, "proximity_in_event", G_CALLBACK (on_canvas_proximity_event), NULL); g_signal_connect ((gpointer) canvas, "proximity_out_event", G_CALLBACK (on_canvas_proximity_event), NULL); g_signal_connect ((gpointer) canvas, "expose_event", G_CALLBACK (on_canvas_expose_event), NULL); g_signal_connect ((gpointer) canvas, "key_press_event", G_CALLBACK (on_canvas_key_press_event), NULL); g_signal_connect ((gpointer) canvas, "motion_notify_event", G_CALLBACK (on_canvas_motion_notify_event), NULL); g_signal_connect ((gpointer) gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), "value-changed", G_CALLBACK (on_vscroll_changed), NULL); g_signal_connect ((gpointer) gtk_layout_get_hadjustment(GTK_LAYOUT(canvas)), "value-changed", G_CALLBACK (on_hscroll_changed), NULL); g_object_set_data (G_OBJECT (winMain), "canvas", canvas); screen = gtk_widget_get_screen(winMain); ui.screen_width = gdk_screen_get_width(screen); ui.screen_height = gdk_screen_get_height(screen); can_xinput = FALSE; dev_list = gdk_devices_list(); while (dev_list != NULL) { device = (GdkDevice *)dev_list->data; if (device != gdk_device_get_core_pointer() && device->num_axes >= 2) { /* get around a GDK bug: map the valuator range CORRECTLY to [0,1] */ #ifdef ENABLE_XINPUT_BUGFIX gdk_device_set_axis_use(device, 0, GDK_AXIS_IGNORE); gdk_device_set_axis_use(device, 1, GDK_AXIS_IGNORE); #endif gdk_device_set_mode(device, GDK_MODE_SCREEN); if (g_strrstr(device->name, "raser")) gdk_device_set_source(device, GDK_SOURCE_ERASER); can_xinput = TRUE; } dev_list = dev_list->next; } if (!can_xinput) gtk_widget_set_sensitive(GET_COMPONENT("optionsUseXInput"), FALSE); ui.use_xinput = ui.allow_xinput && can_xinput; gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsProgressiveBG")), ui.progressive_bg); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsPrintRuling")), ui.print_ruling); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutoloadPdfXoj")), ui.autoload_pdf_xoj); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutosaveXoj")), ui.autosave_enabled); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsLeftHanded")), ui.left_handed); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsShortenMenus")), ui.shorten_menus); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutoSavePrefs")), ui.auto_save_prefs); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsButtonSwitchMapping")), ui.button_switch_mapping); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsLargePenCursor")), ui.large_pencursor); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsPenCursor")), ui.pen_cursor); hide_unimplemented(); update_undo_redo_enabled(); update_copy_paste_enabled(); update_vbox_order(ui.vertical_order[ui.fullscreen?1:0]); gtk_widget_grab_focus(GTK_WIDGET(canvas)); // show everything... gtk_widget_show (winMain); update_cursor(); /* this will cause extension events to get enabled/disabled, but we need the windows to be mapped first */ gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsUseXInput")), ui.use_xinput); /* fix a bug in GTK+ 2.16 and 2.17: scrollbars shouldn't get extended input events from pointer motion when cursor moves into main window */ if (!gtk_check_version(2, 16, 0)) { g_signal_connect ( GET_COMPONENT("menubar"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("toolbarMain"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("toolbarPen"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("statusbar"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( (gpointer)(gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(w))), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( (gpointer)(gtk_scrolled_window_get_hscrollbar(GTK_SCROLLED_WINDOW(w))), "event", G_CALLBACK (filter_extended_events), NULL); } // load the MRU init_mru(); // and finally, open a file specified on the command line // (moved here because display parameters weren't initialized yet...) if (argc == 1) return; set_cursor_busy(TRUE); if (g_path_is_absolute(argv[1])) tmpfn = g_strdup(argv[1]); else { tmppath = g_get_current_dir(); tmpfn = g_build_filename(tmppath, argv[1], NULL); g_free(tmppath); } success = open_journal(tmpfn); g_free(tmpfn); set_cursor_busy(FALSE); if (!success) { w = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), argv[1]); gtk_dialog_run(GTK_DIALOG(w)); gtk_widget_destroy(w); } }
void gui_create_tasks(GUI *appGUI) { GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *table; GtkWidget *label; GtkWidget *top_scrolledwindow; GtkWidget *hseparator; GtkWidget *close_button; GtkCellRenderer *renderer; GtkWidget *top_viewport; GtkWidget *bottom_viewport; GtkTextBuffer *text_buffer; GError *error = NULL; GtkActionGroup *action_group = NULL; gchar tmpbuf[BUFFER_SIZE]; const gchar *ui_info = " <toolbar name=\"toolbar\">\n" " <toolitem name=\"add\" action=\"add\" />\n" " <toolitem name=\"delete\" action=\"delete\" />\n" " <separator name=\"sep1\" />\n" " <toolitem name=\"edit\" action=\"edit\" />\n" " </toolbar>\n"; GtkActionEntry entries[] = { { "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL }, { "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL }, { "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL }, }; guint n_entries = G_N_ELEMENTS (entries); appGUI->tsk->filter_index = 0; label = gtk_label_new(NULL); gtk_label_set_angle (GTK_LABEL(label), -90.0); sprintf(tmpbuf, "<b>%s</b>", _("Tasks")); gtk_label_set_markup (GTK_LABEL (label), tmpbuf); vbox1 = gtk_vbox_new (FALSE, 1); gtk_widget_show (vbox1); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8); gtk_notebook_append_page(GTK_NOTEBOOK(appGUI->notebook), vbox1, label); appGUI->tsk->vbox = GTK_BOX(vbox1); /*-------------------------------------------------------------------------------------*/ action_group = gtk_action_group_new ("_actions"); gtk_action_group_add_actions (action_group, entries, n_entries, NULL); gtk_action_group_set_sensitive(action_group, TRUE); appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0); g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI); if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) { g_message ("building toolbar failed: %s", error->message); g_error_free (error); } gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget); gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS); gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips); /*-------------------------------------------------------------------------------------*/ /* assign callbacks */ g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked", G_CALLBACK(tasks_add_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked", G_CALLBACK(tasks_edit_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked", G_CALLBACK(tasks_remove_item_cb), appGUI); /*-------------------------------------------------------------------------------------*/ gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE); gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); table = gtk_table_new (1, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 8); sprintf(tmpbuf, "<b>%s:</b>", _("Category filter")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); appGUI->tsk->cf_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->cf_combobox); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE); GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(appGUI->tsk->cf_combobox, "changed", G_CALLBACK(category_filter_cb), appGUI); g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus", G_CALLBACK(category_combo_box_focus_cb), NULL); appGUI->tsk->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->tsk->n_items_label); gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); /*-------------------------------------------------------------------------------------*/ appGUI->tsk->tasks_paned = gtk_vpaned_new(); gtk_widget_show (appGUI->tsk->tasks_paned); gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999); gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0); top_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (top_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE); gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE); top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (top_scrolledwindow); gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter), (GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb, appGUI, NULL); appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter)); appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint); gtk_widget_show (appGUI->tsk->tasks_list); GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED])); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL])); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event", G_CALLBACK(list_dbclick_cb), appGUI); appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list)); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed", G_CALLBACK(tasks_item_selected), appGUI); /* create columns */ renderer = gtk_cell_renderer_toggle_new(); appGUI->tsk->tasks_columns[COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"), renderer, "active", COLUMN_DONE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DONE]); g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"), renderer, "text", COLUMN_DUE_DATE, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE], config.visible_due_date_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_DUE_DATE_JULIAN, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_START_DATE_JULIAN, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"), renderer, "text", COLUMN_PRIORITY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_PRIORITY], config.visible_priority_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_PRIORITY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"), renderer, "text", COLUMN_CATEGORY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_CATEGORY], config.visible_category_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_CATEGORY]); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_renderer_set_fixed_size(renderer, 0, -1); appGUI->tsk->tasks_columns[COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"), renderer, "text", COLUMN_SUMMARY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_SUMMARY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", COLUMN_DESCRIPTION, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_COLOR], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_COLOR]); /* configure list options */ gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE); /* configure sorting */ gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0, (GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DUE_DATE, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_PRIORITY, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DONE, config.tasks_sorting_order); /*----------------------------------------------------------------------------*/ bottom_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (bottom_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE); gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0); gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2); appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0); gtk_widget_show(appGUI->tsk->panel_hbox); sprintf(tmpbuf, "%s:", _("Task details")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0); if (config.default_stock_icons) { close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE); } else { close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE); } GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS); gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE); gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL); gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (panel_close_desc_cb), appGUI); appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (appGUI->tsk->panel_scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_desc_textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_widget_show (appGUI->tsk->tasks_desc_textview); gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview); text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview)); gtk_text_buffer_create_tag (text_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL); appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font", "font", (gchar *) config.task_info_font, NULL); }
void create_main_window (ContactsData *data) { GtkWidget *main_window; GtkWidget *vbox7; GtkWidget *main_menubar; GtkWidget *contacts_menu; GtkWidget *contacts_menu_menu; GtkWidget *new_menuitem; GtkWidget *edit_menuitem; GtkWidget *delete_menuitem; GtkWidget *contacts_import; GtkWidget *contacts_quit; GtkWidget *contact_menu; GtkWidget *contact_menu_menu; GtkWidget *contact_delete; GtkWidget *edit_groups; GtkWidget *contact_export; GtkWidget *contact_quit; GtkWidget *edit_menu; GtkWidget *menuitem5_menu; GtkWidget *cut; GtkWidget *copy; GtkWidget *paste; GtkWidget *help_menu; GtkWidget *menuitem7_menu; GtkWidget *about1; GtkWidget *main_notebook; GtkWidget *main_hpane; GtkWidget *contacts_vbox; GtkWidget *scrolledwindow2; GtkWidget *contacts_treeview; GtkWidget *search_hbox; GtkWidget *search_entry_hbox; GtkWidget *search_entry; GtkWidget *search_tab_hbox; GtkWidget *symbols_radiobutton; GSList *symbols_radiobutton_group = NULL; GtkWidget *atog_radiobutton; GtkWidget *hton_radiobutton; GtkWidget *otou_radiobutton; GtkWidget *vtoz_radiobutton; GtkWidget *vbox3; GtkWidget *summary_vbox; GtkWidget *preview_header_hbox; GtkWidget *preview_namegroup_vbox; GtkWidget *summary_name_label; GtkWidget *summary_group_label; GtkWidget *photo_image; GtkWidget *scrolledwindow3; GtkWidget *viewport1; GtkWidget *summary_table; GtkWidget *summary_hbuttonbox; GtkWidget *new_button; GtkWidget *edit_button; GtkWidget *delete_button; GtkWidget *vbox4; GtkWidget *scrolledwindow4; GtkWidget *viewport2; GtkWidget *edit_table; GtkWidget *hbuttonbox2; GtkWidget *add_field_button; GtkWidget *remove_field_button; GtkWidget *edit_done_button; GtkWidget *widget; GtkAccelGroup *accel_group; ContactsUI *ui = data->ui; GtkSizeGroup *size_group; #ifdef HAVE_GCONF GConfClient *client; gchar *search; gint width, height; #endif accel_group = gtk_accel_group_new (); main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (main_window), _("Contacts")); gtk_window_set_icon_name (GTK_WINDOW (main_window), "contacts"); gtk_window_set_default_size (GTK_WINDOW (main_window), 320, 240); vbox7 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (main_window), vbox7); main_menubar = gtk_menu_bar_new (); gtk_box_pack_start (GTK_BOX (vbox7), main_menubar, FALSE, FALSE, 0); contacts_menu = gtk_menu_item_new_with_mnemonic (_("C_ontacts")); gtk_container_add (GTK_CONTAINER (main_menubar), contacts_menu); contacts_menu_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (contacts_menu), contacts_menu_menu); new_menuitem = gtk_image_menu_item_new_from_stock ("gtk-new", accel_group); gtk_container_add (GTK_CONTAINER (contacts_menu_menu), new_menuitem); edit_menuitem = gtk_image_menu_item_new_from_stock ("gtk-open", accel_group); gtk_container_add (GTK_CONTAINER (contacts_menu_menu), edit_menuitem); gtk_widget_set_sensitive (edit_menuitem, FALSE); delete_menuitem = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group); gtk_container_add (GTK_CONTAINER (contacts_menu_menu), delete_menuitem); gtk_widget_set_sensitive (delete_menuitem, FALSE); contacts_import = gtk_menu_item_new_with_mnemonic (_("_Import...")); gtk_container_add (GTK_CONTAINER (contacts_menu_menu), contacts_import); widget = gtk_separator_menu_item_new (); gtk_container_add (GTK_CONTAINER (contacts_menu_menu), widget); gtk_widget_set_sensitive (widget, FALSE); contacts_quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group); gtk_container_add (GTK_CONTAINER (contacts_menu_menu), contacts_quit); contact_menu = gtk_menu_item_new_with_mnemonic (_("C_ontact")); gtk_container_add (GTK_CONTAINER (main_menubar), contact_menu); g_object_set (G_OBJECT (contact_menu), "no-show-all", TRUE, NULL); contact_menu_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (contact_menu), contact_menu_menu); contact_delete = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group); gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_delete); edit_groups = gtk_menu_item_new_with_mnemonic (_("_Groups")); gtk_container_add (GTK_CONTAINER (contact_menu_menu), edit_groups); contact_export = gtk_menu_item_new_with_mnemonic (_("_Export")); gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_export); widget = gtk_separator_menu_item_new (); gtk_container_add (GTK_CONTAINER (contact_menu_menu), widget); gtk_widget_set_sensitive (widget, FALSE); contact_quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group); gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_quit); edit_menu = gtk_menu_item_new_with_mnemonic (_("Ed_it")); gtk_container_add (GTK_CONTAINER (main_menubar), edit_menu); menuitem5_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (edit_menu), menuitem5_menu); cut = gtk_image_menu_item_new_from_stock ("gtk-cut", accel_group); gtk_container_add (GTK_CONTAINER (menuitem5_menu), cut); copy = gtk_image_menu_item_new_from_stock ("gtk-copy", accel_group); gtk_container_add (GTK_CONTAINER (menuitem5_menu), copy); paste = gtk_image_menu_item_new_from_stock ("gtk-paste", accel_group); gtk_container_add (GTK_CONTAINER (menuitem5_menu), paste); help_menu = gtk_menu_item_new_with_mnemonic (_("_Help")); gtk_container_add (GTK_CONTAINER (main_menubar), help_menu); menuitem7_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (help_menu), menuitem7_menu); about1 = gtk_image_menu_item_new_from_stock ("gtk-about", accel_group); gtk_container_add (GTK_CONTAINER (menuitem7_menu), about1); main_notebook = gtk_notebook_new (); gtk_box_pack_start (GTK_BOX (vbox7), main_notebook, TRUE, TRUE, 0); GTK_WIDGET_UNSET_FLAGS (main_notebook, GTK_CAN_FOCUS); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (main_notebook), FALSE); gtk_notebook_set_show_border (GTK_NOTEBOOK (main_notebook), FALSE); main_hpane = gtk_hpaned_new (); gtk_container_add (GTK_CONTAINER (main_notebook), main_hpane); contacts_vbox = gtk_vbox_new (FALSE, 6); gtk_paned_pack1 (GTK_PANED (main_hpane), contacts_vbox, FALSE, FALSE); gtk_container_set_border_width (GTK_CONTAINER (contacts_vbox), 6); groups_combobox = gtk_combo_box_new (); GtkListStore *ls = gtk_list_store_new (1, G_TYPE_STRING); GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (groups_combobox), groups_combo_seperator_func, NULL, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (groups_combobox), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (groups_combobox), renderer, "text", 0); gtk_combo_box_set_model (GTK_COMBO_BOX (groups_combobox), GTK_TREE_MODEL(ls)); gtk_box_pack_start (GTK_BOX (contacts_vbox), groups_combobox, FALSE, TRUE, 0); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (groups_combobox), FALSE); scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (contacts_vbox), scrolledwindow2, TRUE, TRUE, 0); GTK_WIDGET_UNSET_FLAGS (scrolledwindow2, GTK_CAN_FOCUS); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN); contacts_treeview = gtk_tree_view_new (); gtk_container_add (GTK_CONTAINER (scrolledwindow2), contacts_treeview); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (contacts_treeview), FALSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (contacts_treeview), FALSE); search_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_end (GTK_BOX (contacts_vbox), search_hbox, FALSE, TRUE, 0); search_entry_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (search_hbox), search_entry_hbox, TRUE, TRUE, 0); search_entry = gtk_entry_new (); gtk_box_pack_end (GTK_BOX (search_entry_hbox), search_entry, TRUE, TRUE, 0); gtk_entry_set_activates_default (GTK_ENTRY (search_entry), TRUE); widget = gtk_label_new_with_mnemonic (_("_Search:")); gtk_box_pack_start (GTK_BOX (search_entry_hbox), widget, FALSE, FALSE, 0); gtk_misc_set_padding (GTK_MISC (widget), 6, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), search_entry); search_tab_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (search_hbox), search_tab_hbox, TRUE, TRUE, 0); g_object_set (G_OBJECT (search_tab_hbox), "no-show-all", TRUE, NULL); symbols_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("0-9#")); gtk_box_pack_start (GTK_BOX (search_tab_hbox), symbols_radiobutton, TRUE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (symbols_radiobutton), symbols_radiobutton_group); symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (symbols_radiobutton)); atog_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("A-G")); gtk_box_pack_start (GTK_BOX (search_tab_hbox), atog_radiobutton, TRUE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (atog_radiobutton), symbols_radiobutton_group); symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (atog_radiobutton)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (atog_radiobutton), TRUE); hton_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("H-N")); gtk_box_pack_start (GTK_BOX (search_tab_hbox), hton_radiobutton, TRUE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (hton_radiobutton), symbols_radiobutton_group); symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (hton_radiobutton)); otou_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("O-U")); gtk_box_pack_start (GTK_BOX (search_tab_hbox), otou_radiobutton, TRUE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (otou_radiobutton), symbols_radiobutton_group); symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (otou_radiobutton)); vtoz_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("V-Z")); gtk_box_pack_start (GTK_BOX (search_tab_hbox), vtoz_radiobutton, TRUE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (vtoz_radiobutton), symbols_radiobutton_group); symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (vtoz_radiobutton)); vbox3 = gtk_vbox_new (FALSE, 6); gtk_paned_pack2 (GTK_PANED (main_hpane), vbox3, TRUE, FALSE); gtk_container_set_border_width (GTK_CONTAINER (vbox3), 6); summary_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox3), summary_vbox, TRUE, TRUE, 0); preview_header_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (summary_vbox), preview_header_hbox, FALSE, TRUE, 0); preview_namegroup_vbox = gtk_vbox_new (FALSE, 0); summary_name_label = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (preview_namegroup_vbox), summary_name_label, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (summary_name_label, GTK_CAN_FOCUS); gtk_label_set_use_markup (GTK_LABEL (summary_name_label), TRUE); gtk_label_set_selectable (GTK_LABEL (summary_name_label), TRUE); gtk_misc_set_alignment (GTK_MISC (summary_name_label), 0, 0.5); gtk_misc_set_padding (GTK_MISC (summary_name_label), 6, 0); gtk_label_set_ellipsize (GTK_LABEL (summary_name_label), PANGO_ELLIPSIZE_END); summary_group_label = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (preview_namegroup_vbox), summary_group_label, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (summary_group_label, GTK_CAN_FOCUS); gtk_label_set_use_markup (GTK_LABEL (summary_group_label), TRUE); gtk_label_set_selectable (GTK_LABEL (summary_group_label), TRUE); gtk_misc_set_alignment (GTK_MISC (summary_group_label), 0, 0.5); gtk_misc_set_padding (GTK_MISC (summary_group_label), 6, 0); gtk_label_set_ellipsize (GTK_LABEL (summary_group_label), PANGO_ELLIPSIZE_END); gtk_box_pack_start (GTK_BOX (preview_header_hbox), preview_namegroup_vbox, TRUE, TRUE, 0); /* load stock_person as the default icon so the image has the correct * size before a contact is loaded */ photo_image = gtk_image_new_from_icon_name ("stock_person", GTK_ICON_SIZE_DIALOG); gtk_box_pack_end (GTK_BOX (preview_header_hbox), photo_image, FALSE, TRUE, 6); gtk_misc_set_padding (GTK_MISC (photo_image), 1, 0); scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (summary_vbox), scrolledwindow3, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); viewport1 = gtk_viewport_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolledwindow3), viewport1); summary_table = gtk_table_new (1, 2, FALSE); gtk_container_add (GTK_CONTAINER (viewport1), summary_table); gtk_table_set_row_spacings (GTK_TABLE (summary_table), 6); gtk_table_set_col_spacings (GTK_TABLE (summary_table), 6); summary_hbuttonbox = gtk_hbutton_box_new (); gtk_box_pack_end (GTK_BOX (vbox3), summary_hbuttonbox, FALSE, FALSE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (summary_hbuttonbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (summary_hbuttonbox), 6); new_button = gtk_button_new_from_stock ("gtk-new"); gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), new_button); GTK_WIDGET_SET_FLAGS (new_button, GTK_CAN_DEFAULT); edit_button = gtk_button_new_from_stock ("gtk-edit"); gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), edit_button); gtk_widget_set_sensitive (edit_button, FALSE); GTK_WIDGET_SET_FLAGS (edit_button, GTK_CAN_DEFAULT); delete_button = gtk_button_new_from_stock ("gtk-delete"); gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), delete_button); gtk_widget_set_sensitive (delete_button, FALSE); GTK_WIDGET_SET_FLAGS (delete_button, GTK_CAN_DEFAULT); gtk_button_set_focus_on_click (GTK_BUTTON (delete_button), FALSE); vbox4 = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (main_notebook), vbox4); gtk_container_set_border_width (GTK_CONTAINER (vbox4), 6); scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox4), scrolledwindow4, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow4), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); viewport2 = gtk_viewport_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolledwindow4), viewport2); edit_table = gtk_table_new (1, 2, FALSE); gtk_container_add (GTK_CONTAINER (viewport2), edit_table); gtk_container_set_border_width (GTK_CONTAINER (edit_table), 6); gtk_table_set_row_spacings (GTK_TABLE (edit_table), 6); hbuttonbox2 = gtk_hbutton_box_new (); gtk_box_pack_start (GTK_BOX (vbox4), hbuttonbox2, FALSE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox2), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (hbuttonbox2), 6); add_field_button = gtk_button_new_with_mnemonic (_("_Add Field")); gtk_container_add (GTK_CONTAINER (hbuttonbox2), add_field_button); GTK_WIDGET_SET_FLAGS (add_field_button, GTK_CAN_DEFAULT); remove_field_button = gtk_button_new_with_mnemonic (_("_Remove Field")); gtk_container_add (GTK_CONTAINER (hbuttonbox2), remove_field_button); GTK_WIDGET_SET_FLAGS (remove_field_button, GTK_CAN_DEFAULT); gtk_button_set_focus_on_click (GTK_BUTTON (remove_field_button), FALSE); edit_done_button = gtk_button_new_from_stock ("gtk-close"); gtk_container_add (GTK_CONTAINER (hbuttonbox2), edit_done_button); GTK_WIDGET_SET_FLAGS (edit_done_button, GTK_CAN_DEFAULT); gtk_widget_grab_focus (contacts_treeview); gtk_widget_grab_default (edit_button); gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group); /* Set up size group for bottom row of buttons and search */ size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL); gtk_size_group_add_widget (size_group, search_hbox); gtk_size_group_add_widget (size_group, summary_hbuttonbox); g_object_unref (size_group); /* connect signals */ g_signal_connect (G_OBJECT (main_window), "delete-event", G_CALLBACK (contacts_main_window_delete_event_cb), data); g_signal_connect ((gpointer) main_window, "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect_swapped ((gpointer) main_window, "set_focus", G_CALLBACK (contacts_edit_set_focus_cb), GTK_OBJECT (remove_field_button)); g_signal_connect ((gpointer) contacts_quit, "activate", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect ((gpointer) contact_quit, "activate", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect_swapped ((gpointer) cut, "activate", G_CALLBACK (contacts_cut_cb), GTK_OBJECT (main_window)); g_signal_connect_swapped ((gpointer) copy, "activate", G_CALLBACK (contacts_copy_cb), GTK_OBJECT (main_window)); g_signal_connect_swapped ((gpointer) paste, "activate", G_CALLBACK (contacts_paste_cb), GTK_OBJECT (main_window)); g_signal_connect_swapped ((gpointer) about1, "activate", G_CALLBACK (contacts_about_cb), main_window); g_signal_connect_swapped ((gpointer) groups_combobox, "changed", G_CALLBACK (contacts_update_treeview), data); g_signal_connect_data ((gpointer) contacts_treeview, "key_press_event", G_CALLBACK (contacts_treeview_search_cb), GTK_OBJECT (search_entry), NULL, G_CONNECT_AFTER | G_CONNECT_SWAPPED); g_signal_connect ((gpointer) search_entry, "changed", G_CALLBACK (contacts_search_changed_cb), data); g_signal_connect ((gpointer) symbols_radiobutton, "clicked", G_CALLBACK (contacts_search_changed_cb), data); g_signal_connect ((gpointer) atog_radiobutton, "clicked", G_CALLBACK (contacts_search_changed_cb), data); g_signal_connect ((gpointer) hton_radiobutton, "clicked", G_CALLBACK (contacts_search_changed_cb), data); g_signal_connect ((gpointer) otou_radiobutton, "clicked", G_CALLBACK (contacts_search_changed_cb), data); g_signal_connect ((gpointer) vtoz_radiobutton, "clicked", G_CALLBACK (contacts_search_changed_cb), data); g_signal_connect ((gpointer) remove_field_button, "clicked", G_CALLBACK (contacts_remove_field_cb), NULL); g_signal_connect (G_OBJECT (new_button), "clicked", G_CALLBACK (contacts_new_cb), data); g_signal_connect (G_OBJECT (new_menuitem), "activate", G_CALLBACK (contacts_new_cb), data); g_signal_connect (G_OBJECT (edit_button), "clicked", G_CALLBACK (contacts_edit_cb), data); g_signal_connect (G_OBJECT (contacts_treeview), "row_activated", G_CALLBACK (contacts_treeview_edit_cb), data); g_signal_connect (G_OBJECT (edit_menuitem), "activate", G_CALLBACK (contacts_edit_cb), data); g_signal_connect (G_OBJECT (delete_button), "clicked", G_CALLBACK (contacts_delete_cb), data); g_signal_connect (G_OBJECT (delete_menuitem), "activate", G_CALLBACK (contacts_delete_cb), data); g_signal_connect (G_OBJECT (contacts_import), "activate", G_CALLBACK (contacts_import_cb), data); g_signal_connect (G_OBJECT (edit_menu), "activate", G_CALLBACK (contacts_edit_menu_activate_cb), data); g_signal_connect (G_OBJECT (groups_combobox), "changed", G_CALLBACK (groups_combobox_changed_cb), data); ui->contact_delete = contact_delete; ui->contact_export = contact_export; ui->contact_menu = contact_menu; ui->contacts_import = contacts_import; ui->contacts_menu = contacts_menu; ui->contacts_treeview = contacts_treeview; ui->new_menuitem = new_menuitem; ui->copy_menuitem = copy; ui->cut_menuitem = cut; ui->delete_menuitem = delete_menuitem; ui->delete_button = delete_button; ui->edit_menuitem = edit_menuitem; ui->edit_button = edit_button; ui->edit_done_button = edit_done_button; ui->edit_groups = edit_groups; ui->edit_menu = edit_menu; ui->edit_table = edit_table; ui->main_menubar = main_menubar; ui->main_notebook = main_notebook; ui->main_window = main_window; ui->new_button = new_button; ui->paste_menuitem = paste; ui->photo_image = photo_image; ui->preview_header_hbox = preview_header_hbox; ui->add_field_button = add_field_button; ui->remove_field_button = remove_field_button; ui->search_entry = search_entry; ui->search_entry_hbox = search_entry_hbox; ui->search_hbox = search_hbox; ui->search_tab_hbox = search_tab_hbox; //ui->groups_combobox = groups_combobox; ui->summary_hbuttonbox = summary_hbuttonbox; ui->summary_name_label = summary_name_label; ui->summary_group_label = summary_group_label; ui->summary_table = summary_table; ui->summary_vbox = summary_vbox; #ifdef HAVE_GCONF client = gconf_client_get_default (); search = gconf_client_get_string (client, GCONF_KEY_SEARCH, NULL); if (!search) { gconf_client_set_string ( client, GCONF_KEY_SEARCH, "entry", NULL); } else { if (strcmp (search, "alphatab") == 0) { gtk_widget_hide (search_entry_hbox); gtk_widget_show (search_tab_hbox); } g_free (search); } gconf_client_add_dir (client, GCONF_PATH, GCONF_CLIENT_PRELOAD_NONE, NULL); gconf_client_notify_add (client, GCONF_KEY_SEARCH, contacts_gconf_search_cb, data, NULL, NULL); width = gconf_client_get_int (client, GCONF_PATH "/width", NULL); height = gconf_client_get_int (client, GCONF_PATH "/height", NULL); gtk_window_set_default_size (GTK_WINDOW (main_window), width, height); #endif }
static void games_scores_dialog_init (GamesScoresDialog *self) { GtkWidget *vbox; GtkWidget *scroll; GtkWidget *listview; GtkTreeViewColumn *column; GtkTreeViewColumn *timecolumn; GtkCellRenderer *renderer; GtkCellRenderer *timerenderer; self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GAMES_TYPE_SCORES_DIALOG, GamesScoresDialogPrivate); self->priv->style = GAMES_SCORES_STYLE_PLAIN_DESCENDING; /* These two hashes are the reverse of each other. As an optimisation * they share the same set of strings (as keys in the first case and * as data in the second). The first hash is responsible for * deallocating the memory for the strings. These two are only * valid as a pair. */ self->priv->categories = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); self->priv->catindices = g_hash_table_new (g_direct_hash, g_direct_equal); self->priv->catcounter = 0; self->priv->hilight = 0; gtk_container_set_border_width (GTK_CONTAINER (self), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), 2); g_signal_connect (G_OBJECT (self), "show", G_CALLBACK (games_scores_dialog_show), NULL); g_signal_connect (G_OBJECT (self), "hide", G_CALLBACK (games_scores_dialog_hide), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), vbox, TRUE, TRUE, 0); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (scroll, 200, 265); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_ETCHED_IN); gtk_box_pack_end (GTK_BOX (vbox), scroll, TRUE, TRUE, 0); self->priv->message = gtk_label_new (""); gtk_label_set_use_markup (GTK_LABEL (self->priv->message), TRUE); gtk_label_set_justify (GTK_LABEL (self->priv->message), GTK_JUSTIFY_CENTER); gtk_box_pack_start (GTK_BOX (vbox), self->priv->message, FALSE, FALSE, 0); self->priv->hdiv = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), self->priv->hdiv, FALSE, FALSE, 0); self->priv->catbar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), self->priv->catbar, FALSE, FALSE, 0); self->priv->label = gtk_label_new (NULL); gtk_label_set_use_markup (GTK_LABEL (self->priv->label), TRUE); gtk_box_pack_start (GTK_BOX (self->priv->catbar), self->priv->label, FALSE, FALSE, 0); self->priv->combo = gtk_combo_box_text_new (); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (self->priv->combo), FALSE); gtk_box_pack_start (GTK_BOX (self->priv->catbar), self->priv->combo, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (self->priv->label), self->priv->combo); g_signal_connect (G_OBJECT (self->priv->combo), "changed", G_CALLBACK (games_scores_dialog_change_category), self); self->priv->list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); listview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->list)); self->priv->treeview = GTK_TREE_VIEW (listview); timerenderer = gtk_cell_renderer_text_new (); timecolumn = gtk_tree_view_column_new_with_attributes (/* Score dialog column header for the date the score was recorded */ _("Date"), timerenderer, "text", 0, NULL); g_object_set (G_OBJECT (timerenderer), "xalign", 1.0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (listview), GTK_TREE_VIEW_COLUMN (timecolumn)); self->priv->timecolumn = timecolumn; renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", 1, NULL); g_object_set (G_OBJECT (renderer), "xalign", 1.0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (listview), GTK_TREE_VIEW_COLUMN (column)); self->priv->column = column; gtk_container_add (GTK_CONTAINER (scroll), listview); games_scores_dialog_set_buttons (self, GAMES_SCORES_CLOSE_BUTTON); gtk_window_set_destroy_with_parent (GTK_WINDOW (self), TRUE); gtk_widget_grab_focus (self->priv->combo); gtk_widget_show_all (vbox); gtk_widget_hide (self->priv->hdiv); gtk_widget_hide (self->priv->message); }