static GtkWidget* makelist(GtkWidget** plist, gchar* lstname,GtkSelectionMode mode, GtkSignalFunc selfun, GtkSignalFunc unselfun) { static gchar* Colonnes[2]; GtkWidget *scroll, *list; Colonnes[0] = "# "; Colonnes[1] = lstname; scroll = gtk_scrolled_window_new(NULL, NULL); list = gtk_clist_new_with_titles(2, Colonnes); gtk_clist_column_title_passive(GTK_CLIST(list),0); gtk_clist_column_title_passive(GTK_CLIST(list),1); *plist = list; gtk_clist_set_selection_mode(GTK_CLIST(list), mode); if (selfun) gtk_signal_connect(GTK_OBJECT(list),"select_row", selfun, NULL); if (unselfun) gtk_signal_connect(GTK_OBJECT(list),"unselect_row", unselfun, NULL); gtk_container_add(GTK_CONTAINER(scroll), list); gtk_widget_show (list); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize(scroll, 150, 100); return scroll; }
bool FileSelector::Run(bool runMain) { bool dummyBool; if (!runMain) gdk_threads_enter(); filesel = gtk_file_selection_new(title.c_str()); m_context->prefs->GetPrefBoolean(kSetLastResumePref, &dummyBool); if(dummyBool) gtk_file_selection_set_filename (GTK_FILE_SELECTION (filesel), old_path); gtk_window_set_modal(GTK_WINDOW(filesel), TRUE); gtk_signal_connect(GTK_OBJECT(filesel), "destroy", GTK_SIGNAL_FUNC(filesel_destroy), (gpointer)runMain); gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->cancel_button), "clicked", GTK_SIGNAL_FUNC(cancel_internal), this); gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked", GTK_SIGNAL_FUNC(ok_internal), this); if (extended) gtk_clist_set_selection_mode(GTK_CLIST(GTK_FILE_SELECTION(filesel)-> file_list), GTK_SELECTION_EXTENDED); gtk_widget_show(filesel); if (runMain) gtk_main(); else { gdk_threads_leave(); while (!done) usleep(20); } if (ok) return true; return false; }
/* Creates the clist widget used in the "Contents" page of the Properties * dialog for a directory */ GtkWidget * dir_contents_list( GNode *dnode ) { char *col_titles[2]; char *clist_row[2]; GtkWidget *clist_w; Icon *icon; int i; g_assert( NODE_IS_DIR(dnode) ); col_titles[0] = _("Node type"); col_titles[1] = _("Quantity"); /* Don't use gui_clist_add( ) as this one shouldn't be placed * inside a scrolled window */ clist_w = gtk_clist_new_with_titles( 2, col_titles ); gtk_clist_set_selection_mode( GTK_CLIST(clist_w), GTK_SELECTION_SINGLE ); for (i = 0; i < 2; i++) gtk_clist_set_column_auto_resize( GTK_CLIST(clist_w), i, TRUE ); clist_row[0] = NULL; for (i = 1; i < NUM_NODE_TYPES; i++) { clist_row[1] = (char *)i64toa( DIR_NODE_DESC(dnode)->subtree.counts[i] ); gtk_clist_append( GTK_CLIST(clist_w), clist_row ); icon = &node_type_mini_icons[i]; gtk_clist_set_pixtext( GTK_CLIST(clist_w), i - 1, 0, _(node_type_plural_names[i]), 2, icon->pixmap, icon->mask ); } return clist_w; }
GtkCList * create_stat_table(GtkWidget *scrolled_window, GtkWidget *vbox, int columns, const char *titles[]) { GtkCList *table; int i; /* create table */ table = GTK_CLIST(gtk_clist_new_with_titles(columns, (gchar **) titles)); gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0); /* configure clist */ gtk_clist_column_titles_passive(table); gtk_clist_column_titles_show(table); for (i = 0; i < columns; i++) gtk_clist_set_column_auto_resize(table, i, TRUE); gtk_clist_set_selection_mode(table, GTK_SELECTION_SINGLE); /* Put clist into a scrolled window */ gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(table)); gtk_widget_show(GTK_WIDGET(table)); gtk_widget_show(scrolled_window); return table; }
GtkFileBrowser* gtk_file_browser_new (void) { GtkFileBrowser *file_browser; file_browser = gtk_type_new (gtk_file_browser_get_type()); /* Type:Name:Size:Flags:Attr:Access,Modify,Change,Links,Uid,Gid,INode,Device */ gtk_clist_construct (GTK_CLIST(file_browser),13,titles); gtk_clist_set_selection_mode (GTK_CLIST(file_browser),GTK_SELECTION_EXTENDED); gtk_clist_set_column_justification (GTK_CLIST(file_browser),2,GTK_JUSTIFY_RIGHT); gtk_clist_set_column_width (GTK_CLIST(file_browser),0,30); // type gtk_clist_set_column_width (GTK_CLIST(file_browser),1,200); gtk_clist_set_column_width (GTK_CLIST(file_browser),2,70); gtk_clist_set_column_width (GTK_CLIST(file_browser),3,120); gtk_clist_set_column_width (GTK_CLIST(file_browser),4,120); gtk_clist_set_column_width (GTK_CLIST(file_browser),5,4); gtk_clist_set_column_width (GTK_CLIST(file_browser),6,4); gtk_clist_set_column_width (GTK_CLIST(file_browser),7,4); gtk_clist_set_column_width (GTK_CLIST(file_browser),8,4); gtk_clist_set_column_width (GTK_CLIST(file_browser),9,90); gtk_clist_set_column_width (GTK_CLIST(file_browser),10,90); file_browser->use_icons = TRUE; gtk_signal_connect (GTK_OBJECT(GTK_CLIST(file_browser)), "select_row", GTK_SIGNAL_FUNC (on_select_row), NULL); return GTK_FILE_BROWSER(file_browser); }
int x_create_listbox (Dlg_head *h, widget_data parent, WListbox *l) { GtkWidget *listbox, *sw; GtkRequisition req; WLEntry *p; int i; listbox = gtk_clist_new (1); sw = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (sw), listbox); gtk_clist_set_selection_mode (GTK_CLIST (listbox), GTK_SELECTION_BROWSE); gtk_widget_size_request (listbox, &req); gtk_widget_set_usize (listbox, req.width, req.height + 20*8); gtk_signal_connect (GTK_OBJECT (listbox), "select_row", GTK_SIGNAL_FUNC (listbox_select), l); l->widget.wdata = (widget_data) sw; gtk_widget_show (listbox); for (p = l->list, i = 0; i < l->count; i++, p = p->next){ char *text [1]; text [0] = p->text; gtk_clist_append (GTK_CLIST (listbox), text); } x_listbox_select_nth (l, l->pos); return 1; }
void init_breakpoints() { int i; GtkWidget *boxH1, *scrolledwindow1, *boxV1, *buAdd, *buRemove; breakpoints_opened = 1; for(i=0; i<BREAKPOINTS_MAX_NUMBER; i++) { bp_addresses[i]=0; } for(i=0; i<BREAKPOINTS_MAX_NUMBER; i++) { selected[i]=0; } //=== Creation of Breakpoints Management ===========/ winBreakpoints = gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_window_set_title( GTK_WINDOW(winBreakpoints), "Breakpoints"); gtk_window_set_default_size( GTK_WINDOW(winBreakpoints), 100, 150); gtk_container_set_border_width( GTK_CONTAINER(winBreakpoints), 2); boxH1 = gtk_hbox_new( FALSE, 0 ); gtk_container_add( GTK_CONTAINER(winBreakpoints), boxH1 ); //=== Creation of Breakpoints Display ==============/ scrolledwindow1 = gtk_scrolled_window_new( NULL, NULL ); gtk_box_pack_start( GTK_BOX(boxH1), scrolledwindow1, FALSE, FALSE, 0); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC ); gtk_range_set_update_policy( GTK_RANGE (GTK_SCROLLED_WINDOW(scrolledwindow1)->hscrollbar), GTK_POLICY_AUTOMATIC ); clBreakpoints = gtk_clist_new( 1 ); gtk_container_add( GTK_CONTAINER(scrolledwindow1), clBreakpoints ); gtk_clist_set_selection_mode( GTK_CLIST(clBreakpoints), GTK_SELECTION_EXTENDED ); gtk_clist_set_column_width( GTK_CLIST(clBreakpoints), 0, 80 ); gtk_clist_set_auto_sort( GTK_CLIST(clBreakpoints), TRUE ); //=== Creation of the Buttons ======================/ boxV1 = gtk_vbox_new( FALSE, 2 ); gtk_box_pack_end( GTK_BOX(boxH1), boxV1, FALSE, FALSE, 0 ); buAdd = gtk_button_new_with_label("Add"); gtk_box_pack_start( GTK_BOX(boxV1), buAdd, FALSE, FALSE, 0 ); buRemove = gtk_button_new_with_label( "Remove" ); gtk_box_pack_start( GTK_BOX(boxV1), buRemove, FALSE, FALSE, 0 ); gtk_widget_show_all(winBreakpoints); //=== Signal Connections ===========================/ gtk_signal_connect( GTK_OBJECT(clBreakpoints), "select-row", on_row_selection, NULL ); gtk_signal_connect( GTK_OBJECT(clBreakpoints), "unselect-row", on_row_unselection, NULL ); gtk_signal_connect( GTK_OBJECT(buAdd), "clicked", on_add, NULL ); gtk_signal_connect( GTK_OBJECT(buRemove), "clicked", on_remove, NULL ); gtk_signal_connect( GTK_OBJECT(winBreakpoints), "destroy", on_close, NULL ); }
GtkWidget *create_cwidget (GtkWidget *scrollwin, struct clist_def *cldef) { GtkWidget *alignment; GtkWidget *label; GtkWidget *clist; char buf[256]; int i; switch (cldef->type) { case CWIDGET_CLIST: clist = gtk_clist_new (cldef->columns); break; case CWIDGET_CTREE: clist = gtk_ctree_new (cldef->columns, 0); gtk_ctree_set_line_style (GTK_CTREE (clist), GTK_CTREE_LINES_NONE); gtk_ctree_set_expander_style (GTK_CTREE (clist), GTK_CTREE_EXPANDER_TRIANGLE); gtk_ctree_set_indent (GTK_CTREE (clist), 10); break; default: return NULL; } gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); GTK_CLIST_SET_FLAG (GTK_CLIST (clist), CLIST_SHOW_TITLES); gtk_container_add (GTK_CONTAINER (scrollwin), clist); gtk_clist_set_selection_mode (GTK_CLIST (clist), cldef->mode); for (i = 0; i < cldef->columns; i++) { g_snprintf (buf, 256, "/" CONFIG_FILE "/%s Geometry/%s=%d", cldef->name, cldef->cols[i].name, cldef->cols[i].width); gtk_clist_set_column_width (GTK_CLIST (clist), i, config_get_int (buf)); if (cldef->cols[i].justify != GTK_JUSTIFY_LEFT) { gtk_clist_set_column_justification (GTK_CLIST (clist), i, cldef->cols[i].justify); } alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); label = gtk_label_new (_(cldef->cols[i].name)); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_container_add (GTK_CONTAINER (alignment), label); gtk_widget_show (label); cldef->cols[i].widget = label; gtk_clist_set_column_widget (GTK_CLIST (clist), i, alignment); gtk_widget_show (alignment); } gtk_clist_set_sort_column (GTK_CLIST (clist), cldef->sort_column); gtk_clist_set_sort_type (GTK_CLIST (clist), cldef->sort_type); clist_column_set_title (GTK_CLIST (clist), cldef, TRUE); return clist; }
void module_glist (struct session *sess) { gchar *titles[] = { _("Name"), _("Description") }; GtkWidget *okb, *ulb; if (modlist) return; modlist = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (modlist), "delete_event", GTK_SIGNAL_FUNC (module_glist_close), 0); gtk_widget_set_usize (modlist, 350, 200); gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (modlist)->vbox), 4); gtk_window_set_position (GTK_WINDOW (modlist), GTK_WIN_POS_CENTER); gtk_window_set_title (GTK_WINDOW (modlist), _("X-Chat Plugins")); gtk_window_set_wmclass (GTK_WINDOW (modlist), "plugins", "X-Chat"); modclist = gtk_clist_new_with_titles (2, titles); gtk_clist_set_selection_mode (GTK_CLIST (modclist), GTK_SELECTION_BROWSE); gtk_clist_column_titles_passive (GTK_CLIST (modclist)); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (modlist)->vbox), modclist, 1, 1, 10); gtk_widget_show (modclist); gtk_clist_set_column_width (GTK_CLIST (modclist), 0, 40); #ifdef USE_GNOME okb = gnome_stock_button (GNOME_STOCK_BUTTON_OK); #else okb = gtk_button_new_with_label (_("Ok")); #endif gtk_box_pack_start (GTK_BOX (GTK_DIALOG (modlist)->action_area), okb, 1, 1, 10); gtk_signal_connect (GTK_OBJECT (okb), "clicked", GTK_SIGNAL_FUNC (module_glist_close), (gpointer) modlist); gtk_widget_show (okb); ulb = gtk_button_new_with_label (_("Unload")); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (modlist)->action_area), ulb, 1, 1, 10); gtk_signal_connect (GTK_OBJECT (ulb), "clicked", GTK_SIGNAL_FUNC (module_glist_unload), (gpointer) sess); gtk_widget_show (ulb); fe_pluginlist_update (); gtk_widget_show (modlist); }
void init_regSI() { GtkWidget *boxH1, *boxV1, *labRegSI[32]; int i; char **txt; txt=malloc( sizeof(char*) ); txt[0]=malloc( 64*sizeof(char) ); frRegSI = gtk_frame_new("Serial Interface"); boxH1 = gtk_hbox_new( FALSE, 2); gtk_container_add( GTK_CONTAINER(frRegSI), boxH1 ); gtk_container_set_border_width( GTK_CONTAINER(boxH1), 5); //=== Creation of Labels "SD_*_REG" Column =======/ boxV1 = gtk_vbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(boxH1), boxV1, FALSE, FALSE, 0); labRegSI[0] = gtk_label_new( mnemonicSI[0] ); gtk_box_pack_start( GTK_BOX(boxV1), labRegSI[0], FALSE, TRUE, 1); for( i=1; i<4; i++) { labRegSI[i] = gtk_label_new( mnemonicSI[i] ); gtk_box_pack_start( GTK_BOX(boxV1), labRegSI[i], FALSE, TRUE, 0); } //=== Creation of Registers Value Display ========/ clRegSI = gtk_clist_new(1); gtk_box_pack_start( GTK_BOX(boxH1), clRegSI, TRUE, TRUE, 0); gtk_clist_set_selection_mode( GTK_CLIST(clRegSI), GTK_SELECTION_SINGLE); gtk_clist_set_column_width( GTK_CLIST(clRegSI), 0, 130); strcpy( txt[0], "Undefined"); for( i=0; i<4; i++) { gtk_clist_append( GTK_CLIST(clRegSI), txt); } //=== Fantom Registers Initialisation ============/ for( i=0; i<4; i++) { gui_fantom_reg_SI[i] = 0x12345678; //Should be put to the least probable value. } }
GtkWidget *create_source_ctree (GtkWidget *scrollwin) { char *titles[1] = { _("Source") }; GtkWidget *ctree; /* gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); */ ctree = gtk_ctree_new_with_titles (1, 0, titles); gtk_container_add (GTK_CONTAINER (scrollwin), ctree); gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED); gtk_ctree_set_line_style (GTK_CTREE (ctree), GTK_CTREE_LINES_NONE); gtk_ctree_set_expander_style (GTK_CTREE (ctree), GTK_CTREE_EXPANDER_TRIANGLE); gtk_ctree_set_indent (GTK_CTREE (ctree), 10); fill_source_ctree (ctree); return ctree; }
/* * Called once at the beginning of the program for setup */ void select_restore_setup() { const gchar *title[NUM_COLUMNS] = {_("Mark"), _("File"), _("Mode"), _("User"), _("Group"), _("Size"), _("Date")}; restore_file_selection = create_restore_file_selection(); if (!restore_file_selection) { Dmsg0(000, "Restore_files not setup.\n"); } restore_dir = lookup_widget(restore_file_selection, "restore_dir"); scrolled = lookup_widget(restore_file_selection, "scrolled"); if (!scrolled) { Dmsg0(000, "Scrolled not setup.\n"); } restore = new_window(); #ifdef needed check_pixmap = gdk_pixmap_colormap_create_from_xpm(NULL, gdk_colormap_get_system(), &check_trans, NULL, "check.xpm"); blank_pixmap = gdk_pixmap_colormap_create_from_xpm(NULL, gdk_colormap_get_system(), &blank_trans, NULL, "blank.xpm"); #endif /* XXX: Stupid gtk_clist_set_selection_mode() has incorrect declaration of the title argument */ /* XXX: Workaround by typecast... [email protected] */ restore->list = (GtkCList *)gtk_clist_new_with_titles(NUM_COLUMNS, (gchar **) title); gtk_clist_set_selection_mode(restore->list, GTK_SELECTION_EXTENDED); gtk_clist_set_sort_column(restore->list, FILE_COLUMN); gtk_clist_set_auto_sort(restore->list, true); gtk_signal_connect(GTK_OBJECT(restore->list), "click_column", G_CALLBACK(click_column_cb), restore); gtk_signal_connect(GTK_OBJECT(restore->list), "select_row", G_CALLBACK(select_row_cb), restore); gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(restore->list)); restore->buf = get_pool_memory(PM_FNAME); restore->fname = get_pool_memory(PM_FNAME); restore->path = get_pool_memory(PM_NAME); restore->file = get_pool_memory(PM_NAME); }
GtkWidget * gtkutil_clist_new (int columns, char *titles[], GtkWidget * box, int policy, void *select_callback, gpointer select_userdata, void *unselect_callback, gpointer unselect_userdata, int selection_mode) { GtkWidget *clist, *win; win = gtk_scrolled_window_new (0, 0); gtk_container_add (GTK_CONTAINER (box), win); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win), GTK_POLICY_AUTOMATIC, policy); gtk_widget_show (win); if (titles) clist = gtk_clist_new_with_titles (columns, titles); else clist = gtk_clist_new (columns); gtk_clist_set_selection_mode (GTK_CLIST (clist), selection_mode); gtk_clist_column_titles_passive (GTK_CLIST (clist)); gtk_container_add (GTK_CONTAINER (win), clist); if (select_callback) { g_signal_connect (G_OBJECT (clist), "select_row", G_CALLBACK (select_callback), select_userdata); } if (unselect_callback) { g_signal_connect (G_OBJECT (clist), "unselect_row", G_CALLBACK (unselect_callback), unselect_userdata); } gtk_widget_show (clist); return clist; }
static GtkWidget* make_contents(history_calendar_dlg *hcdlg) { GtkWidget *vbox, *button, *scrollwin; gchar *titles[] = { "Time", "Event" }; button = gtk_button_new(); hcdlg->daylabel = gtk_label_new(""); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(popup_calendar), hcdlg); gtk_container_add(GTK_CONTAINER(button), hcdlg->daylabel); scrollwin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); hcdlg->evlist = gtk_clist_new_with_titles(2, titles); gtk_clist_set_selection_mode(GTK_CLIST(hcdlg->evlist), GTK_SELECTION_BROWSE); g_signal_connect(G_OBJECT(hcdlg->evlist), "select-row", G_CALLBACK(hc_row_selected), hcdlg); g_signal_connect(G_OBJECT(hcdlg->evlist), "unselect-row", G_CALLBACK(hc_row_selected), hcdlg); g_signal_connect(G_OBJECT(hcdlg->evlist), "button_press_event", G_CALLBACK(hc_list_click_cb), hcdlg); gtk_clist_column_titles_passive(GTK_CLIST(hcdlg->evlist)); /* fixme gtk2 gtk_clist_set_column_width(GTK_CLIST(hcdlg->evlist), 0, gdk_string_width(hcdlg->evlist->style->font, "00:00a"));*/ titles[0] = NULL; titles[1] = "[select a day]"; gtk_clist_append(GTK_CLIST(hcdlg->evlist), titles); gtk_clist_set_selectable(GTK_CLIST(hcdlg->evlist), 0, FALSE); gtk_container_add(GTK_CONTAINER(scrollwin), hcdlg->evlist); vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0); return vbox; }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_tclist_set_properties (GtkWidget * widget, GtkWidget *child, GbWidgetSetArgData * data) { gchar *widths, *pos, *mode; gchar *shadow; gboolean titles; gint col, w, i; #ifndef GTK_HAVE_FEATURES_1_1_4 gboolean myApply; gchar *hpolicy, *vpolicy; GtkPolicyType hpolicy_value = GTK_POLICY_AUTOMATIC; GtkPolicyType vpolicy_value = GTK_POLICY_AUTOMATIC; #endif if (data->action == GB_LOADING) { widths = gb_widget_input_string (data, ColumnWidths); if (data->apply) { pos = widths; for (col = 0; col < GTK_CLIST (widget)->columns; col++) { w = atoi (pos); gtk_clist_set_column_width (GTK_CLIST (widget), col, w); pos = strchr (pos, ','); if (!pos) break; pos++; } } } mode = gb_widget_input_choice (data, Mode); if (data->apply) { for (i = 0; i < sizeof (GbModeValues) / sizeof (GbModeValues[0]); i++) { if (!strcmp (mode, GbModeChoices[i]) || !strcmp (mode, GbModeSymbols[i])) { gtk_clist_set_selection_mode (GTK_CLIST (widget), GbModeValues[i]); break; } } } titles = gb_widget_input_bool (data, Titles); if (data->apply) { if (titles) gtk_clist_column_titles_show (GTK_CLIST (widget)); else gtk_clist_column_titles_hide (GTK_CLIST (widget)); } shadow = gb_widget_input_choice (data, Shadow); if (data->apply) { for (i = 0; i < sizeof (GbShadowValues) / sizeof (GbShadowValues[0]); i ++) { if (!strcmp (shadow, GbShadowChoices[i]) || !strcmp (shadow, GbShadowSymbols[i])) { #ifdef GTK_HAVE_FEATURES_1_1_4 gtk_clist_set_shadow_type (GTK_CLIST (widget), GbShadowValues[i]); #else gtk_clist_set_border (GTK_CLIST (widget), GbShadowValues[i]); #endif break; } } } #ifndef GTK_HAVE_FEATURES_1_1_4 hpolicy = gb_widget_input_choice (data, HPolicy); myApply = data->apply; vpolicy = gb_widget_input_choice (data, VPolicy); if (data->apply || myApply) { for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i ++) { if (!strcmp (hpolicy, GbPolicyChoices[i]) || !strcmp (hpolicy, GbPolicySymbols[i])) hpolicy_value = GbPolicyValues[i]; if (!strcmp (vpolicy, GbPolicyChoices[i]) || !strcmp (vpolicy, GbPolicySymbols[i])) vpolicy_value = GbPolicyValues[i]; } gtk_clist_set_policy (GTK_CLIST (widget), vpolicy_value, hpolicy_value); } #endif }
GtkWidget * create_file_view(FileView *view) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *menu_bar; GtkWidget *button; GtkWidget *pixmapwid; GdkPixmap *pixmap; GdkBitmap *mask; GtkStyle *style; GdkFont *font; GtkWidget *sw; gint i; /* Top Pane */ vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox); menu_bar = create_filelist_menu_bar(view); gtk_widget_show(menu_bar); gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox); /* Show/Hide Button */ if (view == &app.right_view) button = gtk_button_new_with_label("<"); else button = gtk_button_new_with_label(">"); GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS); gtk_signal_connect(GTK_OBJECT(button), "button_press_event", GTK_SIGNAL_FUNC(show_hide_file_view_cb), view); gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), button, _("Left Click: Maximize/Minimize File View\n" "Right Click: Sync Dirs"), NULL); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); gtk_widget_show(button); /* Hidden files toggle button */ view->hidden_toggle = gtk_toggle_button_new_with_label("H"); GTK_WIDGET_UNSET_FLAGS(view->hidden_toggle, GTK_CAN_FOCUS); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(view->hidden_toggle), view->show_hidden); gtk_signal_connect(GTK_OBJECT(view->hidden_toggle), "toggled", GTK_SIGNAL_FUNC(toggle_show_hidden_cb), view); gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), view->hidden_toggle, _("Show/Hide hidden files"), NULL); gtk_box_pack_start(GTK_BOX(hbox), view->hidden_toggle, FALSE, FALSE, 0); gtk_widget_show(view->hidden_toggle); /* Dir Entry Combo */ view->dir_entry = gtk_combo_new(); gtk_combo_disable_activate(GTK_COMBO(view->dir_entry)); gtk_combo_set_use_arrows_always(GTK_COMBO(view->dir_entry), TRUE); gtk_combo_set_case_sensitive(GTK_COMBO(view->dir_entry), TRUE); gtk_signal_connect(GTK_OBJECT(GTK_COMBO(view->dir_entry)->entry), "activate", GTK_SIGNAL_FUNC(dir_entry_cb), view); gtk_signal_connect(GTK_OBJECT(GTK_COMBO(view->dir_entry)->popwin), "hide", GTK_SIGNAL_FUNC(dir_popwin_cb), view); gtk_box_pack_start(GTK_BOX(hbox), view->dir_entry, TRUE, TRUE, 0); gtk_widget_show(view->dir_entry); /* Up Dir Button */ button = gtk_button_new(); GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS); gtk_signal_connect(GTK_OBJECT(button), "button_press_event", GTK_SIGNAL_FUNC(updir_click_cb), view); gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), button, _("Left Click: Up Dir Right Click: Home"), NULL); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); gtk_widget_show(button); style = gtk_widget_get_style(app.main_window); pixmap = gdk_pixmap_create_from_xpm_d(app.main_window->window, &mask, &style->bg[GTK_STATE_NORMAL], icon_dirparent_xpm); pixmapwid = gtk_pixmap_new(pixmap, mask); gtk_container_add(GTK_CONTAINER(button), pixmapwid); gtk_widget_show(pixmapwid); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); 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_placement(GTK_SCROLLED_WINDOW(sw), cfg.scrollbar_pos); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); gtk_widget_show(sw); /* File List */ view->clist = gtk_clist_new(MAX_COLUMNS); for (i = 0; i < MAX_COLUMNS; i++) { GtkWidget *hbox = gtk_hbox_new(FALSE, 0); GtkWidget *label = gtk_label_new(all_columns[i].title); view->sort_arrows[i] = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); gtk_box_pack_end(GTK_BOX(hbox), view->sort_arrows[i], FALSE, TRUE, 0); gtk_widget_show(label); gtk_widget_show(hbox); gtk_clist_set_column_widget(GTK_CLIST(view->clist), i, hbox); GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(view->clist)->column[i].button, GTK_CAN_FOCUS); } gtk_clist_column_titles_show(GTK_CLIST(view->clist)); gtk_clist_set_shadow_type(GTK_CLIST(view->clist), GTK_SHADOW_ETCHED_IN); gtk_clist_set_selection_mode(GTK_CLIST(view->clist), GTK_SELECTION_EXTENDED); gtk_clist_set_use_drag_icons(GTK_CLIST(view->clist), TRUE); gtk_clist_set_row_height(GTK_CLIST(view->clist), 0); font = gdk_font_load(cfg.list_font); if (font != NULL) { style = gtk_style_copy(gtk_widget_get_style(view->clist)); style->font = font; gtk_widget_set_style(view->clist, style); } for (i = 0; i < MAX_COLUMNS; i++) { gtk_clist_set_column_width(GTK_CLIST(view->clist), i, all_columns[i].size); gtk_clist_set_column_visibility(GTK_CLIST(view->clist), i, all_columns[i].is_visible); } gtk_signal_connect(GTK_OBJECT(view->clist), "select_row", GTK_SIGNAL_FUNC(select_row_cb), view); gtk_signal_connect(GTK_OBJECT(view->clist), "button_press_event", GTK_SIGNAL_FUNC(mouse_click_cb), view); gtk_signal_connect(GTK_OBJECT(view->clist), "key_press_event", GTK_SIGNAL_FUNC(file_list_key_press_cb), view); gtk_signal_connect(GTK_OBJECT(view->clist), "click_column", GTK_SIGNAL_FUNC(column_button_cb), view); gtk_signal_connect(GTK_OBJECT(view->clist), "drag_data_get", GTK_SIGNAL_FUNC(clist_drag_data_get), view); gtk_signal_connect(GTK_OBJECT(view->clist), "drag_motion", GTK_SIGNAL_FUNC(clist_drag_motion), view); gtk_signal_connect(GTK_OBJECT(view->clist), "drag_leave", GTK_SIGNAL_FUNC(clist_drag_leave), view); gtk_signal_connect(GTK_OBJECT(view->clist), "drag_data_received", GTK_SIGNAL_FUNC(clist_drag_data_received), view); gtk_drag_dest_set(view->clist, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, target_table, n_targets, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK); gtk_container_add(GTK_CONTAINER(sw), view->clist); gtk_widget_show(view->clist); /* Set the CLIST_COLOR for resetting from the DRAG_HILIGHT color */ { GtkStyle *style = gtk_widget_get_style(view->clist); CLIST_COLOR.red = style->base[GTK_STATE_NORMAL].red; CLIST_COLOR.green = style->base[GTK_STATE_NORMAL].green; CLIST_COLOR.blue = style->base[GTK_STATE_NORMAL].blue; } return vbox; }
GtkWidget * create_PlayList( void ) { GtkWidget * vbox1; GtkWidget * hbox1; GtkWidget * scrolledwindow1; GtkWidget * vbox2; GtkWidget * scrolledwindow2; GtkWidget * scrolledwindow3; GtkWidget * hbuttonbox1; GtkAccelGroup * accel_group; GdkColor transparent = { 0,0,0,0 }; gchar * root = "/"; gchar * dummy = "dummy"; DirNodeType * DirNode; accel_group=gtk_accel_group_new(); PlayList=gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_object_set_data( GTK_OBJECT( PlayList ),"PlayList",PlayList ); gtk_widget_set_usize( PlayList,512,384 ); gtk_window_set_title( GTK_WINDOW( PlayList ),MSGTR_PlayList ); gtk_window_set_position( GTK_WINDOW( PlayList ),GTK_WIN_POS_CENTER ); // gtk_window_set_policy( GTK_WINDOW( PlayList ),FALSE,FALSE,FALSE ); gtk_window_set_wmclass( GTK_WINDOW( PlayList ),"Playlist","MPlayer" ); gtk_widget_realize( PlayList ); gtkAddIcon( PlayList ); vbox1=AddVBox( AddDialogFrame( PlayList ),0 ); hbox1=AddHBox( NULL,1 ); gtk_box_pack_start( GTK_BOX( vbox1 ),hbox1,TRUE,TRUE,0 ); scrolledwindow1=gtk_scrolled_window_new( NULL,NULL ); gtk_widget_show( scrolledwindow1 ); gtk_container_add( GTK_CONTAINER( AddFrame( NULL,0,hbox1,1 ) ),scrolledwindow1 ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC ); CTDirTree=gtk_ctree_new( 1,0 ); gtk_signal_connect( GTK_OBJECT( CTDirTree ),"tree_expand",GTK_SIGNAL_FUNC( plCTree ),(void*)0 ); gtk_signal_connect( GTK_OBJECT( CTDirTree ),"select_row",GTK_SIGNAL_FUNC( plCTRow ),(void *)0 ); gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),CTDirTree ); gtk_clist_set_column_auto_resize( GTK_CLIST( CTDirTree ),0,TRUE ); gtk_clist_set_column_width( GTK_CLIST( CTDirTree ),0,80 ); gtk_clist_set_selection_mode( GTK_CLIST( CTDirTree ),GTK_SELECTION_SINGLE ); gtk_ctree_set_line_style( GTK_CTREE( CTDirTree ),GTK_CTREE_LINES_SOLID ); gtk_clist_column_titles_show( GTK_CLIST( CTDirTree ) ); gtk_clist_set_shadow_type( GTK_CLIST( CTDirTree ),GTK_SHADOW_NONE ); if ( !pxOpenedBook ) pxOpenedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msOpenedBook,&transparent,(gchar **)dir2_xpm ); if ( !pxClosedBook ) pxClosedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msClosedBook,&transparent,(gchar **)open2_xpm ); parent=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),NULL,NULL,&root,4,pxOpenedBook,msOpenedBook,pxClosedBook,msClosedBook,FALSE,FALSE ); DirNode=malloc( sizeof( DirNodeType ) ); DirNode->scaned=0; DirNode->path=strdup( root ); gtk_ctree_node_set_row_data_full(GTK_CTREE( CTDirTree ),parent,DirNode,NULL ); sibling=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),parent,NULL,&dummy,4,NULL,NULL,NULL,NULL,TRUE,TRUE ); gtk_ctree_expand( GTK_CTREE( CTDirTree ),parent ); gtk_widget_show( CTDirTree ); if ( fsHistory[0] ) old_path = g_filename_from_utf8( fsHistory[0], -1, NULL, NULL, NULL ); gtk_clist_set_column_widget( GTK_CLIST( CTDirTree ),0, AddLabel( MSGTR_PLAYLIST_DirectoryTree,NULL ) ); gtk_clist_column_title_passive( GTK_CLIST( CTDirTree ),0 ); vbox2=AddVBox( AddFrame( NULL,1,hbox1,1 ),0 ); scrolledwindow2=gtk_scrolled_window_new( NULL,NULL ); gtk_widget_show( scrolledwindow2 ); gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow2,TRUE,TRUE,0 ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow2 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC ); CLFiles=gtk_clist_new( 1 ); gtk_widget_show( CLFiles ); gtk_container_add( GTK_CONTAINER( scrolledwindow2 ),CLFiles ); gtk_clist_set_column_width( GTK_CLIST( CLFiles ),0,80 ); gtk_clist_set_selection_mode( GTK_CLIST( CLFiles ),GTK_SELECTION_EXTENDED ); gtk_clist_column_titles_show( GTK_CLIST( CLFiles ) ); gtk_clist_set_shadow_type( GTK_CLIST( CLFiles ),GTK_SHADOW_NONE ); gtk_clist_set_column_widget( GTK_CLIST( CLFiles ),0, AddLabel( MSGTR_PLAYLIST_Files,NULL ) ); gtk_clist_column_title_passive( GTK_CLIST( CLFiles ),0 ); AddHSeparator( vbox2 ); scrolledwindow3=gtk_scrolled_window_new( NULL,NULL ); gtk_widget_show( scrolledwindow3 ); gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow3,TRUE,TRUE,0 ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow3 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC ); CLSelected=gtk_clist_new( 2 ); gtk_widget_show( CLSelected ); gtk_container_add( GTK_CONTAINER( scrolledwindow3 ),CLSelected ); gtk_clist_set_column_width( GTK_CLIST( CLSelected ),0,295 ); gtk_clist_set_column_width( GTK_CLIST( CLSelected ),1,295 ); gtk_clist_set_selection_mode( GTK_CLIST( CLSelected ),GTK_SELECTION_MULTIPLE ); gtk_clist_column_titles_show( GTK_CLIST( CLSelected ) ); gtk_clist_set_shadow_type( GTK_CLIST( CLSelected ),GTK_SHADOW_NONE ); gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),0, AddLabel( MSGTR_PLAYLIST_Selected,NULL ) ); gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),1, AddLabel( MSGTR_PLAYLIST_Path,NULL ) ); gtk_clist_column_title_passive( GTK_CLIST( CLSelected ),0 ); AddHSeparator( vbox1 ); hbuttonbox1=AddHButtonBox( vbox1 ); gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END ); gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 ); Add=AddButton( MSGTR_Add,hbuttonbox1 ); Remove=AddButton( MSGTR_Remove,hbuttonbox1 ); Ok=AddButton( MSGTR_Ok,hbuttonbox1 ); Cancel=AddButton( MSGTR_Cancel,hbuttonbox1 ); gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE ); gtk_signal_connect( GTK_OBJECT( PlayList ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&PlayList ); gtk_signal_connect( GTK_OBJECT( CLFiles ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void *)0 ); gtk_signal_connect( GTK_OBJECT( CLFiles ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void *)0 ); gtk_signal_connect( GTK_OBJECT( CLFiles ),"event",GTK_SIGNAL_FUNC( plEvent ),(void *)0 ); gtk_signal_connect( GTK_OBJECT( CLFiles ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void *)0 ); sigSel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void*)1 ); sigUnsel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void*)1 ); sigEvent=gtk_signal_connect( GTK_OBJECT( CLSelected ),"event",GTK_SIGNAL_FUNC( plEvent ),(void *)1 ); gtk_signal_connect( GTK_OBJECT( CLSelected ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void *)1 ); gtk_signal_connect( GTK_OBJECT( Add ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)3 ); gtk_signal_connect( GTK_OBJECT( Add ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)3 ); gtk_signal_connect( GTK_OBJECT( Remove ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)2 ); gtk_signal_connect( GTK_OBJECT( Remove ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)2 ); gtk_signal_connect( GTK_OBJECT( Ok ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)1 ); gtk_signal_connect( GTK_OBJECT( Ok ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)1 ); gtk_signal_connect( GTK_OBJECT( Cancel ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)0 ); gtk_signal_connect( GTK_OBJECT( Cancel ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)0 ); gtk_window_add_accel_group( GTK_WINDOW( PlayList ),accel_group ); return PlayList; }
static void create_gui (void) { char *titles[] = { "Name", "Type", "Value", "Serial" }; GtkWidget *scrolled_window; GtkWidget *dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL); GtkWidget *vbox, *bbox, *separator, *table, *button; gtk_window_set_title (GTK_WINDOW (dialog), "Sample XSETTINGS Client"); gtk_window_set_default_size (GTK_WINDOW (dialog), -1, 300); gtk_signal_connect (GTK_OBJECT (dialog), "destroy", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (dialog), vbox); bbox = gtk_hbutton_box_new (); gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END); gtk_container_set_border_width (GTK_CONTAINER (bbox), 5); separator = gtk_hseparator_new (); gtk_box_pack_end (GTK_BOX (vbox), separator, FALSE, FALSE, 0); table = gtk_table_new (3, 2, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 5); gtk_table_set_row_spacings (GTK_TABLE (table), 5); gtk_table_set_col_spacings (GTK_TABLE (table), 5); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); settings_clist = gtk_clist_new_with_titles (4, titles); gtk_container_add (GTK_CONTAINER (scrolled_window), settings_clist); gtk_clist_set_selection_mode (GTK_CLIST (settings_clist), GTK_SELECTION_BROWSE); gtk_clist_set_sort_column (GTK_CLIST (settings_clist), 1); gtk_clist_set_auto_sort (GTK_CLIST (settings_clist), TRUE); gtk_clist_set_column_width (GTK_CLIST (settings_clist), NAME, 200); gtk_clist_set_column_width (GTK_CLIST (settings_clist), TYPE, 50); gtk_clist_set_column_width (GTK_CLIST (settings_clist), VALUE, 100); gtk_clist_set_column_width (GTK_CLIST (settings_clist), SERIAL, 50); gtk_table_attach (GTK_TABLE (table), scrolled_window, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Close"); gtk_box_pack_end (GTK_BOX (bbox), button, FALSE, FALSE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); gtk_widget_show_all (dialog); }
int install_gui(GtkWidget *main_window, int w, int h, int x, int y) { GtkWidget *scrolled_window; GtkWidget *button; GtkWidget *label; GtkWidget *pixmapwid; GdkPixmap *pixmap; GdkBitmap *mask; char temp_str[256]; const char *svalue; gchar *titles[] = {"", _("Files to install")}; if (filew) { return EXIT_SUCCESS; } clist_row_selected = 0; g_snprintf(temp_str, sizeof(temp_str), "%s %s", PN, _("Install")); filew = gtk_widget_new(GTK_TYPE_FILE_SELECTION, "type", GTK_WINDOW_TOPLEVEL, "title", temp_str, NULL); gtk_window_set_default_size(GTK_WINDOW(filew), w, h); gtk_widget_set_uposition(filew, x, y); gtk_window_set_modal(GTK_WINDOW(filew), TRUE); gtk_window_set_transient_for(GTK_WINDOW(filew), GTK_WINDOW(main_window)); get_pref(PREF_INSTALL_PATH, NULL, &svalue); if (svalue && svalue[0]) { gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew), svalue); } gtk_file_selection_hide_fileop_buttons((gpointer) filew); gtk_widget_hide((GTK_FILE_SELECTION(filew)->cancel_button)); gtk_signal_connect(GTK_OBJECT(filew), "destroy", GTK_SIGNAL_FUNC(cb_destroy), filew); /* Even though I hide the ok button I still want to connect its signal */ /* because a double click on the file name also calls this callback */ gtk_widget_hide(GTK_WIDGET(GTK_FILE_SELECTION(filew)->ok_button)); gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filew)->ok_button), "clicked", GTK_SIGNAL_FUNC(cb_add), filew); clist = gtk_clist_new_with_titles(2, titles); gtk_widget_set_usize(GTK_WIDGET(clist), 0, 166); gtk_clist_column_titles_passive(GTK_CLIST(clist)); gtk_clist_set_column_auto_resize(GTK_CLIST(clist), INST_SDCARD_COLUMN, TRUE); gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_BROWSE); get_pixmaps(clist, PIXMAP_SDCARD, &pixmap, &mask); #ifdef __APPLE__ mask = NULL; #endif pixmapwid = gtk_pixmap_new(pixmap, mask); gtk_clist_set_column_widget(GTK_CLIST(clist), INST_SDCARD_COLUMN, pixmapwid); gtk_clist_set_column_justification(GTK_CLIST(clist), INST_SDCARD_COLUMN, GTK_JUSTIFY_CENTER); gtk_signal_connect(GTK_OBJECT(clist), "select_row", GTK_SIGNAL_FUNC(cb_clist_selection), NULL); /* Scrolled Window for file list */ scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(clist)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_set_border_width(GTK_CONTAINER(scrolled_window), 5); gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->action_area), scrolled_window, TRUE, TRUE, 0); label = gtk_label_new(_("To change to a hidden directory type it below and hit TAB")); gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->main_vbox), label, FALSE, FALSE, 0); /* Add/Remove/Quit buttons */ button = gtk_button_new_from_stock(GTK_STOCK_ADD); gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->ok_button->parent), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(cb_add), filew); button = gtk_button_new_from_stock(GTK_STOCK_REMOVE); gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->ok_button->parent), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(cb_remove), filew); button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->ok_button->parent), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(cb_quit), filew); /**********************************************************************/ gtk_widget_show_all(filew); /* Hide default buttons not used by Jpilot file selector */ gtk_widget_hide(GTK_FILE_SELECTION(filew)->cancel_button); gtk_widget_hide(GTK_FILE_SELECTION(filew)->ok_button); install_update_clist(); gtk_main(); return EXIT_SUCCESS; }
/* * mainline.. */ void ptrans_searchbox(char *title) { int i; GtkWidget *scrolled_win; GtkWidget *vbox1, *hbox, *hbox0; GtkWidget *button1, *button5, *button6; gchar *titles[]={"Process Filter Select"}; GtkWidget *frame2, *frameh, *frameh0; GtkWidget *table; GtkTooltips *tooltips; if(GLOBALS->is_active_ptranslate_c_2) { gdk_window_raise(GLOBALS->window_ptranslate_c_5->window); return; } GLOBALS->is_active_ptranslate_c_2=1; GLOBALS->current_filter_ptranslate_c_1 = 0; /* create a new modal window */ GLOBALS->window_ptranslate_c_5 = gtk_window_new(GLOBALS->disable_window_manager ? GTK_WINDOW_POPUP : GTK_WINDOW_TOPLEVEL); install_focus_cb(GLOBALS->window_ptranslate_c_5, ((char *)&GLOBALS->window_ptranslate_c_5) - ((char *)GLOBALS)); gtk_window_set_title(GTK_WINDOW (GLOBALS->window_ptranslate_c_5), title); gtkwave_signal_connect(GTK_OBJECT (GLOBALS->window_ptranslate_c_5), "delete_event",(GtkSignalFunc) destroy_callback, NULL); tooltips=gtk_tooltips_new_2(); table = gtk_table_new (256, 1, FALSE); gtk_widget_show (table); vbox1 = gtk_vbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (vbox1), 3); gtk_widget_show (vbox1); frame2 = gtk_frame_new (NULL); gtk_container_border_width (GTK_CONTAINER (frame2), 3); gtk_widget_show(frame2); gtk_table_attach (GTK_TABLE (table), frame2, 0, 1, 0, 254, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); GLOBALS->clist_ptranslate_c_2=gtk_clist_new_with_titles(1,titles); gtk_clist_column_titles_passive(GTK_CLIST(GLOBALS->clist_ptranslate_c_2)); gtk_clist_set_selection_mode(GTK_CLIST(GLOBALS->clist_ptranslate_c_2), GTK_SELECTION_EXTENDED); gtkwave_signal_connect_object (GTK_OBJECT (GLOBALS->clist_ptranslate_c_2), "select_row",GTK_SIGNAL_FUNC(select_row_callback),NULL); gtkwave_signal_connect_object (GTK_OBJECT (GLOBALS->clist_ptranslate_c_2), "unselect_row",GTK_SIGNAL_FUNC(unselect_row_callback),NULL); for(i=0;i<GLOBALS->num_proc_filters;i++) { gtk_clist_append(GTK_CLIST(GLOBALS->clist_ptranslate_c_2),(gchar **)&(GLOBALS->procsel_filter[i+1])); } gtk_clist_set_column_width(GTK_CLIST(GLOBALS->clist_ptranslate_c_2),0,gtk_clist_optimal_column_width(GTK_CLIST(GLOBALS->clist_ptranslate_c_2),0)); gtk_widget_show (GLOBALS->clist_ptranslate_c_2); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize( GTK_WIDGET (scrolled_win), -1, 300); gtk_widget_show(scrolled_win); /* gtk_scrolled_window_add_with_viewport doesn't seen to work right here.. */ gtk_container_add (GTK_CONTAINER (scrolled_win), GLOBALS->clist_ptranslate_c_2); gtk_container_add (GTK_CONTAINER (frame2), scrolled_win); frameh0 = gtk_frame_new (NULL); gtk_container_border_width (GTK_CONTAINER (frameh0), 3); gtk_widget_show(frameh0); gtk_table_attach (GTK_TABLE (table), frameh0, 0, 1, 254, 255, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); hbox0 = gtk_hbox_new (FALSE, 1); gtk_widget_show (hbox0); button6 = gtk_button_new_with_label (" Add Proc Filter to List "); gtk_container_border_width (GTK_CONTAINER (button6), 3); gtkwave_signal_connect_object (GTK_OBJECT (button6), "clicked",GTK_SIGNAL_FUNC(add_filter_callback),GTK_OBJECT (GLOBALS->window_ptranslate_c_5)); gtk_widget_show (button6); gtk_tooltips_set_tip_2(tooltips, button6, "Bring up a file requester to add a process filter to the filter select window.",NULL); gtk_box_pack_start (GTK_BOX (hbox0), button6, TRUE, FALSE, 0); gtk_container_add (GTK_CONTAINER (frameh0), hbox0); frameh = gtk_frame_new (NULL); gtk_container_border_width (GTK_CONTAINER (frameh), 3); gtk_widget_show(frameh); gtk_table_attach (GTK_TABLE (table), frameh, 0, 1, 255, 256, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); hbox = gtk_hbox_new (FALSE, 1); gtk_widget_show (hbox); button1 = gtk_button_new_with_label (" OK "); gtk_container_border_width (GTK_CONTAINER (button1), 3); gtkwave_signal_connect_object (GTK_OBJECT (button1), "clicked",GTK_SIGNAL_FUNC(ok_callback),GTK_OBJECT (GLOBALS->window_ptranslate_c_5)); gtk_widget_show (button1); gtk_tooltips_set_tip_2(tooltips, button1, "Add selected signals to end of the display on the main window.",NULL); gtk_box_pack_start (GTK_BOX (hbox), button1, TRUE, FALSE, 0); button5 = gtk_button_new_with_label (" Cancel "); gtk_container_border_width (GTK_CONTAINER (button5), 3); gtkwave_signal_connect_object (GTK_OBJECT (button5), "clicked",GTK_SIGNAL_FUNC(destroy_callback),GTK_OBJECT (GLOBALS->window_ptranslate_c_5)); gtk_tooltips_set_tip_2(tooltips, button5, "Do nothing and return to the main window.",NULL); gtk_widget_show (button5); gtk_box_pack_start (GTK_BOX (hbox), button5, TRUE, FALSE, 0); gtk_container_add (GTK_CONTAINER (frameh), hbox); gtk_container_add (GTK_CONTAINER (GLOBALS->window_ptranslate_c_5), table); gtk_widget_set_usize(GTK_WIDGET(GLOBALS->window_ptranslate_c_5), 400, 400); gtk_widget_show(GLOBALS->window_ptranslate_c_5); }
int ghack_menu_window_select_menu (GtkWidget *menuWin, MENU_ITEM_P **_selected, gint how) { gint rc; guint num_sel, i, idx; GtkWidget *clist; GList *cur; MENU_ITEM_P *selected = NULL; menuItem* item; g_assert (_selected != NULL); *_selected = NULL; if (how == PICK_NONE) { gnome_dialog_close_hides (GNOME_DIALOG (menuWin), TRUE); rc = gnome_dialog_run_and_close (GNOME_DIALOG (menuWin)); return( rc == 1 ? -1 : 0); } clist = GTK_WIDGET (gtk_object_get_data (GTK_OBJECT (menuWin), "clist")); g_assert (clist != NULL); gtk_object_set_data (GTK_OBJECT (clist), "selection_mode", GINT_TO_POINTER ((how == PICK_ANY)? GTK_SELECTION_MULTIPLE : GTK_SELECTION_SINGLE)); gtk_clist_set_selection_mode (GTK_CLIST (clist), (how == PICK_ANY)? GTK_SELECTION_MULTIPLE : GTK_SELECTION_SINGLE); gnome_dialog_close_hides (GNOME_DIALOG (menuWin), TRUE); rc = gnome_dialog_run_and_close (GNOME_DIALOG (menuWin)); if ((rc == 1) || (GTK_CLIST (clist)->selection == NULL)) { return(-1); } num_sel = g_list_length (GTK_CLIST (clist)->selection); if (num_sel < 1) { return(-1); } /* fill in array with selections from clist */ selected = g_new0( MENU_ITEM_P, num_sel); g_assert (selected != NULL); cur = GTK_CLIST (clist)->selection; i = 0; while (cur) { g_assert (i < num_sel); /* grab row number from clist selection list */ idx = GPOINTER_TO_INT (cur->data); item = (menuItem*) gtk_clist_get_row_data( GTK_CLIST (clist), idx); selected[i].item = item->identifier; selected[i].count = -1; cur = g_list_next(cur); i++; } *_selected = selected; return( (int) num_sel); }
void start(void* v) { GtkWidget *scrolled_win, *tree, *hpanes, *vbox, *menu, *list; /*static gchar *itemnames[] = {"One", "Two", "Three", "Four", "Five"};*/ GtkItemFactory *item_factory; GtkAccelGroup *accel_group; gint nmenu_items; gint i; GtkWidget *table; GtkWidget *name_label, *info_vbox; GtkWidget *type_label; GtkWidget *annot_label, *annot_hbox, *annot_vscroll; GtkWidget *sep1; GtkWidget *props_hbox, *props_scrollwin; GtkWidget *menu_item; gtk_init (&SFE_Globals.ArgC, &SFE_Globals.ArgV); SFE_Globals.Data = stCreateStruct("new","x-unknown/x-unknown"); SFE_Globals.Modified = 0; SFE_Globals.HideColTitles = 0; /* a generic toplevel window */ SFE_Globals.Window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(SFE_Globals.Window), "Centrallix Structure File Editor"); gtk_signal_connect (GTK_OBJECT(SFE_Globals.Window), "delete_event", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); gtk_widget_set_usize(SFE_Globals.Window, 600, 350); /** Build the Open File... dialog box **/ SFE_Globals.OpenDialog = gtk_file_selection_new("Open File..."); gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(SFE_Globals.OpenDialog)->cancel_button), "clicked", (GtkSignalFunc)sfe_ui_FileOpenCancel, GTK_OBJECT(SFE_Globals.OpenDialog)); gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(SFE_Globals.OpenDialog)->ok_button), "clicked", (GtkSignalFunc)sfe_ui_FileOpenOk, GTK_OBJECT(SFE_Globals.OpenDialog)); /* vertical box organizing the menu vs. rest of app */ vbox = gtk_vbox_new(FALSE,1); gtk_container_add(GTK_CONTAINER(SFE_Globals.Window), vbox); gtk_widget_show(vbox); /* menu */ nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]); accel_group = gtk_accel_group_new(); item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group); gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL); gtk_window_add_accel_group(GTK_WINDOW(SFE_Globals.Window), accel_group); menu = gtk_item_factory_get_widget(item_factory, "<main>"); gtk_box_pack_start(GTK_BOX(vbox), menu, FALSE, TRUE, 0); /*menu_item = gtk_item_factory_get_widget(GTK_ITEM_FACTORY(item_factory),"/View/Column Titles"); gtk_menu_item_activate(GTK_MENU_ITEM(menu_item));*/ gtk_widget_show(menu); /* horizontal layout box organizing the treeview and the data view pane */ hpanes = gtk_hpaned_new(); gtk_container_add(GTK_CONTAINER(vbox), hpanes); gtk_container_set_border_width (GTK_CONTAINER(hpanes), 5); gtk_paned_set_gutter_size(GTK_PANED(hpanes), 16); gtk_widget_show(hpanes); /* A generic scrolled window - for the treeview. */ scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize (scrolled_win, 150, 200); gtk_container_add (GTK_CONTAINER(hpanes), scrolled_win); gtk_widget_show (scrolled_win); /* Create the root tree and add it to the scrolled window */ tree = gtk_tree_new(); gtk_signal_connect (GTK_OBJECT(tree), "select_child", GTK_SIGNAL_FUNC(cb_select_child), tree); gtk_signal_connect (GTK_OBJECT(tree), "unselect_child", GTK_SIGNAL_FUNC(cb_unselect_child), tree); gtk_signal_connect (GTK_OBJECT(tree), "selection_changed", GTK_SIGNAL_FUNC(sfe_ui_TreeSelectionChanged), tree); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_win), tree); gtk_tree_set_selection_mode (GTK_TREE(tree), GTK_SELECTION_SINGLE); gtk_tree_set_view_mode(GTK_TREE(tree), GTK_TREE_VIEW_ITEM); gtk_widget_show (tree); SFE_Globals.TreeView = tree; /** build the item name section **/ info_vbox = gtk_vbox_new(FALSE,1); gtk_container_add(GTK_CONTAINER(hpanes), info_vbox); gtk_widget_show(info_vbox); table = gtk_table_new(3,2,FALSE); gtk_box_pack_start(GTK_BOX(info_vbox), table, FALSE, TRUE, 0); gtk_widget_show(table); name_label = gtk_label_new("Name:"); gtk_label_set_justify(GTK_LABEL(name_label), GTK_JUSTIFY_LEFT); gtk_table_attach(GTK_TABLE(table), name_label, 0, 1, 0, 1, 0, 0, 0, 0); gtk_widget_show(name_label); SFE_Globals.NameEdit = gtk_entry_new_with_max_length(63); gtk_table_attach(GTK_TABLE(table), SFE_Globals.NameEdit, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0, 0); gtk_widget_show(SFE_Globals.NameEdit); /** Item type **/ type_label = gtk_label_new("Type:"); gtk_label_set_justify(GTK_LABEL(type_label), GTK_JUSTIFY_LEFT); gtk_table_attach(GTK_TABLE(table), type_label, 0, 1, 1, 2, 0, 0, 0, 0); gtk_widget_show(type_label); SFE_Globals.TypeCombo = gtk_combo_new(); gtk_table_attach(GTK_TABLE(table), SFE_Globals.TypeCombo, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0, 8); gtk_widget_show(SFE_Globals.TypeCombo); /** Annotation/description/comments section **/ annot_label = gtk_label_new("Desc:"); gtk_label_set_justify(GTK_LABEL(annot_label), GTK_JUSTIFY_LEFT); gtk_table_attach(GTK_TABLE(table), annot_label, 0, 1, 2, 3, 0, 0, 0, 0); gtk_widget_show(annot_label); annot_hbox = gtk_hbox_new(FALSE,1); gtk_table_attach(GTK_TABLE(table), annot_hbox, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0, 0); gtk_widget_show(annot_hbox); SFE_Globals.AnnotText = gtk_text_new(NULL,NULL); gtk_text_set_editable(GTK_TEXT(SFE_Globals.AnnotText), TRUE); gtk_widget_set_usize(SFE_Globals.AnnotText, 100, 48); gtk_container_add(GTK_CONTAINER(annot_hbox), SFE_Globals.AnnotText); gtk_widget_show(SFE_Globals.AnnotText); annot_vscroll = gtk_vscrollbar_new(GTK_TEXT(SFE_Globals.AnnotText)->vadj); gtk_box_pack_end(GTK_BOX(annot_hbox), annot_vscroll, FALSE, TRUE, 0); gtk_widget_show(annot_vscroll); sep1 = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(info_vbox), sep1, FALSE, TRUE, 8); gtk_widget_show(sep1); /** Add a columnar list box for the attributes **/ props_scrollwin = gtk_scrolled_window_new(NULL,NULL); gtk_container_add(GTK_CONTAINER(info_vbox), props_scrollwin); gtk_widget_show(props_scrollwin); SFE_Globals.AttrsCList = gtk_clist_new_with_titles(2, props_clist_titles); gtk_clist_set_selection_mode(GTK_CLIST(SFE_Globals.AttrsCList), GTK_SELECTION_SINGLE); gtk_container_add(GTK_CONTAINER(props_scrollwin), SFE_Globals.AttrsCList); gtk_widget_show(SFE_Globals.AttrsCList); gtk_signal_connect (GTK_OBJECT(SFE_Globals.AttrsCList), "select_row", GTK_SIGNAL_FUNC(sfe_ui_CListAttrSelected), SFE_Globals.AttrsCList); #if 0 /** Put some cruft in the treeview **/ for (i = 0; i < 5; i++) { GtkWidget *subtree, *item; gint j; /* Create a tree item */ item = gtk_tree_item_new_with_label (itemnames[i]); /* Add it to the parent tree */ gtk_tree_append (GTK_TREE(tree), item); gtk_widget_show (item); subtree = gtk_tree_new(); /* This is still necessary if you want these signals to be called * for the subtree's children. Note that selection_change will be * signalled for the root tree regardless. */ gtk_signal_connect (GTK_OBJECT(subtree), "select_child", GTK_SIGNAL_FUNC(cb_select_child), subtree); gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child", GTK_SIGNAL_FUNC(cb_unselect_child), subtree); /* Set this item's subtree - note that you cannot do this until * AFTER the item has been added to its parent tree! */ gtk_tree_item_set_subtree (GTK_TREE_ITEM(item), subtree); for (j = 0; j < 5; j++) { GtkWidget *subitem; /* Create a subtree item, in much the same way */ subitem = gtk_tree_item_new_with_label (itemnames[j]); gtk_tree_append (GTK_TREE(subtree), subitem); gtk_widget_show (subitem); } } #endif /** Open the main window **/ gtk_widget_show (SFE_Globals.Window); /** Load any file specified on the command line **/ if (SFE_Globals.ArgC == 2 && SFE_Globals.ArgV[1]) sfeLoadFile(SFE_Globals.ArgV[1]); else sfeRebuildUI(SFE_Globals.Data, GTK_TREE(tree)); /** Create the attribute editing window **/ SFE_Globals.AttrEditWindow = sfe_ui_CreateAttrDialog(); /** Enter the event loop for GTK **/ gtk_main(); thExit(); }
MimeView *mimeview_create(MainWindow *mainwin) { MimeView *mimeview; GtkWidget *paned; GtkWidget *scrolledwin; GtkWidget *ctree; GtkWidget *mime_notebook; GtkWidget *popupmenu; GtkWidget *ctree_mainbox; GtkWidget *vbox; GtkWidget *mime_toggle; GtkWidget *icon_mainbox; GtkWidget *icon_scroll; GtkWidget *icon_vbox; GtkWidget *arrow; GtkWidget *scrollbutton; GtkWidget *hbox; GtkTooltips *tooltips; GtkItemFactory *popupfactory; NoticeView *siginfoview; gchar *titles[N_MIMEVIEW_COLS]; gint n_entries; gint i; debug_print("Creating MIME view...\n"); mimeview = g_new0(MimeView, 1); titles[COL_MIMETYPE] = _("MIME Type"); titles[COL_SIZE] = _("Size"); titles[COL_NAME] = _("Name"); scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwin); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); ctree = gtk_sctree_new_with_titles(N_MIMEVIEW_COLS, 0, titles); gtk_widget_show(ctree); gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_BROWSE); gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_NONE); gtk_clist_set_column_justification(GTK_CLIST(ctree), COL_SIZE, GTK_JUSTIFY_RIGHT); gtk_clist_set_column_width(GTK_CLIST(ctree), COL_MIMETYPE, 240); gtk_clist_set_column_width(GTK_CLIST(ctree), COL_SIZE, 90); for (i = 0; i < N_MIMEVIEW_COLS; i++) GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(ctree)->column[i].button, GTK_CAN_FOCUS); gtk_container_add(GTK_CONTAINER(scrolledwin), ctree); gtk_signal_connect(GTK_OBJECT(ctree), "tree_select_row", GTK_SIGNAL_FUNC(mimeview_selected), mimeview); gtk_signal_connect(GTK_OBJECT(ctree), "button_release_event", GTK_SIGNAL_FUNC(mimeview_button_pressed), mimeview); gtk_signal_connect(GTK_OBJECT(ctree), "key_press_event", GTK_SIGNAL_FUNC(mimeview_key_pressed), mimeview); gtk_signal_connect(GTK_OBJECT (ctree),"start_drag", GTK_SIGNAL_FUNC (mimeview_start_drag), mimeview); gtk_signal_connect(GTK_OBJECT(ctree), "drag_data_get", GTK_SIGNAL_FUNC(mimeview_drag_data_get), mimeview); mime_notebook = gtk_notebook_new(); gtk_widget_show(mime_notebook); GTK_WIDGET_UNSET_FLAGS(mime_notebook, GTK_CAN_FOCUS); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(mime_notebook), FALSE); gtk_notebook_set_show_border(GTK_NOTEBOOK(mime_notebook), FALSE); icon_vbox = gtk_vbox_new(FALSE, 2); gtk_widget_show(icon_vbox); icon_scroll = gtk_layout_new(NULL, NULL); gtk_widget_show(icon_scroll); gtk_layout_put(GTK_LAYOUT(icon_scroll), icon_vbox, 0, 0); scrollbutton = gtk_vscrollbutton_new(gtk_layout_get_vadjustment(GTK_LAYOUT(icon_scroll))); gtk_widget_show(scrollbutton); mime_toggle = gtk_toggle_button_new(); gtk_widget_show(mime_toggle); arrow = gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_NONE); gtk_widget_show(arrow); gtk_container_add(GTK_CONTAINER(mime_toggle), arrow); gtk_signal_connect(GTK_OBJECT(mime_toggle), "toggled", GTK_SIGNAL_FUNC(mime_toggle_button_cb), mimeview); icon_mainbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(icon_mainbox); gtk_box_pack_start(GTK_BOX(icon_mainbox), mime_toggle, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(icon_mainbox), icon_scroll, TRUE, TRUE, 3); gtk_box_pack_end(GTK_BOX(icon_mainbox), scrollbutton, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(icon_mainbox), "size_allocate", GTK_SIGNAL_FUNC(icon_scroll_size_allocate_cb), mimeview); ctree_mainbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(ctree_mainbox), scrolledwin, TRUE, TRUE, 0); n_entries = sizeof(mimeview_popup_entries) / sizeof(mimeview_popup_entries[0]); popupmenu = menu_create_items(mimeview_popup_entries, n_entries, "<MimeView>", &popupfactory, mimeview); tooltips = gtk_tooltips_new(); gtk_tooltips_set_delay(tooltips, 0); vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox); siginfoview = noticeview_create(mainwin); noticeview_hide(siginfoview); gtk_box_pack_start(GTK_BOX(vbox), mime_notebook, TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(vbox), GTK_WIDGET_PTR(siginfoview), FALSE, FALSE, 0); paned = gtk_vpaned_new(); gtk_widget_show(paned); gtk_paned_set_gutter_size(GTK_PANED(paned), 0); gtk_paned_pack1(GTK_PANED(paned), ctree_mainbox, FALSE, TRUE); gtk_paned_pack2(GTK_PANED(paned), vbox, TRUE, TRUE); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), paned, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), icon_mainbox, FALSE, FALSE, 0); gtk_widget_show(hbox); gtk_widget_hide(ctree_mainbox); mimeview->hbox = hbox; mimeview->paned = paned; mimeview->scrolledwin = scrolledwin; mimeview->ctree = ctree; mimeview->mime_notebook = mime_notebook; mimeview->popupmenu = popupmenu; mimeview->popupfactory = popupfactory; mimeview->type = -1; mimeview->ctree_mainbox = ctree_mainbox; mimeview->icon_scroll = icon_scroll; mimeview->icon_vbox = icon_vbox; mimeview->icon_mainbox = icon_mainbox; mimeview->icon_count = 0; mimeview->mainwin = mainwin; mimeview->tooltips = tooltips; mimeview->oldsize = 60; mimeview->mime_toggle = mime_toggle; mimeview->siginfoview = siginfoview; mimeview->target_list = gtk_target_list_new(mimeview_mime_types, 1); mimeviews = g_slist_prepend(mimeviews, mimeview); return mimeview; }
static gboolean dialog_select_source(int chan_num) { scope_vert_t *vert; scope_chan_t *chan; dialog_generic_t dialog; gchar *title, msg[BUFLEN]; int next, n, initial_page, row, initial_row, max_row; gchar *tab_label_text[3], *name; GtkWidget *hbox, *label, *notebk, *button; GtkAdjustment *adj; hal_pin_t *pin; hal_sig_t *sig; hal_param_t *param; vert = &(ctrl_usr->vert); chan = &(ctrl_usr->chan[chan_num - 1]); title = _("Select Channel Source"); snprintf(msg, BUFLEN - 1, _("Select a pin, signal, or parameter\n" "as the source for channel %d."), chan_num); /* create dialog window, disable resizing */ dialog.retval = 0; dialog.window = gtk_dialog_new(); dialog.app_data = &chan_num; /* set initial height of window */ gtk_widget_set_usize(GTK_WIDGET(dialog.window), -2, 300); /* allow user to grow but not shrink the window */ gtk_window_set_policy(GTK_WINDOW(dialog.window), FALSE, TRUE, FALSE); /* window should appear in center of screen */ gtk_window_set_position(GTK_WINDOW(dialog.window), GTK_WIN_POS_CENTER); /* set title */ gtk_window_set_title(GTK_WINDOW(dialog.window), title); /* display message */ label = gtk_label_new(msg); gtk_misc_set_padding(GTK_MISC(label), 15, 5); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->vbox), label, FALSE, TRUE, 0); /* a separator */ gtk_hseparator_new_in_box(GTK_DIALOG(dialog.window)->vbox, 0); /* create a notebook to hold pin, signal, and parameter lists */ notebk = gtk_notebook_new(); /* add the notebook to the dialog */ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->vbox), notebk, TRUE, TRUE, 0); /* set overall notebook parameters */ gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(notebk), TRUE); gtk_signal_connect(GTK_OBJECT(notebk), "switch-page", GTK_SIGNAL_FUNC(change_page), &dialog); /* text for tab labels */ tab_label_text[0] = _("Pins"); tab_label_text[1] = _("Signals"); tab_label_text[2] = _("Parameters"); /* loop to create three identical tabs */ for (n = 0; n < 3; n++) { /* Create a scrolled window to display the list */ vert->windows[n] = gtk_scrolled_window_new(NULL, NULL); vert->adjs[n] = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(vert->windows[n])); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(vert->windows[n]), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_widget_show(vert->windows[n]); /* create a list to hold the data */ vert->lists[n] = gtk_clist_new(1); /* set up a callback for when the user selects a line */ gtk_signal_connect(GTK_OBJECT(vert->lists[n]), "select_row", GTK_SIGNAL_FUNC(selection_made), &dialog); gtk_signal_connect(GTK_OBJECT(vert->lists[n]), "key-press-event", GTK_SIGNAL_FUNC(search_for_entry), &dialog); /* It isn't necessary to shadow the border, but it looks nice :) */ gtk_clist_set_shadow_type(GTK_CLIST(vert->lists[n]), GTK_SHADOW_OUT); /* set list for single selection only */ gtk_clist_set_selection_mode(GTK_CLIST(vert->lists[n]), GTK_SELECTION_BROWSE); /* put the list into the scrolled window */ gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (vert->windows[n]), vert->lists[n]); /* another way to do it - not sure which is better gtk_container_add(GTK_CONTAINER(vert->windows[n]), vert->lists[n]); */ gtk_widget_show(vert->lists[n]); /* create a box for the tab label */ hbox = gtk_hbox_new(TRUE, 0); /* create a label for the page */ gtk_label_new_in_box(tab_label_text[n], hbox, TRUE, TRUE, 0); gtk_widget_show(hbox); /* add page to the notebook */ gtk_notebook_append_page(GTK_NOTEBOOK(notebk), vert->windows[n], hbox); /* set tab attributes */ gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebk), hbox, TRUE, TRUE, GTK_PACK_START); } /* determine initial page: pin, signal, or parameter */ if (( chan->data_source_type >= 0 ) && ( chan->data_source_type <= 2 )) { initial_page = chan->data_source_type; gtk_notebook_set_page(GTK_NOTEBOOK(notebk), initial_page); } else { initial_page = -1; gtk_notebook_set_page(GTK_NOTEBOOK(notebk), 0); } gtk_widget_show(notebk); /* populate the pin, signal, and parameter lists */ gtk_clist_clear(GTK_CLIST(vert->lists[0])); gtk_clist_clear(GTK_CLIST(vert->lists[1])); gtk_clist_clear(GTK_CLIST(vert->lists[2])); rtapi_mutex_get(&(hal_data->mutex)); next = hal_data->pin_list_ptr; initial_row = -1; max_row = -1; while (next != 0) { pin = SHMPTR(next); name = pin->name; row = gtk_clist_append(GTK_CLIST(vert->lists[0]), &name); if ( initial_page == 0 ) { if ( strcmp(name, chan->name) == 0 ) { initial_row = row; } max_row = row; } next = pin->next_ptr; } next = hal_data->sig_list_ptr; while (next != 0) { sig = SHMPTR(next); name = sig->name; row = gtk_clist_append(GTK_CLIST(vert->lists[1]), &name); if ( initial_page == 1 ) { if ( strcmp(name, chan->name) == 0 ) { initial_row = row; } max_row = row; } next = sig->next_ptr; } next = hal_data->param_list_ptr; while (next != 0) { param = SHMPTR(next); name = param->name; row = gtk_clist_append(GTK_CLIST(vert->lists[2]), &name); if ( initial_page == 2 ) { if ( strcmp(name, chan->name) == 0 ) { initial_row = row; } max_row = row; } next = param->next_ptr; } rtapi_mutex_give(&(hal_data->mutex)); if ( initial_row >= 0 ) { /* highlight the currently selected name */ gtk_clist_select_row(GTK_CLIST(vert->lists[initial_page]), initial_row, -1); /* set scrolling window to show the highlighted name */ /* FIXME - I can't seem to get this to work */ adj = vert->adjs[initial_page]; adj->value = adj->lower + (adj->upper - adj->lower)*((double)(initial_row)/(double)(max_row+1)); gtk_adjustment_value_changed(vert->adjs[initial_page]); } /* set up a callback function when the window is destroyed */ gtk_signal_connect(GTK_OBJECT(dialog.window), "destroy", GTK_SIGNAL_FUNC(dialog_generic_destroyed), &dialog); /* make Cancel button */ button = gtk_button_new_with_label(_("Cancel")); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->action_area), button, TRUE, TRUE, 4); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(dialog_generic_button2), &dialog); /* make window transient and modal */ gtk_window_set_transient_for(GTK_WINDOW(dialog.window), GTK_WINDOW(ctrl_usr->main_win)); gtk_window_set_modal(GTK_WINDOW(dialog.window), TRUE); gtk_widget_show_all(dialog.window); gtk_main(); /* we get here when the user makes a selection, hits Cancel, or closes the window */ vert->lists[0] = NULL; vert->lists[1] = NULL; vert->lists[2] = NULL; if ((dialog.retval == 0) || (dialog.retval == 2)) { /* user either closed dialog, or hit cancel */ return FALSE; } /* user made a selection */ channel_changed(); return TRUE; }
/* Create the fingerprint UI, and pack it into the vbox */ static void make_fingerprints_ui(GtkWidget *vbox) { GtkWidget *hbox; GtkWidget *table; GtkWidget *label; char *titles[5]; titles[0] = _("Screenname"); titles[1] = _("Status"); titles[2] = _("Verified"); titles[3] = _("Fingerprint"); titles[4] = _("Account"); ui_layout.scrollwin = gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ui_layout.scrollwin), GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS); ui_layout.keylist = gtk_clist_new_with_titles(5, titles); gtk_clist_set_column_width(GTK_CLIST(ui_layout.keylist), 0, 90); gtk_clist_set_column_width(GTK_CLIST(ui_layout.keylist), 1, 90); gtk_clist_set_column_width(GTK_CLIST(ui_layout.keylist), 2, 60); gtk_clist_set_column_width(GTK_CLIST(ui_layout.keylist), 3, 400); gtk_clist_set_column_width(GTK_CLIST(ui_layout.keylist), 4, 200); gtk_clist_set_selection_mode(GTK_CLIST(ui_layout.keylist), GTK_SELECTION_SINGLE); gtk_clist_column_titles_active(GTK_CLIST(ui_layout.keylist)); gtk_container_add(GTK_CONTAINER(ui_layout.scrollwin), ui_layout.keylist); gtk_box_pack_start(GTK_BOX(vbox), ui_layout.scrollwin, TRUE, TRUE, 0); otrg_gtk_ui_update_keylist(); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); table = gtk_table_new(2, 2, TRUE); gtk_table_set_row_spacings(GTK_TABLE(table), 5); gtk_table_set_col_spacings(GTK_TABLE(table), 20); gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(""), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(""), TRUE, TRUE, 0); ui_layout.connect_button = gtk_button_new(); gtk_signal_connect(GTK_OBJECT(ui_layout.connect_button), "clicked", GTK_SIGNAL_FUNC(connect_connection), NULL); label = gtk_label_new(_("Start private connection")); gtk_container_add(GTK_CONTAINER(ui_layout.connect_button), label); gtk_table_attach_defaults(GTK_TABLE(table), ui_layout.connect_button, 0, 1, 0, 1); ui_layout.disconnect_button = gtk_button_new(); gtk_signal_connect(GTK_OBJECT(ui_layout.disconnect_button), "clicked", GTK_SIGNAL_FUNC(disconnect_connection), NULL); label = gtk_label_new(_("End private connection")); gtk_container_add(GTK_CONTAINER(ui_layout.disconnect_button), label); gtk_table_attach_defaults(GTK_TABLE(table), ui_layout.disconnect_button, 0, 1, 1, 2); ui_layout.verify_button = gtk_button_new(); gtk_signal_connect(GTK_OBJECT(ui_layout.verify_button), "clicked", GTK_SIGNAL_FUNC(verify_fingerprint), NULL); label = gtk_label_new(_("Verify fingerprint")); gtk_container_add(GTK_CONTAINER(ui_layout.verify_button), label); gtk_table_attach_defaults(GTK_TABLE(table), ui_layout.verify_button, 1, 2, 0, 1); ui_layout.forget_button = gtk_button_new(); gtk_signal_connect(GTK_OBJECT(ui_layout.forget_button), "clicked", GTK_SIGNAL_FUNC(forget_fingerprint), NULL); label = gtk_label_new(_("Forget fingerprint")); gtk_container_add(GTK_CONTAINER(ui_layout.forget_button), label); gtk_table_attach_defaults(GTK_TABLE(table), ui_layout.forget_button, 1, 2, 1, 2); gtk_signal_connect(GTK_OBJECT(vbox), "destroy", GTK_SIGNAL_FUNC(ui_destroyed), NULL); /* Handle selections and deselections */ gtk_signal_connect(GTK_OBJECT(ui_layout.keylist), "select_row", GTK_SIGNAL_FUNC(clist_selected), NULL); gtk_signal_connect(GTK_OBJECT(ui_layout.keylist), "unselect_row", GTK_SIGNAL_FUNC(clist_unselected), NULL); /* Handle column sorting */ gtk_signal_connect(GTK_OBJECT(ui_layout.keylist), "click-column", GTK_SIGNAL_FUNC(clist_click_column), NULL); ui_layout.sortcol = 0; ui_layout.sortdir = 1; clist_all_unselected(); }
void init_gui_playlist(void) { GtkWidget *li; GtkWidget *scroller; GtkWidget *box; GtkWidget *table1; GtkWidget *reload_button; GtkWidget * enqueue_button; selected_row = -1; dir_browser = NULL; list_dialog = NULL; files = NULL; /* Create and setup main window */ library_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); //gtk_window_set_decorated(library_window, FALSE); // gtk_widget_set_app_paintable(library_window, TRUE); // gtk_window_set_policy( GTK_WINDOW(library_window), FALSE, FALSE, TRUE); /* Put the window into the xmms class, and hide it from the window list*/ gtk_window_set_wmclass( GTK_WINDOW(library_window), "XMMS_MediaLibrary", "xmms"); gtk_window_set_transient_for( GTK_WINDOW(library_window), GTK_WINDOW(mainwin) ); // hint_set_skip_winlist( library_window ); gtk_window_set_default_size(GTK_WINDOW(library_window), 350, 350); gtk_window_set_title(GTK_WINDOW(library_window), "Media Library"); /* gtk_widget_set_events( library_window, GDK_FOCUS_CHANGE_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK ); */ // gtk_widget_realize( library_window ); // gtk_widget_set_usize( library_window, 300, 200 ); /* background = gdk_pixmap_new( NULL, 300, 200, gdk_rgb_get_visual()->depth ); pl_gc = gdk_gc_new( library_window->window ); printf("init\n"); printf("%i\n", get_skin_color(SKIN_PLEDIT_NORMALBG)); gdk_gc_set_foreground(pl_gc, get_skin_color(SKIN_PLEDIT_NORMALBG) ); gdk_draw_rectangle( background, pl_gc, TRUE, 0, 0, 300, 200 ); gdk_window_set_back_pixmap( library_window->window, background, 0);*/ /* Remove the WMs decorations */ // gdk_window_set_decorations( library_window->window, 0); /* Setup list*/ file_list = gtk_clist_new(1); g_signal_connect(GTK_OBJECT(file_list), "select-row", GTK_SIGNAL_FUNC(file_list_select), NULL); g_signal_connect(GTK_OBJECT(file_list), "unselect-row", GTK_SIGNAL_FUNC(file_list_unselect), NULL); g_signal_connect(GTK_OBJECT(file_list), "button-press-event", G_CALLBACK(file_list_pressed), NULL); g_signal_connect(GTK_OBJECT(file_list), "key-press-event", GTK_SIGNAL_FUNC(file_list_key_press), NULL); gtk_clist_set_column_title(GTK_CLIST(file_list), 0, "Title"); gtk_clist_column_titles_passive(GTK_CLIST(file_list)); gtk_clist_column_titles_show(GTK_CLIST(file_list)); gtk_clist_set_selection_mode(GTK_CLIST(file_list), GTK_SELECTION_EXTENDED); gtk_widget_grab_default( GTK_OBJECT(file_list) ); /* Setup the search field */ search_field = gtk_entry_new(); g_signal_connect(GTK_OBJECT(search_field), "changed", GTK_SIGNAL_FUNC(search_modify), NULL); g_signal_connect(GTK_OBJECT(search_field), "key-press-event", G_CALLBACK(search_field_keypress), NULL); /* gtk_signal_connect(GTK_OBJECT(search_field), "focus-in-event", GTK_SIGNAL_FUNC(search_field_focus_in), NULL);*/ /* Setup the search button search_button = gtk_button_new_with_label("Search"); */ /* Setup the reload button*/ reload_button = gtk_button_new_with_label("Reload"); g_signal_connect( GTK_OBJECT(reload_button), "clicked", GTK_SIGNAL_FUNC(reload_button_clicked), NULL); /* Setup the play and enqueue-buttons */ play_button = gtk_button_new_with_label("Play"); play_button_handler_id = g_signal_connect(GTK_OBJECT(play_button), "clicked", GTK_SIGNAL_FUNC(play_button_clicked), NULL); enqueue_button = gtk_button_new_with_label("Add"); g_signal_connect(GTK_OBJECT(enqueue_button), "clicked", GTK_SIGNAL_FUNC(enqueue_button_clicked), NULL); /* Set the scroller up*/ scroller = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroller), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(scroller), file_list); /* Setup the labels label1 = gtk_label_new("Total songs:"); label2 = gtk_label_new("Songs showing:"); gtk_label_set_justify(GTK_LABEL(label1), GTK_JUSTIFY_RIGHT); gtk_label_set_justify(GTK_LABEL(label2), GTK_JUSTIFY_RIGHT); total_count_label = gtk_label_new("-"); showing_count_label = gtk_label_new("-"); gtk_label_set_justify(GTK_LABEL(total_count_label), GTK_JUSTIFY_LEFT); gtk_label_set_justify(GTK_LABEL(showing_count_label), GTK_JUSTIFY_LEFT);*/ /* Setup layout widgets*/ layout_box = gtk_vbox_new(FALSE, 1); gtk_container_add(GTK_CONTAINER(library_window), layout_box); gtk_widget_show(layout_box); table = gtk_table_new(3,2, TRUE); gtk_box_pack_start(GTK_BOX(layout_box), table, FALSE, FALSE, 0); gtk_box_pack_start_defaults(GTK_BOX(layout_box), scroller); box = gtk_hbox_new(FALSE, 1); //gtk_box_pack_start(GTK_BOX(box), search_field, TRUE, TRUE, 0); /* The top 'bar'*/ table1 = gtk_table_new(1, 4, FALSE); gtk_table_attach_defaults(GTK_TABLE(table1), search_field, 0,1,0,1); gtk_table_attach_defaults(GTK_TABLE(table1), play_button, 1,2,0,1); gtk_table_attach_defaults(GTK_TABLE(table1), enqueue_button, 2,3,0,1); gtk_table_attach_defaults(GTK_TABLE(table1), reload_button, 3,4,0,1); /* gtk_table_attach_defaults(GTK_TABLE(table1), reload_button, 2, 3, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table1), add_random_button, 2, 3, 1, 2); gtk_table_attach_defaults(GTK_TABLE(table1), label1, 0,1, 0,1); gtk_table_attach_defaults(GTK_TABLE(table1), label2, 0,1, 1,2); gtk_table_attach_defaults(GTK_TABLE(table1), total_count_label, 1,2, 0,1); gtk_table_attach_defaults(GTK_TABLE(table1), showing_count_label, 1,2, 1,2);*/ /* Add widgets to the table */ gtk_table_attach_defaults(GTK_TABLE(table), table1, 0, 2, 0, 2); //gtk_table_attach_defaults(GTK_TABLE(table), box, 0, 2, 1, 3); /* Show all the widgets*/ gtk_widget_show(reload_button); gtk_widget_show(play_button); gtk_widget_show(enqueue_button); //gtk_widget_show(box); gtk_widget_show(search_field); gtk_widget_show(scroller); gtk_widget_show(table1); gtk_widget_show(table); gtk_widget_show(file_list); /* And finally, show the window itself*/ gtk_widget_show(library_window); // dock_add_window(dock_window_list, library_window); }
GtkWidget *create_dir_browser(gchar * title, gchar * current_path, GtkSelectionMode mode, void (*handler) (gchar *)) { GtkWidget *window, *scroll_win, *tree, *vbox, *bbox, *ok, *cancel, *sep; gchar *root_text = "/", *node_text = "dummy"; gchar *currentdir, *pos, *tpath, *tpathnew; GtkCTreeNode *root_node, *node, *nextnode; DirNode *dirnode; gboolean leaf; #ifdef _GTK2 window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_modal(GTK_WINDOW(window), TRUE); // gtk_window_set_decorated(GTK_WINDOW(window), TRUE); #else window = gtk_window_new(GTK_WINDOW_DIALOG); #endif gtk_window_set_title(GTK_WINDOW(window), title); gtk_container_border_width(GTK_CONTAINER(window), 10); vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(window), vbox); scroll_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize(scroll_win, 250, 200); gtk_box_pack_start(GTK_BOX(vbox), scroll_win, TRUE, TRUE, 0); gtk_widget_show(scroll_win); gtk_widget_realize(window); if (!folder_pixmap) { folder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &folder_mask, NULL, folder); ofolder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &ofolder_mask, NULL, ofolder); } tree = gtk_ctree_new(1, 0); gtk_clist_set_column_auto_resize(GTK_CLIST(tree), 0, TRUE); gtk_clist_set_selection_mode(GTK_CLIST(tree), mode); gtk_ctree_set_line_style(GTK_CTREE(tree), GTK_CTREE_LINES_DOTTED); gtk_signal_connect(GTK_OBJECT(tree), "tree_expand", GTK_SIGNAL_FUNC(expand_cb), NULL); gtk_signal_connect(GTK_OBJECT(tree), "select_row", GTK_SIGNAL_FUNC(select_row_cb), NULL); gtk_container_add(GTK_CONTAINER(scroll_win), tree); gtk_object_set_user_data(GTK_OBJECT(tree), (gpointer) handler); root_node = gtk_ctree_insert_node(GTK_CTREE(tree), NULL, NULL, &root_text, 4, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, FALSE, FALSE); dirnode = g_malloc0(sizeof (DirNode)); dirnode->path = g_strdup("/"); gtk_ctree_node_set_row_data_full(GTK_CTREE(tree), root_node, dirnode, destroy_cb); node = gtk_ctree_insert_node(GTK_CTREE(tree), root_node, NULL, &node_text, 4, NULL, NULL, NULL, NULL, TRUE, TRUE); gtk_ctree_expand(GTK_CTREE(tree), root_node); gtk_widget_show(tree); sep = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0); gtk_widget_show(sep); bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); ok = gtk_button_new_with_label(tr("Ok")); gtk_object_set_user_data(GTK_OBJECT(ok), window); GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT); gtk_window_set_default(GTK_WINDOW(window), ok); gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(ok_clicked), tree); gtk_widget_show(ok); cancel = gtk_button_new_with_label(tr("Cancel")); GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0); gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window)); gtk_widget_show(cancel); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); gtk_widget_show(bbox); gtk_widget_show(vbox); if (current_path && *current_path) { currentdir = g_strdup(current_path); tpath = g_strdup("/"); pos = strtok(currentdir, "/"); node = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), NULL, "/", filetreeent_compare_func); do { tpathnew = g_strconcat(tpath, pos, "/", NULL); g_free(tpath); tpath = tpathnew; nextnode = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), node, tpath, filetreeent_compare_func); if (!nextnode) break; node = nextnode; pos = strtok(NULL, "/"); gtk_ctree_get_node_info(GTK_CTREE(tree), node, NULL, NULL, NULL, NULL, NULL, NULL, &leaf, NULL); if (!leaf && pos) gtk_ctree_expand(GTK_CTREE(tree), node); else { gtk_ctree_select(GTK_CTREE(tree), node); break; } } while (pos); g_free(tpath); g_free(currentdir); } else gtk_ctree_select(GTK_CTREE(tree), root_node); return window; }
int nsComponentsDlg::Show(int aDirection) { int err = OK; int customSTIndex = 0, i; int numRows = 0; int currRow = 0; GtkWidget *hbox = NULL; XI_VERIFY(gCtx); XI_VERIFY(gCtx->notebook); if (mWidgetsInit == FALSE) { customSTIndex = gCtx->sdlg->GetNumSetupTypes(); sCustomST = gCtx->sdlg->GetSetupTypeList(); for (i=1; i<customSTIndex; i++) sCustomST = sCustomST->GetNext(); DUMP(sCustomST->GetDescShort()); // create a new table and add it as a page of the notebook mTable = gtk_table_new(5, 1, FALSE); gtk_notebook_append_page(GTK_NOTEBOOK(gCtx->notebook), mTable, NULL); mPageNum = gtk_notebook_get_current_page(GTK_NOTEBOOK(gCtx->notebook)); gtk_widget_show(mTable); // 1st row: a label (msg0) // insert a static text widget in the first row GtkWidget *msg0 = gtk_label_new(mMsg0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), msg0, FALSE, FALSE, 0); gtk_widget_show(hbox); gtk_table_attach(GTK_TABLE(mTable), hbox, 0, 1, 1, 2, static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), GTK_FILL, 20, 20); gtk_widget_show(msg0); // 2nd row: a CList with a check box for each row (short desc) GtkWidget *list = NULL; GtkWidget *scrollwin = NULL; GtkStyle *style = NULL; GdkBitmap *ch_mask = NULL; GdkPixmap *checked = NULL; GdkBitmap *un_mask = NULL; GdkPixmap *unchecked = NULL; gchar *dummy[2] = { " ", " " }; nsComponent *currComp = sCustomST->GetComponents()->GetHead(); GtkWidget *descLongTable = NULL; GtkWidget *frame = NULL; scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); list = gtk_clist_new(2); gtk_clist_set_selection_mode(GTK_CLIST(list), GTK_SELECTION_BROWSE); gtk_clist_column_titles_hide(GTK_CLIST(list)); gtk_clist_set_column_auto_resize(GTK_CLIST(list), 0, TRUE); gtk_clist_set_column_auto_resize(GTK_CLIST(list), 1, TRUE); // determine number of rows we'll need numRows = sCustomST->GetComponents()->GetLengthVisible(); for (i = 0; i < numRows; i++) gtk_clist_append(GTK_CLIST(list), dummy); style = gtk_widget_get_style(gCtx->window); checked = gdk_pixmap_create_from_xpm_d(gCtx->window->window, &ch_mask, &style->bg[GTK_STATE_NORMAL], (gchar **)check_on_xpm); unchecked = gdk_pixmap_create_from_xpm_d(gCtx->window->window, &un_mask, &style->bg[GTK_STATE_NORMAL], (gchar **)check_off_xpm); while ((currRow < numRows) && currComp) // paranoia! { if (!currComp->IsInvisible()) { if (currComp->IsSelected()) gtk_clist_set_pixmap(GTK_CLIST(list), currRow, 0, checked, ch_mask); else gtk_clist_set_pixmap(GTK_CLIST(list), currRow, 0, unchecked, un_mask); gtk_clist_set_text(GTK_CLIST(list), currRow, 1, currComp->GetDescShort()); currRow++; } currComp = currComp->GetNext(); } // by default, first row selected upon Show() sCurrRowSelected = 0; gtk_signal_connect(GTK_OBJECT(list), "select_row", GTK_SIGNAL_FUNC(RowSelected), NULL); gtk_signal_connect(GTK_OBJECT(list), "key_press_event", GTK_SIGNAL_FUNC(KeyPressed), NULL); gtk_container_add(GTK_CONTAINER(scrollwin), list); gtk_widget_show(list); gtk_widget_show(scrollwin); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), scrollwin, TRUE, TRUE, 0); gtk_widget_show(hbox); gtk_table_attach(GTK_TABLE(mTable), hbox, 0, 1, 2, 3, static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), 20, 0); // XXX 3rd row: labels for ds avail and ds reqd // 4th row: a frame with a label (long desc) descLongTable = gtk_table_new(1, 1, FALSE); gtk_widget_show(descLongTable); gtk_table_attach(GTK_TABLE(mTable), descLongTable, 0, 1, 4, 5, static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), 20, 20); frame = gtk_frame_new(gCtx->Res("DESCRIPTION")); gtk_table_attach_defaults(GTK_TABLE(descLongTable), frame, 0, 1, 0, 1); gtk_widget_show(frame); sDescLong = gtk_label_new( sCustomST->GetComponents()->GetFirstVisible()->GetDescLong()); gtk_label_set_line_wrap(GTK_LABEL(sDescLong), TRUE); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), sDescLong, FALSE, FALSE, 20); gtk_widget_show(hbox); gtk_table_attach_defaults(GTK_TABLE(descLongTable), hbox, 0, 1, 0, 1); gtk_widget_show(sDescLong); mWidgetsInit = TRUE; } else { gtk_notebook_set_page(GTK_NOTEBOOK(gCtx->notebook), mPageNum); gtk_widget_show(mTable); } // signal connect the buttons gCtx->backID = gtk_signal_connect(GTK_OBJECT(gCtx->back), "clicked", GTK_SIGNAL_FUNC(nsComponentsDlg::Back), gCtx->cdlg); gCtx->nextID = gtk_signal_connect(GTK_OBJECT(gCtx->next), "clicked", GTK_SIGNAL_FUNC(nsComponentsDlg::Next), gCtx->cdlg); // show back btn again after setup type dlg where we couldn't go back gtk_widget_set_sensitive(gCtx->back, TRUE); if (aDirection == nsXInstallerDlg::BACKWARD_MOVE) // from install dlg gtk_button_set_label(GTK_BUTTON(gCtx->next), GTK_STOCK_GO_FORWARD); return err; }
GtkWidget * create_SkinBrowser( void ) { GtkWidget * vbox5; GtkWidget * scrolledwindow1; GtkWidget * hbuttonbox4; GtkWidget * Cancel; GtkWidget * Ok; GtkAccelGroup * accel_group; accel_group = gtk_accel_group_new (); SkinBrowser=gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_widget_set_name( SkinBrowser,MSGTR_SkinBrowser ); gtk_object_set_data( GTK_OBJECT( SkinBrowser ),MSGTR_SkinBrowser,SkinBrowser ); gtk_widget_set_usize( SkinBrowser,256,320 ); gtk_container_set_border_width( GTK_CONTAINER( SkinBrowser ),1 ); GTK_WIDGET_SET_FLAGS( SkinBrowser,GTK_CAN_DEFAULT ); gtk_widget_set_events( SkinBrowser,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_FOCUS_CHANGE_MASK | GDK_STRUCTURE_MASK | GDK_PROPERTY_CHANGE_MASK | GDK_VISIBILITY_NOTIFY_MASK ); gtk_window_set_title( GTK_WINDOW( SkinBrowser ),MSGTR_SkinBrowser ); gtk_window_set_position( GTK_WINDOW( SkinBrowser ),GTK_WIN_POS_CENTER ); gtk_window_set_policy( GTK_WINDOW( SkinBrowser ),FALSE,FALSE,TRUE ); gtk_window_set_wmclass( GTK_WINDOW( SkinBrowser ),"SkinBrowser","MPlayer" ); gtk_widget_realize( SkinBrowser ); gtkAddIcon( SkinBrowser ); vbox5=AddVBox( AddDialogFrame( SkinBrowser ),0 ); AddLabel( MSGTR_SKIN_LABEL,vbox5 ); AddHSeparator( vbox5 ); scrolledwindow1=gtk_scrolled_window_new( NULL,NULL ); gtk_widget_set_name( scrolledwindow1,"scrolledwindow1" ); gtk_widget_ref( scrolledwindow1 ); gtk_object_set_data_full( GTK_OBJECT( SkinBrowser ),"scrolledwindow1",scrolledwindow1,(GtkDestroyNotify)gtk_widget_unref ); gtk_widget_show( scrolledwindow1 ); gtk_box_pack_start( GTK_BOX( vbox5 ),scrolledwindow1,TRUE,TRUE,0 ); gtk_container_set_border_width( GTK_CONTAINER( scrolledwindow1 ),2 ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC ); SkinList=gtk_clist_new( 1 ); gtk_widget_set_name( SkinList,"SkinList" ); gtk_widget_ref( SkinList ); gtk_object_set_data_full( GTK_OBJECT( SkinBrowser ),"SkinList",SkinList,(GtkDestroyNotify)gtk_widget_unref ); gtk_widget_show( SkinList ); gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),SkinList ); gtk_clist_set_column_width( GTK_CLIST( SkinList ),0,80 ); gtk_clist_set_selection_mode( GTK_CLIST( SkinList ),GTK_SELECTION_SINGLE ); gtk_clist_column_titles_hide( GTK_CLIST( SkinList ) ); gtk_clist_set_shadow_type( GTK_CLIST( SkinList ),GTK_SHADOW_ETCHED_OUT ); AddHSeparator( vbox5 ); hbuttonbox4=AddHButtonBox( vbox5 ); gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox4 ),GTK_BUTTONBOX_SPREAD ); gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox4 ),10 ); Ok=AddButton( MSGTR_Ok,hbuttonbox4 ); Cancel=AddButton( MSGTR_Cancel,hbuttonbox4 ); gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE ); gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE ); gtk_signal_connect( GTK_OBJECT( SkinBrowser ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&SkinBrowser ); gtk_signal_connect( GTK_OBJECT( SkinList ),"select_row",GTK_SIGNAL_FUNC( on_SkinList_select_row ),NULL ); gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( prButton ),(void *)1 ); gtk_signal_connect( GTK_OBJECT( Cancel ),"clicked",GTK_SIGNAL_FUNC( prButton ),(void *)0 ); if ( ( sbMPlayerDirInHome=calloc( 1,strlen( skinDirInHome ) + 4 ) ) != NULL ) { strcpy( sbMPlayerDirInHome,skinDirInHome ); strcat( sbMPlayerDirInHome,"/*" ); } if ( ( sbMPlayerPrefixDir=calloc( 1,strlen( skinMPlayerDir ) + 4 ) ) != NULL ) { strcpy( sbMPlayerPrefixDir,skinMPlayerDir ); strcat( sbMPlayerPrefixDir,"/*" ); } gtk_window_add_accel_group( GTK_WINDOW( SkinBrowser ),accel_group ); gtk_widget_grab_focus( SkinList ); return SkinBrowser; }
void ssl_manager_create(void) { GtkWidget *window; GtkWidget *hbox1; GtkWidget *vbox1; GtkWidget *certlist; GtkWidget *view_btn; GtkWidget *delete_btn; GtkWidget *ok_btn; gchar *titles[2]; window = gtk_window_new (GTK_WINDOW_DIALOG); gtk_window_set_title (GTK_WINDOW(window), _("Saved SSL Certificates")); gtk_container_set_border_width (GTK_CONTAINER (window), 8); gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE); gtk_signal_connect (GTK_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC(ssl_manager_ok_cb), NULL); MANAGE_WINDOW_SIGNALS_CONNECT (window); hbox1 = gtk_hbox_new(FALSE,2); vbox1 = gtk_vbox_new(FALSE,0); delete_btn = gtk_button_new_with_label(_("Delete")); gtk_signal_connect (GTK_OBJECT(delete_btn), "clicked", GTK_SIGNAL_FUNC(ssl_manager_delete_cb), NULL); view_btn = gtk_button_new_with_label(_("View")); gtk_signal_connect (GTK_OBJECT(view_btn), "clicked", GTK_SIGNAL_FUNC(ssl_manager_view_cb), NULL); ok_btn = gtk_button_new_with_label(_("OK")); gtk_signal_connect (GTK_OBJECT(ok_btn), "clicked", GTK_SIGNAL_FUNC(ssl_manager_ok_cb), NULL); gtk_widget_set_usize(ok_btn, 80, -1); gtk_widget_set_usize(delete_btn, 80, -1); gtk_widget_set_usize(view_btn, 80, -1); titles[0] = _("Server"); titles[1] = _("Port"); certlist = gtk_sctree_new_with_titles(2, 3, titles); gtk_clist_column_titles_show(GTK_CLIST(certlist)); gtk_clist_set_column_width(GTK_CLIST(certlist), 0, 220); gtk_clist_set_selection_mode(GTK_CLIST(certlist), GTK_SELECTION_SINGLE); gtk_widget_set_usize(certlist, 300, 200); gtk_signal_connect (GTK_OBJECT(certlist), "open_row", GTK_SIGNAL_FUNC(ssl_manager_view_cb), NULL); gtk_box_pack_start(GTK_BOX(hbox1), certlist, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox1), vbox1, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox1), view_btn, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox1), delete_btn, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(vbox1), ok_btn, FALSE, FALSE, 0); gtk_widget_show(certlist); gtk_widget_show(hbox1); gtk_widget_show(vbox1); gtk_widget_show(ok_btn); gtk_widget_show(delete_btn); gtk_widget_show(view_btn); gtk_container_add(GTK_CONTAINER (window), hbox1); manager.window = window; manager.hbox1 = hbox1; manager.vbox1 = vbox1; manager.certlist = certlist; manager.view_btn = view_btn; manager.delete_btn = delete_btn; manager.ok_btn = ok_btn; gtk_widget_show(window); }