int main(int argc, char** argv)
{
GtkWidget *window;
GtkWidget *clist;
gchar* text1[3] = {"刘备","男","23"};
gchar* text2[3] = {"张飞","男","18"};
gchar* text3[3] = {"关羽","男","16"};
gchar* text4[3] = {"孙二娘","女","25"};
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_widget_set_size_request(window, 150, 100);
g_signal_connect(GTK_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
clist = gtk_clist_new(3);
g_signal_connect(GTK_OBJECT(clist), "select_row", G_CALLBACK(select_row_cb), NULL);
gtk_clist_set_column_title(GTK_CLIST(clist), 0, "Name");
gtk_clist_set_column_title(GTK_CLIST(clist), 1, "Sex");
gtk_clist_set_column_title(GTK_CLIST(clist), 2, "Age");
gtk_clist_column_titles_show(GTK_CLIST(clist));
gtk_clist_append(GTK_CLIST(clist), text1);
gtk_clist_append(GTK_CLIST(clist), text2);
gtk_clist_append(GTK_CLIST(clist), text3);
gtk_clist_prepend(GTK_CLIST(clist), text4);
gtk_container_add(GTK_CONTAINER(window), clist);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
int main(int argc, char** argv)
{
GtkWidget *window;
GtkWidget *clist;
GtkWidget *image;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_widget_set_size_request(window, 150, 200);
g_signal_connect(GTK_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
clist = gtk_clist_new(3);
gtk_clist_set_column_title(GTK_CLIST(clist), 0, "Name");
gtk_clist_set_column_title(GTK_CLIST(clist), 1, "Sex");
gtk_clist_set_column_title(GTK_CLIST(clist), 2, "Age");
image = gtk_image_new_from_file("earth.png");
gtk_clist_set_column_widget(GTK_CLIST(clist), 0, image);
gtk_clist_column_titles_show(GTK_CLIST(clist));
gtk_container_add(GTK_CONTAINER(window), clist);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
GtkWidget *dt_clist_get_data_widget(struct formfill *form,
GCallback *activatefunc,
gpointer funcdata)
{
GtkWidget *data_widget;
GtkWidget *clist;
int i;
data_widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data_widget),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(data_widget);
clist = gtk_clist_new(2);
gtk_widget_show(clist);
for ( i = 0 ; i < 2 ; i ++ ) {
gtk_clist_set_column_width(GTK_CLIST(clist), i,
gtk_clist_optimal_column_width(GTK_CLIST(clist), i));
}
gtk_container_add(GTK_CONTAINER(data_widget), clist);
return data_widget;
}
GtkWidget* PLAYLISTUI_CreateWindow(void *pl)
{
GtkWidget *pui = NULL;
TRACE("PLAYLISTUI_CreateWindow");
pui = gtk_clist_new(2);
gtk_clist_set_column_width (GTK_CLIST(pui), 0, 150);
/* Add the CList widget to the vertical box and show it. */
gtk_container_add(GTK_CONTAINER(pl), pui);
{
int indx;
/* Something silly to add to the list. 4 rows of 2 columns each */
gchar *drink[4][2] = { { "Milk", "3 Oz" },
{ "Water", "6 l" },
{ "Carrots", "2" },
{ "Snakes", "55" } };
/* Here we do the actual adding of the text. It's done once for
* each row.
*/
for ( indx=0 ; indx < 4 ; indx++ )
gtk_clist_append( (GtkCList *) pui, drink[indx]);
}
gtk_widget_show(pui);
return pui;
}
/*
* Función mostrarConsultaWindow()
*
* Parámetros de entrada:
* char * dir[3]: nombre direccion y telefono a mostrar
*
* Parámetros de salida:
* Ninguno
*
* Descripción:
* Mostrar en la pantalla una única consulta
*/
void mostrarConsultaWindow(char* dir[3])
{
GtkWidget *datos;
GtkWidget *window;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize (GTK_WIDGET (window), 300, 300);
gtk_window_set_policy(GTK_WINDOW (window), TRUE, TRUE, FALSE);
gtk_window_set_title (GTK_WINDOW (window), "Libro de direcciones");
gtk_container_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_uposition( window, 300, 300 );
datos=gtk_clist_new(3);
gtk_clist_set_column_title(GTK_CLIST(datos),0,"Nombre");
gtk_clist_set_column_title(GTK_CLIST(datos),1,"Direccion");
gtk_clist_set_column_title(GTK_CLIST(datos),2,"Telefono");
gtk_clist_column_titles_show(GTK_CLIST(datos));
gtk_clist_set_column_width(GTK_CLIST(datos),0,100);
gtk_clist_set_column_width(GTK_CLIST(datos),1,100);
gtk_clist_set_column_width(GTK_CLIST(datos),2,50);
gtk_container_add (GTK_CONTAINER (window), datos);
gtk_clist_append(GTK_CLIST(datos),dir);
gtk_widget_show(datos);
gtk_grab_add(window);
gtk_widget_show(window);
}
int
x_create_listbox (Dlg_head *h, widget_data parent, WListbox *l)
{
GtkWidget *listbox, *sw;
GtkRequisition req;
WLEntry *p;
int i;
listbox = gtk_clist_new (1);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (sw), listbox);
gtk_clist_set_selection_mode (GTK_CLIST (listbox), GTK_SELECTION_BROWSE);
gtk_widget_size_request (listbox, &req);
gtk_widget_set_usize (listbox, req.width, req.height + 20*8);
gtk_signal_connect (GTK_OBJECT (listbox), "select_row",
GTK_SIGNAL_FUNC (listbox_select), l);
l->widget.wdata = (widget_data) sw;
gtk_widget_show (listbox);
for (p = l->list, i = 0; i < l->count; i++, p = p->next){
char *text [1];
text [0] = p->text;
gtk_clist_append (GTK_CLIST (listbox), text);
}
x_listbox_select_nth (l, l->pos);
return 1;
}
GtkWidget *create_cwidget (GtkWidget *scrollwin, struct clist_def *cldef) {
GtkWidget *alignment;
GtkWidget *label;
GtkWidget *clist;
char buf[256];
int i;
switch (cldef->type) {
case CWIDGET_CLIST:
clist = gtk_clist_new (cldef->columns);
break;
case CWIDGET_CTREE:
clist = gtk_ctree_new (cldef->columns, 0);
gtk_ctree_set_line_style (GTK_CTREE (clist), GTK_CTREE_LINES_NONE);
gtk_ctree_set_expander_style (GTK_CTREE (clist), GTK_CTREE_EXPANDER_TRIANGLE);
gtk_ctree_set_indent (GTK_CTREE (clist), 10);
break;
default:
return NULL;
}
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GTK_CLIST_SET_FLAG (GTK_CLIST (clist), CLIST_SHOW_TITLES);
gtk_container_add (GTK_CONTAINER (scrollwin), clist);
gtk_clist_set_selection_mode (GTK_CLIST (clist), cldef->mode);
for (i = 0; i < cldef->columns; i++) {
g_snprintf (buf, 256, "/" CONFIG_FILE "/%s Geometry/%s=%d",
cldef->name, cldef->cols[i].name, cldef->cols[i].width);
gtk_clist_set_column_width (GTK_CLIST (clist), i, config_get_int (buf));
if (cldef->cols[i].justify != GTK_JUSTIFY_LEFT) {
gtk_clist_set_column_justification (GTK_CLIST (clist), i, cldef->cols[i].justify);
}
alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0);
label = gtk_label_new (_(cldef->cols[i].name));
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_container_add (GTK_CONTAINER (alignment), label);
gtk_widget_show (label);
cldef->cols[i].widget = label;
gtk_clist_set_column_widget (GTK_CLIST (clist), i, alignment);
gtk_widget_show (alignment);
}
gtk_clist_set_sort_column (GTK_CLIST (clist), cldef->sort_column);
gtk_clist_set_sort_type (GTK_CLIST (clist), cldef->sort_type);
clist_column_set_title (GTK_CLIST (clist), cldef, TRUE);
return clist;
}
void init_breakpoints()
{
int i;
GtkWidget *boxH1,
*scrolledwindow1,
*boxV1,
*buAdd, *buRemove;
breakpoints_opened = 1;
for(i=0; i<BREAKPOINTS_MAX_NUMBER; i++) {
bp_addresses[i]=0;
}
for(i=0; i<BREAKPOINTS_MAX_NUMBER; i++) {
selected[i]=0;
}
//=== Creation of Breakpoints Management ===========/
winBreakpoints = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW(winBreakpoints), "Breakpoints");
gtk_window_set_default_size( GTK_WINDOW(winBreakpoints), 100, 150);
gtk_container_set_border_width( GTK_CONTAINER(winBreakpoints), 2);
boxH1 = gtk_hbox_new( FALSE, 0 );
gtk_container_add( GTK_CONTAINER(winBreakpoints), boxH1 );
//=== Creation of Breakpoints Display ==============/
scrolledwindow1 = gtk_scrolled_window_new( NULL, NULL );
gtk_box_pack_start( GTK_BOX(boxH1), scrolledwindow1, FALSE, FALSE, 0);
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledwindow1),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC );
gtk_range_set_update_policy( GTK_RANGE (GTK_SCROLLED_WINDOW(scrolledwindow1)->hscrollbar),
GTK_POLICY_AUTOMATIC );
clBreakpoints = gtk_clist_new( 1 );
gtk_container_add( GTK_CONTAINER(scrolledwindow1), clBreakpoints );
gtk_clist_set_selection_mode( GTK_CLIST(clBreakpoints), GTK_SELECTION_EXTENDED );
gtk_clist_set_column_width( GTK_CLIST(clBreakpoints), 0, 80 );
gtk_clist_set_auto_sort( GTK_CLIST(clBreakpoints), TRUE );
//=== Creation of the Buttons ======================/
boxV1 = gtk_vbox_new( FALSE, 2 );
gtk_box_pack_end( GTK_BOX(boxH1), boxV1, FALSE, FALSE, 0 );
buAdd = gtk_button_new_with_label("Add");
gtk_box_pack_start( GTK_BOX(boxV1), buAdd, FALSE, FALSE, 0 );
buRemove = gtk_button_new_with_label( "Remove" );
gtk_box_pack_start( GTK_BOX(boxV1), buRemove, FALSE, FALSE, 0 );
gtk_widget_show_all(winBreakpoints);
//=== Signal Connections ===========================/
gtk_signal_connect( GTK_OBJECT(clBreakpoints), "select-row", on_row_selection, NULL );
gtk_signal_connect( GTK_OBJECT(clBreakpoints), "unselect-row", on_row_unselection, NULL );
gtk_signal_connect( GTK_OBJECT(buAdd), "clicked", on_add, NULL );
gtk_signal_connect( GTK_OBJECT(buRemove), "clicked", on_remove, NULL );
gtk_signal_connect( GTK_OBJECT(winBreakpoints), "destroy", on_close, NULL );
}
GtkWidget *gtk_clist_new_with_titles(gint columns, gchar *titles[])
{
GtkWidget *widget;
GtkCList *clist;
gint i;
widget = gtk_clist_new(columns);
clist = GTK_CLIST(widget);
for (i = 0; i < clist->cols; i++) {
gtk_clist_set_column_title(clist, i, titles[i]);
}
return widget;
}
void
ghack_menu_window_start_menu (GtkWidget *menuWin, gpointer data)
{
GtkWidget *frame1, *swin, *clist;
MenuWinType isMenu;
g_assert (menuWin != NULL);
g_assert (data == NULL);
/* destroy existing menu data, if any */
frame1 = gtk_object_get_data (GTK_OBJECT (menuWin), "frame1");
if (frame1)
gtk_widget_destroy (frame1);
isMenu = MenuMenu;
gtk_object_set_data (GTK_OBJECT (menuWin), "isMenu",
GINT_TO_POINTER (isMenu));
gtk_widget_set_usize (GTK_WIDGET (menuWin), 500, 400);
gtk_window_set_policy (GTK_WINDOW (menuWin), TRUE, TRUE, FALSE);
frame1 = gtk_frame_new ("Make your selection");
g_assert (frame1 != NULL);
gtk_object_set_data (GTK_OBJECT(menuWin), "frame1", frame1);
gtk_widget_show (GTK_WIDGET (frame1));
gtk_container_set_border_width (GTK_CONTAINER (frame1), 5);
gtk_box_pack_start (GTK_BOX (GNOME_DIALOG(menuWin)->vbox), frame1,
TRUE, TRUE, 0);
swin = gtk_scrolled_window_new (NULL, NULL);
g_assert (swin != NULL);
gtk_object_set_data (GTK_OBJECT(menuWin), "swin", swin);
gtk_widget_show (GTK_WIDGET (swin));
gtk_container_add (GTK_CONTAINER (frame1), swin);
clist = gtk_clist_new (4);
g_assert (clist != NULL);
gtk_object_set_data (GTK_OBJECT(menuWin), "clist", clist);
gtk_widget_show (GTK_WIDGET (clist));
gtk_container_add (GTK_CONTAINER (swin), clist);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_signal_connect (GTK_OBJECT (clist), "select_row",
GTK_SIGNAL_FUNC (ghack_menu_row_selected), NULL);
gtk_object_set_data (GTK_OBJECT (clist), "numItems",
GINT_TO_POINTER (-1));
}
static GtkCList *mmio_window_add_page( mmio_window_t mmio, char *name, struct mmio_region *io_rgn )
{
GtkCList *list;
GtkWidget *scroll;
GtkWidget *tab;
GtkCheckButton *trace_button;
GtkVBox *vbox;
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS );
list = GTK_CLIST(gtk_clist_new(5));
gtk_clist_set_column_width(list, 0, 70);
gtk_clist_set_column_width(list, 1, 75);
gtk_clist_set_column_width(list, 2, 70);
gtk_clist_set_column_width(list, 3, 280);
gtk_clist_set_column_width(list, 4, 160);
gtk_clist_set_column_justification(list, 0, GTK_JUSTIFY_CENTER );
gtk_clist_set_column_justification(list, 2, GTK_JUSTIFY_CENTER );
gtk_clist_set_column_justification(list, 3, GTK_JUSTIFY_CENTER );
gtk_clist_set_column_title(list, 0, _("Address"));
gtk_clist_set_column_title(list, 1, _("Register"));
gtk_clist_set_column_title(list, 2, _("Value"));
gtk_clist_set_column_title(list, 3, _("Bit Pattern"));
gtk_clist_set_column_title(list, 4, _("Description"));
gtk_clist_column_titles_show(list);
gtk_widget_modify_font( GTK_WIDGET(list), gui_fixed_font );
tab = gtk_label_new(_(name));
gtk_container_add( GTK_CONTAINER(scroll), GTK_WIDGET(list) );
vbox = GTK_VBOX(gtk_vbox_new( FALSE, 0 ));
gtk_container_add( GTK_CONTAINER(vbox), GTK_WIDGET(scroll) );
trace_button = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Trace access")));
if( io_rgn != NULL ) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(trace_button),
io_rgn->trace_flag ? TRUE : FALSE);
}
gtk_container_add( GTK_CONTAINER(vbox), GTK_WIDGET(trace_button) );
gtk_box_set_child_packing( GTK_BOX(vbox), GTK_WIDGET(trace_button),
FALSE, FALSE, 0, GTK_PACK_START );
gtk_notebook_append_page( GTK_NOTEBOOK(mmio->notebook), GTK_WIDGET(vbox), tab );
gtk_object_set_data( GTK_OBJECT(mmio->window), name, list );
g_signal_connect ((gpointer) trace_button, "toggled",
G_CALLBACK (on_trace_button_toggled),
io_rgn);
return list;
}
void init_regSI()
{
GtkWidget *boxH1,
*boxV1,
*labRegSI[32];
int i;
char **txt;
txt=malloc( sizeof(char*) );
txt[0]=malloc( 64*sizeof(char) );
frRegSI = gtk_frame_new("Serial Interface");
boxH1 = gtk_hbox_new( FALSE, 2);
gtk_container_add( GTK_CONTAINER(frRegSI), boxH1 );
gtk_container_set_border_width( GTK_CONTAINER(boxH1), 5);
//=== Creation of Labels "SD_*_REG" Column =======/
boxV1 = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(boxH1), boxV1, FALSE, FALSE, 0);
labRegSI[0] = gtk_label_new( mnemonicSI[0] );
gtk_box_pack_start( GTK_BOX(boxV1), labRegSI[0], FALSE, TRUE, 1);
for( i=1; i<4; i++)
{
labRegSI[i] = gtk_label_new( mnemonicSI[i] );
gtk_box_pack_start( GTK_BOX(boxV1), labRegSI[i], FALSE, TRUE, 0);
}
//=== Creation of Registers Value Display ========/
clRegSI = gtk_clist_new(1);
gtk_box_pack_start( GTK_BOX(boxH1), clRegSI, TRUE, TRUE, 0);
gtk_clist_set_selection_mode( GTK_CLIST(clRegSI), GTK_SELECTION_SINGLE);
gtk_clist_set_column_width( GTK_CLIST(clRegSI), 0, 130);
strcpy( txt[0], "Undefined");
for( i=0; i<4; i++)
{
gtk_clist_append( GTK_CLIST(clRegSI), txt);
}
//=== Fantom Registers Initialisation ============/
for( i=0; i<4; i++)
{
gui_fantom_reg_SI[i] = 0x12345678;
//Should be put to the least probable value.
}
}
static GtkWidget* generate_credit_list(const char *text[], gboolean sec_space)
{
GtkWidget *clist, *scrollwin;
int i = 0;
clist = gtk_clist_new(2);
while (text[i])
{
gchar *temp[2];
guint row;
temp[0] = gettext(text[i++]);
temp[1] = gettext(text[i++]);
row = gtk_clist_append(GTK_CLIST(clist), temp);
gtk_clist_set_selectable(GTK_CLIST(clist), row, FALSE);
temp[0] = "";
while (text[i])
{
temp[1] = gettext(text[i++]);
row = gtk_clist_append(GTK_CLIST(clist), temp);
gtk_clist_set_selectable(GTK_CLIST(clist), row, FALSE);
}
i++;
if (text[i] && sec_space)
{
temp[1] = "";
row = gtk_clist_append(GTK_CLIST(clist), temp);
gtk_clist_set_selectable(GTK_CLIST(clist), row, FALSE);
}
}
gtk_clist_columns_autosize(GTK_CLIST(clist));
gtk_clist_set_column_justification(GTK_CLIST(clist), 0, GTK_JUSTIFY_RIGHT);
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(scrollwin), clist);
gtk_container_set_border_width(GTK_CONTAINER(scrollwin), 10);
gtk_widget_set_usize(scrollwin, -1, 120);
return scrollwin;
}
void init_regHiLo()
{
int i;
char **txt=malloc(sizeof(char*));
txt[0]=malloc(16*sizeof(char));
frRegHiLo = gtk_frame_new("Hi/Lo");
clRegHiLo = gtk_clist_new(1);
gtk_container_add( GTK_CONTAINER(frRegHiLo), clRegHiLo );
strcpy( txt[0], "Undefined" );
for(i=0;i<2;i++)
{
gtk_clist_append( GTK_CLIST(clRegHiLo), txt );
}
gtk_clist_set_column_width( GTK_CLIST(clRegHiLo), i, 130);
gui_fantom_hi=0x1234567890LL;
gui_fantom_lo=0x1234567890LL;
}
static GtkWidget * init_FGR_col()
{
GtkCList *cl;
int i;
char *txt[2];
char txt_regnum[6];
txt[0] = txt_regnum;
txt[1] = "MMMMMMMMMM";
cl = (GtkCList *) gtk_clist_new(2);
gtk_widget_modify_font(GTK_WIDGET(cl), debugger_font_desc);
gtk_clist_set_column_resizeable(cl, 0, FALSE);
gtk_clist_set_column_resizeable(cl, 1, FALSE);
for (i=0; i<32; i++) {
sprintf(txt_regnum, "%d", i);
gtk_clist_append(cl, txt);
}
gtk_clist_set_column_width(cl, 0, gtk_clist_optimal_column_width(cl, 0));
gtk_clist_set_column_width(cl, 1, gtk_clist_optimal_column_width(cl, 1));
return GTK_WIDGET(cl);
}
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;
}
void init_gui_playlist(void) {
GtkWidget *li;
GtkWidget *scroller;
GtkWidget *box;
GtkWidget *table1;
GtkWidget *reload_button;
GtkWidget * enqueue_button;
selected_row = -1;
dir_browser = NULL;
list_dialog = NULL;
files = NULL;
/* Create and setup main window */
library_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
//gtk_window_set_decorated(library_window, FALSE);
// gtk_widget_set_app_paintable(library_window, TRUE);
// gtk_window_set_policy( GTK_WINDOW(library_window), FALSE, FALSE, TRUE);
/* Put the window into the xmms class, and hide it from the window list*/
gtk_window_set_wmclass( GTK_WINDOW(library_window), "XMMS_MediaLibrary",
"xmms");
gtk_window_set_transient_for( GTK_WINDOW(library_window),
GTK_WINDOW(mainwin) );
// hint_set_skip_winlist( library_window );
gtk_window_set_default_size(GTK_WINDOW(library_window), 350, 350);
gtk_window_set_title(GTK_WINDOW(library_window), "Media Library");
/* gtk_widget_set_events( library_window, GDK_FOCUS_CHANGE_MASK |
GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK );
*/
// gtk_widget_realize( library_window );
// gtk_widget_set_usize( library_window, 300, 200 );
/* background = gdk_pixmap_new( NULL, 300, 200, gdk_rgb_get_visual()->depth );
pl_gc = gdk_gc_new( library_window->window );
printf("init\n");
printf("%i\n", get_skin_color(SKIN_PLEDIT_NORMALBG));
gdk_gc_set_foreground(pl_gc, get_skin_color(SKIN_PLEDIT_NORMALBG) );
gdk_draw_rectangle( background, pl_gc, TRUE, 0, 0, 300, 200 );
gdk_window_set_back_pixmap( library_window->window, background, 0);*/
/* Remove the WMs decorations */
// gdk_window_set_decorations( library_window->window, 0);
/* Setup list*/
file_list = gtk_clist_new(1);
g_signal_connect(GTK_OBJECT(file_list), "select-row",
GTK_SIGNAL_FUNC(file_list_select), NULL);
g_signal_connect(GTK_OBJECT(file_list), "unselect-row",
GTK_SIGNAL_FUNC(file_list_unselect), NULL);
g_signal_connect(GTK_OBJECT(file_list), "button-press-event",
G_CALLBACK(file_list_pressed), NULL);
g_signal_connect(GTK_OBJECT(file_list), "key-press-event",
GTK_SIGNAL_FUNC(file_list_key_press), NULL);
gtk_clist_set_column_title(GTK_CLIST(file_list), 0, "Title");
gtk_clist_column_titles_passive(GTK_CLIST(file_list));
gtk_clist_column_titles_show(GTK_CLIST(file_list));
gtk_clist_set_selection_mode(GTK_CLIST(file_list), GTK_SELECTION_EXTENDED);
gtk_widget_grab_default( GTK_OBJECT(file_list) );
/* Setup the search field */
search_field = gtk_entry_new();
g_signal_connect(GTK_OBJECT(search_field), "changed",
GTK_SIGNAL_FUNC(search_modify), NULL);
g_signal_connect(GTK_OBJECT(search_field), "key-press-event",
G_CALLBACK(search_field_keypress), NULL);
/* gtk_signal_connect(GTK_OBJECT(search_field), "focus-in-event",
GTK_SIGNAL_FUNC(search_field_focus_in), NULL);*/
/* Setup the search button
search_button = gtk_button_new_with_label("Search"); */
/* Setup the reload button*/
reload_button = gtk_button_new_with_label("Reload");
g_signal_connect( GTK_OBJECT(reload_button), "clicked",
GTK_SIGNAL_FUNC(reload_button_clicked), NULL);
/* Setup the play and enqueue-buttons */
play_button = gtk_button_new_with_label("Play");
play_button_handler_id = g_signal_connect(GTK_OBJECT(play_button), "clicked",
GTK_SIGNAL_FUNC(play_button_clicked), NULL);
enqueue_button = gtk_button_new_with_label("Add");
g_signal_connect(GTK_OBJECT(enqueue_button), "clicked",
GTK_SIGNAL_FUNC(enqueue_button_clicked), NULL);
/* Set the scroller up*/
scroller = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroller),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(scroller), file_list);
/* Setup the labels
label1 = gtk_label_new("Total songs:");
label2 = gtk_label_new("Songs showing:");
gtk_label_set_justify(GTK_LABEL(label1), GTK_JUSTIFY_RIGHT);
gtk_label_set_justify(GTK_LABEL(label2), GTK_JUSTIFY_RIGHT);
total_count_label = gtk_label_new("-");
showing_count_label = gtk_label_new("-");
gtk_label_set_justify(GTK_LABEL(total_count_label), GTK_JUSTIFY_LEFT);
gtk_label_set_justify(GTK_LABEL(showing_count_label), GTK_JUSTIFY_LEFT);*/
/* Setup layout widgets*/
layout_box = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(library_window), layout_box);
gtk_widget_show(layout_box);
table = gtk_table_new(3,2, TRUE);
gtk_box_pack_start(GTK_BOX(layout_box), table, FALSE, FALSE, 0);
gtk_box_pack_start_defaults(GTK_BOX(layout_box), scroller);
box = gtk_hbox_new(FALSE, 1);
//gtk_box_pack_start(GTK_BOX(box), search_field, TRUE, TRUE, 0);
/* The top 'bar'*/
table1 = gtk_table_new(1, 4, FALSE);
gtk_table_attach_defaults(GTK_TABLE(table1), search_field, 0,1,0,1);
gtk_table_attach_defaults(GTK_TABLE(table1), play_button, 1,2,0,1);
gtk_table_attach_defaults(GTK_TABLE(table1), enqueue_button, 2,3,0,1);
gtk_table_attach_defaults(GTK_TABLE(table1), reload_button, 3,4,0,1);
/* gtk_table_attach_defaults(GTK_TABLE(table1), reload_button, 2, 3, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table1), add_random_button, 2, 3, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table1), label1, 0,1, 0,1);
gtk_table_attach_defaults(GTK_TABLE(table1), label2, 0,1, 1,2);
gtk_table_attach_defaults(GTK_TABLE(table1), total_count_label, 1,2, 0,1);
gtk_table_attach_defaults(GTK_TABLE(table1), showing_count_label, 1,2, 1,2);*/
/* Add widgets to the table */
gtk_table_attach_defaults(GTK_TABLE(table), table1, 0, 2, 0, 2);
//gtk_table_attach_defaults(GTK_TABLE(table), box, 0, 2, 1, 3);
/* Show all the widgets*/
gtk_widget_show(reload_button);
gtk_widget_show(play_button);
gtk_widget_show(enqueue_button);
//gtk_widget_show(box);
gtk_widget_show(search_field);
gtk_widget_show(scroller);
gtk_widget_show(table1);
gtk_widget_show(table);
gtk_widget_show(file_list);
/* And finally, show the window itself*/
gtk_widget_show(library_window);
// dock_add_window(dock_window_list, library_window);
}
void
ghack_settings_dialog()
{
int i;
static GtkWidget* dialog;
static GtkWidget* swin;
static GtkWidget* frame1;
dialog = gnome_dialog_new (_("GnomeHack Settings"),
GNOME_STOCK_BUTTON_OK,
GNOME_STOCK_BUTTON_CANCEL,
NULL);
gnome_dialog_close_hides (GNOME_DIALOG (dialog), FALSE);
gtk_signal_connect (GTK_OBJECT (dialog), "key_press_event",
GTK_SIGNAL_FUNC (opt_sel_key_hit), tilesets );
frame1 = gtk_frame_new (_("Choose one of the following tilesets:"));
gtk_object_set_data (GTK_OBJECT (dialog), "frame1", frame1);
gtk_widget_show (frame1);
gtk_container_border_width (GTK_CONTAINER (frame1), 3);
swin = gtk_scrolled_window_new (NULL, NULL);
clist = gtk_clist_new (2);
gtk_clist_column_titles_hide (GTK_CLIST (clist));
gtk_widget_set_usize (GTK_WIDGET (clist), 100, 180);
gtk_container_add (GTK_CONTAINER (swin), clist);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_signal_connect (GTK_OBJECT (clist), "select_row",
GTK_SIGNAL_FUNC (opt_sel_row_selected), NULL );
gtk_container_add (GTK_CONTAINER (frame1), swin);
gtk_box_pack_start_defaults (GTK_BOX (GNOME_DIALOG (dialog)->vbox), frame1);
/* Add the tilesets into the list here... */
for (i=0; i < no_tilesets; i++) {
gchar accelBuf[BUFSZ];
const char *text[3]={accelBuf, tilesets[i].name,NULL};
if ((tilesets[i].flags & ~TILESET_TRANSPARENT) != 0)
continue; /* Unsupported flag set */
sprintf( accelBuf, "%c ", tolower(tilesets[i].name[0]));
gtk_clist_insert (GTK_CLIST (clist), i, (char**)text);
}
gtk_clist_columns_autosize (GTK_CLIST (clist));
gtk_widget_show_all (swin);
/* Center the dialog over over parent */
gnome_dialog_set_default( GNOME_DIALOG(dialog), 0);
gtk_window_set_modal( GTK_WINDOW(dialog), TRUE);
gnome_dialog_set_parent (GNOME_DIALOG (dialog),
GTK_WINDOW (ghack_get_main_window ()) );
/* Run the dialog -- returning whichever button was pressed */
i = gnome_dialog_run (GNOME_DIALOG (dialog));
gnome_dialog_close (GNOME_DIALOG (dialog));
/* They hit Quit or error */
if (i != 0 ) {
return;
}
if (gn_tileset < no_tilesets) {
if (tilesets[gn_tileset].file[0] != '/') {
char *path;
path = (char *)alloc(strlen(TILESETDIR) +
strlen(tilesets[gn_tileset].file) + 2);
sprintf(path, TILESETDIR "/%s", tilesets[gn_tileset].file);
ghack_free_glyphs();
if (ghack_init_glyphs(path))
g_error ("ERROR: Could not initialize glyphs.\n");
free(path);
}
else {
ghack_free_glyphs();
if (ghack_init_glyphs(tilesets[gn_tileset].file))
g_error ("ERROR: Could not initialize glyphs.\n");
}
ghack_reinit_map_window();
} else {
/* This shouldn't happen */
g_warning("This shouldn't happen\n");
}
}
GtkWidget *
create_file_view(FileView *view)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *menu_bar;
GtkWidget *button;
GtkWidget *pixmapwid;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
GdkFont *font;
GtkWidget *sw;
gint i;
/* Top Pane */
vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox);
menu_bar = create_filelist_menu_bar(view);
gtk_widget_show(menu_bar);
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
/* Show/Hide Button */
if (view == &app.right_view)
button = gtk_button_new_with_label("<");
else
button = gtk_button_new_with_label(">");
GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
gtk_signal_connect(GTK_OBJECT(button), "button_press_event",
GTK_SIGNAL_FUNC(show_hide_file_view_cb), view);
gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), button,
_("Left Click: Maximize/Minimize File View\n"
"Right Click: Sync Dirs"), NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
/* Hidden files toggle button */
view->hidden_toggle = gtk_toggle_button_new_with_label("H");
GTK_WIDGET_UNSET_FLAGS(view->hidden_toggle, GTK_CAN_FOCUS);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(view->hidden_toggle),
view->show_hidden);
gtk_signal_connect(GTK_OBJECT(view->hidden_toggle), "toggled",
GTK_SIGNAL_FUNC(toggle_show_hidden_cb), view);
gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), view->hidden_toggle,
_("Show/Hide hidden files"), NULL);
gtk_box_pack_start(GTK_BOX(hbox), view->hidden_toggle, FALSE, FALSE, 0);
gtk_widget_show(view->hidden_toggle);
/* Dir Entry Combo */
view->dir_entry = gtk_combo_new();
gtk_combo_disable_activate(GTK_COMBO(view->dir_entry));
gtk_combo_set_use_arrows_always(GTK_COMBO(view->dir_entry), TRUE);
gtk_combo_set_case_sensitive(GTK_COMBO(view->dir_entry), TRUE);
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(view->dir_entry)->entry),
"activate", GTK_SIGNAL_FUNC(dir_entry_cb), view);
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(view->dir_entry)->popwin),
"hide", GTK_SIGNAL_FUNC(dir_popwin_cb), view);
gtk_box_pack_start(GTK_BOX(hbox), view->dir_entry, TRUE, TRUE, 0);
gtk_widget_show(view->dir_entry);
/* Up Dir Button */
button = gtk_button_new();
GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
gtk_signal_connect(GTK_OBJECT(button), "button_press_event",
GTK_SIGNAL_FUNC(updir_click_cb), view);
gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), button,
_("Left Click: Up Dir Right Click: Home"), NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
style = gtk_widget_get_style(app.main_window);
pixmap = gdk_pixmap_create_from_xpm_d(app.main_window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
icon_dirparent_xpm);
pixmapwid = gtk_pixmap_new(pixmap, mask);
gtk_container_add(GTK_CONTAINER(button), pixmapwid);
gtk_widget_show(pixmapwid);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(sw), cfg.scrollbar_pos);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
gtk_widget_show(sw);
/* File List */
view->clist = gtk_clist_new(MAX_COLUMNS);
for (i = 0; i < MAX_COLUMNS; i++)
{
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
GtkWidget *label = gtk_label_new(all_columns[i].title);
view->sort_arrows[i] = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), view->sort_arrows[i], FALSE, TRUE, 0);
gtk_widget_show(label);
gtk_widget_show(hbox);
gtk_clist_set_column_widget(GTK_CLIST(view->clist), i, hbox);
GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(view->clist)->column[i].button,
GTK_CAN_FOCUS);
}
gtk_clist_column_titles_show(GTK_CLIST(view->clist));
gtk_clist_set_shadow_type(GTK_CLIST(view->clist), GTK_SHADOW_ETCHED_IN);
gtk_clist_set_selection_mode(GTK_CLIST(view->clist), GTK_SELECTION_EXTENDED);
gtk_clist_set_use_drag_icons(GTK_CLIST(view->clist), TRUE);
gtk_clist_set_row_height(GTK_CLIST(view->clist), 0);
font = gdk_font_load(cfg.list_font);
if (font != NULL)
{
style = gtk_style_copy(gtk_widget_get_style(view->clist));
style->font = font;
gtk_widget_set_style(view->clist, style);
}
for (i = 0; i < MAX_COLUMNS; i++)
{
gtk_clist_set_column_width(GTK_CLIST(view->clist), i, all_columns[i].size);
gtk_clist_set_column_visibility(GTK_CLIST(view->clist), i,
all_columns[i].is_visible);
}
gtk_signal_connect(GTK_OBJECT(view->clist), "select_row",
GTK_SIGNAL_FUNC(select_row_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "button_press_event",
GTK_SIGNAL_FUNC(mouse_click_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "key_press_event",
GTK_SIGNAL_FUNC(file_list_key_press_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "click_column",
GTK_SIGNAL_FUNC(column_button_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_data_get",
GTK_SIGNAL_FUNC(clist_drag_data_get), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_motion",
GTK_SIGNAL_FUNC(clist_drag_motion), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_leave",
GTK_SIGNAL_FUNC(clist_drag_leave), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_data_received",
GTK_SIGNAL_FUNC(clist_drag_data_received), view);
gtk_drag_dest_set(view->clist, GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, target_table,
n_targets, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK |
GDK_ACTION_ASK);
gtk_container_add(GTK_CONTAINER(sw), view->clist);
gtk_widget_show(view->clist);
/* Set the CLIST_COLOR for resetting from the DRAG_HILIGHT color */
{
GtkStyle *style = gtk_widget_get_style(view->clist);
CLIST_COLOR.red = style->base[GTK_STATE_NORMAL].red;
CLIST_COLOR.green = style->base[GTK_STATE_NORMAL].green;
CLIST_COLOR.blue = style->base[GTK_STATE_NORMAL].blue;
}
return vbox;
}
gint gw_plugin_settings_quick_search_pane_create ( GtkWindow *settings, GtkContainer *parent, GtkWidget **pane)
{
gint result = -1;
GtkWidget *hbox;
GtkWidget *scr_clist_hidden;
GtkWidget *clist_hidden;
GtkWidget *col_title_hidden;
GtkWidget *vbox_btn;
GtkWidget *btn_hidden;
GtkWidget *btn_show;
GtkWidget *scr_clist_visible;
GtkWidget *clist_visible;
GtkWidget *col_title_visible;
GtkTooltips *tooltips;
gchar *text_utf8 = NULL;
#ifdef GW_DEBUG_PLUGIN_SETTINGS_COMPONENT
g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
if ( settings != NULL && parent != NULL )
{
#ifdef GW_DEBUG_PLUGIN_SETTINGS_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : Creating configuration pane...\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
tooltips = gtk_tooltips_new ( );
hbox = gtk_hbox_new ( FALSE, 0);
gtk_widget_ref ( GTK_WIDGET ( settings));
gtk_object_set_data_full ( GTK_OBJECT ( hbox), GW_PLUGIN_SETTINGS_WINDOW, settings, (GtkDestroyNotify) gtk_widget_unref);
gtk_container_set_border_width ( GTK_CONTAINER ( hbox), 5);
scr_clist_visible = gtk_scrolled_window_new ( NULL, NULL);
gtk_box_pack_start ( GTK_BOX ( hbox), scr_clist_visible, TRUE, TRUE, 0);
clist_visible = gtk_clist_new ( 1);
gtk_widget_ref ( clist_visible);
gtk_object_set_data_full ( GTK_OBJECT ( hbox), GW_PLUGIN_SETTINGS_QUICK_SEARCH_LIST_VISIBLE, clist_visible, (GtkDestroyNotify) gtk_widget_unref);
gtk_container_add ( GTK_CONTAINER ( scr_clist_visible), clist_visible);
gtk_clist_set_column_width ( GTK_CLIST ( clist_visible), 0, 80);
gtk_clist_optimal_column_width ( GTK_CLIST ( clist_visible), 0);
gtk_clist_column_titles_show (GTK_CLIST (clist_visible));
g_strdup_to_gtk_text ( _( "Visible"), text_utf8);
col_title_visible = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_clist_set_column_widget ( GTK_CLIST ( clist_visible), 0, col_title_visible);
vbox_btn = gtk_vbox_new ( TRUE, 0);
gtk_box_pack_start ( GTK_BOX ( hbox), vbox_btn, TRUE, TRUE, 5);
g_strdup_to_gtk_text ( _( "Hide"), text_utf8);
btn_hidden = gtk_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_box_pack_start ( GTK_BOX ( vbox_btn), btn_hidden, FALSE, FALSE, 0);
g_strdup_to_gtk_text ( _( "Show"), text_utf8);
btn_show = gtk_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_box_pack_start ( GTK_BOX ( vbox_btn), btn_show, FALSE, FALSE, 0);
scr_clist_hidden = gtk_scrolled_window_new ( NULL, NULL);
gtk_box_pack_start ( GTK_BOX ( hbox), scr_clist_hidden, TRUE, TRUE, 0);
clist_hidden = gtk_clist_new ( 1);
gtk_widget_ref ( clist_hidden);
gtk_object_set_data_full ( GTK_OBJECT ( hbox), GW_PLUGIN_SETTINGS_QUICK_SEARCH_LIST_HIDDEN, clist_hidden, (GtkDestroyNotify) gtk_widget_unref);
gtk_container_add ( GTK_CONTAINER (scr_clist_hidden), clist_hidden);
gtk_clist_set_column_width ( GTK_CLIST ( clist_hidden), 0, 80);
gtk_clist_optimal_column_width ( GTK_CLIST ( clist_hidden), 0);
gtk_clist_column_titles_show ( GTK_CLIST ( clist_hidden));
g_strdup_to_gtk_text ( _( "Hidden"), text_utf8);
col_title_hidden = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_clist_set_column_widget ( GTK_CLIST ( clist_hidden), 0, col_title_hidden);
*pane = hbox;
gw_plugin_settings_quick_search_pane_load ( hbox);
/* Connects signals after loading. */
#ifdef GW_DEBUG_PLUGIN_SETTINGS_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : connecting all callbacks to signals...\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
gtk_signal_connect ( GTK_OBJECT ( hbox), "destroy", (GtkSignalFunc)gw_plugin_settings_quick_search_destroy, NULL);
gtk_signal_connect ( GTK_OBJECT ( btn_hidden), "clicked", (GtkSignalFunc)gw_plugin_settings_quick_search_btn_hide_click, hbox);
gtk_signal_connect ( GTK_OBJECT ( btn_show), "clicked", (GtkSignalFunc)gw_plugin_settings_quick_search_btn_show_click, hbox);
result = 0;
}
return result;
}
#include <Gtk/Gtk/CList.h>
TYPE(T, Gtk$Gtk$Container$T, Gtk$Gtk$Widget$T, Gtk$Gtk$Object$T, Gtk$GObject$Object$T);
GLOBAL_FUNCTION(New, 0) {
GtkWidget *Handle = gtk_clist_new();
Result->Val = Gtk$GObject$Object$new(Handle, T);
return SUCCESS;
};
/***********************************************************************
* 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;
}
Meaning::Meaning(const string& title, vector<string>& words, Display& display)
throw(bad_alloc)
: d_title(title), d_words(words), d_display(display), d_lists(4)
{
d_masterLayout = gtk_event_box_new();
ucwords(d_title);
gtk_widget_set_name(d_masterLayout, "ybg");
d_mainLayout = gtk_vbox_new(false, 0);
gtk_container_add( GTK_CONTAINER(d_masterLayout), d_mainLayout );
d_labelLayout = gtk_hbox_new(false, 2);
gtk_box_pack_start( GTK_BOX(d_mainLayout), d_labelLayout, 0, 0, 2);
d_label = gtk_label_new(d_title.c_str());
gtk_widget_set_name(d_label, "mst");
gtk_label_set_justify( GTK_LABEL(d_label), GTK_JUSTIFY_LEFT );
gtk_box_pack_start( GTK_BOX(d_labelLayout), d_label, 0, 0, 4 );
d_subLayout = gtk_hbox_new(false, 0);
gtk_box_pack_start( GTK_BOX(d_mainLayout), d_subLayout, 0, 0, 0 );
int i;
for(i = 0;i < 4;++i)
{
d_lists[i] = gtk_clist_new(1);
gtk_clist_set_shadow_type( GTK_CLIST(d_lists[i]), GTK_SHADOW_NONE );
gtk_container_set_border_width( GTK_CONTAINER(d_lists[i]), 0 );
gtk_widget_set_name(d_lists[i], "wbg"); // <-- this one!!
gtk_box_pack_start( GTK_BOX(d_subLayout), d_lists[i], 1, 1, 0 );
g_signal_connect(
G_OBJECT(d_lists[i]), "select-row",
G_CALLBACK(_wordclick), this
);
}
int n = d_words.size();
int q = n / 4;
int r = n % 4;
int stop1, stop2, stop3;
switch(r)
{
case 0:
stop1 = q;
stop2 = stop1 + q;
stop3 = stop2 + q;
break;
case 1:
stop1 = q + 1;
stop2 = stop1 + q;
stop3 = stop2 + q;
break;
case 2:
stop1 = q + 1;
stop2 = stop1 + (q + 1);
stop3 = stop2 + q;
break;
default: // r = 3
stop1 = q + 1;
stop2 = stop1 + (q + 1);
stop3 = stop2 + (q + 1);
break;
}
for(i = 0;i < stop1;++i)
{
const char* str = d_words[i].c_str();
gtk_clist_append(
GTK_CLIST(d_lists[0]), const_cast<char**>(&str)
);
}
for(; i < stop2;++i)
{
const char* str = d_words[i].c_str();
gtk_clist_append(
GTK_CLIST(d_lists[1]), const_cast<char**>(&str)
);
}
for(; i < stop3;++i)
{
const char* str = d_words[i].c_str();
gtk_clist_append(
GTK_CLIST(d_lists[2]), const_cast<char**>(&str)
);
}
for(; i < static_cast<int>(d_words.size());++i)
{
const char* str = d_words[i].c_str();
gtk_clist_append(
GTK_CLIST(d_lists[3]), const_cast<char**>(&str)
);
}
}
static gboolean dialog_select_source(int chan_num)
{
scope_vert_t *vert;
scope_chan_t *chan;
dialog_generic_t dialog;
gchar *title, msg[BUFLEN];
int next, n, initial_page, row, initial_row, max_row;
gchar *tab_label_text[3], *name;
GtkWidget *hbox, *label, *notebk, *button;
GtkAdjustment *adj;
hal_pin_t *pin;
hal_sig_t *sig;
hal_param_t *param;
vert = &(ctrl_usr->vert);
chan = &(ctrl_usr->chan[chan_num - 1]);
title = _("Select Channel Source");
snprintf(msg, BUFLEN - 1, _("Select a pin, signal, or parameter\n"
"as the source for channel %d."), chan_num);
/* create dialog window, disable resizing */
dialog.retval = 0;
dialog.window = gtk_dialog_new();
dialog.app_data = &chan_num;
/* set initial height of window */
gtk_widget_set_usize(GTK_WIDGET(dialog.window), -2, 300);
/* allow user to grow but not shrink the window */
gtk_window_set_policy(GTK_WINDOW(dialog.window), FALSE, TRUE, FALSE);
/* window should appear in center of screen */
gtk_window_set_position(GTK_WINDOW(dialog.window), GTK_WIN_POS_CENTER);
/* set title */
gtk_window_set_title(GTK_WINDOW(dialog.window), title);
/* display message */
label = gtk_label_new(msg);
gtk_misc_set_padding(GTK_MISC(label), 15, 5);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->vbox), label, FALSE,
TRUE, 0);
/* a separator */
gtk_hseparator_new_in_box(GTK_DIALOG(dialog.window)->vbox, 0);
/* create a notebook to hold pin, signal, and parameter lists */
notebk = gtk_notebook_new();
/* add the notebook to the dialog */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->vbox), notebk, TRUE,
TRUE, 0);
/* set overall notebook parameters */
gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(notebk), TRUE);
gtk_signal_connect(GTK_OBJECT(notebk), "switch-page", GTK_SIGNAL_FUNC(change_page), &dialog);
/* text for tab labels */
tab_label_text[0] = _("Pins");
tab_label_text[1] = _("Signals");
tab_label_text[2] = _("Parameters");
/* loop to create three identical tabs */
for (n = 0; n < 3; n++) {
/* Create a scrolled window to display the list */
vert->windows[n] = gtk_scrolled_window_new(NULL, NULL);
vert->adjs[n] = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(vert->windows[n]));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(vert->windows[n]),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_widget_show(vert->windows[n]);
/* create a list to hold the data */
vert->lists[n] = gtk_clist_new(1);
/* set up a callback for when the user selects a line */
gtk_signal_connect(GTK_OBJECT(vert->lists[n]), "select_row",
GTK_SIGNAL_FUNC(selection_made), &dialog);
gtk_signal_connect(GTK_OBJECT(vert->lists[n]), "key-press-event",
GTK_SIGNAL_FUNC(search_for_entry), &dialog);
/* It isn't necessary to shadow the border, but it looks nice :) */
gtk_clist_set_shadow_type(GTK_CLIST(vert->lists[n]), GTK_SHADOW_OUT);
/* set list for single selection only */
gtk_clist_set_selection_mode(GTK_CLIST(vert->lists[n]),
GTK_SELECTION_BROWSE);
/* put the list into the scrolled window */
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW
(vert->windows[n]), vert->lists[n]);
/* another way to do it - not sure which is better
gtk_container_add(GTK_CONTAINER(vert->windows[n]), vert->lists[n]); */
gtk_widget_show(vert->lists[n]);
/* create a box for the tab label */
hbox = gtk_hbox_new(TRUE, 0);
/* create a label for the page */
gtk_label_new_in_box(tab_label_text[n], hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
/* add page to the notebook */
gtk_notebook_append_page(GTK_NOTEBOOK(notebk), vert->windows[n], hbox);
/* set tab attributes */
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebk), hbox,
TRUE, TRUE, GTK_PACK_START);
}
/* determine initial page: pin, signal, or parameter */
if (( chan->data_source_type >= 0 ) && ( chan->data_source_type <= 2 )) {
initial_page = chan->data_source_type;
gtk_notebook_set_page(GTK_NOTEBOOK(notebk), initial_page);
} else {
initial_page = -1;
gtk_notebook_set_page(GTK_NOTEBOOK(notebk), 0);
}
gtk_widget_show(notebk);
/* populate the pin, signal, and parameter lists */
gtk_clist_clear(GTK_CLIST(vert->lists[0]));
gtk_clist_clear(GTK_CLIST(vert->lists[1]));
gtk_clist_clear(GTK_CLIST(vert->lists[2]));
rtapi_mutex_get(&(hal_data->mutex));
next = hal_data->pin_list_ptr;
initial_row = -1;
max_row = -1;
while (next != 0) {
pin = SHMPTR(next);
name = pin->name;
row = gtk_clist_append(GTK_CLIST(vert->lists[0]), &name);
if ( initial_page == 0 ) {
if ( strcmp(name, chan->name) == 0 ) {
initial_row = row;
}
max_row = row;
}
next = pin->next_ptr;
}
next = hal_data->sig_list_ptr;
while (next != 0) {
sig = SHMPTR(next);
name = sig->name;
row = gtk_clist_append(GTK_CLIST(vert->lists[1]), &name);
if ( initial_page == 1 ) {
if ( strcmp(name, chan->name) == 0 ) {
initial_row = row;
}
max_row = row;
}
next = sig->next_ptr;
}
next = hal_data->param_list_ptr;
while (next != 0) {
param = SHMPTR(next);
name = param->name;
row = gtk_clist_append(GTK_CLIST(vert->lists[2]), &name);
if ( initial_page == 2 ) {
if ( strcmp(name, chan->name) == 0 ) {
initial_row = row;
}
max_row = row;
}
next = param->next_ptr;
}
rtapi_mutex_give(&(hal_data->mutex));
if ( initial_row >= 0 ) {
/* highlight the currently selected name */
gtk_clist_select_row(GTK_CLIST(vert->lists[initial_page]), initial_row, -1);
/* set scrolling window to show the highlighted name */
/* FIXME - I can't seem to get this to work */
adj = vert->adjs[initial_page];
adj->value = adj->lower + (adj->upper - adj->lower)*((double)(initial_row)/(double)(max_row+1));
gtk_adjustment_value_changed(vert->adjs[initial_page]);
}
/* set up a callback function when the window is destroyed */
gtk_signal_connect(GTK_OBJECT(dialog.window), "destroy",
GTK_SIGNAL_FUNC(dialog_generic_destroyed), &dialog);
/* make Cancel button */
button = gtk_button_new_with_label(_("Cancel"));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->action_area),
button, TRUE, TRUE, 4);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(dialog_generic_button2), &dialog);
/* make window transient and modal */
gtk_window_set_transient_for(GTK_WINDOW(dialog.window),
GTK_WINDOW(ctrl_usr->main_win));
gtk_window_set_modal(GTK_WINDOW(dialog.window), TRUE);
gtk_widget_show_all(dialog.window);
gtk_main();
/* we get here when the user makes a selection, hits Cancel, or closes
the window */
vert->lists[0] = NULL;
vert->lists[1] = NULL;
vert->lists[2] = NULL;
if ((dialog.retval == 0) || (dialog.retval == 2)) {
/* user either closed dialog, or hit cancel */
return FALSE;
}
/* user made a selection */
channel_changed();
return TRUE;
}
GtkWidget * create_SkinBrowser( void )
{
GtkWidget * vbox5;
GtkWidget * scrolledwindow1;
GtkWidget * hbuttonbox4;
GtkWidget * Cancel;
GtkWidget * Ok;
GtkAccelGroup * accel_group;
accel_group = gtk_accel_group_new ();
SkinBrowser=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( SkinBrowser,MSGTR_SkinBrowser );
gtk_object_set_data( GTK_OBJECT( SkinBrowser ),MSGTR_SkinBrowser,SkinBrowser );
gtk_widget_set_usize( SkinBrowser,256,320 );
gtk_container_set_border_width( GTK_CONTAINER( SkinBrowser ),1 );
GTK_WIDGET_SET_FLAGS( SkinBrowser,GTK_CAN_DEFAULT );
gtk_widget_set_events( SkinBrowser,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_FOCUS_CHANGE_MASK | GDK_STRUCTURE_MASK | GDK_PROPERTY_CHANGE_MASK | GDK_VISIBILITY_NOTIFY_MASK );
gtk_window_set_title( GTK_WINDOW( SkinBrowser ),MSGTR_SkinBrowser );
gtk_window_set_position( GTK_WINDOW( SkinBrowser ),GTK_WIN_POS_CENTER );
gtk_window_set_policy( GTK_WINDOW( SkinBrowser ),FALSE,FALSE,TRUE );
gtk_window_set_wmclass( GTK_WINDOW( SkinBrowser ),"SkinBrowser","MPlayer" );
gtk_widget_realize( SkinBrowser );
gtkAddIcon( SkinBrowser );
vbox5=AddVBox( AddDialogFrame( SkinBrowser ),0 );
AddLabel( MSGTR_SKIN_LABEL,vbox5 );
AddHSeparator( vbox5 );
scrolledwindow1=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_set_name( scrolledwindow1,"scrolledwindow1" );
gtk_widget_ref( scrolledwindow1 );
gtk_object_set_data_full( GTK_OBJECT( SkinBrowser ),"scrolledwindow1",scrolledwindow1,(GtkDestroyNotify)gtk_widget_unref );
gtk_widget_show( scrolledwindow1 );
gtk_box_pack_start( GTK_BOX( vbox5 ),scrolledwindow1,TRUE,TRUE,0 );
gtk_container_set_border_width( GTK_CONTAINER( scrolledwindow1 ),2 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC );
SkinList=gtk_clist_new( 1 );
gtk_widget_set_name( SkinList,"SkinList" );
gtk_widget_ref( SkinList );
gtk_object_set_data_full( GTK_OBJECT( SkinBrowser ),"SkinList",SkinList,(GtkDestroyNotify)gtk_widget_unref );
gtk_widget_show( SkinList );
gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),SkinList );
gtk_clist_set_column_width( GTK_CLIST( SkinList ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( SkinList ),GTK_SELECTION_SINGLE );
gtk_clist_column_titles_hide( GTK_CLIST( SkinList ) );
gtk_clist_set_shadow_type( GTK_CLIST( SkinList ),GTK_SHADOW_ETCHED_OUT );
AddHSeparator( vbox5 );
hbuttonbox4=AddHButtonBox( vbox5 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox4 ),GTK_BUTTONBOX_SPREAD );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox4 ),10 );
Ok=AddButton( MSGTR_Ok,hbuttonbox4 );
Cancel=AddButton( MSGTR_Cancel,hbuttonbox4 );
gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE );
gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( SkinBrowser ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&SkinBrowser );
gtk_signal_connect( GTK_OBJECT( SkinList ),"select_row",GTK_SIGNAL_FUNC( on_SkinList_select_row ),NULL );
gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( prButton ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"clicked",GTK_SIGNAL_FUNC( prButton ),(void *)0 );
if ( ( sbMPlayerDirInHome=calloc( 1,strlen( skinDirInHome ) + 4 ) ) != NULL )
{ strcpy( sbMPlayerDirInHome,skinDirInHome ); strcat( sbMPlayerDirInHome,"/*" ); }
if ( ( sbMPlayerPrefixDir=calloc( 1,strlen( skinMPlayerDir ) + 4 ) ) != NULL )
{ strcpy( sbMPlayerPrefixDir,skinMPlayerDir ); strcat( sbMPlayerPrefixDir,"/*" ); }
gtk_window_add_accel_group( GTK_WINDOW( SkinBrowser ),accel_group );
gtk_widget_grab_focus( SkinList );
return SkinBrowser;
}
GtkWidget *
create_main_window(void)
{
GtkWidget *notebook1;
GtkWidget *frame3;
GtkWidget *frame4;
GtkWidget *hbox1;
GtkWidget *vbox1;
GtkWidget *scrolledwindow1;
GtkWidget *node_label1;
GtkWidget *node_label2;
GtkWidget *node_label3;
GtkWidget *node_label4;
GtkWidget *node_label7;
GtkWidget *node_label8;
GtkWidget *node_label9;
GtkWidget *mid_frame;
GtkWidget *mpr_frame;
GtkWidget *hna_frame;
GtkWidget *mid_scrolledwindow;
GtkWidget *mpr_scrolledwindow;
GtkWidget *hna_scrolledwindow;
GtkWidget *Main;
GtkWidget *label_routes;
GtkWidget *hbox2;
GtkWidget *frame2;
GtkWidget *scrolledwindow4;
GtkWidget *label17;
GtkWidget *label18;
GtkWidget *label19;
GtkWidget *scrolledwindow3;
GtkWidget *label13;
GtkWidget *label14;
GtkWidget *label15;
GtkWidget *label16;
GtkWidget *label_packets;
//GtkWidget *empty_notebook_page2;
GtkWidget *label3;
GtkWidget *net_vbox;
GtkWidget *pack_vbox;
GtkWidget *pack_disp_vbox;
GtkWidget *disp_frame;
GtkWidget *route_frame;
GtkWidget *route_stats_frame;
GtkWidget *route_scrolledwindow;
GtkWidget *route_label1;
GtkWidget *route_label2;
GtkWidget *route_label3;
GtkWidget *route_label4;
GtkWidget *route_hbox1;
GtkWidget *traffic_label;
GtkWidget *settings_label;
GtkWidget *settings_hbox1;
GtkWidget *about_hbox1;
GtkWidget *about_label;
GtkWidget *empty1;
GdkPixmap *unik_logo_gdk;
GtkWidget *unik_logo;
/*
*The main window
*/
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_object_set_data(GTK_OBJECT(main_window), "main_window", main_window);
gtk_window_set_title(GTK_WINDOW(main_window), (olsrd_version));
gtk_window_set_default_size(GTK_WINDOW(main_window), 600, 550);
gtk_signal_connect(GTK_OBJECT(main_window), "destroy", GTK_SIGNAL_FUNC(gui_shutdown),
//GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_window_set_position(GTK_WINDOW(main_window), GTK_WIN_POS_CENTER); /* Position window in center */
gtk_window_set_policy(GTK_WINDOW(main_window), FALSE, TRUE, TRUE); /* No user-resizing */
/*
*Initialize the pixmaps
*/
unik_logo_gdk =
gdk_pixmap_colormap_create_from_xpm_d(NULL, gtk_widget_get_colormap(main_window), &mask, NULL, (gchar **) logo_xpm);
unik_logo = gtk_pixmap_new(unik_logo_gdk, mask);
/*
*The notebook
*/
notebook1 = gtk_notebook_new();
gtk_widget_ref(notebook1);
gtk_object_set_data_full(GTK_OBJECT(main_window), "notebook1", notebook1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(notebook1);
gtk_container_add(GTK_CONTAINER(main_window), notebook1);
/*
*The first vbox
*/
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_widget_ref(vbox1);
gtk_object_set_data_full(GTK_OBJECT(main_window), "vbox1", vbox1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(vbox1);
//gtk_box_pack_start (GTK_BOX (hbox1), vbox1, TRUE, TRUE, 1);
gtk_container_add(GTK_CONTAINER(notebook1), vbox1);
/*
*The nodes frame
*/
frame3 = gtk_frame_new("Registered nodes:");
gtk_widget_ref(frame3);
gtk_object_set_data_full(GTK_OBJECT(main_window), "frame3", frame3, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(frame3);
gtk_box_pack_start(GTK_BOX(vbox1), frame3, TRUE, TRUE, 0);
gtk_widget_set_size_request(frame3, -1, 300);
gtk_container_set_border_width(GTK_CONTAINER(frame3), 1);
/*
*The scrolled window to contain the node list
*/
scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_ref(scrolledwindow1);
gtk_object_set_data_full(GTK_OBJECT(main_window), "scrolledwindow1", scrolledwindow1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(scrolledwindow1);
gtk_container_add(GTK_CONTAINER(frame3), scrolledwindow1);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (frame3), scrolledwindow1, TRUE, TRUE, 0);
//gtk_widget_set_usize (scrolledwindow1, -2, 332);
/*
*The node list
*/
node_list = gtk_clist_new(7);
gtk_widget_ref(node_list);
gtk_object_set_data_full(GTK_OBJECT(main_window), "node_list", node_list, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(node_list);
gtk_container_add(GTK_CONTAINER(scrolledwindow1), node_list);
gtk_clist_set_column_width(GTK_CLIST(node_list), 0, 150); /* IP */
//gtk_clist_set_column_justification(GTK_CLIST(node_list), 0, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(node_list), 1, 150); /* gateway */
//gtk_clist_set_column_justification(GTK_CLIST(node_list), 1, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(node_list), 2, 50); /* hopcount */
gtk_clist_set_column_justification(GTK_CLIST(node_list), 2, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(node_list), 3, 80); /* dev */
gtk_clist_set_column_justification(GTK_CLIST(node_list), 3, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(node_list), 4, 70); /* timer */
gtk_clist_set_column_justification(GTK_CLIST(node_list), 4, GTK_JUSTIFY_CENTER);
//gtk_clist_set_column_width (GTK_CLIST (node_list), 7, 100); /* last about */
//gtk_clist_set_column_justification(GTK_CLIST(node_list), 7, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(node_list), 5, 40); /* MID */
gtk_clist_set_column_justification(GTK_CLIST(node_list), 5, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(node_list), 6, 40); /* HNA */
gtk_clist_set_column_justification(GTK_CLIST(node_list), 6, GTK_JUSTIFY_CENTER);
gtk_clist_column_titles_show(GTK_CLIST(node_list));
/*
*Row selection callback
*/
gtk_signal_connect(GTK_OBJECT(node_list), "select_row", GTK_SIGNAL_FUNC(selection_made), NULL);
/*
*Column selection callback
*/
gtk_signal_connect(GTK_OBJECT(node_list), "click_column", GTK_SIGNAL_FUNC(column_clicked_callback), NULL);
node_label1 = gtk_label_new("Dest");
gtk_widget_ref(node_label1);
gtk_object_set_data_full(GTK_OBJECT(main_window), "IP", node_label1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(node_label1);
gtk_clist_set_column_widget(GTK_CLIST(node_list), 0, node_label1);
node_label2 = gtk_label_new("Gateway");
gtk_widget_ref(node_label2);
gtk_object_set_data_full(GTK_OBJECT(main_window), "hops", node_label2, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(node_label2);
gtk_clist_set_column_widget(GTK_CLIST(node_list), 1, node_label2);
node_label3 = gtk_label_new("Metric");
gtk_widget_ref(node_label3);
gtk_object_set_data_full(GTK_OBJECT(main_window), "info", node_label3, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(node_label3);
gtk_clist_set_column_widget(GTK_CLIST(node_list), 2, node_label3);
node_label4 = gtk_label_new("Device");
gtk_widget_ref(node_label4);
gtk_object_set_data_full(GTK_OBJECT(main_window), "Device", node_label4, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(node_label4);
gtk_clist_set_column_widget(GTK_CLIST(node_list), 3, node_label4);
node_label7 = gtk_label_new("Timer");
gtk_widget_ref(node_label7);
gtk_object_set_data_full(GTK_OBJECT(main_window), "LMF", node_label7, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(node_label7);
gtk_clist_set_column_widget(GTK_CLIST(node_list), 4, node_label7);
/*
node_label8 = gtk_label_new ("LMA");
gtk_widget_ref (node_label8);
gtk_object_set_data_full (GTK_OBJECT (main_window), "LMA", node_label8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (node_label8);
gtk_clist_set_column_widget (GTK_CLIST (node_list), 7, node_label8);
*/
node_label8 = gtk_label_new("MID");
gtk_widget_ref(node_label8);
gtk_object_set_data_full(GTK_OBJECT(main_window), "MID", node_label8, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(node_label8);
gtk_clist_set_column_widget(GTK_CLIST(node_list), 5, node_label8);
node_label9 = gtk_label_new("HNA");
gtk_widget_ref(node_label9);
gtk_object_set_data_full(GTK_OBJECT(main_window), "HNA", node_label9, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(node_label9);
gtk_clist_set_column_widget(GTK_CLIST(node_list), 6, node_label9);
gtk_clist_column_titles_active(GTK_CLIST(node_list));
gtk_widget_show_now(node_list);
/*
*Row selection callback
*/
gtk_signal_connect(GTK_OBJECT(node_list), "select_row", GTK_SIGNAL_FUNC(node_selection), NULL);
/*
*The first hbox
*/
hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_ref(hbox1);
gtk_object_set_data_full(GTK_OBJECT(main_window), "hbox1", hbox1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, FALSE, 0);
//gtk_container_add (GTK_CONTAINER (notebook1), hbox1);
gtk_container_set_border_width(GTK_CONTAINER(hbox1), 4);
gtk_widget_set_size_request(hbox1, -1, 200);
/*
*The net-info frame
*/
frame4 = gtk_frame_new("Info:");
gtk_widget_ref(frame4);
gtk_object_set_data_full(GTK_OBJECT(main_window), "frame4", frame4, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(frame4);
gtk_box_pack_start(GTK_BOX(hbox1), frame4, TRUE, TRUE, 0);
//gtk_widget_set_size_request(frame4, 200, -1);
gtk_container_set_border_width(GTK_CONTAINER(frame4), 1);
/*
*The net-info hbox
*/
net_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_ref(net_vbox);
gtk_object_set_data_full(GTK_OBJECT(main_window), "net_vbox", net_vbox, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(net_vbox);
gtk_container_add(GTK_CONTAINER(frame4), net_vbox);
/*
*The net-info label field
*/
net_label = gtk_label_new(NULL);
gtk_widget_ref(net_label);
gtk_misc_set_alignment((GtkMisc *) net_label, 0, 0);
//gtk_label_set_justify((GtkLabel *)net_label,GTK_JUSTIFY_LEFT);
gtk_object_set_data_full(GTK_OBJECT(main_window), "net_label", net_label, (GtkDestroyNotify) gtk_widget_unref);
//set_net_info("Not connected...");
gtk_widget_show(net_label);
gtk_box_pack_start(GTK_BOX(net_vbox), net_label, TRUE, TRUE, 0);
//gtk_container_add (GTK_CONTAINER (frame4), net_label);
/*
*The connect button
*/
connect_button = gtk_button_new_with_label("Connect to host");
gtk_widget_ref(connect_button);
gtk_object_set_data_full(GTK_OBJECT(main_window), "connect_button", connect_button, (GtkDestroyNotify) gtk_widget_unref);
/* Connect the "clicked" signal of the button to our callback */
gtk_signal_connect(GTK_OBJECT(connect_button), "clicked", GTK_SIGNAL_FUNC(connect_callback), NULL);
gtk_widget_show(connect_button);
gtk_box_pack_start(GTK_BOX(net_vbox), connect_button, FALSE, FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(connect_button), 5);
/*
*The node MPR info frame
*/
mpr_frame = gtk_frame_new("MPR:");
gtk_widget_ref(mpr_frame);
gtk_object_set_data_full(GTK_OBJECT(main_window), "mpr_frame", mpr_frame, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(mpr_frame);
gtk_box_pack_start(GTK_BOX(hbox1), mpr_frame, FALSE, FALSE, 0);
//gtk_widget_set_size_request(mid_frame, 125, -1);
gtk_container_set_border_width(GTK_CONTAINER(mpr_frame), 1);
/*
*The scrolledwindow to contain the MPR node info
*/
mpr_scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_ref(mpr_scrolledwindow);
gtk_object_set_data_full(GTK_OBJECT(main_window), "mpr_scrolledwindow", mpr_scrolledwindow, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(mpr_scrolledwindow);
gtk_container_add(GTK_CONTAINER(mpr_frame), mpr_scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(mpr_scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_set_border_width(GTK_CONTAINER(mpr_scrolledwindow), 3);
/*
*The node MID info frame
*/
mid_frame = gtk_frame_new("MID:");
gtk_widget_ref(mid_frame);
gtk_object_set_data_full(GTK_OBJECT(main_window), "mid_frame", mid_frame, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(mid_frame);
gtk_box_pack_start(GTK_BOX(hbox1), mid_frame, FALSE, FALSE, 0);
//gtk_widget_set_size_request(mid_frame, 125, -1);
gtk_container_set_border_width(GTK_CONTAINER(mid_frame), 1);
/*
*The scrolledwindow to contain the MID node info
*/
mid_scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_ref(mid_scrolledwindow);
gtk_object_set_data_full(GTK_OBJECT(main_window), "mid_scrolledwindow", mid_scrolledwindow, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(mid_scrolledwindow);
gtk_container_add(GTK_CONTAINER(mid_frame), mid_scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(mid_scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_set_border_width(GTK_CONTAINER(mid_scrolledwindow), 3);
/*
*The MPR list
*/
mpr_list = gtk_clist_new(1);
gtk_widget_ref(mpr_list);
gtk_object_set_data_full(GTK_OBJECT(main_window), "mpr_list", mpr_list, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(mpr_list);
gtk_container_add(GTK_CONTAINER(mpr_scrolledwindow), mpr_list);
gtk_clist_set_column_width(GTK_CLIST(mpr_list), 0, 120); /* IP */
gtk_clist_column_titles_hide(GTK_CLIST(mpr_list));
/*
*The MID list
*/
mid_list = gtk_clist_new(1);
gtk_widget_ref(mid_list);
gtk_object_set_data_full(GTK_OBJECT(main_window), "mid_list", mid_list, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(mid_list);
gtk_container_add(GTK_CONTAINER(mid_scrolledwindow), mid_list);
gtk_clist_set_column_width(GTK_CLIST(mid_list), 0, 120); /* IP */
gtk_clist_column_titles_hide(GTK_CLIST(mid_list));
/*
*The node HNA info frame
*/
hna_frame = gtk_frame_new("HNA:");
gtk_widget_ref(hna_frame);
gtk_object_set_data_full(GTK_OBJECT(main_window), "hna_frame", hna_frame, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(hna_frame);
gtk_box_pack_start(GTK_BOX(hbox1), hna_frame, FALSE, FALSE, 0);
//gtk_widget_set_size_request(mid_frame, 125, -1);
gtk_container_set_border_width(GTK_CONTAINER(hna_frame), 1);
/*
*The HNA scrolled window
*/
hna_scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_ref(hna_scrolledwindow);
gtk_object_set_data_full(GTK_OBJECT(main_window), "hna_scrolledwindow", hna_scrolledwindow, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(hna_scrolledwindow);
gtk_container_add(GTK_CONTAINER(hna_frame), hna_scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(hna_scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_set_border_width(GTK_CONTAINER(hna_scrolledwindow), 3);
/*
*The HNA list
*/
hna_list = gtk_clist_new(1);
gtk_widget_ref(hna_list);
gtk_object_set_data_full(GTK_OBJECT(main_window), "hna_list", hna_list, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(hna_list);
gtk_container_add(GTK_CONTAINER(hna_scrolledwindow), hna_list);
gtk_clist_set_column_width(GTK_CLIST(hna_list), 0, 120); /* IP */
gtk_clist_column_titles_hide(GTK_CLIST(hna_list));
/*
*The "main" notebook page
*/
Main = gtk_label_new("Main");
gtk_widget_ref(Main);
gtk_object_set_data_full(GTK_OBJECT(main_window), "Main", Main, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(Main);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 0), Main);
/*
*The main hbox of the Packet page
*/
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_widget_ref(hbox2);
gtk_object_set_data_full(GTK_OBJECT(main_window), "hbox2", hbox2, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(hbox2);
gtk_container_add(GTK_CONTAINER(notebook1), hbox2);
/*
*The packet hbox
*/
pack_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_ref(pack_vbox);
gtk_object_set_data_full(GTK_OBJECT(main_window), "pack_vbox", pack_vbox, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(pack_vbox);
gtk_box_pack_start(GTK_BOX(hbox2), pack_vbox, TRUE, TRUE, 0);
/*
*The packet frame
*/
frame2 = gtk_frame_new("Packet");
gtk_widget_ref(frame2);
gtk_object_set_data_full(GTK_OBJECT(main_window), "frame2", frame2, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(frame2);
gtk_box_pack_start(GTK_BOX(pack_vbox), frame2, TRUE, TRUE, 0); /* Do not expand */
/*
*Packet list scrolled window
*/
scrolledwindow4 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_ref(scrolledwindow4);
gtk_object_set_data_full(GTK_OBJECT(main_window), "scrolledwindow4", scrolledwindow4, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(scrolledwindow4);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow4), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(frame2), scrolledwindow4);
/*
*The packet list
*/
packet_list = gtk_clist_new(3);
gtk_widget_ref(packet_list);
gtk_object_set_data_full(GTK_OBJECT(main_window), "packet_list", packet_list, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(packet_list);
gtk_container_add(GTK_CONTAINER(scrolledwindow4), packet_list);
gtk_clist_set_column_width(GTK_CLIST(packet_list), 0, 80); /* Type */
gtk_clist_set_column_width(GTK_CLIST(packet_list), 1, 150); /* Origin IP */
gtk_clist_set_column_width(GTK_CLIST(packet_list), 2, 20); /* size */
gtk_clist_column_titles_show(GTK_CLIST(packet_list));
label17 = gtk_label_new("Type");
gtk_widget_ref(label17);
gtk_object_set_data_full(GTK_OBJECT(main_window), "label17", label17, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(label17);
gtk_clist_set_column_widget(GTK_CLIST(packet_list), 0, label17);
label18 = gtk_label_new("Origin");
gtk_widget_ref(label18);
gtk_object_set_data_full(GTK_OBJECT(main_window), "label18", label18, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(label18);
gtk_clist_set_column_widget(GTK_CLIST(packet_list), 1, label18);
label19 = gtk_label_new("Size");
gtk_widget_ref(label19);
gtk_object_set_data_full(GTK_OBJECT(main_window), "label19", label19, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(label19);
gtk_clist_set_column_widget(GTK_CLIST(packet_list), 2, label19);
/*
*Row selection callback
*/
gtk_signal_connect(GTK_OBJECT(packet_list), "select_row", GTK_SIGNAL_FUNC(packet_selection), NULL);
/*
*The packet button
*/
packet_button = gtk_button_new_with_label("Grab packets");
gtk_widget_ref(packet_button);
gtk_object_set_data_full(GTK_OBJECT(main_window), "packet_button", packet_button, (GtkDestroyNotify) gtk_widget_unref);
/* Connect the "clicked" signal of the button to our callback */
gtk_signal_connect(GTK_OBJECT(packet_button), "clicked", GTK_SIGNAL_FUNC(packet_callback), NULL);
gtk_widget_show(packet_button);
gtk_box_pack_start(GTK_BOX(pack_vbox), packet_button, FALSE, FALSE, 5);
/*
*The packet disp hbox
*/
pack_disp_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_ref(pack_disp_vbox);
gtk_object_set_data_full(GTK_OBJECT(main_window), "pack_disp_vbox", pack_disp_vbox, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(pack_disp_vbox);
gtk_box_pack_start(GTK_BOX(hbox2), pack_disp_vbox, TRUE, TRUE, 0);
/*
*The packet disp frame
*/
disp_frame = gtk_frame_new("Packet content");
gtk_widget_ref(disp_frame);
gtk_object_set_data_full(GTK_OBJECT(main_window), "disp_frame", disp_frame, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(disp_frame);
gtk_box_pack_start(GTK_BOX(pack_disp_vbox), disp_frame, TRUE, TRUE, 0); /* Do not expand */
/*
*Scrolled window for the packet display
*list
*/
scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_ref(scrolledwindow3);
gtk_object_set_data_full(GTK_OBJECT(main_window), "scrolledwindow3", scrolledwindow3, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(scrolledwindow3);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow3), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(disp_frame), scrolledwindow3);
//gtk_box_pack_start (GTK_BOX (disp_frame), scrolledwindow3, TRUE, TRUE, 0);
/*
*The packet display list
*/
packet_content_list = gtk_clist_new(4);
gtk_widget_ref(packet_content_list);
gtk_object_set_data_full(GTK_OBJECT(main_window), "packet_content_list", packet_content_list,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(packet_content_list);
gtk_container_add(GTK_CONTAINER(scrolledwindow3), packet_content_list);
gtk_clist_set_column_width(GTK_CLIST(packet_content_list), 0, 70); /* 0-7 */
gtk_clist_set_column_justification(GTK_CLIST(packet_content_list), 0, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(packet_content_list), 1, 70); /* 8-15 */
gtk_clist_set_column_justification(GTK_CLIST(packet_content_list), 1, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(packet_content_list), 2, 70); /* 16-23 */
gtk_clist_set_column_justification(GTK_CLIST(packet_content_list), 2, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(packet_content_list), 3, 70); /* 24-31 */
gtk_clist_set_column_justification(GTK_CLIST(packet_content_list), 3, GTK_JUSTIFY_CENTER);
gtk_clist_column_titles_show(GTK_CLIST(packet_content_list));
label13 = gtk_label_new("0 - 7");
gtk_widget_ref(label13);
gtk_object_set_data_full(GTK_OBJECT(main_window), "label13", label13, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(label13);
gtk_clist_set_column_widget(GTK_CLIST(packet_content_list), 0, label13);
label14 = gtk_label_new("8 - 15");
gtk_widget_ref(label14);
gtk_object_set_data_full(GTK_OBJECT(main_window), "label14", label14, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(label14);
gtk_clist_set_column_widget(GTK_CLIST(packet_content_list), 1, label14);
label15 = gtk_label_new("16 - 23");
gtk_widget_ref(label15);
gtk_object_set_data_full(GTK_OBJECT(main_window), "label15", label15, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(label15);
gtk_clist_set_column_widget(GTK_CLIST(packet_content_list), 2, label15);
label16 = gtk_label_new("24 - 31");
gtk_widget_ref(label16);
gtk_object_set_data_full(GTK_OBJECT(main_window), "label16", label16, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(label16);
gtk_clist_set_column_widget(GTK_CLIST(packet_content_list), 3, label16);
//gtk_clist_set_selection_mode(GTK_CLIST (packet_content_list), GTK_SELECTION_NONE); /* no selections */
/*
*The packet button
*/
packet_disp_button = gtk_button_new_with_label("Display hex");
gtk_widget_ref(packet_disp_button);
gtk_object_set_data_full(GTK_OBJECT(main_window), "packet_disp_button", packet_disp_button, (GtkDestroyNotify) gtk_widget_unref);
/* Connect the "clicked" signal of the button to our callback */
gtk_signal_connect(GTK_OBJECT(packet_disp_button), "clicked", GTK_SIGNAL_FUNC(packet_disp_callback), NULL);
gtk_widget_show(packet_disp_button);
gtk_box_pack_start(GTK_BOX(pack_disp_vbox), packet_disp_button, FALSE, FALSE, 5);
/*
*The "packets" notebook
*/
label_packets = gtk_label_new("Packets");
gtk_widget_ref(label_packets);
gtk_object_set_data_full(GTK_OBJECT(main_window), "label_packets", label_packets, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(label_packets);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 1), label_packets);
/*
*The route hbox
*/
route_hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_ref(route_hbox1);
gtk_object_set_data_full(GTK_OBJECT(main_window), "route_hbox1", route_hbox1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(route_hbox1);
//gtk_box_pack_start (GTK_BOX (hbox1), vbox1, TRUE, TRUE, 1);
gtk_container_add(GTK_CONTAINER(notebook1), route_hbox1);
/*
*The routes frame
*/
route_frame = gtk_frame_new("OLSR routes in kernel:");
gtk_widget_ref(route_frame);
gtk_object_set_data_full(GTK_OBJECT(main_window), "route_frame", route_frame, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(route_frame);
//gtk_container_add (GTK_CONTAINER (notebook1), route_frame);
gtk_widget_set_size_request(route_frame, 200, -1);
gtk_box_pack_start(GTK_BOX(route_hbox1), route_frame, TRUE, TRUE, 0); /* Do not expand */
/*
*Scrolled window for the packet display
*list
*/
route_scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_ref(route_scrolledwindow);
gtk_object_set_data_full(GTK_OBJECT(main_window), "route_scrolledwindow", route_scrolledwindow,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(route_scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(route_scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(route_frame), route_scrolledwindow);
//gtk_box_pack_start (GTK_BOX (route_frame), scrolledwindow3, TRUE, TRUE, 0);
/*
*The routes display list
*/
route_list = gtk_clist_new(4);
gtk_widget_ref(route_list);
gtk_object_set_data_full(GTK_OBJECT(main_window), "route_list", route_list, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(route_list);
gtk_container_add(GTK_CONTAINER(route_scrolledwindow), route_list);
gtk_clist_set_column_width(GTK_CLIST(route_list), 0, 120); /* dest */
//gtk_clist_set_column_justification(GTK_CLIST (route_list), 0, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(route_list), 1, 120); /* gw */
//gtk_clist_set_column_justification(GTK_CLIST (route_list), 1, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(route_list), 2, 50); /* weight */
gtk_clist_set_column_justification(GTK_CLIST(route_list), 2, GTK_JUSTIFY_CENTER);
gtk_clist_set_column_width(GTK_CLIST(route_list), 3, 70); /* interface */
gtk_clist_set_column_justification(GTK_CLIST(route_list), 3, GTK_JUSTIFY_CENTER);
gtk_clist_column_titles_show(GTK_CLIST(route_list));
route_label1 = gtk_label_new("Destination");
gtk_widget_ref(route_label1);
gtk_object_set_data_full(GTK_OBJECT(main_window), "route_label1", route_label1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(route_label1);
gtk_clist_set_column_widget(GTK_CLIST(route_list), 0, route_label1);
route_label2 = gtk_label_new("Gateway");
gtk_widget_ref(route_label2);
gtk_object_set_data_full(GTK_OBJECT(main_window), "route_label2", route_label2, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(route_label2);
gtk_clist_set_column_widget(GTK_CLIST(route_list), 1, route_label2);
route_label3 = gtk_label_new("Weight");
gtk_widget_ref(route_label3);
gtk_object_set_data_full(GTK_OBJECT(main_window), "route_label3", route_label3, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(route_label3);
gtk_clist_set_column_widget(GTK_CLIST(route_list), 2, route_label3);
route_label4 = gtk_label_new("Interface");
gtk_widget_ref(route_label4);
gtk_object_set_data_full(GTK_OBJECT(main_window), "route_label4", route_label4, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(route_label4);
gtk_clist_set_column_widget(GTK_CLIST(route_list), 3, route_label4);
//gtk_clist_set_selection_mode(GTK_CLIST (route_list), GTK_SELECTION_NONE); /* no selections */
/*
*The routes stats frame
*/
route_stats_frame = gtk_frame_new("Stats:");
gtk_widget_ref(route_stats_frame);
gtk_object_set_data_full(GTK_OBJECT(main_window), "route_stats_frame", route_stats_frame, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(route_stats_frame);
//gtk_container_add (GTK_CONTAINER (notebook1), route_frame);
gtk_box_pack_start(GTK_BOX(route_hbox1), route_stats_frame, TRUE, TRUE, 1);
/*
*The "routes" notebook
*/
label_routes = gtk_label_new("Routes");
gtk_widget_ref(label_routes);
gtk_object_set_data_full(GTK_OBJECT(main_window), "label_routes", label_routes, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(label_routes);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 2), label_routes);
empty1 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(empty1);
gtk_container_add(GTK_CONTAINER(notebook1), empty1);
/*
*The "traffic" notebook
*/
traffic_label = gtk_label_new("Traffic");
gtk_widget_ref(traffic_label);
gtk_object_set_data_full(GTK_OBJECT(main_window), "traffic_label", traffic_label, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(traffic_label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 3), traffic_label);
/*
*The settings hbox
*/
settings_hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_ref(settings_hbox1);
gtk_object_set_data_full(GTK_OBJECT(main_window), "settings_hbox1", settings_hbox1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(settings_hbox1);
//gtk_box_pack_start (GTK_BOX (hbox1), vbox1, TRUE, TRUE, 1);
gtk_container_add(GTK_CONTAINER(notebook1), settings_hbox1);
/*
*The settings-info label field
*/
info_label = gtk_label_new(NULL);
gtk_widget_ref(info_label);
gtk_misc_set_alignment((GtkMisc *) info_label, 0, 0);
//gtk_label_set_justify((GtkLabel *)net_label,GTK_JUSTIFY_LEFT);
gtk_object_set_data_full(GTK_OBJECT(main_window), "info_label", info_label, (GtkDestroyNotify) gtk_widget_unref);
//set_net_info("Not connected...");
gtk_widget_show(info_label);
gtk_box_pack_start(GTK_BOX(settings_hbox1), info_label, TRUE, TRUE, 0);
/*
*The "settings" notebook
*/
settings_label = gtk_label_new("Settings");
gtk_widget_ref(settings_label);
gtk_object_set_data_full(GTK_OBJECT(main_window), "settings_label", settings_label, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(settings_label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 4), settings_label);
/*
*The "about" hbox
*/
about_hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_ref(about_hbox1);
gtk_object_set_data_full(GTK_OBJECT(main_window), "about_hbox1", about_hbox1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(about_hbox1);
//gtk_box_pack_start (GTK_BOX (hbox1), vbox1, TRUE, TRUE, 1);
gtk_container_add(GTK_CONTAINER(notebook1), about_hbox1);
gtk_container_set_border_width(GTK_CONTAINER(about_hbox1), 10);
/*
*The about label field
*/
about_label = gtk_label_new(NULL);
gtk_widget_ref(about_label);
gtk_misc_set_alignment((GtkMisc *) about_label, 0, 0);
gtk_label_set_justify((GtkLabel *) about_label, GTK_JUSTIFY_CENTER);
gtk_object_set_data_full(GTK_OBJECT(main_window), "about_label", about_label, (GtkDestroyNotify) gtk_widget_unref);
//set_net_info("Not connected...");
gtk_widget_show(about_label);
gtk_box_pack_start(GTK_BOX(about_hbox1), unik_logo, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(about_hbox1), about_label, TRUE, TRUE, 0);
gtk_widget_show(unik_logo);
gtk_label_set_text((GtkLabel *) about_label, "OLSRD-GUI by Andreas Tonnesen ([email protected])");
/*
*The "about" notebook
*/
label3 = gtk_label_new("About");
gtk_widget_ref(label3);
gtk_object_set_data_full(GTK_OBJECT(main_window), "About", label3, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(label3);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook1), gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook1), 5), label3);
return main_window;
}
void
create_translatorchooser (HWND hwnd, TTRANSLATORCHOOSER *choose_t)
{
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
GtkWidget *translatorchooser;
GtkWidget *vbox41;
GtkWidget *hbox57;
GtkWidget *frame97;
GtkWidget *alignment81;
GtkWidget *pixmap1;
GtkWidget *frame98;
GtkWidget *alignment82;
GtkWidget *scrolledwindow21;
GtkWidget *clist1;
GtkWidget *label158;
GtkWidget *label159;
GtkWidget *label160;
GtkWidget *label161;
GtkWidget *label162;
GtkWidget *hbuttonbox3;
GtkWidget *b_finish;
GtkWidget *b_cancel;
if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
return;
translatorchooser = gtk_dialog_new ();
gtk_widget_set_name (translatorchooser, "translatorchooser");
gtk_widget_set_size_request (translatorchooser, 515, 335);
gtk_window_set_title (GTK_WINDOW (translatorchooser), _("Choose a Translator"));
gtk_window_set_position (GTK_WINDOW (translatorchooser), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal (GTK_WINDOW (translatorchooser), TRUE);
gtk_window_set_default_size (GTK_WINDOW (translatorchooser), 600, 450);
gtk_window_set_type_hint (GTK_WINDOW (translatorchooser), GDK_WINDOW_TYPE_HINT_DIALOG);
#if GTK_CHECK_VERSION(2,0,0)
gtk_widget_show (translatorchooser);
#endif
vbox41 = GTK_DIALOG (translatorchooser)->vbox;
gtk_widget_set_name (vbox41, "vbox41");
gtk_widget_show (vbox41);
hbox57 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox57, "hbox57");
gtk_widget_show (hbox57);
gtk_box_pack_start (GTK_BOX (vbox41), hbox57, TRUE, TRUE, 0);
frame97 = gtk_frame_new (NULL);
gtk_widget_set_name (frame97, "frame97");
gtk_widget_show (frame97);
gtk_box_pack_start (GTK_BOX (hbox57), frame97, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame97), 10);
gtk_frame_set_shadow_type (GTK_FRAME (frame97), GTK_SHADOW_NONE);
alignment81 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment81, "alignment81");
gtk_widget_show (alignment81);
gtk_container_add (GTK_CONTAINER (frame97), alignment81);
gtk_widget_set_size_request (alignment81, 140, -1);
#if GTK_CHECK_VERSION(2,0,0)
style = gtk_widget_get_style (translatorchooser);
pixmap =
gdk_pixmap_create_from_xpm_d (translatorchooser->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) img_xpm);
#else
style = gtk_widget_get_style (GTK_WIDGET (hwnd));
pixmap =
gdk_pixmap_create_from_xpm_d (GTK_WIDGET (hwnd)->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) img_xpm);
#endif
pixmap1 = gtk_pixmap_new (pixmap, mask);
gtk_widget_set_name (pixmap1, "pixmap1");
gtk_widget_show (pixmap1);
gtk_container_add (GTK_CONTAINER (alignment81), pixmap1);
frame98 = gtk_frame_new (NULL);
gtk_widget_set_name (frame98, "frame98");
gtk_widget_show (frame98);
gtk_box_pack_start (GTK_BOX (hbox57), frame98, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame98), GTK_SHADOW_NONE);
alignment82 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment82, "alignment82");
gtk_widget_show (alignment82);
gtk_container_add (GTK_CONTAINER (frame98), alignment82);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment82), 0, 10, 0, 0);
scrolledwindow21 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_name (scrolledwindow21, "scrolledwindow21");
gtk_widget_show (scrolledwindow21);
gtk_container_add (GTK_CONTAINER (alignment82), scrolledwindow21);
clist1 = gtk_clist_new (4);
gtk_widget_set_name (clist1, "clist1");
gtk_widget_show (clist1);
gtk_container_add (GTK_CONTAINER (scrolledwindow21), clist1);
gtk_clist_set_column_width (GTK_CLIST (clist1), 0, 165);
gtk_clist_set_column_width (GTK_CLIST (clist1), 1, 118);
gtk_clist_set_column_width (GTK_CLIST (clist1), 2, 80);
gtk_clist_set_column_width (GTK_CLIST (clist1), 3, 80);
gtk_clist_column_titles_show (GTK_CLIST (clist1));
label158 = gtk_label_new (_("Name"));
gtk_widget_set_name (label158, "label158");
gtk_widget_show (label158);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 0, label158);
gtk_widget_set_size_request (label158, 165, -1);
label159 = gtk_label_new (_("File"));
gtk_widget_set_name (label159, "label159");
gtk_widget_show (label159);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 1, label159);
gtk_widget_set_size_request (label159, 118, -1);
label160 = gtk_label_new (_("Date"));
gtk_widget_set_name (label160, "label160");
gtk_widget_show (label160);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 2, label160);
gtk_widget_set_size_request (label160, 80, -1);
label161 = gtk_label_new (_("Size"));
gtk_widget_set_name (label161, "label161");
gtk_widget_show (label161);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 3, label161);
gtk_widget_set_size_request (label161, 80, -1);
label162 = gtk_label_new (_("Select which ODBC Translator you want to use"));
gtk_widget_set_name (label162, "label162");
gtk_widget_show (label162);
gtk_frame_set_label_widget (GTK_FRAME (frame98), label162);
gtk_label_set_use_markup (GTK_LABEL (label162), TRUE);
hbuttonbox3 = GTK_DIALOG (translatorchooser)->action_area;
gtk_widget_set_name (hbuttonbox3, "hbuttonbox3");
gtk_widget_show (hbuttonbox3);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox3), GTK_BUTTONBOX_END);
b_finish = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_set_name (b_finish, "b_finish");
gtk_widget_show (b_finish);
gtk_dialog_add_action_widget (GTK_DIALOG (translatorchooser), b_finish, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (b_finish, GTK_CAN_DEFAULT);
b_cancel = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_set_name (b_cancel, "b_cancel");
gtk_widget_show (b_cancel);
gtk_dialog_add_action_widget (GTK_DIALOG (translatorchooser), b_cancel, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (translatorchooser, translatorchooser, "translatorchooser");
GLADE_HOOKUP_OBJECT_NO_REF (translatorchooser, vbox41, "vbox41");
GLADE_HOOKUP_OBJECT (translatorchooser, hbox57, "hbox57");
GLADE_HOOKUP_OBJECT (translatorchooser, frame97, "frame97");
GLADE_HOOKUP_OBJECT (translatorchooser, alignment81, "alignment81");
GLADE_HOOKUP_OBJECT (translatorchooser, pixmap1, "pixmap1");
GLADE_HOOKUP_OBJECT (translatorchooser, frame98, "frame98");
GLADE_HOOKUP_OBJECT (translatorchooser, alignment82, "alignment82");
GLADE_HOOKUP_OBJECT (translatorchooser, scrolledwindow21, "scrolledwindow21");
GLADE_HOOKUP_OBJECT (translatorchooser, clist1, "clist1");
GLADE_HOOKUP_OBJECT (translatorchooser, label158, "label158");
GLADE_HOOKUP_OBJECT (translatorchooser, label159, "label159");
GLADE_HOOKUP_OBJECT (translatorchooser, label160, "label160");
GLADE_HOOKUP_OBJECT (translatorchooser, label161, "label161");
GLADE_HOOKUP_OBJECT (translatorchooser, label162, "label162");
GLADE_HOOKUP_OBJECT_NO_REF (translatorchooser, hbuttonbox3, "hbuttonbox3");
GLADE_HOOKUP_OBJECT (translatorchooser, b_finish, "b_finish");
GLADE_HOOKUP_OBJECT (translatorchooser, b_cancel, "b_cancel");
/* Ok button events */
gtk_signal_connect (GTK_OBJECT (b_finish), "clicked",
GTK_SIGNAL_FUNC (translatorchooser_ok_clicked), choose_t);
/* Cancel button events */
gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked",
GTK_SIGNAL_FUNC (translatorchooser_cancel_clicked), choose_t);
/* Close window button events */
gtk_signal_connect (GTK_OBJECT (translatorchooser), "delete_event",
GTK_SIGNAL_FUNC (delete_event), choose_t);
gtk_signal_connect (GTK_OBJECT (translatorchooser), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
/* Translator list events */
gtk_signal_connect (GTK_OBJECT (clist1), "select_row",
GTK_SIGNAL_FUNC (translator_list_select), choose_t);
addtranslators_to_list (clist1, translatorchooser);
choose_t->translatorlist = clist1;
choose_t->translator = NULL;
choose_t->mainwnd = translatorchooser;
choose_t->b_finish = b_finish;
gtk_widget_show_all (translatorchooser);
gtk_main ();
}
int
nsComponentsDlg::Show(int aDirection)
{
int err = OK;
int customSTIndex = 0, i;
int numRows = 0;
int currRow = 0;
GtkWidget *hbox = NULL;
XI_VERIFY(gCtx);
XI_VERIFY(gCtx->notebook);
if (mWidgetsInit == FALSE)
{
customSTIndex = gCtx->sdlg->GetNumSetupTypes();
sCustomST = gCtx->sdlg->GetSetupTypeList();
for (i=1; i<customSTIndex; i++)
sCustomST = sCustomST->GetNext();
DUMP(sCustomST->GetDescShort());
// create a new table and add it as a page of the notebook
mTable = gtk_table_new(5, 1, FALSE);
gtk_notebook_append_page(GTK_NOTEBOOK(gCtx->notebook), mTable, NULL);
mPageNum = gtk_notebook_get_current_page(GTK_NOTEBOOK(gCtx->notebook));
gtk_widget_show(mTable);
// 1st row: a label (msg0)
// insert a static text widget in the first row
GtkWidget *msg0 = gtk_label_new(mMsg0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), msg0, FALSE, FALSE, 0);
gtk_widget_show(hbox);
gtk_table_attach(GTK_TABLE(mTable), hbox, 0, 1, 1, 2,
static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND),
GTK_FILL, 20, 20);
gtk_widget_show(msg0);
// 2nd row: a CList with a check box for each row (short desc)
GtkWidget *list = NULL;
GtkWidget *scrollwin = NULL;
GtkStyle *style = NULL;
GdkBitmap *ch_mask = NULL;
GdkPixmap *checked = NULL;
GdkBitmap *un_mask = NULL;
GdkPixmap *unchecked = NULL;
gchar *dummy[2] = { " ", " " };
nsComponent *currComp = sCustomST->GetComponents()->GetHead();
GtkWidget *descLongTable = NULL;
GtkWidget *frame = NULL;
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
list = gtk_clist_new(2);
gtk_clist_set_selection_mode(GTK_CLIST(list), GTK_SELECTION_BROWSE);
gtk_clist_column_titles_hide(GTK_CLIST(list));
gtk_clist_set_column_auto_resize(GTK_CLIST(list), 0, TRUE);
gtk_clist_set_column_auto_resize(GTK_CLIST(list), 1, TRUE);
// determine number of rows we'll need
numRows = sCustomST->GetComponents()->GetLengthVisible();
for (i = 0; i < numRows; i++)
gtk_clist_append(GTK_CLIST(list), dummy);
style = gtk_widget_get_style(gCtx->window);
checked = gdk_pixmap_create_from_xpm_d(gCtx->window->window, &ch_mask,
&style->bg[GTK_STATE_NORMAL], (gchar **)check_on_xpm);
unchecked = gdk_pixmap_create_from_xpm_d(gCtx->window->window, &un_mask,
&style->bg[GTK_STATE_NORMAL], (gchar **)check_off_xpm);
while ((currRow < numRows) && currComp) // paranoia!
{
if (!currComp->IsInvisible())
{
if (currComp->IsSelected())
gtk_clist_set_pixmap(GTK_CLIST(list), currRow, 0,
checked, ch_mask);
else
gtk_clist_set_pixmap(GTK_CLIST(list), currRow, 0,
unchecked, un_mask);
gtk_clist_set_text(GTK_CLIST(list), currRow, 1,
currComp->GetDescShort());
currRow++;
}
currComp = currComp->GetNext();
}
// by default, first row selected upon Show()
sCurrRowSelected = 0;
gtk_signal_connect(GTK_OBJECT(list), "select_row",
GTK_SIGNAL_FUNC(RowSelected), NULL);
gtk_signal_connect(GTK_OBJECT(list), "key_press_event",
GTK_SIGNAL_FUNC(KeyPressed), NULL);
gtk_container_add(GTK_CONTAINER(scrollwin), list);
gtk_widget_show(list);
gtk_widget_show(scrollwin);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), scrollwin, TRUE, TRUE, 0);
gtk_widget_show(hbox);
gtk_table_attach(GTK_TABLE(mTable), hbox, 0, 1, 2, 3,
static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND),
static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL),
20, 0);
// XXX 3rd row: labels for ds avail and ds reqd
// 4th row: a frame with a label (long desc)
descLongTable = gtk_table_new(1, 1, FALSE);
gtk_widget_show(descLongTable);
gtk_table_attach(GTK_TABLE(mTable), descLongTable, 0, 1, 4, 5,
static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL),
static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL),
20, 20);
frame = gtk_frame_new(gCtx->Res("DESCRIPTION"));
gtk_table_attach_defaults(GTK_TABLE(descLongTable), frame, 0, 1, 0, 1);
gtk_widget_show(frame);
sDescLong = gtk_label_new(
sCustomST->GetComponents()->GetFirstVisible()->GetDescLong());
gtk_label_set_line_wrap(GTK_LABEL(sDescLong), TRUE);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), sDescLong, FALSE, FALSE, 20);
gtk_widget_show(hbox);
gtk_table_attach_defaults(GTK_TABLE(descLongTable), hbox, 0, 1, 0, 1);
gtk_widget_show(sDescLong);
mWidgetsInit = TRUE;
}
else
{
gtk_notebook_set_page(GTK_NOTEBOOK(gCtx->notebook), mPageNum);
gtk_widget_show(mTable);
}
// signal connect the buttons
gCtx->backID = gtk_signal_connect(GTK_OBJECT(gCtx->back), "clicked",
GTK_SIGNAL_FUNC(nsComponentsDlg::Back), gCtx->cdlg);
gCtx->nextID = gtk_signal_connect(GTK_OBJECT(gCtx->next), "clicked",
GTK_SIGNAL_FUNC(nsComponentsDlg::Next), gCtx->cdlg);
// show back btn again after setup type dlg where we couldn't go back
gtk_widget_set_sensitive(gCtx->back, TRUE);
if (aDirection == nsXInstallerDlg::BACKWARD_MOVE) // from install dlg
gtk_button_set_label(GTK_BUTTON(gCtx->next), GTK_STOCK_GO_FORWARD);
return err;
}
MedSLTDocWindow::MedSLTDocWindow(MedSLTDocWindowObserver& observer)
: m_observer(observer),
m_list_index(0),
m_list_items(0),
m_is_fullscreen(FALSE),
m_back_translation(""),
m_ui_state(UI_STATE_DISCONNECTED),
m_wrap_position(5)
{
ACE_TRACE("[MedSLTDocWindow::MedSLTDocWindow()]");
GtkBox* hbox;
GtkBox* coverbox;
GtkBox* textbox;
GtkBox* buthbox;
GtkWidget* menu;
GtkWidget* appimage;
GtkWidget* scroll1;
GtkWidget* scroll2;
GtkWidget* scroll3;
PangoFontDescription* font1;
PangoFontDescription* font2;
//GtkStyle* style;
GtkAccelGroup* accel = gtk_accel_group_new();
// Window
#ifdef _MAEMO
m_window = GTK_WINDOW(hildon_window_new());
#else
m_window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_default_size(m_window, 450, -1);
#endif
gtk_window_add_accel_group(m_window, accel);
gtk_window_set_icon_from_file(m_window, app_icon, NULL);
gtk_container_set_border_width(GTK_CONTAINER(m_window), 5);
// Boxes
coverbox = GTK_BOX(gtk_vbox_new(False, 5));
hbox = GTK_BOX(gtk_hbox_new(False, 5));
textbox = GTK_BOX(gtk_vbox_new(False, 5));
buthbox = GTK_BOX(gtk_vbox_new(False, 5));
// Image
appimage = gtk_image_new_from_file(app_icon_big);
// Fonts
font1 = pango_font_description_from_string("Monospace Bold 21");
font2 = pango_font_description_from_string("Monospace Bold 16");
// Lists
m_list = gtk_clist_new(1);
gtk_widget_set_size_request(GTK_WIDGET(m_list), 550, 180);
gtk_clist_set_row_height((GtkCList*)m_list, 65);
gtk_widget_modify_font(m_list, font1);
gchar* text[3][1] = { {"where is the pain?"},
{"do you have fever?"},
{"do you have headaches in\nthe morning?"}};
gtk_clist_append((GtkCList*)m_list, text[0]);
gtk_clist_append((GtkCList*)m_list, text[1]);
gtk_clist_append((GtkCList*)m_list, text[2]);
m_list_items = 3;
GdkColormap *colormap;
GdkColor color;
colormap = gtk_widget_get_colormap(m_list);
color.red = color_map[0][0];
color.green = color_map[0][1];
color.blue = color_map[0][2];
gdk_color_alloc(colormap, &color);
gtk_clist_set_background(GTK_CLIST(m_list), 0, &color);
color.red = color_map[1][0];
color.green = color_map[1][1];
color.blue = color_map[1][2];
gdk_color_alloc(colormap, &color);
gtk_clist_set_background(GTK_CLIST(m_list), 1, &color);
color.red = color_map[2][0];
color.green = color_map[2][1];
color.blue = color_map[2][2];
gdk_color_alloc(colormap, &color);
gtk_clist_set_background(GTK_CLIST(m_list), 2, &color);
gtk_clist_select_row((GtkCList*)m_list, 0, 0);
// Styles
//style = gtk_style_new();
//style->font_desc = font2;
//gdk_color_parse("red", &(style->bg[GTK_STATE_NORMAL]));
//gdk_color_parse ("green", &(style->bg[GTK_STATE_PRELIGHT]));
//gdk_color_parse ("green", &(style->bg[GTK_STATE_ACTIVE]));
// Text Boxes
m_txtbox1 = gtk_text_view_new();
gtk_widget_modify_font(m_txtbox1, font1);
gtk_widget_set_size_request(GTK_WIDGET(m_txtbox1), 550, 20);
gtk_text_view_set_editable(GTK_TEXT_VIEW(m_txtbox1), false);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(m_txtbox1), GTK_WRAP_WORD_CHAR);
color.red = color_map[3][0];
color.green = color_map[3][1];
color.blue = color_map[3][2];
gtk_widget_modify_base(GTK_WIDGET(m_txtbox1), GTK_STATE_NORMAL, &color);
//gtk_widget_modify_fg(GTK_WIDGET(m_txtbox1), GTK_STATE_NORMAL, &color);
//gtk_widget_set_style(GTK_WIDGET(m_txtbox1), style);
m_txtbox2 = gtk_text_view_new();
gtk_widget_modify_font(m_txtbox2, font1);
gtk_widget_set_size_request(GTK_WIDGET(m_txtbox2), 550, 20);
gtk_text_view_set_editable(GTK_TEXT_VIEW(m_txtbox2), false);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(m_txtbox2), GTK_WRAP_WORD_CHAR);
// Scroll bars
scroll1 = gtk_scrolled_window_new(NULL, NULL);
scroll2 = gtk_scrolled_window_new(NULL, NULL);
scroll3 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll1), GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll2), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll3), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll1), GTK_SHADOW_IN);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll2), GTK_SHADOW_IN);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll3), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scroll1), GTK_WIDGET(m_list));
gtk_container_add(GTK_CONTAINER(scroll2), GTK_WIDGET(m_txtbox1));
gtk_container_add(GTK_CONTAINER(scroll3), GTK_WIDGET(m_txtbox2));
// Text labels
m_understood = gtk_label_new("Understood");
m_response = gtk_label_new("Response");
m_translation = gtk_label_new("Translation");
gtk_widget_modify_font(m_understood, font2);
gtk_widget_modify_font(m_response, font2);
gtk_widget_modify_font(m_translation, font2);
gtk_label_set_justify(GTK_LABEL(m_understood), GTK_JUSTIFY_LEFT);
gtk_label_set_justify(GTK_LABEL(m_response), GTK_JUSTIFY_LEFT);
gtk_label_set_justify(GTK_LABEL(m_translation), GTK_JUSTIFY_LEFT);
gtk_label_set_ellipsize(GTK_LABEL(m_understood), PANGO_ELLIPSIZE_END);
gtk_label_set_ellipsize(GTK_LABEL(m_response), PANGO_ELLIPSIZE_END);
gtk_label_set_ellipsize(GTK_LABEL(m_translation), PANGO_ELLIPSIZE_END);
// Buttons
m_rec = gtk_button_new();
m_speech = gtk_button_new();
m_abort = gtk_button_new();
m_up = gtk_button_new();
m_select = gtk_button_new();
m_down = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(m_rec),
gtk_image_new_from_file(record_icon));
gtk_button_set_image(GTK_BUTTON(m_speech),
gtk_image_new_from_file(speech_icon));
gtk_button_set_image(GTK_BUTTON(m_abort),
gtk_image_new_from_file(stop_icon));
gtk_button_set_image(GTK_BUTTON(m_up),
gtk_image_new_from_file(up_icon));
gtk_button_set_image(GTK_BUTTON(m_select),
gtk_image_new_from_file(select_icon));
gtk_button_set_image(GTK_BUTTON(m_down),
gtk_image_new_from_file(down_icon));
// Menu
// Recheck: Is it destroyed somewhere
menu = CreateMenu(accel);
// Progress bar
m_progressbar = gtk_progress_bar_new();
gtk_progress_set_text_alignment(GTK_PROGRESS(m_progressbar),
0.5, 0.5);
gtk_widget_set_size_request(GTK_WIDGET(m_progressbar), 150, 50);
//gtk_container_add(GTK_CONTAINER(m_window), GTK_WIDGET(vbox));
gtk_box_pack_start(textbox, m_understood, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, scroll1, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, m_response, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, scroll2, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, m_translation, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, scroll3, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_rec, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_speech, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_abort, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_up, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_select, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_down, TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(textbox), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(buthbox), TRUE, TRUE, 0);
gtk_box_pack_start(coverbox, GTK_WIDGET(hbox), TRUE, TRUE, 0);
//gtk_box_pack_start(coverbox, m_progressbar, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(m_window), GTK_WIDGET(coverbox));
#ifdef _MAEMO
hildon_window_set_menu(HILDON_WINDOW(m_window), GTK_MENU(menu));
#else
gtk_box_pack_start(vbox, menu, FALSE, FALSE, 0);
#endif
// Signals
g_signal_connect(G_OBJECT(m_rec), "clicked",
G_CALLBACK(RecognizeClicked), this);
g_signal_connect(G_OBJECT(m_speech), "clicked",
G_CALLBACK(AbortClicked), this);
g_signal_connect(G_OBJECT(m_abort), "clicked",
G_CALLBACK(AbortClicked), this);
g_signal_connect(G_OBJECT(m_up), "clicked",
G_CALLBACK(UpClicked), this);
g_signal_connect(G_OBJECT(m_select), "clicked",
G_CALLBACK(SelectClicked), this);
g_signal_connect(G_OBJECT(m_down), "clicked",
G_CALLBACK(DownClicked), this);
g_signal_connect(G_OBJECT(m_list), "select_row",
G_CALLBACK(ListRowSelected), this);
g_signal_connect(G_OBJECT(m_window), "destroy",
G_CALLBACK(CloseApp), this);
g_signal_connect(G_OBJECT(m_window), "delete_event",
G_CALLBACK(CloseApp), this);
// Shortcuts
#ifndef _MAEMO
gtk_widget_add_accelerator(m_rec, "clicked", accel, GDK_space,
0, 0);
gtk_widget_add_accelerator(m_speech, "clicked", accel, GDK_space,
0, 0);
gtk_widget_add_accelerator(m_abort, "clicked", accel, GDK_space,
0, 0);
gtk_widget_add_accelerator(m_next, "clicked", accel, GDK_Right,
GDK_CONTROL_MASK, 0);
#endif
// Initial state
SetUiState(UI_STATE_DISCONNECTED);
return;
}
GtkWidget *
fontsel_new (ProgressData *pdata)
{
GtkWidget *paned;
GtkWidget *clist;
GtkWidget *clist2;
GtkWidget *scrolled_window;
paned = gtk_hpaned_new ();
g_signal_new ("face_changed",
GTK_TYPE_WIDGET,
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0,
NULL);
g_object_set_data (G_OBJECT (paned), "progress_data", pdata);
/* family */
clist = gtk_clist_new (1);
gtk_clist_set_column_title (GTK_CLIST (clist), 0, _("Font Family"));
gtk_clist_column_titles_show (GTK_CLIST (clist));
gtk_clist_column_titles_passive (GTK_CLIST (clist));
gtk_widget_show (clist);
scrolled_window =
gtk_scrolled_window_new (gtk_clist_get_hadjustment (GTK_CLIST (clist)),
gtk_clist_get_vadjustment (GTK_CLIST (clist)));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (scrolled_window), clist);
gtk_widget_show (scrolled_window);
gtk_paned_pack1 (GTK_PANED (paned), scrolled_window, TRUE, FALSE);
/* style */
clist2 = gtk_clist_new (1);
gtk_clist_set_column_title (GTK_CLIST (clist2), 0, _("Font Style"));
gtk_clist_column_titles_show (GTK_CLIST (clist2));
gtk_clist_column_titles_passive (GTK_CLIST (clist2));
gtk_widget_show (clist2);
scrolled_window =
gtk_scrolled_window_new (gtk_clist_get_hadjustment (GTK_CLIST (clist2)),
gtk_clist_get_vadjustment (GTK_CLIST (clist2)));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (scrolled_window), clist2);
gtk_widget_show (scrolled_window);
gtk_paned_pack2 (GTK_PANED (paned), scrolled_window, TRUE, FALSE);
g_signal_connect (clist, "select_row",
G_CALLBACK (fontsel_family_select_callback),
clist2);
g_signal_connect (clist2, "select_row",
G_CALLBACK (fontsel_style_select_callback),
paned);
g_object_set_data (G_OBJECT (paned), "family_list", clist);
g_object_set_data (G_OBJECT (paned), "style_list", clist2);
return paned;
}
