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();
}
