GtkWidget * do_textview (GtkWidget *do_widget) { static GtkWidget *window = NULL; if (!window) { GtkWidget *vpaned; GtkWidget *view1; GtkWidget *view2; GtkWidget *sw; GtkTextBuffer *buffer; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_default_size (GTK_WINDOW (window), 450, 450); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "TextView"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5); gtk_container_add (GTK_CONTAINER (window), vpaned); /* For convenience, we just use the autocreated buffer from * the first text view; you could also create the buffer * by itself with gtk_text_buffer_new(), then later create * a view widget. */ view1 = gtk_text_view_new (); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view1)); view2 = gtk_text_view_new_with_buffer (buffer); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (vpaned), sw); gtk_container_add (GTK_CONTAINER (sw), view1); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add2 (GTK_PANED (vpaned), sw); gtk_container_add (GTK_CONTAINER (sw), view2); create_tags (buffer); insert_text (buffer); attach_widgets (GTK_TEXT_VIEW (view1)); attach_widgets (GTK_TEXT_VIEW (view2)); gtk_widget_show_all (vpaned); } if (!gtk_widget_get_visible (window)) { gtk_widget_show (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
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 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; }
/** * Statistic Viewer's constructor * * This constructor is used to create StatisticViewerData data structure. * @return The Statistic viewer data created. */ StatisticViewerData * gui_statistic(LttvPluginTab *ptab) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; StatisticViewerData* statistic_viewer_data = g_new(StatisticViewerData,1); statistic_viewer_data->live_trace_count = 0; Tab *tab = ptab->tab; statistic_viewer_data->tab = tab; statistic_viewer_data->ptab = ptab; // statistic_viewer_data->stats = // lttvwindow_get_traceset_stats(statistic_viewer_data->tab); // statistic_viewer_data->calculate_stats = // statistic_insert_traceset_stats((void *)statistic_viewer_data->stats); lttvwindow_register_traceset_notify(statistic_viewer_data->tab, statistic_traceset_changed, statistic_viewer_data); statistic_viewer_data->statistic_hash = g_hash_table_new_full(g_str_hash, g_str_equal, statistic_destroy_hash_key, NULL); statistic_viewer_data->hpaned_v = gtk_hpaned_new(); statistic_viewer_data->store_m = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING); statistic_viewer_data->tree_v = gtk_tree_view_new_with_model ( GTK_TREE_MODEL (statistic_viewer_data->store_m)); g_object_unref (G_OBJECT (statistic_viewer_data->store_m)); // Setup the selection handler statistic_viewer_data->select_c = gtk_tree_view_get_selection (GTK_TREE_VIEW (statistic_viewer_data->tree_v)); gtk_tree_selection_set_mode (statistic_viewer_data->select_c, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (statistic_viewer_data->select_c), "changed", G_CALLBACK (tree_selection_changed_cb), statistic_viewer_data); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Statistic Name", renderer, "text", NAME_COLUMN, NULL); gtk_tree_view_column_set_alignment (column, 0.0); // gtk_tree_view_column_set_fixed_width (column, 45); gtk_tree_view_append_column (GTK_TREE_VIEW (statistic_viewer_data->tree_v), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (statistic_viewer_data->tree_v), FALSE); statistic_viewer_data->scroll_win_tree = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(statistic_viewer_data->scroll_win_tree), GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (statistic_viewer_data->scroll_win_tree), statistic_viewer_data->tree_v); gtk_paned_pack1(GTK_PANED(statistic_viewer_data->hpaned_v),statistic_viewer_data->scroll_win_tree, TRUE, FALSE); gtk_paned_set_position(GTK_PANED(statistic_viewer_data->hpaned_v), 160); statistic_viewer_data->scroll_win_text = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(statistic_viewer_data->scroll_win_text), GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); statistic_viewer_data->text_v = gtk_text_view_new (); gtk_text_view_set_editable(GTK_TEXT_VIEW(statistic_viewer_data->text_v),FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(statistic_viewer_data->text_v),FALSE); gtk_container_add (GTK_CONTAINER (statistic_viewer_data->scroll_win_text), statistic_viewer_data->text_v); gtk_paned_pack2(GTK_PANED(statistic_viewer_data->hpaned_v), statistic_viewer_data->scroll_win_text, TRUE, FALSE); gtk_container_set_border_width( GTK_CONTAINER(statistic_viewer_data->hpaned_v), 1); gtk_widget_show(statistic_viewer_data->scroll_win_tree); gtk_widget_show(statistic_viewer_data->scroll_win_text); gtk_widget_show(statistic_viewer_data->tree_v); gtk_widget_show(statistic_viewer_data->text_v); gtk_widget_show(statistic_viewer_data->hpaned_v); g_object_set_data_full( G_OBJECT(guistatistic_get_widget(statistic_viewer_data)), "statistic_viewer_data", statistic_viewer_data, (GDestroyNotify)gui_statistic_destructor); /* Add the object's information to the module's array */ g_statistic_viewer_data_list = g_slist_append( g_statistic_viewer_data_list, statistic_viewer_data); request_background_data(statistic_viewer_data); return statistic_viewer_data; }
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; }
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)); }
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; }
void tasks_add_edit_dialog_show (gboolean tasks_edit_mode, GUI *appGUI) { GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *label; GtkWidget *select_date_button; GtkWidget *scrolledwindow; GtkWidget *hseparator; GtkWidget *hbuttonbox; GtkWidget *table; GtkWidget *cancel_button; gchar tmpbuf[BUFFER_SIZE]; appGUI->tsk->tasks_add_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (appGUI->tsk->tasks_add_window), 6); if(tasks_edit_mode == TRUE) { gtk_window_set_title (GTK_WINDOW (appGUI->tsk->tasks_add_window), _("Edit task")); } else { gtk_window_set_title (GTK_WINDOW (appGUI->tsk->tasks_add_window), _("Add task")); } gtk_window_move (GTK_WINDOW (appGUI->tsk->tasks_add_window), config.tasks_addedit_win_x, config.tasks_addedit_win_y); gtk_window_set_default_size (GTK_WINDOW(appGUI->tsk->tasks_add_window), config.tasks_addedit_win_w, config.tasks_addedit_win_h); gtk_window_set_transient_for(GTK_WINDOW(appGUI->tsk->tasks_add_window), GTK_WINDOW(appGUI->main_window)); gtk_window_set_modal(GTK_WINDOW(appGUI->tsk->tasks_add_window), TRUE); g_signal_connect (G_OBJECT (appGUI->tsk->tasks_add_window), "key_press_event", G_CALLBACK (tasks_add_edit_key_press_cb), appGUI); g_signal_connect (G_OBJECT (appGUI->tsk->tasks_add_window), "delete_event", G_CALLBACK(tasks_add_edit_window_close_cb), appGUI); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (appGUI->tsk->tasks_add_window), vbox1); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0); table = gtk_table_new (4, 4, FALSE); gtk_widget_show (table); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_box_pack_start (GTK_BOX (vbox2), table, FALSE, FALSE, 4); sprintf(tmpbuf, "<b>%s:</b>", _("Summary")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); sprintf(tmpbuf, "<b>%s:</b>", _("Due date")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->tsk->summary_entry = gtk_entry_new (); gtk_widget_show (appGUI->tsk->summary_entry); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->summary_entry, 1, 4, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); appGUI->tsk->due_date_entry = gtk_entry_new (); gtk_widget_show (appGUI->tsk->due_date_entry); GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->due_date_entry, GTK_CAN_FOCUS); gtk_editable_set_editable (GTK_EDITABLE (appGUI->tsk->due_date_entry), FALSE); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->due_date_entry, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); select_date_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_SELECT_DATE); gtk_widget_show (select_date_button); GTK_WIDGET_UNSET_FLAGS(select_date_button, GTK_CAN_FOCUS); g_signal_connect(select_date_button, "clicked", G_CALLBACK(select_date_cb), appGUI); gtk_table_attach (GTK_TABLE (table), select_date_button, 2, 4, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); sprintf(tmpbuf, "<b>%s:</b>", _("Category")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->tsk->category_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->category_combobox); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->category_combobox), FALSE); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->category_combobox, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); create_category_combobox (GTK_COMBO_BOX (appGUI->tsk->category_combobox), appGUI->opt->tasks_category_store, TRUE); gtk_combo_box_set_active(GTK_COMBO_BOX(appGUI->tsk->category_combobox), gui_list_store_get_text_index (appGUI->opt->tasks_category_store, gtk_combo_box_get_active_text(GTK_COMBO_BOX(appGUI->tsk->cf_combobox)))); sprintf(tmpbuf, "<b>%s:</b>", _("Priority")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_table_attach (GTK_TABLE (table), label, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->tsk->priority_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->priority_combobox); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), _("Low")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), _("Medium")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), _("High")); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), FALSE); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->priority_combobox, 3, 4, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_combo_box_set_active (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), 1); sprintf(tmpbuf, "<b>%s:</b>", _("Description")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox2), scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); appGUI->tsk->desc_textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->desc_textview), GTK_WRAP_WORD); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->desc_textview), 4); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->desc_textview), 4); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->desc_textview), 4); gtk_widget_show (appGUI->tsk->desc_textview); gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->tsk->desc_textview); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4); hbuttonbox = gtk_hbutton_box_new (); gtk_widget_show (hbuttonbox); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox), 2); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (hbuttonbox), 16); if (config.default_stock_icons) { cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); } else { cancel_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_CANCEL); } gtk_widget_show (cancel_button); gtk_container_add (GTK_CONTAINER (hbuttonbox), cancel_button); g_signal_connect(cancel_button, "clicked", G_CALLBACK(button_tasks_add_edit_window_close_cb), appGUI); if (config.default_stock_icons) { appGUI->tsk->tasks_ok_button = gtk_button_new_from_stock (GTK_STOCK_OK); } else { appGUI->tsk->tasks_ok_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_OK); } gtk_widget_show (appGUI->tsk->tasks_ok_button); gtk_container_add (GTK_CONTAINER (hbuttonbox), appGUI->tsk->tasks_ok_button); g_signal_connect(appGUI->tsk->tasks_ok_button, "clicked", G_CALLBACK(tasks_item_entered_cb), appGUI); appGUI->tsk->tasks_edit_state = tasks_edit_mode; appGUI->tsk->tasks_accept_state = FALSE; gtk_entry_set_text (GTK_ENTRY(appGUI->tsk->due_date_entry), _("No date")); if (tasks_edit_mode == TRUE) { appGUI->tsk->tasks_accept_state = TRUE; fill_fields (appGUI->tsk->due_date_entry, appGUI->tsk->summary_entry, appGUI->tsk->desc_textview, appGUI); } gtk_widget_set_sensitive(appGUI->tsk->tasks_ok_button, appGUI->tsk->tasks_accept_state); gtk_widget_show(appGUI->tsk->tasks_add_window); }
/** * entry_properties_new: * * Returns: a new #GtkWidget */ GtkWidget * entry_properties_new (TConnection *tcnc) { EntryProperties *eprop; g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL); eprop = ENTRY_PROPERTIES (g_object_new (ENTRY_PROPERTIES_TYPE, NULL)); eprop->priv->tcnc = g_object_ref (tcnc); GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (eprop), sw, TRUE, TRUE, 0); GtkWidget *textview; textview = gtk_text_view_new (); gtk_container_add (GTK_CONTAINER (sw), textview); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview), 5); gtk_text_view_set_right_margin (GTK_TEXT_VIEW (textview), 5); gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), FALSE); eprop->priv->text = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview)); eprop->priv->view = GTK_TEXT_VIEW (textview); gtk_widget_show_all (sw); gtk_text_buffer_create_tag (eprop->priv->text, "section", "weight", PANGO_WEIGHT_BOLD, "foreground", "blue", NULL); gtk_text_buffer_create_tag (eprop->priv->text, "error", "foreground", "red", NULL); gtk_text_buffer_create_tag (eprop->priv->text, "data", "left-margin", 20, NULL); gtk_text_buffer_create_tag (eprop->priv->text, "convdata", "style", PANGO_STYLE_ITALIC, "background", "lightgray", "left-margin", 20, NULL); gtk_text_buffer_create_tag (eprop->priv->text, "starter", "indent", -10, "left-margin", 20, NULL); g_signal_connect (textview, "key-press-event", G_CALLBACK (key_press_event), eprop); g_signal_connect (textview, "event-after", G_CALLBACK (event_after), eprop); g_signal_connect (textview, "motion-notify-event", G_CALLBACK (motion_notify_event), eprop); g_signal_connect (textview, "visibility-notify-event", G_CALLBACK (visibility_notify_event), eprop); g_signal_connect (textview, "populate-popup", G_CALLBACK (populate_popup_cb), eprop); entry_properties_set_dn (eprop, NULL); return (GtkWidget*) eprop; }
GtkWidget * userlist_create (GtkWidget *box) { GtkWidget *sw, *treeview; static const GtkTargetEntry dnd_dest_targets[] = { {"text/uri-list", 0, 1}, {"XCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 } }; static const GtkTargetEntry dnd_src_target[] = { {"XCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 } }; 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), prefs.pchat_gui_ulist_show_hosts ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (box), sw, TRUE, TRUE, 0); gtk_widget_show (sw); treeview = gtk_tree_view_new (); gtk_widget_set_name (treeview, "xchat-userlist"); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_MULTIPLE); /* set up drops */ gtk_drag_dest_set (treeview, GTK_DEST_DEFAULT_ALL, dnd_dest_targets, 2, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK); gtk_drag_source_set (treeview, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_MOVE); /* file DND (for DCC) */ g_signal_connect (G_OBJECT (treeview), "drag_motion", G_CALLBACK (userlist_dnd_motion), treeview); g_signal_connect (G_OBJECT (treeview), "drag_leave", G_CALLBACK (userlist_dnd_leave), 0); g_signal_connect (G_OBJECT (treeview), "drag_data_received", G_CALLBACK (userlist_dnd_drop), treeview); g_signal_connect (G_OBJECT (treeview), "button_press_event", G_CALLBACK (userlist_click_cb), 0); g_signal_connect (G_OBJECT (treeview), "key_press_event", G_CALLBACK (userlist_key_cb), 0); /* tree/chanview DND */ #ifndef _WIN32 /* leaks GDI pool memory, don't enable */ g_signal_connect (G_OBJECT (treeview), "drag_begin", G_CALLBACK (mg_drag_begin_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_drop", G_CALLBACK (mg_drag_drop_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_motion", G_CALLBACK (mg_drag_motion_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_end", G_CALLBACK (mg_drag_end_cb), NULL); #endif userlist_add_columns (GTK_TREE_VIEW (treeview)); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_widget_show (treeview); return treeview; }
void gui_create_tasks(GUI *appGUI) { GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *table; GtkWidget *label; GtkWidget *top_scrolledwindow; GtkWidget *hseparator; GtkWidget *close_button; GtkCellRenderer *renderer; GtkWidget *top_viewport; GtkWidget *bottom_viewport; GtkTextBuffer *text_buffer; GError *error = NULL; GtkActionGroup *action_group = NULL; gchar tmpbuf[BUFFER_SIZE]; const gchar *ui_info = " <toolbar name=\"toolbar\">\n" " <toolitem name=\"add\" action=\"add\" />\n" " <toolitem name=\"delete\" action=\"delete\" />\n" " <separator name=\"sep1\" />\n" " <toolitem name=\"edit\" action=\"edit\" />\n" " </toolbar>\n"; GtkActionEntry entries[] = { { "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL }, { "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL }, { "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL }, }; guint n_entries = G_N_ELEMENTS (entries); appGUI->tsk->filter_index = 0; vbox1 = gtk_vbox_new (FALSE, 1); gtk_widget_show (vbox1); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8); sprintf(tmpbuf, "<b>%s</b>", _("Tasks")); gui_add_to_notebook (vbox1, tmpbuf, appGUI); appGUI->tsk->vbox = GTK_BOX(vbox1); /*-------------------------------------------------------------------------------------*/ action_group = gtk_action_group_new ("_actions"); gtk_action_group_add_actions (action_group, entries, n_entries, NULL); gtk_action_group_set_sensitive(action_group, TRUE); appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0); g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI); if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) { g_message ("building toolbar failed: %s", error->message); g_error_free (error); } gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget); gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS); gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips); /*-------------------------------------------------------------------------------------*/ /* assign callbacks */ g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked", G_CALLBACK(tasks_add_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked", G_CALLBACK(tasks_edit_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked", G_CALLBACK(tasks_remove_item_cb), appGUI); /*-------------------------------------------------------------------------------------*/ gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE); gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); table = gtk_table_new (1, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 8); sprintf(tmpbuf, "<b>%s:</b>", _("Category filter")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); appGUI->tsk->cf_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->cf_combobox); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE); GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(appGUI->tsk->cf_combobox, "changed", G_CALLBACK(category_filter_cb), appGUI); g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus", G_CALLBACK(category_combo_box_focus_cb), NULL); appGUI->tsk->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->tsk->n_items_label); gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); /*-------------------------------------------------------------------------------------*/ appGUI->tsk->tasks_paned = gtk_vpaned_new(); gtk_widget_show (appGUI->tsk->tasks_paned); gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999); gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0); top_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (top_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE); gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE); top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (top_scrolledwindow); gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter), (GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb, appGUI, NULL); appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter)); appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint); gtk_widget_show (appGUI->tsk->tasks_list); GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED])); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL])); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event", G_CALLBACK(list_dbclick_cb), appGUI); appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list)); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed", G_CALLBACK(tasks_item_selected), appGUI); /* create columns */ renderer = gtk_cell_renderer_toggle_new(); appGUI->tsk->tasks_columns[COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"), renderer, "active", COLUMN_DONE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DONE]); g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"), renderer, "text", COLUMN_DUE_DATE, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE], config.visible_due_date_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_DUE_DATE_JULIAN, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_START_DATE_JULIAN, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"), renderer, "text", COLUMN_PRIORITY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_PRIORITY], config.visible_priority_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_PRIORITY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"), renderer, "text", COLUMN_CATEGORY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_CATEGORY], config.visible_category_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_CATEGORY]); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_renderer_set_fixed_size(renderer, 0, -1); appGUI->tsk->tasks_columns[COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"), renderer, "text", COLUMN_SUMMARY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_SUMMARY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", COLUMN_DESCRIPTION, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_COLOR], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_COLOR]); /* configure list options */ gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE); /* configure sorting */ gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0, (GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DUE_DATE, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_PRIORITY, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DONE, config.tasks_sorting_order); /*----------------------------------------------------------------------------*/ bottom_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (bottom_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE); gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0); gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2); appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0); gtk_widget_show(appGUI->tsk->panel_hbox); sprintf(tmpbuf, "%s:", _("Task details")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0); if (config.default_stock_icons) { close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE); } else { close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE); } GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS); gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE); gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL); gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (panel_close_desc_cb), appGUI); appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (appGUI->tsk->panel_scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_desc_textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_widget_show (appGUI->tsk->tasks_desc_textview); gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview); text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview)); gtk_text_buffer_create_tag (text_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL); appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font", "font", (gchar *) config.task_info_font, NULL); }
static void gb_book_links_construct (GbBookLinks *self) { GbBookLinksPrivate *priv; GtkWidget *swindow; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; priv = self->priv; swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow), GTK_SHADOW_IN); /* Create tree view */ priv->tree_view = gtk_tree_view_new (); gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW (priv->tree_view), TRUE); g_signal_connect_swapped (priv->tree_view, "row-activated", G_CALLBACK (schedule_emit_link_activated), self); gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (priv->tree_view), FALSE); gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (priv->tree_view), 20); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view), FALSE); gtk_container_add (GTK_CONTAINER (swindow), priv->tree_view); gtk_box_pack_start (GTK_BOX (self), swindow, TRUE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (self)); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), column); renderer = (GtkCellRenderer *) g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, "weight", PANGO_WEIGHT_BOLD, "xpad", 10, NULL); gtk_tree_view_column_pack_start (GTK_TREE_VIEW_COLUMN (column), renderer, TRUE); gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer, "markup", BOOK_LINKS_COLUMN_MARKUP, NULL); renderer = gd_styled_text_renderer_new (); gd_styled_text_renderer_add_class (GD_STYLED_TEXT_RENDERER (renderer), "dim-label"); g_object_set (renderer, "max-width-chars", 12, "scale", PANGO_SCALE_SMALL, "xalign", 1.0, "xpad", 10, NULL); gtk_tree_view_column_pack_end (GTK_TREE_VIEW_COLUMN (column), renderer, FALSE); /* gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer, "text", BOOK_LINKS_COLUMN_LABEL, NULL); */ priv->model = (GtkTreeModel *)gtk_list_store_new (BOOK_LINKS_COLUMN_N, G_TYPE_STRING, G_TYPE_STRING); }
static PanelAddtoDialog * panel_addto_dialog_new (PanelWidget *panel_widget) { PanelAddtoDialog *dialog; GtkWidget *dialog_vbox; #if !GTK_CHECK_VERSION (3, 0, 0) GtkWidget *vbox; #endif GtkWidget *inner_vbox; GtkWidget *find_hbox; GtkWidget *sw; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; dialog = g_new0 (PanelAddtoDialog, 1); g_object_set_qdata_full (G_OBJECT (panel_widget->toplevel), panel_addto_dialog_quark, dialog, (GDestroyNotify) panel_addto_dialog_free); dialog->panel_widget = panel_widget; g_signal_connect (dialog->panel_widget->toplevel->settings, "changed::" PANEL_TOPLEVEL_NAME_KEY, G_CALLBACK (panel_addto_name_notify), dialog); dialog->addto_dialog = gtk_dialog_new (); gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP); dialog->back_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_GO_BACK, PANEL_ADDTO_RESPONSE_BACK); dialog->add_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_ADD, PANEL_ADDTO_RESPONSE_ADD); gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (dialog->addto_dialog), PANEL_ADDTO_RESPONSE_ADD); gtk_container_set_border_width (GTK_CONTAINER (dialog->addto_dialog), 5); dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog->addto_dialog)); #if GTK_CHECK_VERSION (3, 0, 0) gtk_box_set_spacing (GTK_BOX (dialog_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5); #else gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2); #endif g_signal_connect (G_OBJECT (dialog->addto_dialog), "response", G_CALLBACK (panel_addto_dialog_response), dialog); g_signal_connect (dialog->addto_dialog, "destroy", G_CALLBACK (panel_addto_dialog_destroy), dialog); #if !GTK_CHECK_VERSION (3, 0, 0) vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_container_add (GTK_CONTAINER (dialog_vbox), vbox); #endif inner_vbox = gtk_vbox_new (FALSE, 6); #if GTK_CHECK_VERSION (3, 0, 0) gtk_box_pack_start (GTK_BOX (dialog_vbox), inner_vbox, TRUE, TRUE, 0); #else gtk_box_pack_start (GTK_BOX (vbox), inner_vbox, TRUE, TRUE, 0); #endif find_hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (inner_vbox), find_hbox, FALSE, FALSE, 0); dialog->label = gtk_label_new_with_mnemonic (""); gtk_misc_set_alignment (GTK_MISC (dialog->label), 0.0, 0.5); gtk_label_set_use_markup (GTK_LABEL (dialog->label), TRUE); gtk_box_pack_start (GTK_BOX (find_hbox), dialog->label, FALSE, FALSE, 0); dialog->search_entry = gtk_entry_new (); g_signal_connect (G_OBJECT (dialog->search_entry), "changed", G_CALLBACK (panel_addto_search_entry_changed), dialog); g_signal_connect (G_OBJECT (dialog->search_entry), "activate", G_CALLBACK (panel_addto_search_entry_activated), dialog); gtk_box_pack_end (GTK_BOX (find_hbox), dialog->search_entry, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (dialog->label), dialog->search_entry); 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_box_pack_start (GTK_BOX (inner_vbox), sw, TRUE, TRUE, 0); dialog->tree_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->tree_view), FALSE); gtk_tree_view_expand_all (GTK_TREE_VIEW (dialog->tree_view)); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, "xpad", 4, "ypad", 4, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view), -1, NULL, renderer, "pixbuf", COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view), -1, NULL, renderer, "markup", COLUMN_TEXT, NULL); //FIXME use the same search than the one for the search entry? gtk_tree_view_set_search_column (GTK_TREE_VIEW (dialog->tree_view), COLUMN_SEARCH); gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (dialog->tree_view), panel_addto_separator_func, GINT_TO_POINTER (COLUMN_TEXT), NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->tree_view), COLUMN_TEXT); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect (selection, "changed", G_CALLBACK (panel_addto_selection_changed), dialog); g_signal_connect (dialog->tree_view, "row-activated", G_CALLBACK (panel_addto_selection_activated), dialog); gtk_container_add (GTK_CONTAINER (sw), dialog->tree_view); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_show_all (dialog_vbox); #else gtk_widget_show_all (vbox); #endif panel_toplevel_push_autohide_disabler (dialog->panel_widget->toplevel); panel_widget_register_open_dialog (panel_widget, dialog->addto_dialog); panel_addto_name_change (dialog, panel_toplevel_get_name (dialog->panel_widget->toplevel)); return dialog; }
GtkWidget * do_tree_store (GtkWidget *do_widget) { if (!window) { GtkWidget *vbox; GtkWidget *sw; GtkWidget *treeview; GtkTreeModel *model; /* create window, etc */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Card planning sheet"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("Jonathan's Holiday Card Planning Sheet"), FALSE, FALSE, 0); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); /* create model */ model = create_model (); /* create tree view */ treeview = gtk_tree_view_new_with_model (model); g_object_unref (model); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_MULTIPLE); add_columns (GTK_TREE_VIEW (treeview)); gtk_container_add (GTK_CONTAINER (sw), treeview); /* expand all rows after the treeview widget has been realized */ g_signal_connect (treeview, "realize", G_CALLBACK (gtk_tree_view_expand_all), NULL); gtk_window_set_default_size (GTK_WINDOW (window), 650, 400); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else { gtk_widget_destroy (window); window = NULL; } return window; }
/*主界面进入点*/ int main(int argc,char **argv) { GtkWidget *win; GtkWidget *menu; GtkWidget *menu_bar; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *text; GtkWidget *scrolled; GtkWidget *open; GtkWidget *close; GtkWidget *clean; GtkTextBuffer *buffer; GtkAccelGroup *accel_group; PangoFontDescription *font_name; DATA data; CONFDATA conf; ABOUT about_data; //HELP help_data; struct sigaction act,old; setpgrp(); init_with_conf(&conf); init_about_data(&about_data); //init_help_data(&help_data); data.buf=g_string_new(NULL); data.python_path=conf.python_path; data.proxy_py_path=conf.proxy_py_path; setlocale(LC_ALL,""); /*设置语言环境*/ if(conf.language_env == NULL) { setlocale(LC_CTYPE,"zh_CN.UTF-8"); setenv("LANG","zh_CN.UTF-8",1); } else { setlocale(LC_CTYPE,conf.language_env); setenv("LANG",conf.language_env,1); } if(conf.gtk_goagent_path!=NULL) chdir(conf.gtk_goagent_path); /*是否自动更新 * 如果是则在后台运行版更新进程 */ if(strcmp(conf.goagent_auto_upgrade,"true")==0) auto_upgrade_goagent(GOAGENT_URL,&conf); /*国际化*/ bindtextdomain("gtk_goagent","./locale/"); textdomain("gtk_goagent"); act.sa_flags=0; act.sa_handler=clean_data; /*设置自定义信号处理 * 用于在启动GoAgent失败时清理数据 */ sigaction(SIGUSR1,&act,&old); gtk_init(&argc,&argv); win=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER); gtk_window_set_title(GTK_WINDOW(win),"Gtk GoAgent"); gtk_window_set_icon_from_file(GTK_WINDOW(win),"img/64x64/gtk_goagent.png",NULL); create_tray(win); //create_pre_ui(&pre,&conf); vbox=gtk_vbox_new(FALSE,0); accel_group=gtk_accel_group_new(); gtk_window_add_accel_group(GTK_WINDOW(win),accel_group); gtk_container_add(GTK_CONTAINER(win),vbox); text=gtk_text_view_new(); /*设置日志显示框字体*/ if(conf.font!=NULL) { font_name=pango_font_description_from_string(conf.font); gtk_widget_modify_font(text,font_name); } buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)); /*创建红色黑色和黄色标记 * 正常日志黑色输出 * 绿色用于警告 * 红色用于错误 * 黄色用于调试 */ gtk_text_buffer_create_tag(buffer,"green_fg", "foreground","green",NULL); gtk_text_buffer_create_tag(buffer,"red_fg","foreground", "red",NULL); gtk_text_buffer_create_tag(buffer,"black_fg","foreground", "black",NULL); gtk_text_buffer_create_tag(buffer,"yellow_fg", "foreground","yellow",NULL); data.text=text; data.off=0; menu_bar=gtk_menu_bar_new(); gtk_box_pack_start(GTK_BOX(vbox),menu_bar,FALSE,FALSE,0); /*创建菜单*/ menu=create_menu(menu_bar,_("_File")); create_menu_with_image(menu,GTK_STOCK_OPEN,accel_group,connect_goagent,&data); create_menu_with_image(menu,GTK_STOCK_CLOSE,accel_group,disconnect_goagent,&data); gtk_menu_shell_append(GTK_MENU_SHELL(menu),gtk_separator_menu_item_new()); create_menu_with_image(menu,GTK_STOCK_QUIT,accel_group,really_quit,&data); menu=create_menu(menu_bar,_("_Edit")); create_menu_with_image(menu,GTK_STOCK_PREFERENCES,accel_group,preferences,NULL); create_menu_with_image(menu,_("Up_load"),accel_group,upload,&conf); menu=create_menu(menu_bar,_("_Help")); create_menu_with_image(menu,GTK_STOCK_HELP,accel_group,help,NULL); create_menu_with_image(menu,GTK_STOCK_ABOUT,accel_group,about,&about_data); gtk_menu_shell_append(GTK_MENU_SHELL(menu),gtk_separator_menu_item_new()); create_menu_with_image(menu,_("Upgrade GoAg_ent"),accel_group,upgrade_goagent,conf.proxy_py_path); //create_menu_with_image(menu,_("Upgrade _Gtk GoAGent"),accel_group,upgrade_gtk_goagent,NULL); gtk_widget_set_size_request(text,0x300,0x180); /*设置显示构件不可编辑和自动换行*/ gtk_text_view_set_editable(GTK_TEXT_VIEW(text),FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text),GTK_WRAP_CHAR); /*创建滚动条并设置自动更新*/ 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(GTK_CONTAINER(scrolled),text); gtk_box_pack_start(GTK_BOX(vbox),scrolled,FALSE,FALSE,0); gtk_box_pack_start(GTK_BOX(vbox),gtk_separator_menu_item_new(),FALSE,FALSE,5); show_time(vbox); gtk_box_pack_start(GTK_BOX(vbox),gtk_separator_menu_item_new(),FALSE,FALSE,5); hbox=gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,5); open=gtk_button_new_with_label(_("Connect")); gtk_box_pack_start(GTK_BOX(hbox),open,FALSE,FALSE,30); g_signal_connect(G_OBJECT(open),"clicked",G_CALLBACK(connect_goagent),&data); clean=gtk_button_new_with_label(_("Clean")); gtk_box_pack_start(GTK_BOX(hbox),clean,TRUE,TRUE,100); g_signal_connect(G_OBJECT(clean),"clicked",G_CALLBACK(clean_buffer),&data); close=gtk_button_new_with_label(_("Disconnect")); gtk_box_pack_end(GTK_BOX(hbox),close,FALSE,FALSE,30); g_signal_connect(G_OBJECT(close),"clicked",G_CALLBACK(disconnect_goagent),&data); g_signal_connect(G_OBJECT(win),"delete_event",G_CALLBACK(really_quit),NULL); gtk_widget_show_all(win); gtk_main(); //setpgrp(); g_idle_remove_by_data(&data); g_string_free(data.buf,TRUE); kill(0,SIGKILL); //killpg(getpgrp(),SIGKILL); while(waitpid(-1,NULL,WNOHANG)!=-1); //g_idle_remove_by_data(&data); return 0; }
GtkWidget * create_disk_view(ProcData *procdata) { GtkWidget *disk_box; GtkWidget *scrolled; GtkWidget *disk_tree; GtkListStore *model; GtkTreeViewColumn *col; GtkCellRenderer *cell; guint i; const gchar * const titles[] = { N_("Device"), N_("Directory"), N_("Type"), N_("Total"), N_("Free"), N_("Available"), N_("Used") }; disk_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width(GTK_CONTAINER(disk_box), 12); 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(disk_box), scrolled, TRUE, TRUE, 0); model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */ G_TYPE_STRING, /* DISK_DEVICE */ G_TYPE_STRING, /* DISK_DIR */ G_TYPE_STRING, /* DISK_TYPE */ G_TYPE_UINT64, /* DISK_TOTAL */ G_TYPE_UINT64, /* DISK_FREE */ G_TYPE_UINT64, /* DISK_AVAIL */ G_TYPE_UINT64, /* DISK_USED */ GDK_TYPE_PIXBUF, /* DISK_ICON */ G_TYPE_INT /* DISK_USED_PERCENTAGE */ ); disk_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL); procdata->disk_list = disk_tree; gtk_container_add(GTK_CONTAINER(scrolled), disk_tree); g_object_unref(G_OBJECT(model)); /* icon + device */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON, NULL); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE, NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE])); gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_min_width (col, 30); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); /* sizes - used */ for (i = DISK_DIR; i <= DISK_AVAIL; i++) { cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_title(col, _(titles[i])); gtk_tree_view_column_set_sort_column_id(col, i); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_min_width (col, 30); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); switch (i) { case DISK_TOTAL: case DISK_FREE: case DISK_AVAIL: g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_cell_data_func, GUINT_TO_POINTER(i), NULL); break; default: gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL); break; } } /* used + percentage */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_text_new(); g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_cell_data_func, GUINT_TO_POINTER(DISK_USED), NULL); cell = gtk_cell_renderer_progress_new(); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_attributes(col, cell, "value", DISK_USED_PERCENTAGE, NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_USED])); gtk_tree_view_column_set_sort_column_id(col, DISK_USED); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_min_width (col, 150); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); /* numeric sort */ gtk_widget_show_all(disk_box); procman_get_tree_state(procdata->settings, disk_tree, "disktreenew"); g_signal_connect (G_OBJECT(disk_tree), "columns-changed", G_CALLBACK(cb_disk_columns_changed), procdata); return disk_box; }
static void gimp_palette_editor_init (GimpPaletteEditor *editor) { GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor); GtkWidget *hbox; GtkWidget *label; GtkWidget *spinbutton; editor->zoom_factor = 1.0; editor->col_width = 0; editor->last_width = 0; editor->columns = COLUMNS; data_editor->view = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (data_editor->view, -1, PREVIEW_HEIGHT); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data_editor->view), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (editor), data_editor->view, TRUE, TRUE, 0); gtk_widget_show (data_editor->view); editor->view = gimp_view_new_full_by_types (NULL, GIMP_TYPE_PALETTE_VIEW, GIMP_TYPE_PALETTE, PREVIEW_WIDTH, PREVIEW_HEIGHT, 0, FALSE, TRUE, FALSE); gimp_view_renderer_palette_set_cell_size (GIMP_VIEW_RENDERER_PALETTE (GIMP_VIEW (editor->view)->renderer), -1); gimp_view_renderer_palette_set_draw_grid (GIMP_VIEW_RENDERER_PALETTE (GIMP_VIEW (editor->view)->renderer), TRUE); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (data_editor->view), editor->view); gtk_widget_show (editor->view); g_signal_connect (gtk_widget_get_parent (editor->view), "size-allocate", G_CALLBACK (palette_editor_viewport_size_allocate), editor); g_signal_connect (editor->view, "entry-clicked", G_CALLBACK (palette_editor_entry_clicked), editor); g_signal_connect (editor->view, "entry-selected", G_CALLBACK (palette_editor_entry_selected), editor); g_signal_connect (editor->view, "entry-activated", G_CALLBACK (palette_editor_entry_activated), editor); g_signal_connect (editor->view, "entry-context", G_CALLBACK (palette_editor_entry_context), editor); g_signal_connect (editor->view, "color-dropped", G_CALLBACK (palette_editor_color_dropped), editor); gimp_dnd_viewable_dest_add (editor->view, GIMP_TYPE_PALETTE, palette_editor_drop_palette, editor); gimp_dnd_viewable_dest_add (gtk_widget_get_parent (editor->view), GIMP_TYPE_PALETTE, palette_editor_drop_palette, editor); gimp_dnd_color_dest_add (gtk_widget_get_parent (editor->view), palette_editor_drop_color, editor); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (editor), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* The color name entry */ editor->color_name = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox), editor->color_name, TRUE, TRUE, 0); gtk_entry_set_text (GTK_ENTRY (editor->color_name), _("Undefined")); gtk_editable_set_editable (GTK_EDITABLE (editor->color_name), FALSE); gtk_widget_show (editor->color_name); g_signal_connect (editor->color_name, "changed", G_CALLBACK (palette_editor_color_name_changed), editor); label = gtk_label_new (_("Columns:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); editor->columns_adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 64, 1, 4, 0); spinbutton = gtk_spin_button_new (editor->columns_adj, 1.0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); g_signal_connect (editor->columns_adj, "value-changed", G_CALLBACK (palette_editor_columns_changed), editor); }
static GdkWindow * draw_popup_image (GtkWidget *widget, GtkTreePath *path, GtkTreeViewColumn *column, GdkRegion *tr) { g_assert (GTK_IS_TREE_VIEW (widget)); g_assert (!GTK_WIDGET_NO_WINDOW (widget)); /* Iterator for the data in the current row of the list. */ GtkTreeIter iter; gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store), &iter, path); char *file, *ancillary_file, *polsarpro_aux_info, *uavsar_type; gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter, COL_INPUT_FILE, &file, COL_ANCILLARY_FILE, &ancillary_file, COL_UAVSAR_TYPE, &uavsar_type, COL_POLSARPRO_INFO, &polsarpro_aux_info, -1); char *metadata_file = meta_file_name (file); char *data_file = data_file_name (file, uavsar_type); char *lut_basename = extract_lut_name(polsarpro_aux_info); if (is_polsarpro(file)) { if(strlen(metadata_file) > 0) { g_free(data_file); data_file = (gchar*)g_malloc(sizeof(gchar)*(strlen(metadata_file) + 1)); sprintf(data_file, "%s", metadata_file); } else { g_free(metadata_file); metadata_file = (gchar*)g_malloc(sizeof(gchar)*(strlen(data_file) + 5)); sprintf(metadata_file, "%s%s", data_file, ".hdr"); } if (!fileExists(metadata_file)) strcpy(metadata_file, ""); } GdkPixbuf *popup_image_pixbuf = make_input_image_thumbnail_pixbuf (metadata_file, data_file, lut_basename, uavsar_type, THUMB_SIZE_BIG); if (!popup_image_pixbuf && strlen(ancillary_file) > 0) { popup_image_pixbuf = make_input_image_thumbnail_pixbuf ( ancillary_file, ancillary_file, lut_basename, uavsar_type, THUMB_SIZE_BIG); } g_free(file); g_free(ancillary_file); g_free(metadata_file); g_free(data_file); g_free(polsarpro_aux_info); free(lut_basename); if (popup_image_pixbuf) { /* We want to center the popup over the original thumbnail. Since we know the original thumbnail is square, the clipbox corresponds to the region, so we can just get the clipbox of the thumbnail and take the center of that as the center of our popum image. */ GdkRectangle tn_rec; gdk_region_get_clipbox (tr, &tn_rec); gint tree_view_x, tree_view_y; gdk_window_get_origin (widget->window, &tree_view_x, &tree_view_y); GdkWindowAttr nwa; nwa.event_mask = GDK_ALL_EVENTS_MASK; // popup must take into account any horizontal scrolling // that has taken place in the tree view GtkScrolledWindow *s = GTK_SCROLLED_WINDOW(get_widget_checked("scrolledwindow_in")); GtkAdjustment *adj = gtk_scrolled_window_get_hadjustment(s); gint h_adj = (gint)(.5 + gtk_adjustment_get_value(adj)); // FIXME: when the pointer is over the popup itself, // maybe_clear_popup_image doesn't notice that we are still over the // thumbnail below and so clears things! FIXME: I don't understand // why this code puts the popup image top left corner only halfway // down the thumbnail edge. It looks fine this way actually, but as // I understand this code it should put popup top left at thumbnail // bottom right. nwa.x = tree_view_x + tn_rec.x + tn_rec.width - h_adj; nwa.y = tree_view_y + tn_rec.y + tn_rec.height; nwa.width = gdk_pixbuf_get_width(popup_image_pixbuf); nwa.height = gdk_pixbuf_get_height(popup_image_pixbuf); nwa.wclass = GDK_INPUT_OUTPUT; nwa.window_type = GDK_WINDOW_CHILD; nwa.override_redirect = TRUE; GdkWindow *root_window = gdk_screen_get_root_window (gdk_screen_get_default ()); GdkWindow *popup_image_window = gdk_window_new (root_window, &nwa, GDK_WA_X | GDK_WA_Y | GDK_WA_NOREDIR); gdk_window_show (popup_image_window); /* Magic number understood by gdk_draw_pixbuf to mean "use pixbuf width". */ const gint use_pixbuf_width = -1; gdk_draw_pixbuf (GDK_DRAWABLE (popup_image_window), NULL, popup_image_pixbuf, 0, 0, 0, 0, use_pixbuf_width, use_pixbuf_width, GDK_RGB_DITHER_NONE, 0, 0); g_object_unref (popup_image_pixbuf); return popup_image_window; } else { return NULL; } }
GtkWidget *Create_Log_Area (void) { GtkWidget *Frame; GtkWidget *ScrollWindowLogList; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *PopupMenu; Frame = gtk_frame_new(_("Log")); gtk_container_set_border_width(GTK_CONTAINER(Frame), 2); /* * The ScrollWindow and the List */ ScrollWindowLogList = gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowLogList), GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(Frame),ScrollWindowLogList); /* The file list */ logListModel = gtk_list_store_new(LOG_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_COLOR, GDK_TYPE_COLOR); LogList = gtk_tree_view_new_with_model(GTK_TREE_MODEL(logListModel)); g_object_unref (logListModel); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(LogList), FALSE); gtk_container_add(GTK_CONTAINER(ScrollWindowLogList), LogList); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(LogList), FALSE); gtk_widget_set_size_request(LogList, 0, 0); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(LogList), FALSE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(LogList)),GTK_SELECTION_MULTIPLE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(LogList), column); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "stock-id", LOG_PIXBUF, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "text", LOG_TIME_TEXT, "background-gdk", LOG_ROW_BACKGROUND, "foreground-gdk", LOG_ROW_FOREGROUND, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "text", LOG_TEXT, "background-gdk", LOG_ROW_BACKGROUND, "foreground-gdk", LOG_ROW_FOREGROUND, NULL); // Create Popup Menu on browser album list PopupMenu = gtk_ui_manager_get_widget(UIManager, "/LogPopup"); gtk_menu_attach_to_widget (GTK_MENU (PopupMenu), LogList, NULL); g_signal_connect (G_OBJECT (LogList), "button-press-event", G_CALLBACK (Log_Popup_Menu_Handler), PopupMenu); // Load pending messages in the Log list Log_Print_Tmp_List(); if (SHOW_LOG_VIEW) //gtk_widget_show_all(ScrollWindowLogList); gtk_widget_show_all(Frame); //return ScrollWindowLogList; return Frame; }
/* Create a minimal web browser that has Emacsy integrated into it. */ int main(int argc, char* argv[]) { int err; // Initialize GNU Guile. scm_init_guile(); // Initialize Emacsy. err = emacsy_initialize(); if (err) return err; // Register the primitive procedures that control the browser. init_primitives(); // You can evaluate S-expressions here. scm_c_eval_string("(use-modules (system repl error-handling))" "(define (safe-load filename) " " (call-with-error-handling " " (lambda () (load filename)))) "); // But to make the application easy to mold, it's best to load the // Scheme code from a file. const char *startup_script = "emacsy-webkit-gtk-w-buffers.scm"; if (access(startup_script, R_OK) != -1) { printf("Loading '%s'.\n", startup_script); // We could load the file like this: //scm_c_primitive_load(".emacy-webkit-gtk.scm"); // But this will drop us into a REPL if anything goes wrong. scm_call_1(scm_c_private_ref("guile-user", "safe-load"), scm_from_locale_string(startup_script)); } else { printf("Did not find '%s'.\n", startup_script); } // Initialize GTK+. gtk_init(&argc, &argv); // Create an 800x600 window that will contain the browser instance. GtkWidget *main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(main_window), 800, 600); //gtk_window_set_size(GTK_WINDOW(main_window), 800, 600); GdkGeometry geom_struct; geom_struct.max_width = 800; geom_struct.max_height = 600; gtk_window_set_geometry_hints(GTK_WINDOW(main_window), NULL, &geom_struct, GDK_HINT_MAX_SIZE); /* you might need to use GTK_STATE_ACTIVE or GTK_STATE_PRELIGHT */ GdkColor black = {0, 0x0, 0x0, 0x0}; GdkColor white = {0, 0xFFFF, 0xFFFF, 0xFFFF}; gtk_widget_modify_bg(GTK_WINDOW(main_window), GTK_STATE_NORMAL, &black); gtk_widget_modify_fg(GTK_WINDOW(main_window), GTK_STATE_NORMAL, &white); // Create a browser instance /* web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); */ /* webkit_web_view_set_highlight_text_matches(web_view, TRUE); */ web_view = NULL; // Create a scrollable area, and put the browser instance into it scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); scm_c_eval_string("(new-tab)"); //gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(web_view)); // Set up callbacks so that if either the main window or the browser // instance is closed, the program will exit. g_signal_connect(main_window, "destroy", G_CALLBACK(destroy_window), NULL); //g_signal_connect(web_view, "close-web-view", G_CALLBACK(close_window), main_window); // This label will be where we display Emacsy's echo-area. label = gtk_label_new("label"); gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.0f); gtk_label_set_use_underline(GTK_LABEL(label), FALSE); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_single_line_mode(GTK_LABEL(label), TRUE); gtk_label_set_max_width_chars(GTK_LABEL(label), 160); modeline = gtk_label_new("modeline"); gtk_misc_set_alignment(GTK_MISC(modeline), 0.0f, 0.0f); gtk_label_set_use_underline(GTK_LABEL(modeline), FALSE); gtk_label_set_line_wrap(GTK_LABEL(modeline), TRUE); gtk_label_set_single_line_mode(GTK_LABEL(modeline), TRUE); gtk_label_set_max_width_chars(GTK_LABEL(modeline), 160); // While idle, process events in Emacsy and upate the echo-area. g_idle_add((GSourceFunc) process_and_update_emacsy, NULL); // Handle key press and release events. g_signal_connect(main_window, "key_press_event", G_CALLBACK(key_press), NULL); g_signal_connect(main_window, "key_release_event", G_CALLBACK(key_press), NULL); GtkWidget *vbox; vbox = gtk_vbox_new(FALSE, 1); gtk_container_add(GTK_CONTAINER(vbox), scrolled_window); gtk_box_pack_start(GTK_BOX(vbox), modeline, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); // Put the scrollable area into the main window. gtk_container_add(GTK_CONTAINER(main_window), vbox); // Load a web page into the browser instance. webkit_web_view_load_uri(web_view, "http://shanecelis.github.io/2013/06/15/the-garden/"); // Make sure that when the browser area becomes visible, it will get mouse // and keyboard events. gtk_widget_grab_focus(GTK_WIDGET(web_view)); // Make sure the main window and all its contents are visible. gtk_widget_show_all(main_window); gtk_window_set_resizable(GTK_WINDOW(main_window), FALSE); // Run the main GTK+ event loop. gtk_main(); return 0; }
static int show_console(void) { GtkWidget *hbox; GtkWidget *wbox; GtkWidget *notebook; GtkWidget *sw; GtkWidget *bbox, *hbbox, *add, *removew, *reloadw; char *modtitles[3] = { "Module", "Description", "Use Count" }; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); statusbar = gtk_statusbar_new(); gtk_widget_show(statusbar); gtk_signal_connect(GTK_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC (exit_nicely), window); gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC (exit_now), window); gtk_container_set_border_width(GTK_CONTAINER(window), 10); quit = gtk_button_new_with_label("Quit Asterisk"); gtk_signal_connect(GTK_OBJECT(quit), "clicked", GTK_SIGNAL_FUNC (exit_completely), window); gtk_widget_show(quit); closew = gtk_button_new_with_label("Close Window"); gtk_signal_connect(GTK_OBJECT(closew), "clicked", GTK_SIGNAL_FUNC (exit_nicely), window); gtk_widget_show(closew); notebook = gtk_notebook_new(); verb = gtk_clist_new(1); gtk_clist_columns_autosize(GTK_CLIST(verb)); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(sw), verb); gtk_widget_show(verb); gtk_widget_show(sw); gtk_widget_set_usize(verb, 640, 400); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sw, gtk_label_new("Verbose Status")); modules = gtk_clist_new_with_titles(3, modtitles); gtk_clist_columns_autosize(GTK_CLIST(modules)); gtk_clist_set_column_auto_resize(GTK_CLIST(modules), 0, TRUE); gtk_clist_set_column_auto_resize(GTK_CLIST(modules), 1, TRUE); gtk_clist_set_column_auto_resize(GTK_CLIST(modules), 2, TRUE); gtk_clist_set_sort_column(GTK_CLIST(modules), 0); gtk_clist_set_auto_sort(GTK_CLIST(modules), TRUE); gtk_clist_column_titles_passive(GTK_CLIST(modules)); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(sw), modules); gtk_clist_set_selection_mode(GTK_CLIST(modules), GTK_SELECTION_BROWSE); gtk_widget_show(modules); gtk_widget_show(sw); add = gtk_button_new_with_label("Load..."); gtk_widget_show(add); removew = gtk_button_new_with_label("Unload"); gtk_widget_show(removew); reloadw = gtk_button_new_with_label("Reload"); gtk_widget_show(reloadw); gtk_signal_connect(GTK_OBJECT(removew), "clicked", GTK_SIGNAL_FUNC (remove_module), window); gtk_signal_connect(GTK_OBJECT(add), "clicked", GTK_SIGNAL_FUNC (add_module), window); gtk_signal_connect(GTK_OBJECT(reloadw), "clicked", GTK_SIGNAL_FUNC (reload_module), window); bbox = gtk_vbox_new(FALSE, 5); gtk_widget_show(bbox); gtk_widget_set_usize(bbox, 100, -1); gtk_box_pack_start(GTK_BOX(bbox), add, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(bbox), removew, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(bbox), reloadw, FALSE, FALSE, 5); hbbox = gtk_hbox_new(FALSE, 5); gtk_widget_show(hbbox); gtk_box_pack_start(GTK_BOX(hbbox), sw, TRUE, TRUE, 5); gtk_box_pack_start(GTK_BOX(hbbox), bbox, FALSE, FALSE, 5); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), hbbox, gtk_label_new("Module Information")); gtk_widget_show(notebook); wbox = gtk_hbox_new(FALSE, 5); gtk_widget_show(wbox); gtk_box_pack_end(GTK_BOX(wbox), quit, FALSE, FALSE, 5); gtk_box_pack_end(GTK_BOX(wbox), closew, FALSE, FALSE, 5); hbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(hbox); /* Command line */ cli = gtk_entry_new(); gtk_widget_show(cli); gtk_signal_connect(GTK_OBJECT(cli), "activate", GTK_SIGNAL_FUNC (cli_activate), NULL); gtk_box_pack_start(GTK_BOX(hbox), notebook, TRUE, TRUE, 5); gtk_box_pack_start(GTK_BOX(hbox), wbox, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), cli, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), statusbar, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(window), hbox); gtk_window_set_title(GTK_WINDOW(window), "Asterisk Console"); gtk_widget_grab_focus(cli); ast_pthread_create(&console_thread, NULL, consolethread, NULL); /* XXX Okay, seriously fix me! XXX */ usleep(100000); ast_register_verbose(verboser); gtk_clist_freeze(GTK_CLIST(verb)); ast_loader_register(mod_update); gtk_clist_thaw(GTK_CLIST(verb)); gdk_input_add(clipipe[0], GDK_INPUT_READ, cliinput, NULL); mod_update(); update_statusbar("Asterisk Console Ready"); return 0; }
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; }
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; }
void gftpui_ask_transfer (gftp_transfer * tdata) { char *dltitles[4], *add_data[4] = { NULL, NULL, NULL, NULL }, tempstr[50], temp1str[50], *pos; GtkWidget * dialog, * tempwid, * scroll, * hbox; gftp_file * tempfle; GList * templist; size_t len; int i; dltitles[0] = _("Filename"); dltitles[1] = tdata->fromreq->hostname; dltitles[2] = tdata->toreq->hostname; dltitles[3] = _("Action"); #if GTK_MAJOR_VERSION == 1 dialog = gtk_dialog_new (); gtk_grab_add (dialog); gtk_window_set_title (GTK_WINDOW (dialog), _("Transfer Files")); gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area), 5); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->action_area), 35); gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dialog)->action_area), TRUE); gtk_signal_connect_object (GTK_OBJECT (dialog), "delete_event", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (dialog)); #else dialog = gtk_dialog_new_with_buttons (_("Transfer Files"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); #endif gtk_window_set_wmclass (GTK_WINDOW(dialog), "transfer", "gFTP"); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE); gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 10); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 5); tempwid = gtk_label_new (_("The following file(s) exist on both the local and remote computer\nPlease select what you would like to do")); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), tempwid, FALSE, FALSE, 0); gtk_widget_show (tempwid); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (scroll, 450, 200); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); tdata->clist = gtk_clist_new_with_titles (4, dltitles); gtk_container_add (GTK_CONTAINER (scroll), tdata->clist); #if GTK_MAJOR_VERSION == 1 gtk_clist_set_selection_mode (GTK_CLIST (tdata->clist), GTK_SELECTION_EXTENDED); #else gtk_clist_set_selection_mode (GTK_CLIST (tdata->clist), GTK_SELECTION_MULTIPLE); #endif gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 0, 100); gtk_clist_set_column_justification (GTK_CLIST (tdata->clist), 1, GTK_JUSTIFY_RIGHT); gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 1, 85); gtk_clist_set_column_justification (GTK_CLIST (tdata->clist), 2, GTK_JUSTIFY_RIGHT); gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 2, 85); gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 3, 85); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scroll, TRUE, TRUE, 0); gtk_widget_show (tdata->clist); gtk_widget_show (scroll); for (templist = tdata->files; templist != NULL; templist = templist->next) { tempfle = templist->data; if (tempfle->startsize == 0 || S_ISDIR (tempfle->st_mode)) { tempfle->shown = 0; continue; } tempfle->shown = 1; len = strlen (tdata->toreq->directory); pos = tempfle->destfile; if (len == 1 && (*tdata->toreq->directory) == '/') pos++; if (strncmp (pos, tdata->toreq->directory, len) == 0) pos += len + 1; add_data[0] = pos; gftp_get_transfer_action (tdata->fromreq, tempfle); switch (tempfle->transfer_action) { case GFTP_TRANS_ACTION_OVERWRITE: add_data[3] = _("Overwrite"); break; case GFTP_TRANS_ACTION_SKIP: add_data[3] = _("Skip"); break; case GFTP_TRANS_ACTION_RESUME: add_data[3] = _("Resume"); break; default: add_data[3] = _("Error"); break; } add_data[1] = insert_commas (tempfle->size, tempstr, sizeof (tempstr)); add_data[2] = insert_commas (tempfle->startsize, temp1str, sizeof (temp1str)); i = gtk_clist_append (GTK_CLIST (tdata->clist), add_data); gtk_clist_set_row_data (GTK_CLIST (tdata->clist), i, tempfle); } gtk_clist_select_all (GTK_CLIST (tdata->clist)); hbox = gtk_hbox_new (TRUE, 20); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); tempwid = gtk_button_new_with_label (_("Overwrite")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gftpui_gtk_overwrite), (gpointer) tdata); gtk_widget_show (tempwid); tempwid = gtk_button_new_with_label (_("Resume")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gftpui_gtk_resume), (gpointer) tdata); gtk_widget_show (tempwid); tempwid = gtk_button_new_with_label (_("Skip File")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gftpui_gtk_skip), (gpointer) tdata); gtk_widget_show (tempwid); hbox = gtk_hbox_new (TRUE, 20); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); tempwid = gtk_button_new_with_label (_("Select All")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gftpui_gtk_trans_selectall), (gpointer) tdata); gtk_widget_show (tempwid); tempwid = gtk_button_new_with_label (_("Deselect All")); gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gftpui_gtk_trans_unselectall), (gpointer) tdata); gtk_widget_show (tempwid); #if GTK_MAJOR_VERSION == 1 tempwid = gtk_button_new_with_label (_("OK")); GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gftpui_gtk_ok), (gpointer) tdata); gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (dialog)); gtk_widget_grab_default (tempwid); gtk_widget_show (tempwid); tempwid = gtk_button_new_with_label (_(" Cancel ")); GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gftpui_gtk_cancel), (gpointer) tdata); gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (dialog)); gtk_widget_show (tempwid); #else g_signal_connect (GTK_OBJECT (dialog), "response", G_CALLBACK (gftpui_gtk_transfer_action),(gpointer) tdata); #endif gtk_widget_show (dialog); dialog = NULL; }
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) ; }
void SetupHashWindow() { /* Setup window */ gui.windows.hash = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(gui.windows.hash), "Hashes"); gtk_window_set_default_size(GTK_WINDOW(gui.windows.hash), 580, 340); gtk_window_set_deletable(GTK_WINDOW(gui.windows.hash), false); gui.fixed.hash = gtk_fixed_new(); gtk_container_add(GTK_CONTAINER(gui.windows.hash), gui.fixed.hash); /* Load hashes */ gui.entries.hash = gtk_entry_new(); gtk_widget_set_size_request(gui.entries.hash, 380, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.entries.hash, 8, 8); gui.cbox.hash = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hashlist"); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hash"); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "pwdump"); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Cain"); gtk_widget_set_size_request(gui.cbox.hash, 90, 32); gtk_combo_box_set_active(GTK_COMBO_BOX(gui.cbox.hash), 0); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.cbox.hash, 390, 8); gui.buttons.hash_load = gtk_button_new_with_label("Load"); gtk_widget_set_size_request(gui.buttons.hash_load, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_load, 485, 8); /* TreeView */ gui.hash.scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gui.hash.scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gui.hash.tree = gtk_tree_view_new(); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(gui.hash.tree), true); gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(gui.hash.tree), true); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(gui.hash.tree), true); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(gui.hash.tree), true); gui.hash.store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(gui.hash.tree), GTK_TREE_MODEL(gui.hash.store)); gui.hash.render = gtk_cell_renderer_text_new(); GtkTreeViewColumn *col = gtk_tree_view_column_new_with_attributes("Algorithm", gui.hash.render, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id(col, 0); gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col); col = gtk_tree_view_column_new_with_attributes("Length", gui.hash.render, "text", 1, NULL); gtk_tree_view_column_set_sort_column_id(col, 1); gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col); col = gtk_tree_view_column_new_with_attributes("Hash", gui.hash.render, "text", 2, NULL); gtk_tree_view_column_set_sort_column_id(col, 2); gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col); GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gui.hash.tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_container_add(GTK_CONTAINER(gui.hash.scroll), gui.hash.tree); gtk_widget_set_size_request(gui.hash.tree, 560, 240); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.hash.scroll, 8, 48); /* Buttons */ gui.buttons.hash_delete = gtk_button_new_with_label("Remove"); gtk_widget_set_size_request(gui.buttons.hash_delete, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_delete, 8, 300); gui.buttons.hash_clear = gtk_button_new_with_label("Clear"); gtk_widget_set_size_request(gui.buttons.hash_clear, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_clear, 100, 300); gui.buttons.hash_ok = gtk_button_new_with_label("OK"); gtk_widget_set_size_request(gui.buttons.hash_ok, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_ok, 480, 300); g_signal_connect(gui.buttons.hash_load, "clicked", G_CALLBACK(LoadHashes), NULL); g_signal_connect(gui.buttons.hash_ok, "clicked", G_CALLBACK(HideHashWindow), NULL); g_signal_connect(gui.buttons.hash_delete, "clicked", G_CALLBACK(DeleteHashes), NULL); g_signal_connect(gui.buttons.hash_clear, "clicked", G_CALLBACK(ClearHashes), NULL); return; }
int main(int argc, char **argv) { printf("%d command line arguments \n", argc); for (int i = 0; i < argc; i++) printf("%d: %s \n", i, argv[i]); if (argc == 1) { printf("usage: scrscr filename.png\n"); return 0; } fn = argv[1]; gtk_init( &argc, &argv ); GError* error = NULL; pixbuf = gdk_pixbuf_new_from_file(fn, &error); if (pixbuf == NULL) { printf("cant open file\n"); exit(1); } window = gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); //gtk_window_move(window, 10, 300); gtk_window_set_resizable(GTK_WINDOW(window), TRUE); gtk_container_set_border_width(GTK_CONTAINER(window), 10); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(cb_save_and_quit), NULL); g_signal_connect(window, "key-press-event", G_CALLBACK(keypress), NULL); vbox = gtk_vbox_new( FALSE, 6 ); gtk_container_add( GTK_CONTAINER( window ), vbox ); swindow = gtk_scrolled_window_new( NULL, NULL ); gtk_box_pack_start( GTK_BOX( vbox ), swindow, TRUE, TRUE, 0 ); hbox = gtk_hbox_new( TRUE, 6 ); vbox2 = gtk_vbox_new( TRUE, 6 ); //pixbuf = gdk_pixbuf_new( GDK_COLORSPACE_RGB, FALSE, 8, 200, 200 ); //gdk_pixbuf_fill( pixbuf, 0xffff00ff ); image = gtk_image_new_from_pixbuf( pixbuf ); //g_object_unref( G_OBJECT( pixbuf ) ); prepare_blits(); gtk_window_set_default_size(GTK_WINDOW(window), width+100, height+150); gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW( swindow ), hbox ); image_evbox = gtk_event_box_new(); gtk_container_add(image_evbox, image); //gtk_box_pack_start( GTK_BOX( hbox ), image, FALSE, FALSE, 0 ); gtk_box_pack_start(hbox, vbox2, FALSE, FALSE, 0); gtk_box_pack_start(vbox2, image_evbox, FALSE, FALSE, 0); g_signal_connect(image_evbox, "button-press-event", G_CALLBACK(i_mousedown), NULL); g_signal_connect(image_evbox, "button-release-event", G_CALLBACK(i_mouseup), NULL); g_signal_connect(image_evbox, "motion-notify-event", G_CALLBACK(i_mousemove), NULL); hbox = gtk_hbox_new( FALSE, 6 ); gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 ); GtkWidget* button = gtk_button_new_with_label( "undo" ); g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK(cb_undo), NULL ); gtk_box_pack_start( GTK_BOX( hbox ), button, FALSE, FALSE, 0 ); GtkWidget* button_blue = gtk_button_new_with_label( "blue" ); GtkWidget* button_red = gtk_button_new_with_label( "red" ); GtkWidget* button_green = gtk_button_new_with_label( "green" ); //GtkWidget* button_fill = gtk_button_new_with_label( "fill" ); GtkWidget* button_fill = gtk_toggle_button_new_with_label( "fill" ); gtk_toggle_button_set_active(button_fill, fill); g_signal_connect( G_OBJECT( button_blue ), "clicked", G_CALLBACK(cb_blue), NULL ); g_signal_connect( G_OBJECT( button_red ), "clicked", G_CALLBACK(cb_red), NULL ); g_signal_connect( G_OBJECT( button_green ), "clicked", G_CALLBACK(cb_green), NULL ); g_signal_connect( G_OBJECT( button_fill ), "clicked", G_CALLBACK(cb_fill_stroke), NULL ); gtk_box_pack_start( GTK_BOX( hbox ), button_blue, FALSE, FALSE, 0 ); gtk_box_pack_start( GTK_BOX( hbox ), button_red, FALSE, FALSE, 0 ); gtk_box_pack_start( GTK_BOX( hbox ), button_green, FALSE, FALSE, 0 ); gtk_box_pack_start( GTK_BOX( hbox ), button_fill, FALSE, FALSE, 0 ); button = gtk_button_new_with_label( "done" ); g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK(cb_save_and_quit), NULL ); gtk_box_pack_end( GTK_BOX( hbox ), button, FALSE, FALSE, 0 ); gtk_widget_show_all( window ); gtk_main(); return 0; }
int main(int argc, char ** argv) { GtkWidget * vbox; GtkWidget * hpaned; GtkWidget * sc_win, * sc_buffer; GtkWidget * menu_bar; GtkWidget * file_menu, * file_item; GtkWidget * generate_menu, * generate_item; GtkWidget * settings_menu, * settings_item; GtkWidget * zoom_box, * zoom_button; int i; //init general colors = (color_t *)malloc(NUM_COLORS * sizeof(color_t)); oldcolors = (color_t *)malloc(OLD_NUM_COLORS * sizeof(color_t)); memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *)); memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *)); memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *)); mdata[current_buffer] = (unsigned char *)malloc(128 * 128); load_colors_plain(colors, "colors"); load_colors_plain(oldcolors, "oldcolors"); newcolors = colors; //save_colors(colors, "colors.bin"); //load_colors(colors, "colors.bin"); srand(time(NULL)); config = config_new(); //init gtk gtk_init(&argc, &argv); //window window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER); g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL); //vbox #ifdef GTK2 vbox = gtk_vbox_new(FALSE, 0); #else vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif gtk_frame_set_shadow_type(GTK_FRAME(vbox), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER (window), vbox); gtk_widget_show(vbox); //////menu_bar menu_bar = gtk_menu_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0); gtk_widget_show(menu_bar); ////////file_menu file_menu = gtk_menu_new(); //////////file_menu items construct_tool_bar_add(file_menu, "Open", ITEM_SIGNAL_OPEN); construct_tool_bar_add(file_menu, "Open Grid Image", ITEM_SIGNAL_OPEN_GRID_IMAGE); construct_tool_bar_add(file_menu, "Save", ITEM_SIGNAL_SAVE); construct_tool_bar_add(file_menu, "Save Increment", ITEM_SIGNAL_SAVE_INCREMENT); construct_tool_bar_add(file_menu, "Save All", ITEM_SIGNAL_SAVE_ALL); construct_tool_bar_add(file_menu, "Save Raw Map", ITEM_SIGNAL_SAVE_RM); construct_tool_bar_add(file_menu, "Export Image", ITEM_SIGNAL_EXPORT_IMAGE); /* construct_tool_bar_add_deactivate(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM); */ construct_tool_bar_add(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM); construct_tool_bar_add(file_menu, "Clean Buffer List", ITEM_SIGNAL_CLEAN); construct_tool_bar_add(file_menu, "Quit", ITEM_SIGNAL_QUIT); /////////file_item file_item = gtk_menu_item_new_with_label("File"); gtk_widget_show(file_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item); ////////generate_menu generate_menu = gtk_menu_new(); //////////generate_menu items construct_tool_bar_add(generate_menu, "Mandelbrot", ITEM_SIGNAL_GENERATE_MANDELBROT); construct_tool_bar_add(generate_menu, "Julia", ITEM_SIGNAL_GENERATE_JULIA); construct_tool_bar_add(generate_menu, "Palette", ITEM_SIGNAL_GENERATE_PALETTE); construct_tool_bar_add(generate_menu, "Random Noise", ITEM_SIGNAL_GENERATE_RANDOM_NOISE); construct_tool_bar_add(generate_menu, "From Clipboard", ITEM_SIGNAL_GENERATE_FROM_CLIPBOARD); /////////generate_item generate_item = gtk_menu_item_new_with_label("Generate"); gtk_widget_show(generate_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item); ////////settings_menu settings_menu = gtk_menu_new(); ////////settings_item settings_item = gtk_menu_item_new_with_label("Settings"); gtk_widget_show(settings_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item); //////////FSD_checkbox FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox); gtk_widget_show(FSD_checkbox); //////////YUV_checkbox YUV_checkbox = gtk_check_menu_item_new_with_label("YUV color conversion"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), YUV_checkbox); gtk_widget_show(YUV_checkbox); //////////old_colors_checkbox old_colors_checkbox = gtk_check_menu_item_new_with_label("Old Colors"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), old_colors_checkbox); gtk_widget_show(old_colors_checkbox); g_signal_connect_swapped(old_colors_checkbox, "toggled", G_CALLBACK(old_colors_checkbox_toggle), 0); //drop_down_menu init_drop_down_menu(); //hpaned #ifdef GTK2 hpaned = gtk_hpaned_new(); #else hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL); #endif gtk_widget_set_size_request (hpaned, 220, -1); gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show(hpaned); ////sc_buffer sc_buffer = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_buffer, 128 + 32, 512); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512); #endif gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE); gtk_widget_show(sc_buffer); //////list_vbox #ifdef GTK2 list_vbox = gtk_vbox_new(FALSE, 0); #else list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif #ifdef GTK2 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox); #else gtk_container_add(GTK_CONTAINER(sc_buffer), list_vbox); #endif gtk_widget_show(list_vbox); ////sc_win sc_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4); gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); #endif gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE); gtk_widget_show(sc_win); //////image dimage = gdk_pixbuf_new_from_file("start.png", NULL); image = gtk_image_new(); gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage); #ifdef GTK2 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image); #else gtk_container_add(GTK_CONTAINER(sc_win), image); #endif gtk_widget_show(image); ////zoom_box #ifdef GTK2 zoom_box = gtk_hbox_new(FALSE, 0); #else zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #endif gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0); gtk_widget_show(zoom_box); //////zoom_button (+) zoom_button = gtk_button_new_with_label("+"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp"); gtk_widget_show(zoom_button); //////zoom_button (|) zoom_button = gtk_button_new_with_label("|"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome"); gtk_widget_show(zoom_button); //////zoom_button (-) zoom_button = gtk_button_new_with_label("-"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm"); gtk_widget_show(zoom_button); //icon gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico")); //Drag and drop gtk_drag_dest_set(window, GTK_DEST_DEFAULT_ALL, targets, sizeof(targets)/sizeof(*targets), GDK_ACTION_COPY); gtk_drag_dest_add_uri_targets(window); g_signal_connect(window, "drag-drop", G_CALLBACK(drag_drop), NULL); g_signal_connect(window, "drag-motion", G_CALLBACK(drag_motion), NULL); g_signal_connect(window, "drag-data-received", G_CALLBACK(drag_received), NULL); g_signal_connect(window, "drag-leave", G_CALLBACK(drag_leave), NULL); //display window gtk_widget_show (window); gtk_main(); //clean up free(colors); for(i = 0; i < BUFFER_COUNT; i++) free(mdata[i]); config_free(config); return 0; }
GtkWidget *create_notebook_page_dialog(int page, dialog_buttons btn[MAX_KEYS], dialog_checkbox checkbox[CHECK_NBR]) { GtkWidget *main_box; GtkWidget *joy_choose_frame, *joy_choose_box; GtkWidget *keys_frame, *keys_box; GtkWidget *keys_tree_box, *keys_tree_scroll; GtkWidget *keys_tree_clear_btn, *keys_tree_remove_btn, *keys_tree_modify_btn, *keys_tree_show_key_btn, *keys_tree_show_joy_btn; GtkWidget *keys_btn_box, *keys_filter_box; GtkWidget *keys_static_frame, *keys_static_box; GtkWidget *keys_static_area; joy_choose_cbox = GTK_COMBO_BOX(gtk_combo_box_new_text()); populate_new_joysticks(joy_choose_cbox); set_current_joy(); g_signal_connect(GTK_OBJECT (joy_choose_cbox), "changed", G_CALLBACK(joy_changed), NULL); keys_tree_scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(keys_tree_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER(keys_tree_scroll), key_tree_manager->view_widget(page)); gtk_widget_set_size_request(keys_tree_scroll, 300, 500); keys_tree_clear_btn = gtk_button_new_with_label("Clear All"); g_signal_connect(GTK_OBJECT (keys_tree_clear_btn), "clicked", G_CALLBACK(on_clear_clicked), NULL); gtk_widget_set_size_request(keys_tree_clear_btn, 70, 24); keys_tree_remove_btn = gtk_button_new_with_label("Remove"); g_signal_connect(GTK_OBJECT (keys_tree_remove_btn), "clicked", G_CALLBACK(on_remove_clicked), NULL); gtk_widget_set_size_request(keys_tree_remove_btn, 70, 24); keys_tree_modify_btn = gtk_button_new_with_label("Modify"); g_signal_connect(GTK_OBJECT (keys_tree_modify_btn), "clicked", G_CALLBACK(on_modify_clicked), NULL); gtk_widget_set_size_request(keys_tree_modify_btn, 70, 24); keys_tree_show_joy_btn = gtk_check_button_new_with_label("Show joy"); g_signal_connect(GTK_OBJECT (keys_tree_show_joy_btn), "toggled", G_CALLBACK(on_view_joy_clicked), NULL); gtk_widget_set_size_request(keys_tree_show_joy_btn, 100, 24); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(keys_tree_show_joy_btn), true); keys_tree_show_key_btn = gtk_check_button_new_with_label("Show key"); g_signal_connect(GTK_OBJECT (keys_tree_show_key_btn), "toggled", G_CALLBACK(on_view_key_clicked), NULL); gtk_widget_set_size_request(keys_tree_show_key_btn, 100, 24); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(keys_tree_show_key_btn), true); joy_choose_box = gtk_hbox_new(false, 5); joy_choose_frame = gtk_frame_new ("Joystick to use for this pad"); gtk_container_add (GTK_CONTAINER(joy_choose_frame), joy_choose_box); keys_btn_box = gtk_hbox_new(false, 5); keys_filter_box = gtk_hbox_new(false, 5); keys_tree_box = gtk_vbox_new(false, 5); keys_static_box = gtk_hbox_new(false, 5); keys_static_frame = gtk_frame_new (""); gtk_container_add (GTK_CONTAINER(keys_static_frame), keys_static_box); keys_static_area = gtk_fixed_new(); for(int i = 0; i < MAX_KEYS; i++) { btn[i].put(b_pos[i].label, i, GTK_FIXED(keys_static_area), b_pos[i].x, b_pos[i].y); } u32 mask = 1 << (16*page); for(int i = 0; i < CHECK_NBR; i++) { checkbox[i].create(keys_static_area, check_pos[i].label, check_pos[i].x, check_pos[i].y, mask); mask = mask << 1; } keys_box = gtk_hbox_new(false, 5); keys_frame = gtk_frame_new ("Key Settings"); gtk_container_add (GTK_CONTAINER(keys_frame), keys_box); gtk_box_pack_start (GTK_BOX (keys_tree_box), keys_tree_scroll, true, true, 0); gtk_box_pack_start (GTK_BOX (keys_tree_box), keys_btn_box, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_tree_box), keys_filter_box, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_filter_box), keys_tree_show_joy_btn, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_filter_box), keys_tree_show_key_btn, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_btn_box), keys_tree_clear_btn, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_btn_box), keys_tree_remove_btn, false, false, 0); gtk_box_pack_start (GTK_BOX (keys_btn_box), keys_tree_modify_btn, false, false, 0); gtk_container_add(GTK_CONTAINER(joy_choose_box), GTK_WIDGET(joy_choose_cbox)); gtk_box_pack_start(GTK_BOX (keys_box), keys_tree_box, false, false, 0); gtk_container_add(GTK_CONTAINER(keys_box), keys_static_area); main_box = gtk_vbox_new(false, 5); gtk_container_add(GTK_CONTAINER(main_box), joy_choose_frame); gtk_container_add(GTK_CONTAINER(main_box), keys_frame); return main_box; }
int main (int argc, char *argv[]) { GtkWidget *window, *swin, *viewport, *table1, *table2, *vbox; GtkAdjustment *horizontal, *vertical; GtkWidget *buttons1[10][10], *buttons2[10][10]; unsigned int i, j; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Scrolled Windows & Viewports"); gtk_container_set_border_width (GTK_CONTAINER (window), 10); gtk_widget_set_size_request (window, 500, 400); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); table1 = gtk_table_new (10, 10, TRUE); table2 = gtk_table_new (10, 10, TRUE); gtk_table_set_row_spacings (GTK_TABLE (table1), 5); gtk_table_set_row_spacings (GTK_TABLE (table2), 5); gtk_table_set_col_spacings (GTK_TABLE (table1), 5); gtk_table_set_col_spacings (GTK_TABLE (table2), 5); /* Pack each table with 100 buttons. */ for (i = 0; i < 10; i++) { for (j = 0; j < 10; j++) { buttons1[i][j] = gtk_button_new_from_stock (GTK_STOCK_CLOSE); buttons2[i][j] = gtk_button_new_from_stock (GTK_STOCK_CLOSE); gtk_button_set_relief (GTK_BUTTON (buttons1[i][j]), GTK_RELIEF_NONE); gtk_button_set_relief (GTK_BUTTON (buttons2[i][j]), GTK_RELIEF_NONE); gtk_table_attach_defaults (GTK_TABLE (table1), buttons1[i][j], i, i + 1, j, j + 1); gtk_table_attach_defaults (GTK_TABLE (table2), buttons2[i][j], i, i + 1, j, j + 1); } } /* Create a scrolled window and a viewport, each with one table. Use the * adjustments in the scrolled window to synchronize both containers. */ swin = gtk_scrolled_window_new (NULL, NULL); horizontal = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (swin)); vertical = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (swin)); viewport = gtk_viewport_new (horizontal, vertical); gtk_container_set_border_width (GTK_CONTAINER (swin), 5); gtk_container_set_border_width (GTK_CONTAINER (viewport), 5); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swin), table1); gtk_container_add (GTK_CONTAINER (viewport), table2); /* Pack the widgets into a GtkVBox and then into the window. */ vbox = gtk_vbox_new (TRUE, 5); gtk_box_pack_start_defaults (GTK_BOX (vbox), viewport); gtk_box_pack_start_defaults (GTK_BOX (vbox), swin); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show_all (window); gtk_main(); return 0; }