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; }
/* 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; }
static void glade_keys_dialog_init (GladeKeysDialog *dialog) { GtkWidget *scrolled_win; int i, row; gchar *titles[1]; gtk_window_set_title (GTK_WINDOW (dialog), _("Select Accelerator Key")); gtk_window_set_wmclass (GTK_WINDOW (dialog), "accelerator_key", "Glade"); titles[0] = _("Keys"); dialog->clist = gtk_clist_new_with_titles (1, titles); gtk_clist_column_titles_passive (GTK_CLIST (dialog->clist)); gtk_widget_set_usize (dialog->clist, 200, 300); gtk_widget_show (dialog->clist); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_win), dialog->clist); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scrolled_win, TRUE, TRUE, 0); gtk_widget_show (scrolled_win); /* Insert events & descriptions */ gtk_clist_freeze (GTK_CLIST (dialog->clist)); i = 0; while (GbKeys[i].name) { row = gtk_clist_append (GTK_CLIST (dialog->clist), (gchar**) (&GbKeys[i].name)); gtk_clist_set_row_data (GTK_CLIST (dialog->clist), row, GINT_TO_POINTER (i)); i++; } gtk_clist_thaw (GTK_CLIST (dialog->clist)); #ifdef USE_GNOME dialog->ok_button = gnome_stock_button (GNOME_STOCK_BUTTON_OK); #else dialog->ok_button = gtk_button_new_with_label (_ ("OK")); #endif gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), dialog->ok_button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (dialog->ok_button, GTK_CAN_DEFAULT); gtk_widget_grab_default (dialog->ok_button); gtk_widget_show (dialog->ok_button); #ifdef USE_GNOME dialog->cancel_button = gnome_stock_button (GNOME_STOCK_BUTTON_CANCEL); #else dialog->cancel_button = gtk_button_new_with_label (_("Cancel")); #endif gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), dialog->cancel_button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (dialog->cancel_button, GTK_CAN_DEFAULT); gtk_widget_show (dialog->cancel_button); }
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; }
static int create_disassembly( GtkBox *parent, gtkui_font font ) { size_t i; GtkWidget *scrollbar; gchar *disassembly_titles[] = { "Address", "Instruction" }; /* A box to hold the disassembly listing and the scrollbar */ disassembly_box = gtk_hbox_new( FALSE, 0 ); gtk_box_pack_start_defaults( parent, disassembly_box ); /* The disassembly CList itself */ disassembly = gtk_clist_new_with_titles( 2, disassembly_titles ); gtkui_set_font( disassembly, font ); gtk_clist_column_titles_passive( GTK_CLIST( disassembly ) ); for( i = 0; i < 2; i++ ) gtk_clist_set_column_auto_resize( GTK_CLIST( disassembly ), i, TRUE ); gtk_box_pack_start_defaults( GTK_BOX( disassembly_box ), disassembly ); /* The disassembly scrollbar */ disassembly_scrollbar_adjustment = gtk_adjustment_new( 0, 0x0000, 0xffff, 0.5, 20, 20 ); gtk_signal_connect( GTK_OBJECT( disassembly_scrollbar_adjustment ), "value-changed", GTK_SIGNAL_FUNC( move_disassembly ), NULL ); scrollbar = gtk_vscrollbar_new( GTK_ADJUSTMENT( disassembly_scrollbar_adjustment ) ); gtk_box_pack_start( GTK_BOX( disassembly_box ), scrollbar, FALSE, FALSE, 0 ); gtkui_scroll_connect( GTK_CLIST( disassembly ), GTK_ADJUSTMENT( disassembly_scrollbar_adjustment ) ); return 0; }
void SONGDBUI_Redraw(void *w) { SongdbWidgets *widgets=(SongdbWidgets*)w; SongDBSubgroup *sg; GtkWidget *table; GtkWidget *label; gchar *titles[3] = { "ID","Song","Time" }; // if(SONGDB_GroupChanged()) { // sg=SONGDB_GetSubgroupList(); /* Remove all tabs */ //SDL_NotebookClear(widgets->Tabs); // while(sg) // { table = gtk_clist_new_with_titles( 3, titles); gtk_clist_set_column_width (GTK_CLIST(table), 0, 30); gtk_clist_set_column_width (GTK_CLIST(table), 1, 290); gtk_clist_set_column_width (GTK_CLIST(table), 0, 200); /* When a selection is made, we want to know about it. The callback * used is selection_made, and its code can be found further down */ gtk_signal_connect(GTK_OBJECT(table), "select_row", GTK_SIGNAL_FUNC(selection_made), NULL); // SDL_SignalConnect(table,"activate",testplay,table); { gchar *songinfo[3]; int r=0,c=0; for(c=0;c<3;c++) songinfo[c]=malloc(255); // SONGDB_SetActiveSubgroup(sg); for(r=0;r< 3;r++) { for(c=0;c<3;c++) { sprintf(songinfo[c],"Hello%d",c); } gtk_clist_append( (GtkCList *)table, songinfo); } for(c=0;c<3;c++) free(songinfo[c]); } gtk_widget_show(table); label = gtk_label_new ("AAA"); gtk_notebook_append_page (GTK_NOTEBOOK (widgets->Tabs), table, label); // sg=sg->next; // } // sg=SONGDB_GetSubgroupList(); // SONGDB_SetActiveSubgroup(sg); // SDL_WidgetSetFocus(SDL_NotebookGetChildWidget(Widgets->Tabs)); // SDL_WidgetRedrawEvent(widgets->Tabs); } }
GtkWidget *gtk_scrolled_clist_new_with_titles(gint columns, gchar *titles[], GtkWidget **pack_widg) { GtkWidget *widget; widget = gtk_clist_new_with_titles(columns, titles); *pack_widg = widget; return widget; }
void ManagerInitGtk() { GtkWidget *ManagerWindow; GtkWidget *vbox; GtkWidget *hbox; char * List[ ] = {"Section Name ", "Language ", "Type ", "debug" }; pNameSectionSelected = NULL; ManagerWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title ((GtkWindow *)ManagerWindow, "Sections Manager"); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (ManagerWindow), vbox); gtk_widget_show (vbox); SectionsList = gtk_clist_new_with_titles( /*3*/ 4, List ); gtk_box_pack_start (GTK_BOX(vbox), SectionsList, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (SectionsList), "select-row", (GtkSignalFunc) SelectRowSignal, 0); gtk_widget_show( SectionsList ); hbox = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (vbox), hbox); gtk_widget_show (hbox); ButtonAddSection = gtk_button_new_with_label("Add section"); gtk_box_pack_start (GTK_BOX (hbox), ButtonAddSection, TRUE, FALSE, 0); gtk_signal_connect(GTK_OBJECT (ButtonAddSection), "clicked", (GtkSignalFunc) ButtonAddClickSignal, 0); gtk_widget_show (ButtonAddSection); ButtonDelSection = gtk_button_new_with_label("Delete section"); gtk_box_pack_start (GTK_BOX (hbox), ButtonDelSection, TRUE, FALSE, 0); gtk_signal_connect(GTK_OBJECT (ButtonDelSection), "clicked", (GtkSignalFunc) ButtonDelClickSignal, 0); gtk_widget_show (ButtonDelSection); ButtonMoveUpSection = gtk_button_new_with_label("Move Up"); gtk_box_pack_start (GTK_BOX (hbox), ButtonMoveUpSection, TRUE, FALSE, 0); gtk_signal_connect(GTK_OBJECT (ButtonMoveUpSection), "clicked", (GtkSignalFunc) ButtonMoveUpClickSignal, 0); gtk_widget_show (ButtonMoveUpSection); ButtonMoveDownSection = gtk_button_new_with_label("Move Down"); gtk_box_pack_start (GTK_BOX (hbox), ButtonMoveDownSection, TRUE, FALSE, 0); gtk_signal_connect(GTK_OBJECT (ButtonMoveDownSection), "clicked", (GtkSignalFunc) ButtonMoveDownClickSignal, 0); gtk_widget_show (ButtonMoveDownSection); ManagerDisplaySections( ); gtk_signal_connect( GTK_OBJECT(ManagerWindow), "delete_event", (GtkSignalFunc)ManagerWindowDeleteEvent, 0 ); gtk_widget_show (ManagerWindow); AddSectionWindowInit( ); }
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); }
GtkWidget *gtk_scrolled_clist_new_with_titles(gint columns, gchar *titles[], GtkWidget **pack_widg) { GtkWidget *scrollwin, *clist; clist = gtk_clist_new_with_titles(columns, titles); scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrollwin), clist); *pack_widg = scrollwin; return clist; }
void DownloadUI::CreateDownloadList(GtkWidget *box) { static const char *titles[] = { "Song Title", "Status" }; m_List = gtk_clist_new_with_titles(2, (gchar **)titles); gtk_container_add(GTK_CONTAINER(box), m_List); gtk_clist_set_column_width(GTK_CLIST(m_List), 0, 200); gtk_signal_connect(GTK_OBJECT(m_List), "select_row", GTK_SIGNAL_FUNC(set_current_sel_internal), this); gtk_widget_show(m_List); gtk_clist_column_titles_passive(GTK_CLIST(m_List)); }
void trigger_dialog_init () { GtkWidget *hbox, *vbox, *hbox1; GtkWidget *trig_scroller; trig_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(trig_window), "Triggers"); trig_list = gtk_clist_new_with_titles(2, titles); trig_scroller = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(trig_scroller), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); trigger_dialog_reload_list(); trig_match_entry = gtk_entry_new(); trig_command_entry = gtk_entry_new(); trig_add = gtk_button_new_with_label("Add"); trig_close = gtk_button_new_with_label("Close"); trig_delete = gtk_button_new_with_label("Delete"); trig_save = gtk_button_new_with_label("Save"); gtk_signal_connect(GTK_OBJECT(trig_list), "select-row", GTK_SIGNAL_FUNC(trig_list_select_row), NULL); gtk_signal_connect(GTK_OBJECT(trig_add), "clicked", GTK_SIGNAL_FUNC(trig_add_clicked), NULL); gtk_signal_connect(GTK_OBJECT(trig_close), "clicked", GTK_SIGNAL_FUNC(trig_close_clicked), NULL); gtk_signal_connect(GTK_OBJECT(trig_delete), "clicked", GTK_SIGNAL_FUNC(trig_delete_clicked), NULL); gtk_signal_connect(GTK_OBJECT(trig_save), "clicked", GTK_SIGNAL_FUNC(trig_save_clicked), NULL); hbox = gtk_hbox_new(FALSE, 0); hbox1 = gtk_hbox_new(FALSE, 0); vbox = gtk_vbox_new(FALSE, 0); pack(hbox1, trig_delete, FALSE, FALSE, 0); pack(hbox, trig_match_entry, TRUE, TRUE, 0); pack(hbox, trig_command_entry, TRUE, TRUE, 0); pack(hbox, trig_save, FALSE, FALSE, 0); pack(hbox, trig_add, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(trig_scroller), trig_list); pack(vbox, trig_scroller, TRUE, TRUE, 0); pack(vbox, hbox1, FALSE, FALSE, 0); pack(vbox, hbox, FALSE, FALSE, 0); pack(vbox, trig_close, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(trig_window), vbox); }
static int create_breakpoints( GtkBox *parent ) { size_t i; gchar *breakpoint_titles[] = { "ID", "Type", "Value", "Ignore", "Life", "Condition" }; breakpoints = gtk_clist_new_with_titles( 6, breakpoint_titles ); gtk_clist_column_titles_passive( GTK_CLIST( breakpoints ) ); for( i = 0; i < 6; i++ ) gtk_clist_set_column_auto_resize( GTK_CLIST( breakpoints ), i, TRUE ); gtk_box_pack_start_defaults( parent, breakpoints ); return 0; }
static void glade_keys_dialog_init (GladeKeysDialog *dialog) { GtkWidget *scrolled_win; int i, row; gchar *titles[1]; gtk_window_set_title (GTK_WINDOW (dialog), _("Select Accelerator Key")); gtk_window_set_wmclass (GTK_WINDOW (dialog), "accelerator_key", "Glade"); titles[0] = _("Keys"); dialog->clist = gtk_clist_new_with_titles (1, titles); gtk_clist_column_titles_passive (GTK_CLIST (dialog->clist)); gtk_widget_set_usize (dialog->clist, 200, 300); gtk_widget_show (dialog->clist); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_win), dialog->clist); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scrolled_win, TRUE, TRUE, 0); gtk_widget_show (scrolled_win); /* Insert events & descriptions */ gtk_clist_freeze (GTK_CLIST (dialog->clist)); i = 0; while (GbKeys[i].name) { row = gtk_clist_append (GTK_CLIST (dialog->clist), (gchar**) (&GbKeys[i].name)); gtk_clist_set_row_data (GTK_CLIST (dialog->clist), row, GINT_TO_POINTER (i)); i++; } gtk_clist_thaw (GTK_CLIST (dialog->clist)); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); }
static int create_stack_display( GtkBox *parent, gtkui_font font ) { size_t i; gchar *stack_titles[] = { "Address", "Value" }; stack = gtk_clist_new_with_titles( 2, stack_titles ); gtkui_set_font( stack, font ); gtk_clist_column_titles_passive( GTK_CLIST( stack ) ); for( i = 0; i < 2; i++ ) gtk_clist_set_column_auto_resize( GTK_CLIST( stack ), i, TRUE ); gtk_box_pack_start( parent, stack, TRUE, TRUE, 5 ); gtk_signal_connect( GTK_OBJECT( stack ), "select-row", GTK_SIGNAL_FUNC( stack_click ), NULL ); return 0; }
/* * 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); }
/* * Función notasWidget() */ GtkWidget *notasWidget(void) { GtkWidget *scroll; GtkWidget *notas; gchar *notas_titulo[2] = {"índice", "contenido"}; /* * Se crea los componentes asociados a notas: * una ventana con barra de desplazamiento y una lista */ scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_widget_set_usize(scroll,150,200); notas=gtk_clist_new_with_titles (2,notas_titulo); datosAgenda.gtk_notas=notas; gtk_clist_set_shadow_type (GTK_CLIST(notas), GTK_SHADOW_OUT); gtk_container_add(GTK_CONTAINER(scroll), notas); return (scroll); }
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; }
static void create_plugin_tab(GtkWidget *tab_vbox) { Reader *reader; GtkWidget *tabs; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *button; GtkWidget *arrow; GtkWidget *scrolled; GtkWidget *text; GtkWidget *label; gchar *buf[CLIST_WIDTH]; gint row, i; /* Make a couple of tabs. One for setup and one for info */ tabs = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tabs), GTK_POS_TOP); gtk_box_pack_start(GTK_BOX(tab_vbox), tabs, TRUE, TRUE, 0); /* --- Setup tab */ vbox = gkrellm_gtk_framed_notebook_page(tabs, "Setup"); hbox = gtk_hbox_new(FALSE,0); label = gtk_label_new("Label : "); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); label_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(label_entry), ""); gtk_box_pack_start(GTK_BOX(hbox),label_entry,FALSE,FALSE,0); label = gtk_label_new("Peer : "); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); peer_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(peer_entry), ""); gtk_box_pack_start(GTK_BOX(hbox),peer_entry,FALSE,FALSE,0); label = gtk_label_new("Port : "); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); port_spin_adj = gtk_adjustment_new (161, 1, 65535, 1, 10, 10); port_spin = gtk_spin_button_new (GTK_ADJUSTMENT (port_spin_adj), 1, 0); gtk_box_pack_start(GTK_BOX(hbox),port_spin,FALSE,FALSE,0); label = gtk_label_new("Freq : "); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); freq_spin_adj = gtk_adjustment_new (100, 10, 6000, 10, 100, 100); freq_spin = gtk_spin_button_new (GTK_ADJUSTMENT (freq_spin_adj), 1, 0); gtk_box_pack_start(GTK_BOX(hbox),freq_spin,FALSE,FALSE,0); gtk_container_add(GTK_CONTAINER(vbox),hbox); hbox = gtk_hbox_new(FALSE,0); label = gtk_label_new("Community : "); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); community_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(community_entry), ""); gtk_box_pack_start(GTK_BOX(hbox), community_entry, FALSE, FALSE, 0); label = gtk_label_new("OID : "); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); oid_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(oid_entry), ""); gtk_box_pack_start(GTK_BOX(hbox), oid_entry, FALSE, FALSE, 0); label = gtk_label_new("Unit : "); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); unit_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(unit_entry), ""); gtk_box_pack_start(GTK_BOX(hbox),unit_entry,FALSE,FALSE,0); gtk_container_add(GTK_CONTAINER(vbox),hbox); hbox = gtk_hbox_new(FALSE,0); label = gtk_label_new("Divisor : "); gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0); div_spin_adj = gtk_adjustment_new (1, 1, 1024, 1, 1, 1); div_spin = gtk_spin_button_new (GTK_ADJUSTMENT (div_spin_adj), 1, 0); gtk_box_pack_start(GTK_BOX(hbox),div_spin,FALSE,FALSE,0); delta_button = gtk_check_button_new_with_label("Compute delta"); gtk_box_pack_start(GTK_BOX(hbox),delta_button,FALSE,FALSE,0); scale_button = gtk_check_button_new_with_label("Auto scale"); gtk_box_pack_start(GTK_BOX(hbox),scale_button,FALSE,FALSE,0); button = gtk_button_new_with_label("Probe"); gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc) cb_probe, NULL); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 4); gtk_container_add(GTK_CONTAINER(vbox),hbox); hbox = gtk_hbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 2); /* *mount_button = gtk_check_button_new_with_label( "Enable /etc/fstab mounting"); gtk_box_pack_start(GTK_BOX(hbox), *mount_button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(GTK_BUTTON(*mount_button)), "clicked", GTK_SIGNAL_FUNC (cb_mount_button_clicked), NULL); */ button = gtk_button_new(); arrow = gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_ETCHED_OUT); gtk_container_add(GTK_CONTAINER(button), arrow); gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc) cb_clist_up, NULL); gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 4); button = gtk_button_new(); arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_ETCHED_OUT); gtk_container_add(GTK_CONTAINER(button), arrow); gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc) cb_clist_down, NULL); gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 4); button = gtk_button_new_with_label("Enter"); gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc) cb_enter, NULL); gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 4); button = gtk_button_new_with_label("Delete"); gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc) cb_delete, NULL); gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 4); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0); reader_clist = gtk_clist_new_with_titles(CLIST_WIDTH, reader_title); gtk_clist_set_shadow_type (GTK_CLIST(reader_clist), GTK_SHADOW_OUT); gtk_clist_set_column_width (GTK_CLIST(reader_clist), 1, 100); gtk_clist_set_column_width (GTK_CLIST(reader_clist), 4, 100); gtk_signal_connect(GTK_OBJECT(reader_clist), "select_row", (GtkSignalFunc) cb_clist_selected, NULL); gtk_signal_connect(GTK_OBJECT(reader_clist), "unselect_row", (GtkSignalFunc) cb_clist_unselected, NULL); gtk_container_add(GTK_CONTAINER(scrolled), reader_clist); for (reader = readers; reader; reader = reader->next) { i = 0; buf[i++] = reader->label; buf[i++] = reader->peer; buf[i++] = g_strdup_printf("%d", reader->port); buf[i++] = reader->community; buf[i++] = reader->oid_str; buf[i++] = reader->unit; buf[i++] = g_strdup_printf("%d", reader->delay); buf[i++] = g_strdup_printf("%d", reader->divisor); buf[i++] = reader->delta ? "yes" : "no"; buf[i++] = reader->scale ? "yes" : "no"; buf[i++] = reader->active ? "yes" : "no"; row = gtk_clist_append(GTK_CLIST(reader_clist), buf); } /* --- Info tab */ vbox = gkrellm_gtk_framed_notebook_page(tabs, "Info"); // scrolled = gtk_scrolled_window_new(NULL, NULL); // gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), // GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); // gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0); // text = gtk_text_new(NULL, NULL); text = gkrellm_gtk_scrolled_text_view(vbox, NULL, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); // gtk_text_insert(GTK_TEXT(text), NULL, NULL, NULL, plugin_info_text, -1); gkrellm_gtk_text_view_append(text, plugin_info_text); // gtk_text_set_editable(GTK_TEXT(text), FALSE); // gtk_container_add(GTK_CONTAINER(scrolled), text); /* --- about text */ text = gtk_label_new(plugin_about_text); gtk_notebook_append_page(GTK_NOTEBOOK(tabs), text, gtk_label_new("About")); }
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(); }
/* ****************************************************************** * */ gint create_route_cb (GtkWidget * widget, guint datum) { GtkWidget *window; gchar *tabeltitel1[] = { "#", _("Waypoint"), _("Latitude"), _("Longitude"), _("Distance"), NULL }; GtkWidget *scrwindow, *vbox, *button, *button3, *hbox, *hbox_displays, *l1; gint i, j; gchar *text[5], text0[20], text1[20], text2[20], text3[20]; GtkTooltips *tooltips; route.edit = TRUE; window = gtk_dialog_new (); routewindow = window; /* gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, TRUE); */ gtk_window_set_title (GTK_WINDOW (window), _("Define route")); gtk_window_set_default_size (GTK_WINDOW (window), 320, 320); myroutelist = gtk_clist_new_with_titles (5, tabeltitel1); gtk_signal_connect (GTK_OBJECT (GTK_CLIST (myroutelist)), "select-row", GTK_SIGNAL_FUNC (setroutetarget), GTK_OBJECT (myroutelist)); select_route_button = gtk_button_new_with_label (_("Start route")); gtk_widget_set_sensitive (select_route_button, FALSE); GTK_WIDGET_SET_FLAGS (select_route_button, GTK_CAN_DEFAULT); gtk_signal_connect (GTK_OBJECT (select_route_button), "clicked", GTK_SIGNAL_FUNC (do_route_cb), 0); gtk_window_set_default (GTK_WINDOW (window), select_route_button); create_route2_button = gtk_button_new_with_label (_("Take all WP as route")); GTK_WIDGET_SET_FLAGS (create_route2_button, GTK_CAN_DEFAULT); gtk_signal_connect (GTK_OBJECT (create_route2_button), "clicked", GTK_SIGNAL_FUNC (insertallroutepoints), 0); button = gtk_button_new_with_label (_("Abort route")); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (sel_routecancel_cb), GTK_OBJECT (window)); gtk_signal_connect_object (GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC (sel_routeclose_cb), GTK_OBJECT (window)); /* button3 = gtk_button_new_with_label (_("Close")); */ button3 = gtk_button_new_from_stock (GTK_STOCK_CLOSE); GTK_WIDGET_SET_FLAGS (button3, GTK_CAN_DEFAULT); gtk_signal_connect_object (GTK_OBJECT (button3), "clicked", GTK_SIGNAL_FUNC (sel_routeclose_cb), GTK_OBJECT (window)); /* Font �ndern falls PDA-Mode und Touchscreen */ if (local_config.guimode == GUI_PDA) { if (onemousebutton) { /* Change default font throughout the widget */ PangoFontDescription *font_desc; font_desc = pango_font_description_from_string ("Sans 10"); gtk_widget_modify_font (myroutelist, font_desc); pango_font_description_free (font_desc); } } gtk_clist_set_column_justification (GTK_CLIST (myroutelist), 4, GTK_JUSTIFY_RIGHT); gtk_clist_set_column_justification (GTK_CLIST (myroutelist), 0, GTK_JUSTIFY_RIGHT); gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 0, TRUE); gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 1, TRUE); gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 2, TRUE); gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 3, TRUE); gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 4, TRUE); scrwindow = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrwindow), myroutelist); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrwindow), (GtkPolicyType) GTK_POLICY_AUTOMATIC, (GtkPolicyType) GTK_POLICY_AUTOMATIC); vbox = gtk_vbox_new (FALSE, 2); /* gtk_container_add (GTK_CONTAINER (window), vbox); */ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (vbox), scrwindow, TRUE, TRUE, 2); hbox = gtk_hbox_new (TRUE, 2); hbox_displays = gtk_hbox_new (TRUE, 2); if (!route.active) l1 = gtk_label_new (_ ("Click on waypoints list\nto add waypoints")); else l1 = gtk_label_new (_ ("Click on list item\nto select next waypoint")); gtk_box_pack_start (GTK_BOX (vbox), l1, FALSE, FALSE, 2); /* gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2); */ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), hbox, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), select_route_button, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), create_route2_button, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox_displays, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (hbox), button3, TRUE, TRUE, 2); gtk_widget_set_sensitive (create_route_button, FALSE); if (route.active) { gtk_widget_set_sensitive (select_route_button, FALSE); gtk_clist_clear (GTK_CLIST (myroutelist)); for (i = 0; i < route.items; i++) { (routelist + i)->dist = calcdist ((routelist + i)->lon, (routelist + i)->lat); text[1] = (routelist + i)->name; g_snprintf (text0, sizeof (text0), "%d", i + 1); g_snprintf (text1, sizeof (text1), "%8.5f", (routelist + i)->lat); g_snprintf (text2, sizeof (text2), "%8.5f", (routelist + i)->lon); g_snprintf (text3, sizeof (text3), "%9.3f", (routelist + i)->dist); text[0] = text0; text[2] = text1; text[3] = text2; text[4] = text3; j = gtk_clist_append (GTK_CLIST (myroutelist), (gchar **) text); gtk_clist_set_foreground (GTK_CLIST (myroutelist), j, &colors.black); } } else route.items = 0; tooltips = gtk_tooltips_new (); gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), create_route2_button, _ ("Create a route from all waypoints. Sorted with order in file, not distance."), NULL); gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), select_route_button, _ ("Click here to start your journey. GpsDrive guides you through the waypoints in this list."), NULL); gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), button, _("Abort your journey"), NULL); gtk_widget_show_all (window); return TRUE; }
/* If title == NULL then it is the main gradient select dialog */ GradientSelect * gradient_select_new (gchar *title, gchar *initial_gradient) { GradientSelect *gsp; GtkWidget *vbox; GtkWidget *scrolled_win; GdkColormap *colormap; gchar *titles[2]; gint column_width; gint select_pos; gradient_t *active = NULL; static gboolean first_call = TRUE; gsp = g_new (GradientSelect, 1); gsp->callback_name = NULL; gsp->dnd_gradient = NULL; /* The shell */ /* gsp->shell = gimp_dialog_new (title ? title : _("Gradient Selection"), "gradient_selection", gimp_standard_help_func, "dialogs/gradient_selection.html", title ? GTK_WIN_POS_MOUSE : GTK_WIN_POS_NONE, FALSE, TRUE, FALSE, _("Edit"), gradient_select_edit_callback, gsp, NULL, NULL, FALSE, FALSE, _("Close"), gradient_select_close_callback, gsp, NULL, NULL, TRUE, TRUE, NULL); if (title) { gsp->context = gimp_context_new (title, NULL); } else { gsp->context = gimp_context_get_user (); session_set_window_geometry (gsp->shell, &gradient_select_session_info, TRUE); dialog_register (gsp->shell); } if (no_data && first_call) gradients_init (FALSE); */ first_call = FALSE; if (title && initial_gradient && strlen (initial_gradient)) { active = gradient_list_get_gradient (gradients_list, initial_gradient); } else { /* active = gimp_context_get_gradient (gimp_context_get_user ()); */ } if (!active) { /* active = gimp_context_get_gradient (gimp_context_get_standard ()); */ } if (title) { /* gimp_context_set_gradient (gsp->context, active); */ } vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 2); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (gsp->shell)->vbox), vbox); /* clist preview of gradients */ scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (vbox), scrolled_win); gtk_widget_show (scrolled_win); titles[0] = _("Gradient"); titles[1] = _("Name"); gsp->clist = gtk_clist_new_with_titles (2, titles); gtk_clist_set_shadow_type (GTK_CLIST (gsp->clist), GTK_SHADOW_IN); gtk_clist_set_selection_mode (GTK_CLIST (gsp->clist), GTK_SELECTION_BROWSE); gtk_clist_set_row_height (GTK_CLIST (gsp->clist), 18); gtk_clist_set_use_drag_icons (GTK_CLIST (gsp->clist), FALSE); gtk_clist_column_titles_passive (GTK_CLIST (gsp->clist)); gtk_widget_set_usize (gsp->clist, 200, 250); gtk_container_add (GTK_CONTAINER (scrolled_win), gsp->clist); column_width = MAX (50, gtk_clist_optimal_column_width (GTK_CLIST (gsp->clist), 0)); gtk_clist_set_column_min_width (GTK_CLIST (gsp->clist), 0, 50); gtk_clist_set_column_width (GTK_CLIST (gsp->clist), 0, column_width); gtk_widget_show (gsp->clist); colormap = gtk_widget_get_colormap (gsp->clist); gdk_color_parse ("black", &gsp->black); gdk_color_alloc (colormap, &gsp->black); gtk_widget_realize (gsp->shell); gsp->gc = gdk_gc_new (gsp->shell->window); select_pos = gradient_clist_init (gsp->shell, gsp->gc, gsp->clist, active); /* Now show the dialog */ gtk_widget_show (vbox); gtk_widget_show (gsp->shell); gtk_signal_connect (GTK_OBJECT (gsp->clist), "button_press_event", GTK_SIGNAL_FUNC (gradient_select_button_press), (gpointer) gsp); gtk_signal_connect (GTK_OBJECT (gsp->clist), "select_row", GTK_SIGNAL_FUNC (gradient_select_list_item_update), (gpointer) gsp); gtk_signal_connect (GTK_OBJECT (gsp->context), "gradient_changed", GTK_SIGNAL_FUNC (gradient_select_gradient_changed), (gpointer) gsp); /* dnd stuff */ /* gtk_drag_source_set (gsp->clist, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK, clist_target_table, clist_n_targets, GDK_ACTION_COPY); gimp_dnd_gradient_source_set (gsp->clist, gradient_select_drag_gradient, gsp); gtk_drag_dest_set (gsp->clist, GTK_DEST_DEFAULT_ALL, clist_target_table, clist_n_targets, GDK_ACTION_COPY); gimp_dnd_gradient_dest_set (gsp->clist, gradient_select_drop_gradient, gsp); */ if (active) gradient_select_select (gsp, active); /* Add to active gradient dialogs list */ gradient_active_dialogs = g_slist_append (gradient_active_dialogs, gsp); return gsp; }
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; }
static void create_config(GtkWidget *tab) { GtkWidget *tabs; GtkWidget *text, *label, *panel, *button, *hbox, *scrolled, *frame, *vbox; GtkObject *adj; gchar *plugin_about_text; gchar *station_tab_titles[3] = { _("Station"), _("Frequency"), "" }; char *f[3]; int i; tabs = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tabs),GTK_POS_TOP); gtk_box_pack_start(GTK_BOX(tab),tabs,TRUE,TRUE,0); /* STATION TAB */ panel = gtk_vbox_new(0, 0); gui_station_list = gtk_clist_new_with_titles(3, station_tab_titles); gtk_clist_set_column_auto_resize(GTK_CLIST(gui_station_list), 0, TRUE); gtk_clist_set_column_auto_resize(GTK_CLIST(gui_station_list), 0, TRUE); gtk_clist_set_reorderable(GTK_CLIST(gui_station_list), TRUE); gtk_clist_set_column_justification(GTK_CLIST(gui_station_list), 1, GTK_JUSTIFY_RIGHT); /* fill data in clist */ f[1] = malloc(32); f[2] = ""; for (i = 0; i< nstations; i++) { f[0] = stations[i].station_name; snprintf(f[1],32, "%.2f", stations[i].freq); gtk_clist_append(GTK_CLIST(gui_station_list), f); } gui_station_count = nstations; free(f[1]); gtk_signal_connect(GTK_OBJECT(gui_station_list), "select-row", (GtkSignalFunc)gui_select_row, NULL); 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),gui_station_list); gtk_container_add(GTK_CONTAINER(panel), scrolled); hbox = gtk_hbox_new(0, 0); button = gtk_button_new_with_label(_("New")); gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)gui_new_station, NULL); gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 2); button = gtk_button_new_with_label(_("Edit")); gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)gui_edit_station, NULL); gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 2); button = gtk_button_new_with_label(_("Delete")); gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)gui_delete_station, NULL); gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 2); button = gtk_button_new_with_label(_("Up")); gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)gui_moveup_station, NULL); gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 2); button = gtk_button_new_with_label(_("Down")); gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)gui_movedown_station, NULL); gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 2); label = gtk_label_new(_("Stations")); gtk_box_pack_start(GTK_BOX(panel), hbox, FALSE, FALSE, 4); gtk_notebook_append_page(GTK_NOTEBOOK(tabs), panel, label); /* OPTIONS TAB */ vbox = gtk_vbox_new(0,0); /* mutetime */ { hbox = gtk_hbox_new(0, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, 0, 0, 2); label = gtk_label_new(_("Time to mute on channel jump (seconds):")); gtk_box_pack_start(GTK_BOX(hbox), label, 0, 0, 2); adj = gtk_adjustment_new(mutetime, 0.0, 9.99, 0.01, 0.1, 1); gui_mutetime_entry = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 0.01, 2); gtk_spin_button_set_value(GTK_SPIN_BUTTON(gui_mutetime_entry), mutetime); gtk_box_pack_start(GTK_BOX(hbox), gui_mutetime_entry, 0, 0, 2); } /* reopenoption */ { gui_reopen_toggle = gtk_check_button_new_with_label(_("Attempt to reopen radio on startup")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gui_reopen_toggle), attempt_reopen); gtk_box_pack_start(GTK_BOX(vbox), gui_reopen_toggle, 0, 0, 2); /* close radio on exit toggle */ gui_close_toggle = gtk_check_button_new_with_label(_("Turn radio off when exiting gkrellm")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gui_close_toggle), close_atexit); gtk_box_pack_start(GTK_BOX(vbox), gui_close_toggle, 0, 0, 2); } label = gtk_label_new(_("Options")); gtk_notebook_append_page(GTK_NOTEBOOK(tabs), vbox, label); /* INFO TAB */ frame = gtk_frame_new(NULL); scrolled = gkrellm_gtk_notebook_page(tabs,_("Info")); text = gkrellm_gtk_scrolled_text_view(scrolled,NULL, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); for (i=0; i < sizeof(info_text)/sizeof(gchar *); ++i) gkrellm_gtk_text_view_append(text, _(info_text[i])); /* ABOUT TAB */ plugin_about_text = g_strdup_printf( _("Radio Plugin %s\n" \ "GKrellM radio Plugin\n\n" \ "Copyright (C) 2001-2002 Sjoerd Simons\n" \ "[email protected]\n" \ "http://gkrellm.luon.net/gkrellm-radio.phtml\n\n" \ "Released under the GNU General Public Licence"), VERSION); text = gtk_label_new(plugin_about_text); label = gtk_label_new(_("About")); gtk_notebook_append_page(GTK_NOTEBOOK(tabs),text,label); g_free(plugin_about_text); }
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); }
GtkWidget *create_main_win() { GtkWidget *main_win, *notebook, *scroll, *label, *vb, *hb, *button, *entry, *box; GtkAccelGroup *accel_group; GtkItemFactory *item_factory; gchar *titoli[] = {"host", "port", "fd", "traffic", "logged", "identd"}; main_win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(main_win), "ASI Chat Server"); gtk_signal_connect(GTK_OBJECT(main_win), "delete_event", GTK_SIGNAL_FUNC(delete_event), NULL); box = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(main_win), box); accel_group = gtk_accel_group_new(); item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<blah>", accel_group); gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL); gtk_accel_group_attach(accel_group, GTK_OBJECT(main_win)); gtk_box_pack_start(GTK_BOX(box), gtk_item_factory_get_widget(item_factory, "<blah>"), FALSE, FALSE, 0); notebook = gtk_notebook_new(); scroll = gtk_scrolled_window_new(NULL, NULL); label = gtk_label_new("Clients"); lista = gtk_clist_new_with_titles(6, titoli); gtk_signal_connect(GTK_OBJECT(lista), "select-row", GTK_SIGNAL_FUNC(seleziona_client), NULL); gtk_signal_connect(GTK_OBJECT(lista), "unselect-row", GTK_SIGNAL_FUNC(deseleziona_client), NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), lista); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scroll, label); scroll = gtk_scrolled_window_new(NULL, NULL); label = gtk_label_new("Status"); status = gtk_text_new(NULL, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), status); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scroll, label); vb = gtk_vbox_new(FALSE, 0); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(vb), scroll, TRUE, TRUE, 0); label = gtk_label_new("All"); all_in_all = gtk_text_new(NULL, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), all_in_all); hb = gtk_hbox_new(FALSE, 0); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hb), entry, TRUE, TRUE, 0); gtk_object_set_data(GTK_OBJECT(main_win), "entry", entry); button = gtk_button_new_with_label("Send all!"); gtk_box_pack_start(GTK_BOX(hb), button, FALSE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(send_msg_all), main_win); gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, TRUE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vb, label); gtk_box_pack_start(GTK_BOX(box), notebook, TRUE, TRUE, 0); hash = g_hash_table_new(NULL, NULL); return main_win; }
/*********************************************************************** * Create * ***********************************************************************/ GtkWidget *widget_table_create( AttributeSet *Attr, tag_attr *attr, gint Type) { GList *element; GtkWidget *widget; gchar *value; gint column; gint sort_function; list_t *sliced; #ifdef DEBUG_TRANSITS fprintf(stderr, "%s(): Entering.\n", __func__); #endif #if !GTK_CHECK_VERSION(3,0,0) /* gtk3: Deprecated in gtk2 and now gone */ if (attributeset_is_avail(Attr, ATTR_LABEL)) { sliced = linecutter(g_strdup(attributeset_get_first( &element, Attr, ATTR_LABEL)), '|'); widget = gtk_clist_new_with_titles(sliced->n_lines, sliced->line); if (sliced) list_t_free(sliced); /* Free linecutter memory */ } else { widget = gtk_clist_new(1); /* 1 column */ } if (attr) { /* Get sort-function (custom) */ if ((value = get_tag_attribute(attr, "sort-function"))) { sort_function = atoi(value); if (sort_function == 1) { gtk_clist_set_compare_func(GTK_CLIST(widget), widget_table_natcmp); } else if (sort_function == 2) { gtk_clist_set_compare_func(GTK_CLIST(widget), widget_table_natcasecmp); } } /* Get sort-type (auto-sort will require this preset) */ if ((value = get_tag_attribute(attr, "sort-type"))) { gtk_clist_set_sort_type(GTK_CLIST(widget), atoi(value)); } /* Get sort-column (custom) */ if ((value = get_tag_attribute(attr, "sort-column"))) { gtk_clist_set_sort_column(GTK_CLIST(widget), atoi(value)); } /* Get auto-sort (custom) */ if ((value = get_tag_attribute(attr, "auto-sort")) && ((strcasecmp(value, "true") == 0) || (strcasecmp(value, "yes") == 0) || (atoi(value) == 1))) { gtk_clist_set_auto_sort(GTK_CLIST(widget), TRUE); } else { gtk_clist_set_auto_sort(GTK_CLIST(widget), FALSE); } /* Get column-header-active (custom) */ if ((value = get_tag_attribute(attr, "column-header-active"))) { sliced = linecutter(g_strdup(value), '|'); for (column = 0; column < sliced->n_lines; column++) { if ((strcasecmp(sliced->line[column], "true") == 0) || (strcasecmp(sliced->line[column], "yes") == 0) || (atoi(sliced->line[column]) == 1)) { gtk_clist_column_title_active(GTK_CLIST(widget), column); } else { gtk_clist_column_title_passive(GTK_CLIST(widget), column); } } if (sliced) list_t_free(sliced); /* Free linecutter memory */ } /* Get column-visible (custom) */ if ((value = get_tag_attribute(attr, "column-visible"))) { sliced = linecutter(g_strdup(value), '|'); for (column = 0; column < sliced->n_lines; column++) { if ((strcasecmp(sliced->line[column], "true") == 0) || (strcasecmp(sliced->line[column], "yes") == 0) || (atoi(sliced->line[column]) == 1)) { gtk_clist_set_column_visibility(GTK_CLIST(widget), column, TRUE); } else { gtk_clist_set_column_visibility(GTK_CLIST(widget), column, FALSE); } } if (sliced) list_t_free(sliced); /* Free linecutter memory */ } } #else fprintf(stderr, "%s(): The table (GtkCList) widget has been removed from GTK+ 3 and tree is recommended as a replacement.\n", __func__); exit(EXIT_FAILURE); #endif #ifdef DEBUG_TRANSITS fprintf(stderr, "%s(): Exiting.\n", __func__); #endif return widget; }
/* * 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); }
/* 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(); }