void l_usldoks(short ds,short ms,short gs, //Дата начала просмотра GtkWidget *wpredok) { usldoks_data data; char bros[512]; GdkColor color; data.ds=data.dn=ds; data.ms=data.mn=ms; data.gs=data.gn=gs; data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); //gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1); //gdk_color_parse("black",&color); //gtk_widget_modify_bg(data.window,GTK_STATE_NORMAL,&color); sprintf(bros,"%s %s",name_system,gettext("Список документов")); gtk_window_set_title (GTK_WINDOW (data.window),bros); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(usldoks_key_press),&data); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift); GtkWidget *hbox = gtk_hbox_new (FALSE, 1); gtk_container_add (GTK_CONTAINER (data.window), hbox); GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1); GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1); gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); gtk_widget_show(hbox); data.label_kolstr=gtk_label_new (gettext("Список документов")); gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0); gtk_widget_show(vbox1); gtk_widget_show(vbox2); data.label_poisk=gtk_label_new (""); /************ PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno()); gtk_widget_modify_font(GTK_WIDGET(data.label_ost),font_pango); pango_font_description_free(font_pango); ***************/ gdk_color_parse("red",&color); gtk_widget_modify_fg(data.label_poisk,GTK_STATE_NORMAL,&color); gtk_box_pack_start (GTK_BOX (vbox2),data.label_poisk,FALSE, FALSE, 0); data.sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_usize(GTK_WIDGET(data.sw),-1,200); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); //gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0); //Кнопки GtkTooltips *tooltips[KOL_F_KL]; sprintf(bros,"F2 ?"); data.knopka[FK2]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Включение/выключение показа только не подтверждённых документов"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_widget_show(data.knopka[FK2]); sprintf(bros,"SF2 %s",gettext("Метка")); data.knopka[SFK2]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[SFK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Снятие метки неподтверждённого документа"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2); gtk_widget_show(data.knopka[SFK2]); sprintf(bros,"F3 *"); data.knopka[FK3]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Включение/выключение показа документов без проводок"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3); gtk_widget_show(data.knopka[FK3]); sprintf(bros,"SF3 %s",gettext("Метка")); data.knopka[SFK3]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK3],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[SFK3]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[SFK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[SFK3],data.knopka[SFK3],gettext("Снятие метки документа без проводок"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK3]),(gpointer)SFK3); gtk_widget_show(data.knopka[SFK3]); sprintf(bros,"F4 %s",gettext("Поиск")); data.knopka[FK4]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Поиск нужных записей"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_widget_show(data.knopka[FK4]); sprintf(bros,"F5 %s",gettext("Просмотр")); data.knopka[FK5]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK5]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Просмотр выбранного документа"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5); gtk_widget_show(data.knopka[FK5]); sprintf(bros,"F6 %s",gettext("Экспорт")); data.knopka[FK6]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK6],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK6]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK6]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK6],data.knopka[FK6],gettext("Экспорт кассовых ордеров в подсистему \"Учёт кассовых ордеров\""),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK6]),(gpointer)FK6); gtk_widget_show(data.knopka[FK6]); sprintf(bros,"F9 %s",gettext("Оплата")); data.knopka[FK9]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK9],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK9]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK9]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK9],data.knopka[FK9],gettext("Переключение режимов просмотра (только оплаченыые, только не оплаченные, все)"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK9]),(gpointer)FK9); gtk_widget_show(data.knopka[FK9]); sprintf(bros,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_widget_show(data.knopka[FK10]); gtk_widget_realize(data.window); gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR)); gtk_widget_grab_focus(data.knopka[FK10]); usldoks_create_list(&data); gtk_widget_show(data.window); //if(metka == 0) gtk_window_maximize(GTK_WINDOW(data.window)); //gtk_window_fullscreen(GTK_WINDOW(data.window)); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); }
GtkWidget * CChoosebook::create_list() { GtkWidget *tree_view; GtkWidget *sw; GtkListStore *model; model = gtk_list_store_new (8,G_TYPE_STRING,G_TYPE_INT,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE); list_view= tree_view; g_object_unref (model); GtkCellRenderer *renderer; GtkTreeViewColumn *column; renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Book Name"), renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW(tree_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Count"), renderer, "text", 1, NULL); gtk_tree_view_column_set_sort_column_id (column, 1); gtk_tree_view_append_column (GTK_TREE_VIEW(tree_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Author"), renderer, "text", 2, NULL); gtk_tree_view_column_set_sort_column_id (column, 2); gtk_tree_view_append_column (GTK_TREE_VIEW(tree_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Website"), renderer, "text", 3, NULL); gtk_tree_view_column_set_sort_column_id (column, 3); gtk_tree_view_append_column (GTK_TREE_VIEW(tree_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Email"), renderer, "text", 4, NULL); gtk_tree_view_column_set_sort_column_id (column, 4); gtk_tree_view_append_column (GTK_TREE_VIEW(tree_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("About"), renderer, "text", 5, NULL); gtk_tree_view_column_set_sort_column_id (column, 5); gtk_tree_view_append_column (GTK_TREE_VIEW(tree_view), column); GtkTreeSelection *selection; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (on_choosebook_list_selection_changed), this); g_signal_connect (G_OBJECT (tree_view), "button_press_event", G_CALLBACK (on_choosebook_list_button_press), this); sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request(sw,Skin->choosebook.book_list.w,Skin->choosebook.book_list.h); 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_container_add (GTK_CONTAINER (sw), tree_view); gtk_widget_show(tree_view); return sw; }
static void qq_chatwidget_init(QQChatWidget *widget) { QQChatWidgetPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE(widget , qq_chatwidget_get_type() , QQChatWidgetPriv); GtkWidget *scrolled_win; gchar buf[100]; // message text view priv -> message_textview = qq_chat_textview_new(); scrolled_win= gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_win) , GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(scrolled_win), priv -> message_textview); gtk_box_pack_start(GTK_BOX(widget), scrolled_win, TRUE, TRUE, 0); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(priv -> message_textview) , FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(priv -> message_textview) , GTK_WRAP_CHAR); gtk_text_view_set_editable(GTK_TEXT_VIEW(priv -> message_textview) , FALSE); // font tools priv -> font_tool_box = gtk_hbox_new(FALSE, 5); g_object_ref(priv -> font_tool_box); priv -> font_cb = gtk_combo_box_text_new(); gint i; for(i = 0; font_names[i] != NULL; ++i){ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv -> font_cb) , font_names[i]); } gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> font_cb , FALSE, FALSE, 0); priv -> size_cb = gtk_combo_box_text_new(); for(i = 8; i < 23; ++i){ g_snprintf(buf, 10, "%d", i); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv -> size_cb) , buf); } gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> size_cb , FALSE, FALSE, 0); priv -> bold_btn = qq_toggle_button_new_with_stock(GTK_STOCK_BOLD); priv -> italic_btn = qq_toggle_button_new_with_stock(GTK_STOCK_ITALIC); priv -> underline_btn = qq_toggle_button_new_with_stock( GTK_STOCK_UNDERLINE); gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> bold_btn , FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> italic_btn , FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> underline_btn , FALSE, FALSE, 0); priv -> color_btn = gtk_color_button_new(); gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> color_btn , FALSE, FALSE, 0); gtk_widget_show_all(priv -> font_tool_box); g_signal_connect(G_OBJECT(priv -> font_cb), "changed" , G_CALLBACK(qq_chat_widget_font_changed), widget); g_signal_connect(G_OBJECT(priv -> size_cb), "changed" , G_CALLBACK(qq_chat_widget_font_changed), widget); g_signal_connect(G_OBJECT(priv -> bold_btn), "toggled" , G_CALLBACK(qq_chat_widget_font_changed), widget); g_signal_connect(G_OBJECT(priv -> italic_btn), "toggled" , G_CALLBACK(qq_chat_widget_font_changed), widget); g_signal_connect(G_OBJECT(priv -> underline_btn), "toggled" , G_CALLBACK(qq_chat_widget_font_changed), widget); g_signal_connect(G_OBJECT(priv -> color_btn), "color-set" , G_CALLBACK(qq_chat_widget_font_changed), widget); // tool bar priv -> tool_bar = gtk_toolbar_new(); GtkWidget *img = NULL; img = gtk_image_new_from_file(IMGDIR"/selectfont.png"); priv -> font_item = gtk_toggle_tool_button_new(); g_signal_connect(G_OBJECT(priv -> font_item), "toggled" , G_CALLBACK(qq_chat_view_font_button_clicked) , widget); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(priv -> font_item), img); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> font_item, -1); img = gtk_image_new_from_file(IMGDIR"/selectface.png"); priv -> face_item = gtk_tool_button_new(img, NULL); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> face_item, -1); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar) , gtk_separator_tool_item_new() , -1); g_signal_connect(G_OBJECT(priv -> face_item), "clicked", G_CALLBACK(face_tool_button_clicked), widget); img = gtk_image_new_from_file(IMGDIR"/sendfile.png"); priv -> sendfile_item = gtk_tool_button_new(img, NULL); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> sendfile_item, -1); img = gtk_image_new_from_file(IMGDIR"/sendpic.png"); priv -> sendpic_item = gtk_tool_button_new(img, NULL); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> sendpic_item, -1); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar) , gtk_separator_tool_item_new() , -1); img = gtk_image_new_from_file(IMGDIR"/clearscreen.png"); priv -> clear_item = gtk_tool_button_new(img, NULL); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> clear_item, -1); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar) , gtk_separator_tool_item_new() , -1); g_signal_connect(G_OBJECT(priv -> clear_item), "clicked", G_CALLBACK(clear_button_clicked), widget); img = gtk_image_new_from_file(IMGDIR"/showhistory.png"); priv -> history_item = gtk_tool_button_new(img, NULL); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> history_item, -1); gtk_box_pack_start(GTK_BOX(widget), priv -> tool_bar , FALSE, FALSE, 0); // input text view priv -> input_textview = qq_chat_textview_new(); gtk_text_view_set_indent(GTK_TEXT_VIEW(priv -> input_textview), 1); scrolled_win= gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_win) , GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(scrolled_win), priv -> input_textview); gtk_box_pack_start(GTK_BOX(widget), scrolled_win, FALSE, FALSE, 0); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(priv -> input_textview) , GTK_WRAP_CHAR); gtk_combo_box_set_active(GTK_COMBO_BOX(priv -> font_cb), 1); gtk_combo_box_set_active(GTK_COMBO_BOX(priv -> size_cb), 3); gtk_widget_grab_focus(priv -> input_textview); priv -> facepopupwindow = qq_face_popup_window_new(); g_signal_connect(G_OBJECT(priv -> facepopupwindow), "face-clicked" , G_CALLBACK(qq_chatwidget_face_clicked) , priv); }
static void xfsm_chooser_init (XfsmChooser *chooser) { GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkListStore *model; GtkWidget *button; GtkWidget *swin; GtkWidget *dbox; dbox = GTK_DIALOG (chooser)->vbox; gtk_dialog_set_has_separator (GTK_DIALOG (chooser), FALSE); g_signal_connect_after (G_OBJECT (chooser), "realize", G_CALLBACK (xfsm_chooser_realized), chooser); /* scrolled window */ swin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin), GTK_SHADOW_ETCHED_IN); gtk_box_pack_start (GTK_BOX (dbox), swin, TRUE, TRUE, 0); gtk_widget_show (swin); /* tree view */ model = gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); chooser->tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(model)); g_object_unref (G_OBJECT (model)); gtk_widget_set_tooltip_text (chooser->tree, _("Choose the session you want to restore. " "You can simply double-click the session " "name to restore it.")); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (chooser->tree), FALSE); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", PREVIEW_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "markup", TITLE_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (chooser->tree), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (chooser->tree)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (chooser->tree), "row-activated", G_CALLBACK (xfsm_chooser_row_activated), chooser); gtk_container_add (GTK_CONTAINER (swin), chooser->tree); gtk_widget_set_size_request (chooser->tree, -1, 150); gtk_widget_show (chooser->tree); /* "Logout" button */ button = xfce_gtk_button_new_mixed (GTK_STOCK_QUIT, _("Log out")); gtk_widget_set_tooltip_text (button, _("Cancel the login attempt and return to " "the login screen.")); gtk_dialog_add_action_widget (GTK_DIALOG (chooser), button, GTK_RESPONSE_CANCEL); gtk_widget_show (button); /* "New" button */ button = xfce_gtk_button_new_mixed (GTK_STOCK_NEW, _("New session")); gtk_widget_set_tooltip_text (button, _("Create a new session.")); gtk_dialog_add_action_widget (GTK_DIALOG (chooser), button, XFSM_RESPONSE_NEW); gtk_widget_show (button); }
gboolean edit_bookmarks( GtkWindow* parent ) { GList* l; GtkWidget* dlg; GtkWidget* btn_box; GtkWidget* add_btn; GtkWidget* delete_btn; GtkWidget* scroll; GtkWidget* list_view; GtkListStore* list; GtkTreeViewColumn* col; GtkTreeIter it; GtkTreeSelection* sel; gchar *name, *path, *item; gboolean ret = FALSE; PtkBookmarks* bookmarks; GtkCellRenderer *renderer, *icon_renderer; GdkPixbuf* icon; dlg = gtk_dialog_new_with_buttons ( _("Edit Bookmarks"), parent, GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL ); gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 ); list = gtk_list_store_new( NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING ); icon = gtk_icon_theme_load_icon( gtk_icon_theme_get_default(), "gnome-fs-directory", 20, 0, NULL ); bookmarks = ptk_bookmarks_get(); for( l = bookmarks->list; l; l = l->next ) { gtk_list_store_append( list, &it ); gtk_list_store_set( list, &it, COL_ICON, icon, COL_NAME, l->data, COL_DIRPATH, ptk_bookmarks_item_get_path((char*)l->data), -1); } if( icon ) g_object_unref( icon ); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_IN); list_view = gtk_tree_view_new_with_model( GTK_TREE_MODEL(list) ); g_object_set_data( G_OBJECT(dlg), "list_view", list_view ); sel = gtk_tree_view_get_selection( GTK_TREE_VIEW(list_view) ); gtk_tree_selection_set_mode( sel, GTK_SELECTION_BROWSE ); if( gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(list), &it ) ) { gtk_tree_selection_select_iter( sel, &it ); } icon_renderer = gtk_cell_renderer_pixbuf_new(); renderer = gtk_cell_renderer_text_new(); g_object_set( G_OBJECT(renderer), "editable", TRUE, NULL ); g_signal_connect( renderer, "edited", G_CALLBACK(on_name_edited), list ); col = gtk_tree_view_column_new_with_attributes(NULL, icon_renderer, "pixbuf", COL_ICON, NULL ); gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col ); col = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", COL_NAME, NULL); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_fixed_width(col, 160); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col ); renderer = gtk_cell_renderer_text_new(); g_object_set( G_OBJECT(renderer), "editable", TRUE, NULL ); g_signal_connect( renderer, "edited", G_CALLBACK(on_path_edited), list ); col = gtk_tree_view_column_new_with_attributes(_("Path"), renderer, "text", COL_DIRPATH, NULL); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col ); gtk_tree_view_set_reorderable ( GTK_TREE_VIEW(list_view), TRUE ); gtk_container_add( GTK_CONTAINER(scroll), list_view); btn_box = gtk_hbutton_box_new(); gtk_button_box_set_layout ( GTK_BUTTON_BOX(btn_box), GTK_BUTTONBOX_START ); add_btn = gtk_button_new_from_stock ( GTK_STOCK_ADD ); g_signal_connect( add_btn, "clicked", G_CALLBACK(on_add), dlg ); gtk_box_pack_start ( GTK_BOX(btn_box), add_btn, TRUE, TRUE, 0 ); delete_btn = gtk_button_new_from_stock ( GTK_STOCK_DELETE ); g_signal_connect( delete_btn, "clicked", G_CALLBACK(on_delete), dlg ); gtk_box_pack_start ( GTK_BOX(btn_box), delete_btn, TRUE, TRUE, 0 ); gtk_box_pack_start( GTK_BOX(gtk_dialog_get_content_area ( GTK_DIALOG(dlg) )), btn_box, FALSE, FALSE, 4 ); gtk_box_pack_start( GTK_BOX(gtk_dialog_get_content_area ( GTK_DIALOG(dlg) )), scroll, TRUE, TRUE, 0 ); gtk_box_pack_start( GTK_BOX(gtk_dialog_get_content_area ( GTK_DIALOG(dlg) )), gtk_label_new(_("Use drag & drop to sort the items")), FALSE, FALSE, 4 ); gtk_window_set_default_size ( GTK_WINDOW(dlg), 480, 400 ); gtk_widget_show_all( dlg ); gtk_widget_grab_focus( list_view ); pcmanfm_ref(); if( gtk_dialog_run( GTK_DIALOG(dlg) ) == GTK_RESPONSE_OK ) { l = NULL; if( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(list), &it ) ) { do { gtk_tree_model_get( GTK_TREE_MODEL(list), &it, COL_NAME, &name, COL_DIRPATH, &path, -1 ); if( ! name ) name = g_path_get_basename( path ); item = ptk_bookmarks_item_new( name, strlen(name), path ? path : "", path ? strlen(path) : 0 ); l = g_list_append( l, item ); g_free(name); g_free(path); } while( gtk_tree_model_iter_next( GTK_TREE_MODEL(list), &it) ); } ptk_bookmarks_set( l ); ret = TRUE; } ptk_bookmarks_unref(); gtk_widget_destroy( dlg ); pcmanfm_unref(); return ret; }
GtkWidget * text_create_widget (GtkWidget * dlg) { GtkWidget *w; w = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); text_view = gtk_text_view_new (); gtk_widget_set_name (text_view, "yad-text-widget"); text_buffer = gtk_text_buffer_new (NULL); gtk_text_view_set_buffer (GTK_TEXT_VIEW (text_view), text_buffer); gtk_text_view_set_justification (GTK_TEXT_VIEW (text_view), options.text_data.justify); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (text_view), options.text_data.margins); gtk_text_view_set_right_margin (GTK_TEXT_VIEW (text_view), options.text_data.margins); gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), options.common_data.editable); if (!options.common_data.editable) gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (text_view), FALSE); if (options.text_data.wrap) gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD_CHAR); if (options.text_data.fore) { #if GTK_CHECK_VERSION(3,0,0) GdkRGBA clr; if (gdk_rgba_parse (&clr, options.text_data.fore)) gtk_widget_override_color (text_view, GTK_STATE_FLAG_NORMAL, &clr); #else GdkColor clr; if (gdk_color_parse (options.text_data.fore, &clr)) gtk_widget_modify_text (text_view, GTK_STATE_NORMAL, &clr); #endif } if (options.text_data.back) { #if GTK_CHECK_VERSION(3,0,0) GdkRGBA clr; if (gdk_rgba_parse (&clr, options.text_data.fore)) gtk_widget_override_background_color (text_view, GTK_STATE_FLAG_NORMAL, &clr); #else GdkColor clr; if (gdk_color_parse (options.text_data.back, &clr)) gtk_widget_modify_base (text_view, GTK_STATE_NORMAL, &clr); #endif } if (options.common_data.font) { PangoFontDescription *fd = pango_font_description_from_string (options.common_data.font); #if GTK_CHECK_VERSION(3,0,0) gtk_widget_override_font (text_view, fd); #else gtk_widget_modify_font (text_view, fd); #endif pango_font_description_free (fd); } /* Add submit on ctrl+enter */ g_signal_connect (text_view, "key-press-event", G_CALLBACK (key_press_cb), dlg); /* Initialize linkifying */ if (options.text_data.uri) { GRegex *regex; regex = g_regex_new (YAD_URL_REGEX, G_REGEX_CASELESS | G_REGEX_OPTIMIZE | G_REGEX_EXTENDED, G_REGEX_MATCH_NOTEMPTY, NULL); /* Create text tag for URI */ tag = gtk_text_buffer_create_tag (text_buffer, NULL, "foreground", "blue", "underline", PANGO_UNDERLINE_SINGLE, NULL); g_object_set_data (G_OBJECT (tag), "is_link", GINT_TO_POINTER (1)); g_signal_connect (G_OBJECT (tag), "event", G_CALLBACK (tag_event_cb), NULL); /* Create cursors */ hand = gdk_cursor_new (GDK_HAND2); normal= gdk_cursor_new (GDK_XTERM); g_signal_connect (G_OBJECT (text_view), "motion-notify-event", G_CALLBACK (motion_cb), NULL); g_signal_connect_after (G_OBJECT (text_buffer), "changed", G_CALLBACK (linkify_cb), regex); } gtk_container_add (GTK_CONTAINER (w), text_view); if (options.common_data.uri) fill_buffer_from_file (); else fill_buffer_from_stdin (); return w; }
/* * plugin management */ void gtkui_plugin_mgmt(GSimpleAction *action, GVariant *value, gpointer data) { GtkWidget *scrolled, *vbox; GtkCellRenderer *renderer; GtkTreeViewColumn *column; (void) action; (void) value; (void) data; DEBUG_MSG("gtk_plugin_mgmt"); /* if the object already exist, set the focus to it */ if (plugins_window) { if(GTK_IS_WINDOW (plugins_window)) gtk_window_present(GTK_WINDOW (plugins_window)); else gtkui_page_present(plugins_window); return; } plugins_window = gtkui_page_new("Plugins", >kui_plug_destroy, >kui_plugins_detach); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER (plugins_window), vbox); gtk_widget_show(vbox); /* list */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); treeview = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER (scrolled), treeview); gtk_widget_show(treeview); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (treeview), "row_activated", G_CALLBACK (gtkui_select_plugin), NULL); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (" ", renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Name", renderer, "text", 1, NULL); gtk_tree_view_column_set_sort_column_id (column, 1); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Version", renderer, "text", 2, NULL); gtk_tree_view_column_set_sort_column_id (column, 2); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Info", renderer, "text", 3, NULL); gtk_tree_view_column_set_sort_column_id (column, 3); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); /* create the array for the list widget */ /* or refreshes it if it exists */ gtkui_create_plug_array(); gtk_tree_view_set_model(GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (ls_plugins)); g_signal_connect(G_OBJECT(treeview), "button-press-event", G_CALLBACK(gtkui_plugin_context), NULL); gtk_widget_show(plugins_window); }
/* static void cb_scroll_event(GtkAdjustment *adj, GtkWidget *view) { gtk_text_view_place_cursor_onscreen(GTK_TEXT_VIEW(view)); } */ MainWin *create_main_window(void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *menubar; GtkWidget *sw; GtkWidget *view; // gint size; // GtkAdjustment *hadj, *vadj; MainWin *mw = g_malloc(sizeof(MainWin)); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); // gtk_window_set_title(GTK_WINDOW(window), PACKAGE_NAME); gtk_widget_set_name(window, PACKAGE_NAME); /* #if GTK_CHECK_VERSION(2, 4, 0) // size = gtk_icon_size_lookup(GTK_ICON_SIZE_LARGE_TOOLBAR, &size, NULL); icon = gtk_icon_theme_load_icon( gtk_icon_theme_get_default(), PACKAGE, 16, // size 0, // flags NULL); gtk_window_set_default_icon(icon); */ #if GTK_CHECK_VERSION(2, 6, 0) gtk_window_set_default_icon_name(PACKAGE); #else GdkPixbuf *icon = gdk_pixbuf_new_from_file( ICONDIR G_DIR_SEPARATOR_S PACKAGE ".png", NULL); gtk_window_set_icon(GTK_WINDOW(window), icon); if (icon) g_object_unref(icon); #endif g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(on_file_quit), NULL); g_signal_connect_after(G_OBJECT(window), "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); menubar = create_menu_bar(window); gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); view = create_text_view(); gtk_container_add(GTK_CONTAINER(sw), view); /* hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(sw)); vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(sw)); g_signal_connect_after(G_OBJECT(hadj), "value-changed", G_CALLBACK(cb_scroll_event), view); g_signal_connect_after(G_OBJECT(vadj), "value-changed", G_CALLBACK(cb_scroll_event), view); */ mw->window = window; mw->menubar = menubar; mw->view = view; mw->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view)); return mw; }
NewStylesheetDialog::NewStylesheetDialog(const ustring & worksheet, GtkWindow *transient_parent) { myworksheet = worksheet; Shortcuts shortcuts(0); newstylesheetdialog = gtk_dialog_new(); gtk_window_set_transient_for(GTK_WINDOW(newstylesheetdialog), transient_parent); if (!worksheet.empty()) { gtk_window_set_title(GTK_WINDOW(newstylesheetdialog), _("New style")); } else { gtk_window_set_title(GTK_WINDOW(newstylesheetdialog), _("New stylesheet")); } //gtk_window_set_position(GTK_WINDOW(newstylesheetdialog), GTK_WIN_POS_CENTER_ON_PARENT); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (newstylesheetdialog)); gtk_widget_show(dialog_vbox1); hbox2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox2); gtk_box_pack_start(GTK_BOX(dialog_vbox1), hbox2, TRUE, TRUE, 0); vbox1 = gtk_vbox_new(FALSE, 4); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(hbox2), vbox1, TRUE, TRUE, 0); if (myworksheet.empty()) { hbox1 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, TRUE, TRUE, 0); label1 = gtk_label_new(_("Name")); gtk_widget_show(label1); gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0); shortcuts.label(label1); entry1 = gtk_entry_new(); gtk_widget_show(entry1); gtk_box_pack_start(GTK_BOX(hbox1), entry1, TRUE, TRUE, 0); } ustring info; if (!myworksheet.empty()) info = _("Select one or more styles from the list"); label_info = gtk_label_new(info.c_str()); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(vbox1), label_info, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(label_info), 0, 0.5); GSList *radiobutton_basic_group = NULL; radiobutton_basic = gtk_radio_button_new_with_mnemonic(NULL, _("Basic")); gtk_widget_show(radiobutton_basic); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_basic, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_basic), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_basic)); shortcuts.button(radiobutton_basic); radiobutton_paragraph = gtk_radio_button_new_with_mnemonic(NULL, _("Basic, paragraph")); gtk_widget_show(radiobutton_paragraph); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_paragraph, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_paragraph), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_paragraph)); shortcuts.button(radiobutton_paragraph); radiobutton_word_note = gtk_radio_button_new_with_mnemonic(NULL, _("Basic, paragraph, word, note")); gtk_widget_show(radiobutton_word_note); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_word_note, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_word_note), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_word_note)); shortcuts.button(radiobutton_word_note); radiobutton_sbp = gtk_radio_button_new_with_mnemonic(NULL, _("SIL best practice")); gtk_widget_show(radiobutton_sbp); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_sbp, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_sbp), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_sbp)); shortcuts.button(radiobutton_sbp); radiobutton_full = gtk_radio_button_new_with_mnemonic(NULL, _("Full")); gtk_widget_show(radiobutton_full); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_full, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_full), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_full)); shortcuts.button(radiobutton_full); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_full), true); if (!myworksheet.empty()) { expander1 = gtk_expander_new(NULL); gtk_widget_show(expander1); gtk_box_pack_start(GTK_BOX(vbox1), expander1, TRUE, TRUE, 0); label2 = gtk_label_new(_("Add non-standard style")); gtk_widget_show(label2); gtk_expander_set_label_widget(GTK_EXPANDER(expander1), label2); shortcuts.label(label2); hbox1 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox1); gtk_container_add(GTK_CONTAINER(expander1), hbox1); label1 = gtk_label_new(_("Name")); gtk_widget_show(label1); gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0); shortcuts.label(label1); entry1 = gtk_entry_new(); gtk_widget_show(entry1); gtk_box_pack_start(GTK_BOX(hbox1), entry1, TRUE, TRUE, 0); scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow1); gtk_box_pack_start(GTK_BOX(hbox2), 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_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview1), FALSE); store1 = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview1), GTK_TREE_MODEL(store1)); g_object_unref(store1); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); column1 = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview1), column1); select1 = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview1)); gtk_tree_selection_set_mode(select1, GTK_SELECTION_SINGLE); } dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(newstylesheetdialog)); gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); new InDialogHelp(newstylesheetdialog, NULL, &shortcuts, "file/styles/stylesheet/new"); cancelbutton1 = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton1); gtk_dialog_add_action_widget(GTK_DIALOG(newstylesheetdialog), cancelbutton1, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true); okbutton = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton); gtk_dialog_add_action_widget(GTK_DIALOG(newstylesheetdialog), okbutton, GTK_RESPONSE_OK); gtk_widget_set_can_default (GTK_WIDGET (okbutton), true); shortcuts.stockbutton(cancelbutton1); shortcuts.stockbutton(okbutton); shortcuts.process(); g_signal_connect((gpointer) entry1, "changed", G_CALLBACK(on_entry_changed), gpointer(this)); g_signal_connect((gpointer) radiobutton_basic, "toggled", G_CALLBACK(on_radiobutton_basic_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_paragraph, "toggled", G_CALLBACK(on_radiobutton_paragraph_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_word_note, "toggled", G_CALLBACK(on_radiobutton_word_note_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_sbp, "toggled", G_CALLBACK(on_radiobutton_sbp_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_full, "toggled", G_CALLBACK(on_radiobutton_full_toggled), gpointer(this)); g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this)); gtk_widget_grab_focus(entry1); gtk_widget_grab_default(okbutton); gtk_label_set_mnemonic_widget(GTK_LABEL(label1), entry1); on_entry(); on_radiobutton(); }
static void create_bus_layout_dialog (bus_layout_D *dialog) { GtkWidget *tblMain = NULL, *frm = NULL, *img = NULL, *tbl = NULL, *align = 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) ; dialog->bbox = gtk_vbutton_box_new () ; gtk_widget_show (dialog->bbox) ; gtk_table_attach (GTK_TABLE (tbl), dialog->bbox, 0, 1, 0, 1, (GtkAttachOptions)(0), (GtkAttachOptions)(0), 2, 2) ; gtk_container_set_border_width (GTK_CONTAINER (dialog->bbox), 2) ; gtk_button_box_set_spacing (GTK_BUTTON_BOX (dialog->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 (dialog->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 (dialog->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 (dialog->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 (dialog->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 (dialog->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 (dialog->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 = gtk_entry_new () ; gtk_widget_show (dialog->txtBusName) ; gtk_table_attach (GTK_TABLE (tbl), dialog->txtBusName, 0, 1, 2, 3, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 2, 2) ; dialog->lblWarning = gtk_label_new (NULL) ; gtk_table_attach (GTK_TABLE (tbl), dialog->lblWarning, 0, 1, 3, 4, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 2, 2) ; gtk_label_set_markup (GTK_LABEL (dialog->lblWarning), _("<span foreground=\"red\">Warning:</span> The bus must have a name.")) ; gtk_label_set_justify (GTK_LABEL (dialog->lblWarning), GTK_JUSTIFY_LEFT) ; gtk_misc_set_alignment (GTK_MISC (dialog->lblWarning), 0.0, 0.0) ; gtk_label_set_line_wrap (GTK_LABEL (dialog->lblWarning), TRUE) ; gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL) ; dialog->btnOK = 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) ; }
int main(int argc, char *argv[]) { GtkWidget *main_window, *scroll; GtkWidget *treeview; GtkTreeViewColumn *column; GtkCellRenderer *name_renderer, *size_renderer; GtkTreeStore *store; GtkTreeIter categories[14]; GValue value = { 0, }; gint offset; uint32 res_counts[14]; uint32 res_sizes[14]; int i; Common::File in; uint32 index_pos; uint32 pos, len; gtk_init(&argc, &argv); if (argc != 2) { printf("Usage: %s filename\n", argv[0]); return EXIT_FAILURE; } in.open(argv[1], "rb"); if (!in.isOpen()) { printf("Couldn't open %s for reading\n", argv[1]); return EXIT_FAILURE; } /* Create the main window, scrollable in both directions */ main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(main_window), "CLUster Explorer"); gtk_window_set_default_size(GTK_WINDOW(main_window), 400, 400); g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(main_window_destroy_cb), NULL); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* Create the tree view */ for (i = 0; i < ARRAYSIZE(res_counts); i++) { res_counts[i] = 0; res_sizes[i] = 0; } store = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT); gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), compare_items, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); index_pos = in.readUint32LE(); in.seek(index_pos, SEEK_SET); for (;;) { GtkTreeIter iter; byte type; gchar *utf8_name; gchar name[34]; gchar *size; try { pos = in.readUint32LE(); len = in.readUint32LE(); } catch (...) { break; } size = make_size(len); index_pos = in.pos(); in.seek(pos, SEEK_SET); type = in.readByte(); in.readByte(); /* compType */ in.readUint32LE(); /* compSize */ in.readUint32LE(); /* decompSize */ in.read_noThrow(name, sizeof(name)); /* * We need to convert from Latin-1 to UTF-8. Otherwise the text * "CAFÉ" won't be displayed properly. */ utf8_name = g_convert(name, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL); if (!res_counts[type]) { gtk_tree_store_append(store, &categories[type], NULL); gtk_tree_store_set(store, &categories[type], NAME_COLUMN, getType(type), SIZE_COLUMN, "", TYPE_COLUMN, -1, POSITION_COLUMN, -1, LENGTH_COLUMN, -1, -1); } res_counts[type]++; res_sizes[type] += len; gtk_tree_store_append(store, &iter, &categories[type]); gtk_tree_store_set(store, &iter, NAME_COLUMN, utf8_name, SIZE_COLUMN, size, TYPE_COLUMN, type, POSITION_COLUMN, pos, LENGTH_COLUMN, len); in.seek(index_pos, SEEK_SET); } in.close(); for (i = 0; i < ARRAYSIZE(res_counts); i++) { if (res_counts[i]) { gchar size[80]; sprintf(size, "%s [%d]", make_size(res_sizes[i]), res_counts[i]); gtk_tree_store_set(store, &categories[i], SIZE_COLUMN, size, -1); } } treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE); g_signal_connect(G_OBJECT(treeview), "button-press-event", G_CALLBACK(tree_view_button_cb), argv[1]); /* The view now holds a reference. We can get rid of our own. */ g_object_unref(G_OBJECT(store)); name_renderer = gtk_cell_renderer_text_new(); size_renderer = gtk_cell_renderer_text_new(); g_value_init(&value, G_TYPE_FLOAT); g_value_set_float(&value, 1.0); g_object_set_property(G_OBJECT(size_renderer), "xalign", &value); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(treeview), -1, "Name", name_renderer, "text", NAME_COLUMN, NULL); offset = gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(treeview), -1, "Size", size_renderer, "text", SIZE_COLUMN, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), offset - 1); gtk_tree_view_column_set_alignment(column, 1.0); gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(treeview)); gtk_container_add(GTK_CONTAINER(main_window), scroll); gtk_widget_show_all(GTK_WIDGET(main_window)); gtk_main(); return EXIT_SUCCESS; }
static GtkWidget * servlist_open_edit (GtkWidget *parent, ircnet *net) { GtkWidget *editwindow; GtkWidget *vbox5; GtkWidget *table3; GtkWidget *label17; GtkWidget *label16; GtkWidget *label21; GtkWidget *label22; GtkWidget *label34; GtkWidget *comboboxentry_charset; GtkWidget *hbox1; GtkWidget *scrolledwindow2; GtkWidget *treeview_servers; GtkWidget *vbuttonbox1; GtkWidget *buttonadd; GtkWidget *buttonremove; GtkWidget *buttonedit; GtkWidget *check; GtkTreeModel *model; GtkListStore *store; GtkCellRenderer *renderer; char buf[128]; char buf2[128 + 8]; char tbuf[256]; snprintf (tbuf, sizeof tbuf, _("conspire: Network Editor (%s)"), net->name); editwindow = mg_create_generic_tab(_("Network Editor"), tbuf, FALSE, TRUE, servlist_closegui, NULL, 550, 200, &vbox5, NULL); table3 = gtk_table_new (17, 3, FALSE); gtk_widget_show (table3); gtk_box_pack_start (GTK_BOX (vbox5), table3, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table3), 2); gtk_table_set_col_spacings (GTK_TABLE (table3), 8); snprintf (buf, sizeof (buf), _("Servers for %s"), net->name); snprintf (buf2, sizeof (buf2), "<b>%s</b>", buf); label16 = gtk_label_new (buf2); gtk_widget_show (label16); gtk_table_attach (GTK_TABLE (table3), label16, 0, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); gtk_label_set_use_markup (GTK_LABEL (label16), TRUE); gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5); check = servlist_create_check (0, !(net->flags & FLAG_CYCLE), table3, 2, 1, _("Connect to selected server only")); add_tip (check, _("Don't cycle through all the servers when the connection fails.")); label17 = bold_label (_("Your Details")); gtk_table_attach (GTK_TABLE (table3), label17, 0, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); servlist_create_check (1, net->flags & FLAG_USE_GLOBAL, table3, 4, 1, _("Use global user information")); edit_entry_nick = servlist_create_entry (table3, _("_Nick name:"), 5, net->nick, &edit_label_nick, 0); edit_entry_nick2 = servlist_create_entry (table3, _("Second choice:"), 6, net->nick2, &edit_label_nick2, 0); edit_entry_user = servlist_create_entry (table3, _("_User name:"), 7, net->user, &edit_label_user, 0); edit_entry_real = servlist_create_entry (table3, _("Rea_l name:"), 8, net->real, &edit_label_real, 0); label21 = bold_label (_("Connecting")); gtk_table_attach (GTK_TABLE (table3), label21, 0, 3, 9, 10, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); servlist_create_check (3, net->flags & FLAG_AUTO_CONNECT, table3, 11, 1, _("Auto connect to this network at startup")); servlist_create_check (4, net->flags & FLAG_USE_PROXY, table3, 12, 1, _("Use a proxy server")); edit_entry_join = servlist_create_entry (table3, _("C_hannels to join:"), 15, net->autojoin, 0, _("Channels to join, separated by commas, but not spaces!")); edit_entry_nickserv = servlist_create_entry (table3, _("Nickserv password:"******"If your nickname requires a password, enter it here. Not all IRC networks support this.")); gtk_entry_set_visibility (GTK_ENTRY (edit_entry_nickserv), FALSE); edit_entry_pass = servlist_create_entry (table3, _("Server password:"******"Password for the server, if in doubt, leave blank.")); gtk_entry_set_visibility (GTK_ENTRY (edit_entry_pass), FALSE); edit_entry_sasl_user = servlist_create_entry (table3, _("SASL username:"******"If your network uses SASL, put your username here.")); edit_entry_sasl_pass = servlist_create_entry (table3, _("SASL password:"******"If your network uses SASL, put your password here.")); gtk_entry_set_visibility (GTK_ENTRY (edit_entry_sasl_pass), FALSE); label34 = gtk_label_new (_("Character set:")); gtk_widget_show (label34); gtk_table_attach (GTK_TABLE (table3), label34, 1, 2, 21, 22, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label34), 0, 0.5); comboboxentry_charset = servlist_create_charsetcombo (); ignore_changed = TRUE; gtk_entry_set_text (GTK_ENTRY (GTK_BIN (comboboxentry_charset)->child), net->encoding ? net->encoding : "System default"); ignore_changed = FALSE; gtk_widget_show (comboboxentry_charset); gtk_table_attach (GTK_TABLE (table3), comboboxentry_charset, 2, 3, 21, 22, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); label22 = bold_label (_("Perform")); gtk_table_attach (GTK_TABLE (table3), label22, 0, 3, 22, 23, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); edit_entry_cmd = servlist_create_textview (table3, _("Connect commands:"), 24, net->command, 0, _("Extra commands to execute after connecting. Alternatively, to run a large series of commands on connect, use LOAD -e <filename>, where <filename> is a text-file full of commands to execute.")); /*********** FINITO *************/ hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_table_attach (GTK_TABLE (table3), hbox1, 1, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow2); gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN); store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN); model = GTK_TREE_MODEL (store); edit_tree = treeview_servers = gtk_tree_view_new_with_model (model); g_object_unref (model); gtk_widget_show (treeview_servers); gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview_servers); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_servers), FALSE); renderer = gtk_cell_renderer_text_new (); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (servlist_editserver_cb), model); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (treeview_servers), -1, 0, renderer, "text", 0, "editable", 1, NULL); vbuttonbox1 = gtk_vbutton_box_new (); gtk_box_set_spacing (GTK_BOX (vbuttonbox1), 3); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox1), GTK_BUTTONBOX_START); gtk_widget_show (vbuttonbox1); gtk_box_pack_start (GTK_BOX (hbox1), vbuttonbox1, FALSE, FALSE, 3); buttonadd = gtk_button_new_from_stock ("gtk-add"); g_signal_connect (G_OBJECT (buttonadd), "clicked", G_CALLBACK (servlist_addserver_cb), edit_tree); gtk_widget_show (buttonadd); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonadd); GTK_WIDGET_SET_FLAGS (buttonadd, GTK_CAN_DEFAULT); buttonremove = gtk_button_new_from_stock ("gtk-remove"); g_signal_connect (G_OBJECT (buttonremove), "clicked", G_CALLBACK (servlist_deleteserver_cb), NULL); gtk_widget_show (buttonremove); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonremove); GTK_WIDGET_SET_FLAGS (buttonremove, GTK_CAN_DEFAULT); buttonedit = gtk_button_new_with_mnemonic (_("_Edit")); g_signal_connect (G_OBJECT (buttonedit), "clicked", G_CALLBACK (servlist_editserverbutton_cb), NULL); gtk_widget_show (buttonedit); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonedit); GTK_WIDGET_SET_FLAGS (buttonedit, GTK_CAN_DEFAULT); if (net->flags & FLAG_USE_GLOBAL) { gtk_widget_hide (edit_label_nick); gtk_widget_hide (edit_entry_nick); gtk_widget_hide (edit_label_nick2); gtk_widget_hide (edit_entry_nick2); gtk_widget_hide (edit_label_user); gtk_widget_hide (edit_entry_user); gtk_widget_hide (edit_label_real); gtk_widget_hide (edit_entry_real); } return editwindow; }
static GtkWidget * servlist_open_networks (void) { GtkWidget *servlist; GtkWidget *vbox1; GtkWidget *label2; GtkWidget *table1; GtkWidget *label3; GtkWidget *label4; GtkWidget *label5; GtkWidget *label6; GtkWidget *label7; GtkWidget *entry1; GtkWidget *entry2; GtkWidget *entry3; GtkWidget *entry4; GtkWidget *entry5; GtkWidget *vbox2; GtkWidget *label1; GtkWidget *table4; GtkWidget *scrolledwindow3; GtkWidget *treeview_networks; GtkWidget *checkbutton_skip; GtkWidget *vbuttonbox2; GtkWidget *button_add; GtkWidget *button_remove; GtkWidget *button_edit; GtkWidget *button_sort; GtkWidget *button_connect; GtkTreeModel *model; GtkListStore *store; GtkCellRenderer *renderer; servlist = mg_create_generic_tab(_("Network List"), _("conspire: Networks"), FALSE, TRUE, servlist_close_cb, NULL, 640, 480, &vbox1, NULL); label2 = bold_label (_("User Information")); gtk_box_pack_start (GTK_BOX (vbox1), label2, FALSE, FALSE, 0); table1 = gtk_table_new (5, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (table1), 8); gtk_table_set_row_spacings (GTK_TABLE (table1), 2); gtk_table_set_col_spacings (GTK_TABLE (table1), 4); label3 = gtk_label_new_with_mnemonic (_("_Nick name:")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new (_("Second choice:")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); label5 = gtk_label_new (_("Third choice:")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); label6 = gtk_label_new_with_mnemonic (_("_User name:")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); label7 = gtk_label_new_with_mnemonic (_("Rea_l name:")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); entry_nick1 = entry1 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry1), prefs.nick1); gtk_widget_show (entry1); gtk_table_attach (GTK_TABLE (table1), entry1, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_nick2 = entry2 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry2), prefs.nick2); gtk_widget_show (entry2); gtk_table_attach (GTK_TABLE (table1), entry2, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_nick3 = entry3 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry3), prefs.nick3); gtk_widget_show (entry3); gtk_table_attach (GTK_TABLE (table1), entry3, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_guser = entry4 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry4), prefs.username); gtk_widget_show (entry4); gtk_table_attach (GTK_TABLE (table1), entry4, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_greal = entry5 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry5), prefs.realname); gtk_widget_show (entry5); gtk_table_attach (GTK_TABLE (table1), entry5, 1, 2, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0); label1 = bold_label (_("Networks")); gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0); table4 = gtk_table_new (2, 2, FALSE); gtk_widget_show (table4); gtk_box_pack_start (GTK_BOX (vbox2), table4, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (table4), 8); gtk_table_set_row_spacings (GTK_TABLE (table4), 2); gtk_table_set_col_spacings (GTK_TABLE (table4), 3); scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow3); gtk_table_attach (GTK_TABLE (table4), scrolledwindow3, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_SHADOW_IN); store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN); model = GTK_TREE_MODEL (store); networks_tree = treeview_networks = gtk_tree_view_new_with_model (model); g_object_unref (model); gtk_widget_show (treeview_networks); gtk_container_add (GTK_CONTAINER (scrolledwindow3), treeview_networks); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_networks), FALSE); renderer = gtk_cell_renderer_text_new (); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (servlist_celledit_cb), model); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (treeview_networks), -1, 0, renderer, "text", 0, "editable", 1, NULL); checkbutton_skip = gtk_check_button_new_with_mnemonic (_("Skip network list on startup")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_skip), prefs.skip_serverlist); g_signal_connect (G_OBJECT (checkbutton_skip), "toggled", G_CALLBACK (no_servlist), 0); gtk_widget_show (checkbutton_skip); gtk_table_attach (GTK_TABLE (table4), checkbutton_skip, 0, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); vbuttonbox2 = gtk_vbutton_box_new (); gtk_box_set_spacing (GTK_BOX (vbuttonbox2), 3); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox2), GTK_BUTTONBOX_START); gtk_widget_show (vbuttonbox2); gtk_table_attach (GTK_TABLE (table4), vbuttonbox2, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); button_add = gtk_button_new_from_stock ("gtk-add"); g_signal_connect (G_OBJECT (button_add), "clicked", G_CALLBACK (servlist_addnet_cb), networks_tree); gtk_widget_show (button_add); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_add); GTK_WIDGET_SET_FLAGS (button_add, GTK_CAN_DEFAULT); button_remove = gtk_button_new_from_stock ("gtk-remove"); g_signal_connect (G_OBJECT (button_remove), "clicked", G_CALLBACK (servlist_deletenet_cb), 0); gtk_widget_show (button_remove); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_remove); GTK_WIDGET_SET_FLAGS (button_remove, GTK_CAN_DEFAULT); button_edit = gtk_button_new_with_mnemonic (_("_Edit...")); g_signal_connect (G_OBJECT (button_edit), "clicked", G_CALLBACK (servlist_edit_cb), 0); gtk_widget_show (button_edit); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_edit); GTK_WIDGET_SET_FLAGS (button_edit, GTK_CAN_DEFAULT); button_sort = gtk_button_new_with_mnemonic (_("_Sort")); add_tip (button_sort, _("Sorts the network list in alphabetical order. " "Use SHIFT-UP and SHIFT-DOWN keys to move a row.")); g_signal_connect (G_OBJECT (button_sort), "clicked", G_CALLBACK (servlist_sort), 0); gtk_widget_show (button_sort); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_sort); GTK_WIDGET_SET_FLAGS (button_sort, GTK_CAN_DEFAULT); button_connect = gtkutil_button (vbuttonbox2, GTK_STOCK_CONNECT, NULL, servlist_connect_cb, NULL, _("C_onnect")); GTK_WIDGET_SET_FLAGS (button_connect, GTK_CAN_DEFAULT); gtk_label_set_mnemonic_widget (GTK_LABEL (label3), entry1); gtk_label_set_mnemonic_widget (GTK_LABEL (label6), entry4); gtk_label_set_mnemonic_widget (GTK_LABEL (label7), entry5); gtk_widget_grab_focus (networks_tree); return servlist; }
int main(int argc, char* argv[]) { // VMime initialization vmime::platform::setHandler<vmime::platforms::posix::posixHandler>(); // GTK+ initialization gtk_init(&argc, &argv); // Create a new window window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(window), 800, 550); gtk_window_set_title(GTK_WINDOW(window), "VMime Viewer Example"); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL); GtkWidget* vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); // Menubar GtkActionGroup* actionGroup = gtk_action_group_new ("Actions"); gtk_action_group_add_actions(actionGroup, uiActions, G_N_ELEMENTS(uiActions), NULL); GtkUIManager* uiManager = gtk_ui_manager_new(); gtk_ui_manager_insert_action_group(uiManager, actionGroup, 1); gtk_ui_manager_add_ui_from_string(uiManager, uiDefinition, -1, NULL); GtkWidget* menuBar = gtk_ui_manager_get_widget(uiManager, "/MainMenuBar"); gtk_box_pack_start(GTK_BOX(vbox), menuBar, FALSE, FALSE, 0); // Horizontal Pane GtkWidget* hpane = gtk_hpaned_new(); gtk_box_pack_start(GTK_BOX(vbox), hpane, TRUE, TRUE, 0); // Tree View treeModel = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_POINTER); treeView = gtk_tree_view_new(); g_signal_connect(G_OBJECT(treeView), "cursor-changed", G_CALLBACK(treeViewSelChanged), NULL); GtkWidget* scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(scroll), treeView); gtk_paned_add1(GTK_PANED(hpane), scroll); GtkTreeViewColumn* col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, "Component Name"); gtk_tree_view_append_column(GTK_TREE_VIEW(treeView), col); GtkCellRenderer* renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", 0); gtk_tree_view_set_model(GTK_TREE_VIEW(treeView), GTK_TREE_MODEL(treeModel)); g_object_unref(treeModel); gtk_widget_set_size_request(treeView, 200, 100); // Text Area textArea = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(textArea), FALSE); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(scroll), textArea); gtk_paned_add2(GTK_PANED(hpane), scroll); // Show main window gtk_widget_show_all(window); // GTK main loop gtk_main(); return 0; }
GtkWidget * create_large_items_page (void) { GtkWidget *vbox, *hbox, *w, *scrolled_win, *canvas; GtkAdjustment *adj; GooCanvasItem *root, *item; gchar *text; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_container_set_border_width (GTK_CONTAINER (vbox), 4); gtk_widget_show (vbox); text = g_strdup_printf ("This is a very large canvas, from (%i, %i) to (%i, %i).\nThe maximum zoom is %i. At this scale the canvas comes very close to the GDK window size limit (32-bit gint).\nThe items have been specially written to work around cairo's limits (transformed coords must be < +/- 32768).", CANVAS_LEFT, CANVAS_TOP, CANVAS_RIGHT, CANVAS_BOTTOM, MAX_ZOOM); w = gtk_label_new (text); g_free (text); gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); gtk_widget_show (w); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN); gtk_widget_show (scrolled_win); gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0); /* Create the canvas. */ canvas = goo_canvas_new (); gtk_widget_set_size_request (canvas, 600, 450); gtk_container_add (GTK_CONTAINER (scrolled_win), canvas); root = goo_canvas_get_root_item (GOO_CANVAS (canvas)); g_signal_connect (root, "motion_notify_event", G_CALLBACK (on_motion_notify), NULL); #if 1 item = goo_demo_large_rect_new (root, CANVAS_LEFT + 10, CANVAS_TOP + 10, CANVAS_RIGHT - CANVAS_LEFT - 20, CANVAS_BOTTOM - CANVAS_TOP - 20, "fill-color", "yellow", NULL); g_object_set_data (G_OBJECT (item), "id", "Large Yellow Rect"); #endif #if 1 item = goo_demo_large_rect_new (root, CANVAS_LEFT + 100, CANVAS_TOP + 100, CANVAS_RIGHT - CANVAS_LEFT - 200, 50, "fill-color", "orange", NULL); g_object_set_data (G_OBJECT (item), "id", "Large Orange Rect"); #endif #if 1 item = goo_demo_large_line_new (root, CANVAS_LEFT + 100, CANVAS_TOP + 200, CANVAS_RIGHT - 100, CANVAS_TOP + 200, "stroke-color", "purple", "line-width", 10.0, NULL); g_object_set_data (G_OBJECT (item), "id", "Large Purple Line"); #endif #if 1 item = goo_demo_large_line_new (root, CANVAS_LEFT + 100, CANVAS_TOP + 300, CANVAS_RIGHT - 100, CANVAS_BOTTOM - 100, "stroke-color", "blue", "line-width", 10.0, NULL); g_object_set_data (G_OBJECT (item), "id", "Large Blue Line"); /*goo_canvas_item_rotate (item, 10, CANVAS_LEFT + 100, CANVAS_TOP + 200);*/ #endif goo_canvas_set_bounds (GOO_CANVAS (canvas), CANVAS_LEFT, CANVAS_TOP, CANVAS_RIGHT, CANVAS_BOTTOM); gtk_widget_show (canvas); /* Zoom */ w = gtk_label_new ("Zoom:"); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); adj = GTK_ADJUSTMENT (gtk_adjustment_new (1.00, 0.05, 10.00, 0.05, 0.50, 0.50)); w = gtk_spin_button_new (adj, 0.0, 2); g_signal_connect (adj, "value_changed", G_CALLBACK (zoom_changed), canvas); gtk_widget_set_size_request (w, 50, -1); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); gtk_widget_show (w); return vbox; }
static GtkWidget *create_window(void) { // Basic window stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE); gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls stwidgets.hlayout = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout); // banner { GdkPixbuf *pixbuf = load_banner(); stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons stwidgets.vlayout = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0); // Tab control stwidgets.tabs = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4); // layout table of config page stwidgets.configtlayout = gtk_table_new(6, 3, FALSE); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout); // 3D video mode LabelText stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, 0, 4, 0); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Fullscreen checkbox stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, 0, 4, 0); stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0); #ifdef POLYMER // Polymer checkbox stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0); #endif // Input devices LabelText stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, 0, 4, 0); // Input devices combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.inputdevcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Custom mod LabelText stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, 0, 4, 7); // Custom mod combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.custommodcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3, GTK_EXPAND | GTK_FILL, 0, 4, 7); // Empty horizontal layout stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, 0, GTK_EXPAND | GTK_FILL, 4, 0); // Autoload checkbox stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, 0, 2, 2); // Always show config checkbox stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, 0, 2, 2); // Configuration tab stwidgets.configtab = gtk_label_new("Configuration"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab); // Game data layout stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4); // Game data field LabelText stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:"); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5); // Game data scrollable area stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_SHADOW_IN); // Game data list { GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); GtkCellRenderer *cell; GtkTreeViewColumn *col; gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING); stwidgets.gamelist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL); gtk_tree_view_column_set_expand(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL); gtk_tree_view_column_set_min_width(col, 64); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); } gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); // Game tab stwidgets.gametab = gtk_label_new("Game"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab); // Messages scrollable area stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area stwidgets.messagestext = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext); gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); // Messages tab stwidgets.messagestab = gtk_label_new("Messages"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab); // Dialogue box buttons layout stwidgets.buttons = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3); gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END); // Cancel button stwidgets.cancelbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton); GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT); stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign); stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout); stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0); stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel"); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0); // Start button stwidgets.startbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton); GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT); gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton); stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign); stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout); stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0); stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start"); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect((gpointer) stwidgets.startwin, "delete_event", G_CALLBACK(on_startwin_delete_event), NULL); g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed", G_CALLBACK(on_vmode3dcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled", G_CALLBACK(on_fullscreencheck_toggled), NULL); #ifdef POLYMER g_signal_connect((gpointer) stwidgets.polymercheck, "toggled", G_CALLBACK(on_polymercheck_toggled), NULL); #endif g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed", G_CALLBACK(on_inputdevcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.custommodcombo, "changed", G_CALLBACK(on_custommodcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled", G_CALLBACK(on_autoloadcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled", G_CALLBACK(on_alwaysshowcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked", G_CALLBACK(on_cancelbutton_clicked), NULL); g_signal_connect((gpointer) stwidgets.startbutton, "clicked", G_CALLBACK(on_startbutton_clicked), NULL); { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.gamelist)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); g_signal_connect((gpointer) sel, "changed", G_CALLBACK(on_gamelist_selection_changed), NULL); } // Associate labels with their controls gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist); return stwidgets.startwin; }
void gtkui_help(void) { GtkWidget *dialog, *scrolled, *treeview, *hbox, *textview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; help_pair *section; DEBUG_MSG("gtkui_help"); dialog = gtk_dialog_new_with_buttons(EC_PROGRAM" Help", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_window_set_default_size(GTK_WINDOW (dialog), 780, 580); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), TRUE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), scrolled, FALSE, FALSE, 0); gtk_widget_show(scrolled); treeview = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (treeview), FALSE); gtk_container_add(GTK_CONTAINER (scrolled), treeview); gtk_widget_show(treeview); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect(selection, "changed", G_CALLBACK (gtkui_help_selected), liststore); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Contents", renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); liststore = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); for(section = help_list; section->title; section++) { gtk_list_store_append (liststore, &iter); gtk_list_store_set (liststore, &iter, 0, section->title, 1, section->file, -1); } gtk_tree_view_set_model(GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (liststore)); /* text area */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); textview = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (textview), FALSE); gtk_container_add(GTK_CONTAINER (scrolled), textview); gtk_widget_show(textview); textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW (textview)); gtk_widget_show_all(hbox); gtk_dialog_run(GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); }
static void gtk_assert_dialog_init(GTypeInstance* instance, void*) { GtkAssertDialog* dlg = GTK_ASSERT_DIALOG(instance); GtkWidget *continuebtn; { GtkWidget *vbox, *hbox, *image; /* start the main vbox */ gtk_widget_push_composite_child (); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8); gtk_container_set_border_width (GTK_CONTAINER(vbox), 8); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))), vbox, true, true, 5); /* add the icon+message hbox */ hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* icon */ image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG); gtk_box_pack_start (GTK_BOX(hbox), image, FALSE, FALSE, 12); { GtkWidget *vbox2, *info; /* message */ vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); info = gtk_label_new ("An assertion failed!"); gtk_box_pack_start (GTK_BOX(vbox2), info, TRUE, TRUE, 8); /* assert message */ dlg->message = gtk_label_new (NULL); gtk_label_set_selectable (GTK_LABEL (dlg->message), TRUE); gtk_label_set_line_wrap (GTK_LABEL (dlg->message), TRUE); gtk_label_set_justify (GTK_LABEL (dlg->message), GTK_JUSTIFY_LEFT); gtk_widget_set_size_request (GTK_WIDGET(dlg->message), 450, -1); gtk_box_pack_end (GTK_BOX(vbox2), GTK_WIDGET(dlg->message), TRUE, TRUE, 8); } #if wxUSE_STACKWALKER /* add the expander */ dlg->expander = gtk_expander_new_with_mnemonic ("Back_trace:"); gtk_box_pack_start (GTK_BOX(vbox), dlg->expander, TRUE, TRUE, 0); g_signal_connect (dlg->expander, "activate", G_CALLBACK(gtk_assert_dialog_expander_callback), dlg); #endif // wxUSE_STACKWALKER } #if wxUSE_STACKWALKER { GtkWidget *hbox, *vbox, *button, *sw; /* create expander's vbox */ vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (dlg->expander), vbox); /* add a scrollable window under the expander */ 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(vbox), sw, TRUE, TRUE, 8); /* add the treeview to the scrollable window */ dlg->treeview = gtk_assert_dialog_create_backtrace_list_model (); gtk_widget_set_size_request (GTK_WIDGET(dlg->treeview), -1, 180); gtk_container_add (GTK_CONTAINER (sw), dlg->treeview); /* create button's hbox */ hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_end (GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); /* add the buttons */ button = gtk_assert_dialog_add_button_to (GTK_BOX(hbox), "Save to _file", GTK_STOCK_SAVE); g_signal_connect (button, "clicked", G_CALLBACK(gtk_assert_dialog_save_backtrace_callback), dlg); button = gtk_assert_dialog_add_button_to (GTK_BOX(hbox), "Copy to clip_board", GTK_STOCK_COPY); g_signal_connect (button, "clicked", G_CALLBACK(gtk_assert_dialog_copy_callback), dlg); } #endif // wxUSE_STACKWALKER /* add the checkbutton */ dlg->shownexttime = gtk_check_button_new_with_mnemonic("Show this _dialog the next time"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(dlg->shownexttime), TRUE); gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(dlg))), dlg->shownexttime, false, true, 8); /* add the stop button */ gtk_assert_dialog_add_button (dlg, "_Stop", GTK_STOCK_QUIT, GTK_ASSERT_DIALOG_STOP); /* add the continue button */ continuebtn = gtk_assert_dialog_add_button (dlg, "_Continue", GTK_STOCK_YES, GTK_ASSERT_DIALOG_CONTINUE); gtk_dialog_set_default_response (GTK_DIALOG (dlg), GTK_ASSERT_DIALOG_CONTINUE); g_signal_connect (continuebtn, "clicked", G_CALLBACK(gtk_assert_dialog_continue_callback), dlg); /* complete creation */ dlg->callback = NULL; dlg->userdata = NULL; /* the resizable property of this window is modified by the expander: when it's collapsed, the window must be non-resizable! */ gtk_window_set_resizable (GTK_WINDOW (dlg), FALSE); gtk_widget_pop_composite_child (); gtk_widget_show_all (GTK_WIDGET(dlg)); }
static GtkWidget * normal_contents (void) { GtkWidget *grid; GtkWidget *statusbar; GtkWidget *contents; GtkWidget *sw; GtkActionGroup *action_group; GtkUIManager *ui_manager; grid = gtk_grid_new (); /* Create the menubar */ action_group = gtk_action_group_new ("mainmenu"); gtk_action_group_add_actions (action_group, menu_items, G_N_ELEMENTS (menu_items), NULL); gtk_action_group_add_actions (action_group, tool_items, G_N_ELEMENTS (tool_items), NULL); ui_manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); /* create menu items */ gtk_ui_manager_add_ui_from_string (ui_manager, menu_item_string, -1, NULL); gtk_grid_attach (GTK_GRID (grid), gtk_ui_manager_get_widget (ui_manager, "/ui/menubar"), 0, 0, 1, 1); gtk_widget_set_hexpand (gtk_ui_manager_get_widget (ui_manager, "/ui/menubar"), TRUE); /* Create the toolbar */ gtk_grid_attach (GTK_GRID (grid), gtk_ui_manager_get_widget (ui_manager, "/ui/toolbar"), 0, 1, 1, 1); gtk_widget_set_hexpand (gtk_ui_manager_get_widget (ui_manager, "/ui/toolbar"), TRUE); /* Create document */ sw = gtk_scrolled_window_new (NULL, NULL); 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_grid_attach (GTK_GRID (grid), sw, 0, 2, 1, 1); gtk_widget_set_hexpand (sw, TRUE); gtk_widget_set_vexpand (sw, TRUE); contents = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents), PANGO_WRAP_WORD); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_grid_attach (GTK_GRID (grid), statusbar, 0, 3, 1, 1); gtk_widget_set_hexpand (statusbar, TRUE); gtk_widget_show_all (grid); g_object_unref (ui_manager); return grid; }
/** * favorite_selector_new * * Returns: a new #GtkWidget */ GtkWidget * favorite_selector_new (BrowserConnection *bcnc) { FavoriteSelector *tsel; GdaTreeManager *manager; g_return_val_if_fail (BROWSER_IS_CONNECTION (bcnc), NULL); tsel = FAVORITE_SELECTOR (g_object_new (FAVORITE_SELECTOR_TYPE, NULL)); tsel->priv->bcnc = g_object_ref (bcnc); g_signal_connect (browser_connection_get_favorites (tsel->priv->bcnc), "favorites-changed", G_CALLBACK (favorites_changed_cb), tsel); /* create tree managers */ tsel->priv->tree = gda_tree_new (); manager = mgr_favorites_new (bcnc, GDA_TOOLS_FAVORITES_TABLES | GDA_TOOLS_FAVORITES_DIAGRAMS, ORDER_KEY_SCHEMA); gda_tree_add_manager (tsel->priv->tree, manager); g_object_unref (manager); /* update the tree's contents */ if (tsel->priv->idle_update_favorites == 0) tsel->priv->idle_update_favorites = g_idle_add ((GSourceFunc) idle_update_favorites, tsel); /* header */ GtkWidget *label; gchar *str; str = g_strdup_printf ("<b>%s</b>", _("Favorites")); label = gdaui_bar_new (str); g_free (str); gdaui_bar_set_icon_from_pixbuf (GDAUI_BAR (label), browser_get_pixbuf_icon (BROWSER_ICON_BOOKMARK)); gtk_box_pack_start (GTK_BOX (tsel), label, FALSE, FALSE, 0); gtk_widget_show (label); /* tree model */ GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; model = gdaui_tree_store_new (tsel->priv->tree, 5, G_TYPE_STRING, "markup", G_TYPE_OBJECT, "icon", G_TYPE_STRING, MGR_FAVORITES_CONTENTS_ATT_NAME, G_TYPE_UINT, MGR_FAVORITES_TYPE_ATT_NAME, G_TYPE_INT, MGR_FAVORITES_ID_ATT_NAME); treeview = browser_make_tree_view (model); tsel->priv->treeview = treeview; g_object_unref (model); /* icon */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COLUMN_ICON); /* text */ renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "markup", COLUMN_MARKUP); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); /* scrolled window packing */ GtkWidget *sw; 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_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_box_pack_start (GTK_BOX (tsel), sw, TRUE, TRUE, 0); gtk_widget_show_all (sw); g_signal_connect (G_OBJECT (treeview), "row-activated", G_CALLBACK (selection_changed_cb), tsel); g_signal_connect (G_OBJECT (treeview), "key-press-event", G_CALLBACK (key_press_event_cb), tsel); /* DnD */ gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (treeview), dbo_table, G_N_ELEMENTS (dbo_table), GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (treeview), GDK_BUTTON1_MASK, dbo_table, G_N_ELEMENTS (dbo_table), GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect (model, "drag-drop", G_CALLBACK (tree_store_drag_drop_cb), tsel); g_signal_connect (model, "drag-can-drag", G_CALLBACK (tree_store_drag_can_drag_cb), tsel); g_signal_connect (model, "drag-get", G_CALLBACK (tree_store_drag_get_cb), tsel); return (GtkWidget*) tsel; }
static void bt_settings_page_interaction_controller_init_ui (const BtSettingsPageInteractionController * self, GtkWidget * pages) { GtkWidget *label, *widget, *scrolled_window; GtkCellRenderer *renderer; GtkTreeViewColumn *tree_col; GtkTreeSelection *tree_sel; BtIcRegistry *ic_registry; gchar *str; gtk_widget_set_name (GTK_WIDGET (self), "interaction controller settings"); // create the widget already so that we can set the initial text self->priv->message = GTK_LABEL (gtk_label_new (NULL)); g_object_set (GTK_WIDGET (self->priv->message), "hexpand", TRUE, NULL); // add setting widgets label = gtk_label_new (NULL); str = g_strdup_printf ("<big><b>%s</b></big>", _("Interaction Controller")); gtk_label_set_markup (GTK_LABEL (label), str); g_free (str); g_object_set (label, "xalign", 0.0, NULL); gtk_grid_attach (GTK_GRID (self), label, 0, 0, 3, 1); gtk_grid_attach (GTK_GRID (self), gtk_label_new (" "), 0, 1, 1, 3); label = gtk_label_new (_("Device")); g_object_set (label, "xalign", 1.0, NULL); gtk_grid_attach (GTK_GRID (self), label, 1, 1, 1, 1); widget = gtk_combo_box_new (); self->priv->device_menu = GTK_COMBO_BOX (widget); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_fixed_size (renderer, 1, -1); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->priv->device_menu), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self->priv->device_menu), renderer, "text", DEVICE_MENU_LABEL, NULL); // get list of devices from libbtic and listen to changes g_object_get (self->priv->app, "ic-registry", &ic_registry, NULL); g_signal_connect_object (ic_registry, "notify::devices", G_CALLBACK (on_ic_registry_devices_changed), (gpointer) self, 0); g_object_unref (ic_registry); g_object_set (widget, "hexpand", TRUE, "margin-left", LABEL_PADDING, NULL); gtk_grid_attach (GTK_GRID (self), widget, 2, 1, 1, 1); g_signal_connect (widget, "changed", G_CALLBACK (on_device_menu_changed), (gpointer) self); // add list of controllers (updated when selecting a device) scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); self->priv->controller_list = GTK_TREE_VIEW (gtk_tree_view_new ()); g_object_set (self->priv->controller_list, "enable-search", FALSE, "rules-hint", TRUE, NULL); // have this first as the last column gets the remaining space (always :/) renderer = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (self->priv->controller_list, -1, _("In use"), renderer, "active", CONTROLLER_LIST_USED, NULL); self->priv->id_renderer = renderer = gtk_cell_renderer_text_new (); //gtk_cell_renderer_set_fixed_size (renderer, 1, -1); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1); g_signal_connect (renderer, "edited", G_CALLBACK (on_control_name_edited), (gpointer) self); if ((tree_col = gtk_tree_view_column_new_with_attributes (_("Controller"), renderer, "text", CONTROLLER_LIST_LABEL, NULL)) ) { g_object_set (tree_col, "expand", TRUE, NULL); gtk_tree_view_insert_column (self->priv->controller_list, tree_col, -1); } else GST_WARNING ("can't create treeview column"); tree_sel = gtk_tree_view_get_selection (self->priv->controller_list); gtk_tree_selection_set_mode (tree_sel, GTK_SELECTION_BROWSE); g_signal_connect (tree_sel, "changed", G_CALLBACK (on_control_selected), (gpointer) self); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (self->priv->controller_list)); g_object_set (GTK_WIDGET (scrolled_window), "hexpand", TRUE, "vexpand", TRUE, "margin-left", LABEL_PADDING, NULL); gtk_grid_attach (GTK_GRID (self), GTK_WIDGET (scrolled_window), 1, 2, 2, 1); // add a message pane #if ! defined(USE_GUDEV) && ! defined(USE_ALSA) gtk_label_set_text (self->priv->message, _("This package has been built without GUdev and Alsa support and thus " "supports no interaction controllers.")); #endif gtk_grid_attach (GTK_GRID (self), GTK_WIDGET (self->priv->message), 0, 3, 3, 1); // listen to page changes g_signal_connect ((gpointer) pages, "notify::page", G_CALLBACK (on_page_switched), (gpointer) self); // initial refresh on_ic_registry_devices_changed (ic_registry, NULL, (gpointer) self); }
void telatotalvendas(void){ calendario = gtk_calendar_new(); gtk_widget_set_usize (calendario, 320, 180); gtk_fixed_put(GTK_FIXED(fixed),calendario,20,4); gtk_widget_set_sensitive(GTK_WIDGET(botaocliente),FALSE); gtk_widget_set_sensitive(GTK_WIDGET(vendastotal),FALSE); gtk_widget_set_sensitive(GTK_WIDGET(btproduto),FALSE); btfechavendastotal = gtk_tool_button_new_from_stock(GTK_STOCK_CLOSE); gtk_fixed_put(GTK_FIXED(fixed),btfechavendastotal,1240,0); /* Create a radio button with a GtkEntry widget */ radio1 = gtk_radio_button_new_with_label(NULL,"Total Dia"); /* Create a radio button with a label */ radio2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1),"Total Mes"); radio3 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1),"Total Ano"); btrefdavs = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH); gtk_fixed_put(GTK_FIXED(fixed),btrefdavs,380,150); gtk_fixed_put(GTK_FIXED(fixed), radio1, 380,30); gtk_fixed_put(GTK_FIXED(fixed), radio2, 380,60); gtk_fixed_put(GTK_FIXED(fixed), radio3, 380,90); svendas= gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(svendas),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(svendas),GTK_SHADOW_ETCHED_IN); //gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(svendas),ldesprod); gtk_widget_set_usize (svendas, 690, 680); gtk_fixed_put(GTK_FIXED(fixed),svendas,550,0); stotalvendedor= gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(stotalvendedor),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(stotalvendedor),GTK_SHADOW_ETCHED_IN); //gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(svendas),ldesprod); gtk_widget_set_usize (stotalvendedor, 520, 480); gtk_fixed_put(GTK_FIXED(fixed),stotalvendedor,10,200); arvoretotalvendasvendedor(); arvorevendedortotal(); btrefdavsclick(); g_signal_connect(G_OBJECT(btrefdavs), "clicked",G_CALLBACK(btrefdavsclick),NULL); g_signal_connect(G_OBJECT(calendario),"day-selected",G_CALLBACK(btrefdavsclick),NULL); g_signal_connect(G_OBJECT(btfechavendastotal), "clicked",G_CALLBACK(fechavendastotal),NULL); g_signal_connect(G_OBJECT(radio1),"clicked",G_CALLBACK(btrefdavsclick),NULL); g_signal_connect(G_OBJECT(radio2),"clicked",G_CALLBACK(btrefdavsclick),NULL); g_signal_connect(G_OBJECT(radio3),"clicked",G_CALLBACK(btrefdavsclick),NULL); // g_signal_connect(G_OBJECT(ckdia),"clicked",G_CALLBACK(ckdiaclick),NULL); // g_signal_connect(G_OBJECT(ckmes),"clicked",G_CALLBACK(ckmesclick),NULL); //g_signal_connect(G_OBJECT(ckano),"clicked",G_CALLBACK(ckanoclick),NULL); gtk_widget_show_all(window); }
static void init_widgets(char *path) { GtkWidget *vbox, *hbox, *dialog; icalcomponent_kind kind; icalcomponent *subcomp; GtkWidget *selector, *label; ESourceList *source_list; ESource *primary; GtkWidget *scrolled; ICalImporterData *icidata = g_malloc0(sizeof(*icidata)); GtkWidget *icon, *button; char *label_str = NULL; char *markup; g_return_if_fail ( path != NULL); dialog = gtk_dialog_new_with_buttons (_("Import ICS"), NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); icidata->window = dialog; g_signal_connect (dialog, "response", G_CALLBACK (dialog_response_cb), icidata); vbox = GTK_DIALOG(dialog)->vbox; hbox = gtk_hbox_new (FALSE, FALSE); label = gtk_label_new(NULL); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6); icidata->icalcomp = get_icalcomponent_from_file (path); subcomp = icalcomponent_get_inner(icidata->icalcomp); kind = icalcomponent_isa (subcomp); if (kind == ICAL_VTODO_COMPONENT ) { e_cal_get_sources (&source_list, E_CAL_SOURCE_TYPE_TODO, NULL); label_str = _("Select Task List"); icidata->source_type = E_CAL_SOURCE_TYPE_TODO; } else if ( kind == ICAL_VEVENT_COMPONENT) { e_cal_get_sources (&source_list, E_CAL_SOURCE_TYPE_EVENT, NULL); label_str = _("Select Calendar"); icidata->source_type = E_CAL_SOURCE_TYPE_EVENT; } markup = g_markup_printf_escaped ("<b>%s</b>", label_str); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); hbox = gtk_hbox_new (FALSE, FALSE); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 6); selector = e_source_selector_new (source_list); e_source_selector_show_selection (E_SOURCE_SELECTOR (selector), FALSE); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add((GtkContainer *)scrolled, selector); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); hbox = gtk_hbox_new (FALSE, FALSE); gtk_box_pack_start (GTK_BOX (hbox), scrolled, TRUE, TRUE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 6); icidata->selector = selector; /* FIXME What if no sources? */ primary = e_source_list_peek_source_any (source_list); e_source_selector_set_primary_selection (E_SOURCE_SELECTOR (selector), primary); g_object_unref (source_list); hbox = gtk_hbox_new (FALSE, FALSE); icon = e_icon_factory_get_image ("stock_mail-import", E_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX(hbox), icon, FALSE, FALSE, 6); label = gtk_label_new_with_mnemonic (_("_Import")); gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 6); gtk_widget_show(label); button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (button), hbox); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, GTK_RESPONSE_OK); gtk_widget_grab_focus (button); gtk_window_set_default_size (GTK_WINDOW (dialog), 210,340); gtk_widget_show_all (dialog); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); }
void gtk_assert_dialog_init(GtkAssertDialog *dlg) { GtkWidget *vbox, *hbox, *image, *continuebtn; /* start the main vbox */ gtk_widget_push_composite_child (); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER(vbox), 8); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), vbox, TRUE, TRUE, 5); /* add the icon+message hbox */ hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* icon */ image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG); gtk_box_pack_start (GTK_BOX(hbox), image, FALSE, FALSE, 12); { GtkWidget *vbox2, *info; /* message */ vbox2 = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); info = gtk_label_new ("An assertion failed!"); gtk_box_pack_start (GTK_BOX(vbox2), info, TRUE, TRUE, 8); /* assert message */ dlg->message = gtk_label_new (NULL); gtk_label_set_selectable (GTK_LABEL (dlg->message), TRUE); gtk_label_set_line_wrap (GTK_LABEL (dlg->message), TRUE); gtk_label_set_justify (GTK_LABEL (dlg->message), GTK_JUSTIFY_LEFT); gtk_widget_set_size_request (GTK_WIDGET(dlg->message), 450, -1); gtk_box_pack_end (GTK_BOX(vbox2), GTK_WIDGET(dlg->message), TRUE, TRUE, 8); } /* add the expander */ #if GTK_CHECK_VERSION(2,4,0) if (!gtk_check_version (2, 4, 0)) { dlg->expander = gtk_expander_new_with_mnemonic ("Back_trace:"); gtk_box_pack_start (GTK_BOX(vbox), dlg->expander, TRUE, TRUE, 0); g_signal_connect (GTK_EXPANDER(dlg->expander), "activate", G_CALLBACK(gtk_assert_dialog_expander_callback), dlg); } else #endif { // if GtkExpander is unavailable, then use a static frame instead dlg->expander = gtk_frame_new ("Back_trace:"); gtk_box_pack_start (GTK_BOX(vbox), dlg->expander, TRUE, TRUE, 0); } { GtkWidget *hbox, *vbox, *button, *sw; /* create expander's vbox */ vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (dlg->expander), vbox); /* add a scrollable window under the expander */ 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(vbox), sw, TRUE, TRUE, 8); /* add the treeview to the scrollable window */ dlg->treeview = gtk_assert_dialog_create_backtrace_list_model (); gtk_widget_set_size_request (GTK_WIDGET(dlg->treeview), -1, 180); gtk_container_add (GTK_CONTAINER (sw), dlg->treeview); /* create button's hbox */ hbox = gtk_hbutton_box_new (); gtk_box_pack_end (GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); /* add the buttons */ #if GTK_CHECK_VERSION(2,4,0) if (!gtk_check_version (2, 4, 0)) { /* add this button only if GTK supports GtkFileChooserDialog */ button = gtk_assert_dialog_add_button_to (GTK_BOX(hbox), "Save to _file", GTK_STOCK_SAVE, GTK_RESPONSE_NONE); g_signal_connect (button, "clicked", G_CALLBACK(gtk_assert_dialog_save_backtrace_callback), dlg); } #endif button = gtk_assert_dialog_add_button_to (GTK_BOX(hbox), "Copy to clip_board", GTK_STOCK_COPY, GTK_RESPONSE_NONE); g_signal_connect (button, "clicked", G_CALLBACK(gtk_assert_dialog_copy_callback), dlg); } /* add the checkbutton */ dlg->shownexttime = gtk_check_button_new_with_mnemonic("Show this _dialog the next time"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(dlg->shownexttime), TRUE); gtk_box_pack_end (GTK_BOX(GTK_DIALOG(dlg)->action_area), dlg->shownexttime, FALSE, TRUE, 8); /* add the stop button */ gtk_assert_dialog_add_button (dlg, "_Stop", GTK_STOCK_QUIT, GTK_ASSERT_DIALOG_STOP); /* add the continue button */ continuebtn = gtk_assert_dialog_add_button (dlg, "_Continue", GTK_STOCK_YES, GTK_ASSERT_DIALOG_CONTINUE); gtk_dialog_set_default_response (GTK_DIALOG (dlg), GTK_ASSERT_DIALOG_CONTINUE); g_signal_connect (continuebtn, "clicked", G_CALLBACK(gtk_assert_dialog_continue_callback), dlg); /* complete creation */ dlg->callback = NULL; dlg->userdata = NULL; /* the resizeable property of this window is modified by the expander: when it's collapsed, the window must be non-resizeable! */ gtk_window_set_resizable (GTK_WINDOW (dlg), FALSE); gtk_widget_pop_composite_child (); gtk_widget_show_all (GTK_WIDGET(dlg)); }
GtkWidget * CChoosebook::create_tree() { GtkWidget *sw; GtkTreeStore *model; GtkTreeIter iter; gchar *filename; model = gtk_tree_store_new (3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING); filename = g_build_filename(g_pReciteWord->userpath, "hardbooks", NULL); gtk_tree_store_append (model, &iter, NULL); gtk_tree_store_set (model, &iter, 0,Skin->choosebook.dir.p[0],1, _("hardbooks"),2,filename, -1); create_tree_model(filename,model, &iter); g_free(filename); filename = g_build_filename(g_pReciteWord->userpath, "books", NULL); gtk_tree_store_append (model, &iter, NULL); gtk_tree_store_set (model, &iter, 0,Skin->choosebook.dir.p[0],1, _("my books"),2,filename, -1); create_tree_model(filename,model, &iter); g_free(filename); gtk_tree_store_append (model, &iter, NULL); filename = g_build_filename(reciteword_data_dir, "books", NULL); gtk_tree_store_set (model, &iter, 0,Skin->choosebook.dir.p[0],1, _("books"),2, filename, -1); create_tree_model(filename,model, &iter); g_free(filename); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE); g_object_unref (model); GtkCellRenderer *renderer_image; GtkCellRenderer *renderer_text; GtkTreeViewColumn *column; renderer_image = gtk_cell_renderer_pixbuf_new(); renderer_text = gtk_cell_renderer_text_new (); //g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column,_("Directories")); gtk_tree_view_column_pack_start(column,renderer_image,FALSE); gtk_tree_view_column_add_attribute(column, renderer_image, "pixbuf",0); gtk_tree_view_column_pack_end(column,renderer_text,TRUE); gtk_tree_view_column_add_attribute(column, renderer_text, "text",1); gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view),column,-1); gtk_tree_view_column_set_clickable (column, TRUE); GtkTreeSelection *selection; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); gtk_tree_view_expand_all(GTK_TREE_VIEW(tree_view)); //gtk_tree_selection_set_select_function(selection,tree_selection_func,this,NULL); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (on_choosebook_tree_selection_changed), this); sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request(sw,Skin->choosebook.book_tree.w,Skin->choosebook.book_tree.h); 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_container_add (GTK_CONTAINER (sw), tree_view); gtk_widget_show(tree_view); return sw; }
static GtkWidget * get_plugin_manager(void) { static GtkWidget *dialog = NULL; GtkWidget *vbox, *scrolled_window, *tree_view; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeViewColumn *col; GtkTreeIter iter; GList *tmp; if (dialog) return dialog; /* build up the user interface */ dialog = gtk_dialog_new_with_buttons( _("Plug-ins"), NULL, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); vbox = GTK_DIALOG(dialog)->vbox; /* don't destroy dialog when window manager close button pressed */ g_signal_connect(G_OBJECT (dialog), "response", G_CALLBACK(pm_respond), NULL); g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(gtk_widget_hide), NULL); g_signal_connect(GTK_OBJECT(dialog), "delete_event", G_CALLBACK(gtk_true), NULL); g_signal_connect(GTK_OBJECT(dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &dialog); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0); /* create the TreeStore */ store = gtk_list_store_new (NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_POINTER); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE); /* fill list */ for (tmp = dia_list_plugins(); tmp != NULL; tmp = tmp->next) { PluginInfo *info = tmp->data; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, LOADED_COLUMN, dia_plugin_is_loaded(info), NAME_COLUMN, dia_plugin_get_name(info), DESC_COLUMN, dia_plugin_get_description(info), FILENAME_COLUMN, dia_plugin_get_filename(info), AUTOLOAD_COLUMN, !dia_plugin_get_inhibit_load(info), PLUGIN_COLUMN, info, -1); } /* setup renderers and view */ renderer = gtk_cell_renderer_toggle_new (); g_signal_connect(G_OBJECT (renderer), "toggled", G_CALLBACK (toggle_loaded_callback), tree_view); col = gtk_tree_view_column_new_with_attributes( _("Loaded"), renderer, "active", LOADED_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func ( col, renderer, can_unload, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); col = gtk_tree_view_column_new_with_attributes( _("Name"), gtk_cell_renderer_text_new (), "text", NAME_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id (col, NAME_COLUMN); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); col = gtk_tree_view_column_new_with_attributes( _("Description"), gtk_cell_renderer_text_new (), "text", DESC_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id (col, DESC_COLUMN); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect(G_OBJECT (renderer), "toggled", G_CALLBACK (toggle_autoload_callback), tree_view); col = gtk_tree_view_column_new_with_attributes( _("Load at Startup"), renderer, "active", AUTOLOAD_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func ( col, renderer, can_inhibit, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); col = gtk_tree_view_column_new_with_attributes( _("File Name"), gtk_cell_renderer_text_new (), "text", FILENAME_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id (col, FILENAME_COLUMN); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view); gtk_window_set_default_size (GTK_WINDOW (dialog), 480, 400); gtk_widget_show_all (dialog); return dialog; }
void pw_col_choose (void) { if (window) { gtk_window_present ((GtkWindow *) window); return; } chosen = index_new (); avail = index_new (); gboolean added[PW_COLS]; memset (added, 0, sizeof added); for (gint i = 0; i < pw_num_cols; i ++) { if (added[pw_cols[i]]) continue; added[pw_cols[i]] = TRUE; Column * column = g_slice_new (Column); column->column = pw_cols[i]; column->selected = 0; index_append (chosen, column); } for (gint i = 0; i < PW_COLS; i ++) { if (added[i]) continue; Column * column = g_slice_new (Column); column->column = i; column->selected = 0; index_append (avail, column); } window = gtk_dialog_new_with_buttons (_("Choose Columns"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_default_size ((GtkWindow *) window, 400, 300); gtk_dialog_set_default_response ((GtkDialog *) window, GTK_RESPONSE_ACCEPT); g_signal_connect (window, "response", (GCallback) response_cb, NULL); g_signal_connect (window, "destroy", (GCallback) destroy_cb, NULL); GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area ((GtkDialog *) window), hbox, TRUE, TRUE, 0); GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); gtk_box_pack_start ((GtkBox *) hbox, vbox, TRUE, TRUE, 0); GtkWidget * label = gtk_label_new (_("Available:")); g_object_set ((GObject *) label, "xalign", (gfloat) 0, NULL); gtk_box_pack_start ((GtkBox *) vbox, label, FALSE, FALSE, 0); GtkWidget * scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scroll, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scroll, GTK_SHADOW_IN); gtk_box_pack_start ((GtkBox *) vbox, scroll, TRUE, TRUE, 0); avail_list = audgui_list_new (& callbacks, avail, index_count (avail)); gtk_tree_view_set_headers_visible ((GtkTreeView *) avail_list, FALSE); audgui_list_add_column (avail_list, NULL, 0, G_TYPE_STRING, -1); gtk_container_add ((GtkContainer *) scroll, avail_list); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start ((GtkBox *) hbox, vbox, FALSE, FALSE, 0); GtkWidget * button = gtk_button_new (); gtk_container_add ((GtkContainer *) button, gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start ((GtkBox *) vbox, button, TRUE, FALSE, 0); g_signal_connect_swapped (button, "clicked", (GCallback) transfer, avail); button = gtk_button_new (); gtk_container_add ((GtkContainer *) button, gtk_image_new_from_stock (GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start ((GtkBox *) vbox, button, TRUE, FALSE, 0); g_signal_connect_swapped (button, "clicked", (GCallback) transfer, chosen); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); gtk_box_pack_start ((GtkBox *) hbox, vbox, TRUE, TRUE, 0); label = gtk_label_new (_("Chosen:")); g_object_set ((GObject *) label, "xalign", (gfloat) 0, NULL); gtk_box_pack_start ((GtkBox *) vbox, label, FALSE, FALSE, 0); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scroll, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scroll, GTK_SHADOW_IN); gtk_box_pack_start ((GtkBox *) vbox, scroll, TRUE, TRUE, 0); chosen_list = audgui_list_new (& callbacks, chosen, index_count (chosen)); gtk_tree_view_set_headers_visible ((GtkTreeView *) chosen_list, FALSE); audgui_list_add_column (chosen_list, NULL, 0, G_TYPE_STRING, -1); gtk_container_add ((GtkContainer *) scroll, chosen_list); gtk_widget_show_all (window); }
static void thunar_uca_chooser_init (ThunarUcaChooser *uca_chooser) { GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkCellRenderer *renderer; ThunarUcaModel *uca_model; GtkWidget *image; GtkWidget *label; GtkWidget *hbox; GtkWidget *swin; GtkWidget *vbox; /* configure the dialog window */ gtk_dialog_add_button (GTK_DIALOG (uca_chooser), GTK_STOCK_HELP, GTK_RESPONSE_HELP); gtk_dialog_add_button (GTK_DIALOG (uca_chooser), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response (GTK_DIALOG (uca_chooser), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator (GTK_DIALOG (uca_chooser), FALSE); gtk_window_set_default_size (GTK_WINDOW (uca_chooser), 500, 350); gtk_window_set_destroy_with_parent (GTK_WINDOW (uca_chooser), TRUE); gtk_window_set_title (GTK_WINDOW (uca_chooser), _("Custom Actions")); hbox = gtk_hbox_new (FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (uca_chooser)->vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DND); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_widget_show (image); label = gtk_label_new (_("You can configure custom actions that will appear in the\n" "file managers context menus for certain kinds of files.")); gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (uca_chooser)->vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); swin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), swin, TRUE, TRUE, 0); gtk_widget_show (swin); uca_chooser->treeview = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (uca_chooser->treeview), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (uca_chooser->treeview), TRUE); gtk_container_add (GTK_CONTAINER (swin), uca_chooser->treeview); g_signal_connect_swapped (G_OBJECT (uca_chooser->treeview), "row-activated", G_CALLBACK (thunar_uca_chooser_edit_clicked), uca_chooser); gtk_widget_show (uca_chooser->treeview); uca_model = thunar_uca_model_get_default (); gtk_tree_view_set_model (GTK_TREE_VIEW (uca_chooser->treeview), GTK_TREE_MODEL (uca_model)); g_object_unref (G_OBJECT (uca_model)); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (uca_chooser->treeview), column); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, "stock-size", GTK_ICON_SIZE_DND, "xpad", 2, "ypad", 2, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "icon-name", THUNAR_UCA_MODEL_COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "markup", THUNAR_UCA_MODEL_COLUMN_STOCK_LABEL, NULL); vbox = gtk_vbox_new (FALSE, 3); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); uca_chooser->add_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->add_button, _("Add a new custom action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->add_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->add_button), "clicked", G_CALLBACK (thunar_uca_chooser_add_clicked), uca_chooser); gtk_widget_show (uca_chooser->add_button); image = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->add_button), image); gtk_widget_show (image); uca_chooser->edit_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->edit_button, _("Edit the currently selected action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->edit_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->edit_button), "clicked", G_CALLBACK (thunar_uca_chooser_edit_clicked), uca_chooser); gtk_widget_show (uca_chooser->edit_button); image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->edit_button), image); gtk_widget_show (image); uca_chooser->delete_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->delete_button, _("Delete the currently selected action.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->delete_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->delete_button), "clicked", G_CALLBACK (thunar_uca_chooser_delete_clicked), uca_chooser); gtk_widget_show (uca_chooser->delete_button); image = gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->delete_button), image); gtk_widget_show (image); uca_chooser->up_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->up_button, _("Move the currently selected action up by one row.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->up_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->up_button), "clicked", G_CALLBACK (thunar_uca_chooser_up_clicked), uca_chooser); gtk_widget_show (uca_chooser->up_button); image = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->up_button), image); gtk_widget_show (image); uca_chooser->down_button = gtk_button_new (); gtk_widget_set_tooltip_text (uca_chooser->down_button, _("Move the currently selected action down by one row.")); gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->down_button, FALSE, FALSE, 0); g_signal_connect_swapped (G_OBJECT (uca_chooser->down_button), "clicked", G_CALLBACK (thunar_uca_chooser_down_clicked), uca_chooser); gtk_widget_show (uca_chooser->down_button); image = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (uca_chooser->down_button), image); gtk_widget_show (image); /* configure the tree view selection after the buttons have been created */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (uca_chooser->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect_swapped (G_OBJECT (selection), "changed", G_CALLBACK (thunar_uca_chooser_selection_changed), uca_chooser); thunar_uca_chooser_selection_changed (uca_chooser, selection); }
void gnetconfig_if_detect_dlg_init (void) { GtkWidget *button_save; GtkWidget *button_cancel; GtkWidget *button_box; GtkWidget *vbox; GtkWidget *label; GtkWidget *scrollw; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeViewColumn *column; if_detect_dlg = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW(if_detect_dlg), 450, 200); scrollw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrollw), GTK_SHADOW_ETCHED_OUT); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrollw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_set_border_width (GTK_CONTAINER(if_detect_dlg), 8); gtk_window_set_title (GTK_WINDOW(if_detect_dlg), _("Detected Interfaces")); gtk_window_set_transient_for (GTK_WINDOW(if_detect_dlg), GTK_WINDOW(gn_if_add_dialog)); vbox = gtk_vbox_new (FALSE, 4); if_detect_treeview = gtk_tree_view_new (); label = gtk_label_new (_("The following interfaces were detected")); gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, TRUE, 2); gtk_container_add (GTK_CONTAINER(scrollw), GTK_WIDGET(if_detect_treeview)); gtk_box_pack_start (GTK_BOX(vbox), GTK_WIDGET(scrollw), TRUE, TRUE, 2); gtk_container_add (GTK_CONTAINER(if_detect_dlg), GTK_WIDGET(vbox)); store = gtk_list_store_new (5, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); gtk_tree_view_set_model (GTK_TREE_VIEW(if_detect_treeview), GTK_TREE_MODEL(store)); renderer = gtk_cell_renderer_pixbuf_new (); column = gtk_tree_view_column_new_with_attributes ("S", renderer, "pixbuf", 0, NULL); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW(if_detect_treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Interface", renderer, "text", 1, NULL); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_column_set_min_width (column, 40); g_object_set (G_OBJECT(column), "expand", FALSE, "spacing", 4, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(if_detect_treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", 2, NULL); gtk_tree_view_column_set_min_width (column, 60); gtk_tree_view_column_set_resizable (column, TRUE); g_object_set (G_OBJECT(column), "expand", TRUE, "spacing", 4, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(if_detect_treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Status", renderer, "text", 3, NULL); gtk_tree_view_column_set_min_width (column, 60); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW(if_detect_treeview), column); button_save = gtk_button_new_from_stock (GTK_STOCK_OK); button_cancel = gtk_button_new_from_stock (GTK_STOCK_CLOSE); button_box = gtk_hbutton_box_new (); gtk_container_add (GTK_CONTAINER(button_box), button_save); gtk_container_add (GTK_CONTAINER(button_box), button_cancel); gtk_box_pack_start (GTK_BOX(vbox), GTK_WIDGET(button_box), FALSE, FALSE, 2); g_signal_connect (G_OBJECT(button_save), "clicked", G_CALLBACK(cb_gn_if_detect_ok_clicked), NULL); g_signal_connect (G_OBJECT(button_cancel), "clicked", G_CALLBACK(cb_gn_if_detect_cancel_clicked), NULL); g_signal_connect (G_OBJECT(if_detect_dlg), "delete-event", G_CALLBACK(gtk_widget_hide), NULL); return; }
GtkWidget * itip_formatter_page_factory (EPlugin *ep, EConfigHookItemFactoryData *hook_data) { EShell *shell; ESourceRegistry *registry; GtkWidget *page; GtkWidget *tab_label; GtkWidget *frame; GtkWidget *frame_label; GtkWidget *padding_label; GtkWidget *hbox; GtkWidget *inner_vbox; GtkWidget *check; GtkWidget *label; GtkWidget *ess; GtkWidget *scrolledwin; gchar *str; GSettings *settings; shell = e_shell_get_default (); registry = e_shell_get_registry (shell); /* Create a new notebook page */ page = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (page), 12); tab_label = gtk_label_new (_("Meeting Invitations")); gtk_notebook_append_page (GTK_NOTEBOOK (hook_data->parent), page, tab_label); /* Frame */ frame = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0); /* "General" */ frame_label = gtk_label_new (""); str = g_strdup_printf ("<span weight=\"bold\">%s</span>", _("General")); gtk_label_set_markup (GTK_LABEL (frame_label), str); g_free (str); gtk_misc_set_alignment (GTK_MISC (frame_label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (frame), frame_label, FALSE, FALSE, 0); /* Indent/padding */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (frame), hbox, FALSE, TRUE, 0); padding_label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), padding_label, FALSE, FALSE, 0); inner_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (hbox), inner_vbox, FALSE, FALSE, 0); /* Delete message after acting */ settings = e_util_ref_settings ("org.gnome.evolution.plugin.itip"); check = gtk_check_button_new_with_mnemonic (_("_Delete message after acting")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), g_settings_get_boolean (settings, CONF_KEY_DELETE)); g_signal_connect ( check, "toggled", G_CALLBACK (delete_toggled_cb), NULL); gtk_box_pack_start (GTK_BOX (inner_vbox), check, FALSE, FALSE, 0); g_object_unref (settings); /* "Conflict searching" */ frame = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (page), frame, TRUE, TRUE, 24); frame_label = gtk_label_new (""); str = g_strdup_printf ("<span weight=\"bold\">%s</span>", _("Conflict Search")); gtk_label_set_markup (GTK_LABEL (frame_label), str); g_free (str); gtk_misc_set_alignment (GTK_MISC (frame_label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (frame), frame_label, FALSE, FALSE, 0); /* Indent/padding */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (frame), hbox, TRUE, TRUE, 0); padding_label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), padding_label, FALSE, FALSE, 0); inner_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (hbox), inner_vbox, TRUE, TRUE, 0); /* Source selector */ label = gtk_label_new (_("Select the calendars to search for meeting conflicts")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (inner_vbox), label, FALSE, FALSE, 0); scrolledwin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW (scrolledwin), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (inner_vbox), scrolledwin, TRUE, TRUE, 0); ess = e_conflict_search_selector_new (registry); atk_object_set_name (gtk_widget_get_accessible (ess), _("Conflict Search")); gtk_container_add (GTK_CONTAINER (scrolledwin), ess); gtk_widget_show_all (page); return page; }