/*
* Función notasWidget()
*/
GtkWidget *notasWidget(void)
{
GtkWidget *scroll;
GtkWidget *notas;
gchar *notas_titulo[2] = {"índice", "contenido"};
/*
* Se crea los componentes asociados a notas:
* una ventana con barra de desplazamiento y una lista
*/
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_widget_set_usize(scroll,150,200);
notas=gtk_clist_new_with_titles (2,notas_titulo);
datosAgenda.gtk_notas=notas;
gtk_clist_set_shadow_type (GTK_CLIST(notas), GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(scroll), notas);
return (scroll);
}
GtkWidget * 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_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;
}
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;
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_tclist_set_properties (GtkWidget * widget, GtkWidget *child, GbWidgetSetArgData * data)
{
gchar *widths, *pos, *mode;
gchar *shadow;
gboolean titles;
gint col, w, i;
#ifndef GTK_HAVE_FEATURES_1_1_4
gboolean myApply;
gchar *hpolicy, *vpolicy;
GtkPolicyType hpolicy_value = GTK_POLICY_AUTOMATIC;
GtkPolicyType vpolicy_value = GTK_POLICY_AUTOMATIC;
#endif
if (data->action == GB_LOADING)
{
widths = gb_widget_input_string (data, ColumnWidths);
if (data->apply)
{
pos = widths;
for (col = 0; col < GTK_CLIST (widget)->columns; col++)
{
w = atoi (pos);
gtk_clist_set_column_width (GTK_CLIST (widget), col, w);
pos = strchr (pos, ',');
if (!pos)
break;
pos++;
}
}
}
mode = gb_widget_input_choice (data, Mode);
if (data->apply)
{
for (i = 0; i < sizeof (GbModeValues) / sizeof (GbModeValues[0]); i++)
{
if (!strcmp (mode, GbModeChoices[i])
|| !strcmp (mode, GbModeSymbols[i]))
{
gtk_clist_set_selection_mode (GTK_CLIST (widget), GbModeValues[i]);
break;
}
}
}
titles = gb_widget_input_bool (data, Titles);
if (data->apply)
{
if (titles)
gtk_clist_column_titles_show (GTK_CLIST (widget));
else
gtk_clist_column_titles_hide (GTK_CLIST (widget));
}
shadow = gb_widget_input_choice (data, Shadow);
if (data->apply)
{
for (i = 0; i < sizeof (GbShadowValues) / sizeof (GbShadowValues[0]); i
++)
{
if (!strcmp (shadow, GbShadowChoices[i])
|| !strcmp (shadow, GbShadowSymbols[i]))
{
#ifdef GTK_HAVE_FEATURES_1_1_4
gtk_clist_set_shadow_type (GTK_CLIST (widget),
GbShadowValues[i]);
#else
gtk_clist_set_border (GTK_CLIST (widget), GbShadowValues[i]);
#endif
break;
}
}
}
#ifndef GTK_HAVE_FEATURES_1_1_4
hpolicy = gb_widget_input_choice (data, HPolicy);
myApply = data->apply;
vpolicy = gb_widget_input_choice (data, VPolicy);
if (data->apply || myApply)
{
for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i
++)
{
if (!strcmp (hpolicy, GbPolicyChoices[i])
|| !strcmp (hpolicy, GbPolicySymbols[i]))
hpolicy_value = GbPolicyValues[i];
if (!strcmp (vpolicy, GbPolicyChoices[i])
|| !strcmp (vpolicy, GbPolicySymbols[i]))
vpolicy_value = GbPolicyValues[i];
}
gtk_clist_set_policy (GTK_CLIST (widget), vpolicy_value, hpolicy_value);
}
#endif
}
GtkWidget * create_PlayList( void )
{
GtkWidget * vbox1;
GtkWidget * hbox1;
GtkWidget * scrolledwindow1;
GtkWidget * vbox2;
GtkWidget * scrolledwindow2;
GtkWidget * scrolledwindow3;
GtkWidget * hbuttonbox1;
GtkAccelGroup * accel_group;
GdkColor transparent = { 0,0,0,0 };
gchar * root = "/";
gchar * dummy = "dummy";
DirNodeType * DirNode;
accel_group=gtk_accel_group_new();
PlayList=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_object_set_data( GTK_OBJECT( PlayList ),"PlayList",PlayList );
gtk_widget_set_usize( PlayList,512,384 );
gtk_window_set_title( GTK_WINDOW( PlayList ),MSGTR_PlayList );
gtk_window_set_position( GTK_WINDOW( PlayList ),GTK_WIN_POS_CENTER );
// gtk_window_set_policy( GTK_WINDOW( PlayList ),FALSE,FALSE,FALSE );
gtk_window_set_wmclass( GTK_WINDOW( PlayList ),"Playlist","MPlayer" );
gtk_widget_realize( PlayList );
gtkAddIcon( PlayList );
vbox1=AddVBox( AddDialogFrame( PlayList ),0 );
hbox1=AddHBox( NULL,1 );
gtk_box_pack_start( GTK_BOX( vbox1 ),hbox1,TRUE,TRUE,0 );
scrolledwindow1=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow1 );
gtk_container_add( GTK_CONTAINER(
AddFrame( NULL,0,hbox1,1 ) ),scrolledwindow1 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CTDirTree=gtk_ctree_new( 1,0 );
gtk_signal_connect( GTK_OBJECT( CTDirTree ),"tree_expand",GTK_SIGNAL_FUNC( plCTree ),(void*)0 );
gtk_signal_connect( GTK_OBJECT( CTDirTree ),"select_row",GTK_SIGNAL_FUNC( plCTRow ),(void *)0 );
gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),CTDirTree );
gtk_clist_set_column_auto_resize( GTK_CLIST( CTDirTree ),0,TRUE );
gtk_clist_set_column_width( GTK_CLIST( CTDirTree ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( CTDirTree ),GTK_SELECTION_SINGLE );
gtk_ctree_set_line_style( GTK_CTREE( CTDirTree ),GTK_CTREE_LINES_SOLID );
gtk_clist_column_titles_show( GTK_CLIST( CTDirTree ) );
gtk_clist_set_shadow_type( GTK_CLIST( CTDirTree ),GTK_SHADOW_NONE );
if ( !pxOpenedBook ) pxOpenedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msOpenedBook,&transparent,(gchar **)dir2_xpm );
if ( !pxClosedBook ) pxClosedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msClosedBook,&transparent,(gchar **)open2_xpm );
parent=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),NULL,NULL,&root,4,pxOpenedBook,msOpenedBook,pxClosedBook,msClosedBook,FALSE,FALSE );
DirNode=malloc( sizeof( DirNodeType ) );
DirNode->scaned=0; DirNode->path=strdup( root );
gtk_ctree_node_set_row_data_full(GTK_CTREE( CTDirTree ),parent,DirNode,NULL );
sibling=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),parent,NULL,&dummy,4,NULL,NULL,NULL,NULL,TRUE,TRUE );
gtk_ctree_expand( GTK_CTREE( CTDirTree ),parent );
gtk_widget_show( CTDirTree );
if ( fsHistory[0] ) old_path = g_filename_from_utf8( fsHistory[0], -1, NULL, NULL, NULL );
gtk_clist_set_column_widget( GTK_CLIST( CTDirTree ),0,
AddLabel( MSGTR_PLAYLIST_DirectoryTree,NULL ) );
gtk_clist_column_title_passive( GTK_CLIST( CTDirTree ),0 );
vbox2=AddVBox(
AddFrame( NULL,1,hbox1,1 ),0 );
scrolledwindow2=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow2 );
gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow2,TRUE,TRUE,0 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow2 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CLFiles=gtk_clist_new( 1 );
gtk_widget_show( CLFiles );
gtk_container_add( GTK_CONTAINER( scrolledwindow2 ),CLFiles );
gtk_clist_set_column_width( GTK_CLIST( CLFiles ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( CLFiles ),GTK_SELECTION_EXTENDED );
gtk_clist_column_titles_show( GTK_CLIST( CLFiles ) );
gtk_clist_set_shadow_type( GTK_CLIST( CLFiles ),GTK_SHADOW_NONE );
gtk_clist_set_column_widget( GTK_CLIST( CLFiles ),0,
AddLabel( MSGTR_PLAYLIST_Files,NULL ) );
gtk_clist_column_title_passive( GTK_CLIST( CLFiles ),0 );
AddHSeparator( vbox2 );
scrolledwindow3=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow3 );
gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow3,TRUE,TRUE,0 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow3 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CLSelected=gtk_clist_new( 2 );
gtk_widget_show( CLSelected );
gtk_container_add( GTK_CONTAINER( scrolledwindow3 ),CLSelected );
gtk_clist_set_column_width( GTK_CLIST( CLSelected ),0,295 );
gtk_clist_set_column_width( GTK_CLIST( CLSelected ),1,295 );
gtk_clist_set_selection_mode( GTK_CLIST( CLSelected ),GTK_SELECTION_MULTIPLE );
gtk_clist_column_titles_show( GTK_CLIST( CLSelected ) );
gtk_clist_set_shadow_type( GTK_CLIST( CLSelected ),GTK_SHADOW_NONE );
gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),0,
AddLabel( MSGTR_PLAYLIST_Selected,NULL ) );
gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),1,
AddLabel( MSGTR_PLAYLIST_Path,NULL ) );
gtk_clist_column_title_passive( GTK_CLIST( CLSelected ),0 );
AddHSeparator( vbox1 );
hbuttonbox1=AddHButtonBox( vbox1 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 );
Add=AddButton( MSGTR_Add,hbuttonbox1 );
Remove=AddButton( MSGTR_Remove,hbuttonbox1 );
Ok=AddButton( MSGTR_Ok,hbuttonbox1 );
Cancel=AddButton( MSGTR_Cancel,hbuttonbox1 );
gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( PlayList ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&PlayList );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"event",GTK_SIGNAL_FUNC( plEvent ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void *)0 );
sigSel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void*)1 );
sigUnsel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void*)1 );
sigEvent=gtk_signal_connect( GTK_OBJECT( CLSelected ),"event",GTK_SIGNAL_FUNC( plEvent ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( CLSelected ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( Add ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( Add ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( Remove ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( Remove ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( Ok ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( Ok ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)0 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)0 );
gtk_window_add_accel_group( GTK_WINDOW( PlayList ),accel_group );
return PlayList;
}
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)
);
}
}
GtkWidget * create_FileSelect( void )
{
GtkWidget * vbox4;
GtkWidget * hbox4;
GtkWidget * vseparator1;
GtkWidget * hbox6;
GtkWidget * fsFNameListWindow;
GtkWidget * hbuttonbox3;
GtkWidget * uppixmapwid;
GdkPixmap * uppixmap;
GdkBitmap * upmask;
GtkStyle * upstyle;
fsFileSelect=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( fsFileSelect,"fsFileSelect" );
gtk_object_set_data( GTK_OBJECT( fsFileSelect ),"fsFileSelect",fsFileSelect );
gtk_widget_set_usize( fsFileSelect,512,300 );
GTK_WIDGET_SET_FLAGS( fsFileSelect,GTK_CAN_DEFAULT );
gtk_widget_set_events( fsFileSelect,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( fsFileSelect ),MSGTR_FileSelect );
gtk_window_set_position( GTK_WINDOW( fsFileSelect ),GTK_WIN_POS_CENTER );
gtk_window_set_policy( GTK_WINDOW( fsFileSelect ),TRUE,TRUE,TRUE );
gtk_window_set_wmclass( GTK_WINDOW( fsFileSelect ),"FileSelect","MPlayer" );
fsColorMap=gdk_colormap_get_system();
gtk_widget_realize( fsFileSelect );
gtkAddIcon( fsFileSelect );
style=gtk_widget_get_style( fsFileSelect );
dpixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&dmask,&style->bg[GTK_STATE_NORMAL],(gchar **)dir_xpm );
fpixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&fmask,&style->bg[GTK_STATE_NORMAL],(gchar **)file_xpm );
vbox4=AddVBox( AddDialogFrame( fsFileSelect ),0 );
hbox4=AddHBox( vbox4,1 );
fsCombo4=gtk_combo_new();
gtk_widget_set_name( fsCombo4,"fsCombo4" );
gtk_widget_show( fsCombo4 );
gtk_box_pack_start( GTK_BOX( hbox4 ),fsCombo4,TRUE,TRUE,0 );
gtk_widget_set_usize( fsCombo4,-2,20 );
fsPathCombo=GTK_COMBO( fsCombo4 )->entry;
gtk_widget_set_name( fsPathCombo,"fsPathCombo" );
gtk_widget_show( fsPathCombo );
gtk_widget_set_usize( fsPathCombo,-2,20 );
vseparator1=gtk_vseparator_new();
gtk_widget_set_name( vseparator1,"vseparator1" );
gtk_widget_show( vseparator1 );
gtk_box_pack_start( GTK_BOX( hbox4 ),vseparator1,FALSE,TRUE,0 );
gtk_widget_set_usize( vseparator1,7,20 );
upstyle=gtk_widget_get_style( fsFileSelect );
uppixmap=gdk_pixmap_colormap_create_from_xpm_d( fsFileSelect->window,fsColorMap,&upmask,&upstyle->bg[GTK_STATE_NORMAL],(gchar **)up_xpm );
uppixmapwid=gtk_pixmap_new( uppixmap,upmask );
gtk_widget_show( uppixmapwid );
fsUp=gtk_button_new();
gtk_container_add( GTK_CONTAINER(fsUp ),uppixmapwid );
gtk_widget_show( fsUp );
gtk_box_pack_start( GTK_BOX( hbox4 ),fsUp,FALSE,FALSE,0 );
gtk_widget_set_usize( fsUp,65,15 );
AddHSeparator( vbox4 );
hbox6=AddHBox( NULL,0 );
gtk_box_pack_start( GTK_BOX( vbox4 ),hbox6,TRUE,TRUE,0 );
fsFNameListWindow=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_set_name( fsFNameListWindow,"fsFNameListWindow" );
gtk_widget_show( fsFNameListWindow );
gtk_box_pack_start( GTK_BOX( hbox6 ),fsFNameListWindow,TRUE,TRUE,0 );
gtk_widget_set_usize( fsFNameListWindow,-2,145 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( fsFNameListWindow ),GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC );
fsFNameList=gtk_clist_new( 2 );
gtk_widget_set_name( fsFNameList,"fsFNameList" );
gtk_container_add( GTK_CONTAINER( fsFNameListWindow ),fsFNameList );
gtk_clist_set_column_width( GTK_CLIST( fsFNameList ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( fsFNameList ),GTK_SELECTION_BROWSE );
gtk_clist_column_titles_hide( GTK_CLIST( fsFNameList ) );
gtk_clist_set_shadow_type( GTK_CLIST( fsFNameList ),GTK_SHADOW_ETCHED_OUT );
AddHSeparator( vbox4 );
List=gtk_combo_new();
gtk_widget_set_name( List,"List" );
gtk_widget_ref( List );
gtk_object_set_data_full( GTK_OBJECT( fsFileSelect ),"List",List,(GtkDestroyNotify)gtk_widget_unref );
gtk_widget_show( List );
gtk_box_pack_start( GTK_BOX( vbox4 ),List,FALSE,FALSE,0 );
gtk_widget_set_usize( List,-2,20 );
fsFilterCombo=GTK_COMBO( List )->entry;
gtk_widget_set_name( fsFilterCombo,"fsFilterCombo" );
gtk_widget_show( fsFilterCombo );
gtk_entry_set_editable (GTK_ENTRY( fsFilterCombo ),FALSE );
AddHSeparator( vbox4 );
hbuttonbox3=AddHButtonBox( vbox4 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox3 ),GTK_BUTTONBOX_END );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox3 ),10 );
fsOk=AddButton( MSGTR_Ok,hbuttonbox3 );
fsCancel=AddButton( MSGTR_Cancel,hbuttonbox3 );
gtk_signal_connect( GTK_OBJECT( fsFileSelect ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&fsFileSelect );
gtk_signal_connect( GTK_OBJECT( fsFileSelect ),"key_release_event",GTK_SIGNAL_FUNC( on_FileSelect_key_release_event ),NULL );
gtk_signal_connect( GTK_OBJECT( fsFilterCombo ),"changed",GTK_SIGNAL_FUNC( fs_fsFilterCombo_changed ),fsFilterCombo );
gtk_signal_connect( GTK_OBJECT( fsFilterCombo ),"activate",GTK_SIGNAL_FUNC( fs_fsFilterCombo_activate ),fsFilterCombo );
gtk_signal_connect( GTK_OBJECT( fsPathCombo ),"changed",GTK_SIGNAL_FUNC( fs_fsPathCombo_changed ),fsPathCombo );
gtk_signal_connect( GTK_OBJECT( fsPathCombo ),"activate",GTK_SIGNAL_FUNC( fs_fsPathCombo_activate ),fsPathCombo );
gtk_signal_connect( GTK_OBJECT( fsUp ),"released",GTK_SIGNAL_FUNC( fs_Up_released ),fsFNameList );
gtk_signal_connect( GTK_OBJECT( fsOk ),"released",GTK_SIGNAL_FUNC( fs_Ok_released ),fsCombo4 );
gtk_signal_connect( GTK_OBJECT( fsCancel ),"released",GTK_SIGNAL_FUNC( fs_Cancel_released ),NULL );
gtk_signal_connect( GTK_OBJECT( fsFNameList ),"select_row",(GtkSignalFunc)fs_fsFNameList_select_row,NULL );
gtk_widget_grab_focus( fsFNameList );
return fsFileSelect;
}
static void
create_plugin_tab(GtkWidget *tab_vbox)
{
Reader *reader;
GtkWidget *tabs;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *arrow;
GtkWidget *scrolled;
GtkWidget *text;
GtkWidget *label;
gchar *buf[CLIST_WIDTH];
gint row, i;
/* Make a couple of tabs. One for setup and one for info
*/
tabs = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tabs), GTK_POS_TOP);
gtk_box_pack_start(GTK_BOX(tab_vbox), tabs, TRUE, TRUE, 0);
/* --- Setup tab */
vbox = gkrellm_gtk_framed_notebook_page(tabs, "Setup");
hbox = gtk_hbox_new(FALSE,0);
label = gtk_label_new("Label : ");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
label_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(label_entry), "");
gtk_box_pack_start(GTK_BOX(hbox),label_entry,FALSE,FALSE,0);
label = gtk_label_new("Peer : ");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
peer_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(peer_entry), "");
gtk_box_pack_start(GTK_BOX(hbox),peer_entry,FALSE,FALSE,0);
label = gtk_label_new("Port : ");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
port_spin_adj = gtk_adjustment_new (161, 1, 65535, 1, 10, 10);
port_spin = gtk_spin_button_new (GTK_ADJUSTMENT (port_spin_adj), 1, 0);
gtk_box_pack_start(GTK_BOX(hbox),port_spin,FALSE,FALSE,0);
label = gtk_label_new("Freq : ");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
freq_spin_adj = gtk_adjustment_new (100, 10, 6000, 10, 100, 100);
freq_spin = gtk_spin_button_new (GTK_ADJUSTMENT (freq_spin_adj), 1, 0);
gtk_box_pack_start(GTK_BOX(hbox),freq_spin,FALSE,FALSE,0);
gtk_container_add(GTK_CONTAINER(vbox),hbox);
hbox = gtk_hbox_new(FALSE,0);
label = gtk_label_new("Community : ");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
community_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(community_entry), "");
gtk_box_pack_start(GTK_BOX(hbox), community_entry, FALSE, FALSE, 0);
label = gtk_label_new("OID : ");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
oid_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(oid_entry), "");
gtk_box_pack_start(GTK_BOX(hbox), oid_entry, FALSE, FALSE, 0);
label = gtk_label_new("Unit : ");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
unit_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(unit_entry), "");
gtk_box_pack_start(GTK_BOX(hbox),unit_entry,FALSE,FALSE,0);
gtk_container_add(GTK_CONTAINER(vbox),hbox);
hbox = gtk_hbox_new(FALSE,0);
label = gtk_label_new("Divisor : ");
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
div_spin_adj = gtk_adjustment_new (1, 1, 1024, 1, 1, 1);
div_spin = gtk_spin_button_new (GTK_ADJUSTMENT (div_spin_adj), 1, 0);
gtk_box_pack_start(GTK_BOX(hbox),div_spin,FALSE,FALSE,0);
delta_button = gtk_check_button_new_with_label("Compute delta");
gtk_box_pack_start(GTK_BOX(hbox),delta_button,FALSE,FALSE,0);
scale_button = gtk_check_button_new_with_label("Auto scale");
gtk_box_pack_start(GTK_BOX(hbox),scale_button,FALSE,FALSE,0);
button = gtk_button_new_with_label("Probe");
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) cb_probe, NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 4);
gtk_container_add(GTK_CONTAINER(vbox),hbox);
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 2);
/*
*mount_button = gtk_check_button_new_with_label(
"Enable /etc/fstab mounting");
gtk_box_pack_start(GTK_BOX(hbox), *mount_button, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(GTK_BUTTON(*mount_button)), "clicked",
GTK_SIGNAL_FUNC (cb_mount_button_clicked), NULL);
*/
button = gtk_button_new();
arrow = gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_ETCHED_OUT);
gtk_container_add(GTK_CONTAINER(button), arrow);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) cb_clist_up, NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 4);
button = gtk_button_new();
arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_ETCHED_OUT);
gtk_container_add(GTK_CONTAINER(button), arrow);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) cb_clist_down, NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 4);
button = gtk_button_new_with_label("Enter");
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) cb_enter, NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 4);
button = gtk_button_new_with_label("Delete");
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) cb_delete, NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 4);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);
reader_clist = gtk_clist_new_with_titles(CLIST_WIDTH, reader_title);
gtk_clist_set_shadow_type (GTK_CLIST(reader_clist), GTK_SHADOW_OUT);
gtk_clist_set_column_width (GTK_CLIST(reader_clist), 1, 100);
gtk_clist_set_column_width (GTK_CLIST(reader_clist), 4, 100);
gtk_signal_connect(GTK_OBJECT(reader_clist), "select_row",
(GtkSignalFunc) cb_clist_selected, NULL);
gtk_signal_connect(GTK_OBJECT(reader_clist), "unselect_row",
(GtkSignalFunc) cb_clist_unselected, NULL);
gtk_container_add(GTK_CONTAINER(scrolled), reader_clist);
for (reader = readers; reader; reader = reader->next)
{
i = 0;
buf[i++] = reader->label;
buf[i++] = reader->peer;
buf[i++] = g_strdup_printf("%d", reader->port);
buf[i++] = reader->community;
buf[i++] = reader->oid_str;
buf[i++] = reader->unit;
buf[i++] = g_strdup_printf("%d", reader->delay);
buf[i++] = g_strdup_printf("%d", reader->divisor);
buf[i++] = reader->delta ? "yes" : "no";
buf[i++] = reader->scale ? "yes" : "no";
buf[i++] = reader->active ? "yes" : "no";
row = gtk_clist_append(GTK_CLIST(reader_clist), buf);
}
/* --- Info tab */
vbox = gkrellm_gtk_framed_notebook_page(tabs, "Info");
// scrolled = gtk_scrolled_window_new(NULL, NULL);
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
// GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
// gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);
// text = gtk_text_new(NULL, NULL);
text = gkrellm_gtk_scrolled_text_view(vbox, NULL, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
// gtk_text_insert(GTK_TEXT(text), NULL, NULL, NULL, plugin_info_text, -1);
gkrellm_gtk_text_view_append(text, plugin_info_text);
// gtk_text_set_editable(GTK_TEXT(text), FALSE);
// gtk_container_add(GTK_CONTAINER(scrolled), text);
/* --- about text */
text = gtk_label_new(plugin_about_text);
gtk_notebook_append_page(GTK_NOTEBOOK(tabs), text,
gtk_label_new("About"));
}
/* If title == NULL then it is the main gradient select dialog */
GradientSelect *
gradient_select_new (gchar *title,
gchar *initial_gradient)
{
GradientSelect *gsp;
GtkWidget *vbox;
GtkWidget *scrolled_win;
GdkColormap *colormap;
gchar *titles[2];
gint column_width;
gint select_pos;
gradient_t *active = NULL;
static gboolean first_call = TRUE;
gsp = g_new (GradientSelect, 1);
gsp->callback_name = NULL;
gsp->dnd_gradient = NULL;
/* The shell */
/*
gsp->shell = gimp_dialog_new (title ? title : _("Gradient Selection"),
"gradient_selection",
gimp_standard_help_func,
"dialogs/gradient_selection.html",
title ? GTK_WIN_POS_MOUSE : GTK_WIN_POS_NONE,
FALSE, TRUE, FALSE,
_("Edit"), gradient_select_edit_callback,
gsp, NULL, NULL, FALSE, FALSE,
_("Close"), gradient_select_close_callback,
gsp, NULL, NULL, TRUE, TRUE,
NULL);
if (title)
{
gsp->context = gimp_context_new (title, NULL);
}
else
{
gsp->context = gimp_context_get_user ();
session_set_window_geometry (gsp->shell, &gradient_select_session_info,
TRUE);
dialog_register (gsp->shell);
}
if (no_data && first_call)
gradients_init (FALSE);
*/
first_call = FALSE;
if (title && initial_gradient && strlen (initial_gradient))
{
active = gradient_list_get_gradient (gradients_list, initial_gradient);
}
else
{
/*
active = gimp_context_get_gradient (gimp_context_get_user ());
*/
}
if (!active)
{
/*
active = gimp_context_get_gradient (gimp_context_get_standard ());
*/
}
if (title)
{
/*
gimp_context_set_gradient (gsp->context, active);
*/
}
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (gsp->shell)->vbox), vbox);
/* clist preview of gradients */
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (vbox), scrolled_win);
gtk_widget_show (scrolled_win);
titles[0] = _("Gradient");
titles[1] = _("Name");
gsp->clist = gtk_clist_new_with_titles (2, titles);
gtk_clist_set_shadow_type (GTK_CLIST (gsp->clist), GTK_SHADOW_IN);
gtk_clist_set_selection_mode (GTK_CLIST (gsp->clist), GTK_SELECTION_BROWSE);
gtk_clist_set_row_height (GTK_CLIST (gsp->clist), 18);
gtk_clist_set_use_drag_icons (GTK_CLIST (gsp->clist), FALSE);
gtk_clist_column_titles_passive (GTK_CLIST (gsp->clist));
gtk_widget_set_usize (gsp->clist, 200, 250);
gtk_container_add (GTK_CONTAINER (scrolled_win), gsp->clist);
column_width =
MAX (50, gtk_clist_optimal_column_width (GTK_CLIST (gsp->clist), 0));
gtk_clist_set_column_min_width (GTK_CLIST (gsp->clist), 0, 50);
gtk_clist_set_column_width (GTK_CLIST (gsp->clist), 0, column_width);
gtk_widget_show (gsp->clist);
colormap = gtk_widget_get_colormap (gsp->clist);
gdk_color_parse ("black", &gsp->black);
gdk_color_alloc (colormap, &gsp->black);
gtk_widget_realize (gsp->shell);
gsp->gc = gdk_gc_new (gsp->shell->window);
select_pos = gradient_clist_init (gsp->shell, gsp->gc, gsp->clist, active);
/* Now show the dialog */
gtk_widget_show (vbox);
gtk_widget_show (gsp->shell);
gtk_signal_connect (GTK_OBJECT (gsp->clist), "button_press_event",
GTK_SIGNAL_FUNC (gradient_select_button_press),
(gpointer) gsp);
gtk_signal_connect (GTK_OBJECT (gsp->clist), "select_row",
GTK_SIGNAL_FUNC (gradient_select_list_item_update),
(gpointer) gsp);
gtk_signal_connect (GTK_OBJECT (gsp->context), "gradient_changed",
GTK_SIGNAL_FUNC (gradient_select_gradient_changed),
(gpointer) gsp);
/* dnd stuff */
/*
gtk_drag_source_set (gsp->clist,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
clist_target_table, clist_n_targets,
GDK_ACTION_COPY);
gimp_dnd_gradient_source_set (gsp->clist, gradient_select_drag_gradient, gsp);
gtk_drag_dest_set (gsp->clist,
GTK_DEST_DEFAULT_ALL,
clist_target_table, clist_n_targets,
GDK_ACTION_COPY);
gimp_dnd_gradient_dest_set (gsp->clist, gradient_select_drop_gradient, gsp);
*/
if (active)
gradient_select_select (gsp, active);
/* Add to active gradient dialogs list */
gradient_active_dialogs = g_slist_append (gradient_active_dialogs, gsp);
return gsp;
}
GtkWidget*
create_window1 (void)
{
GtkWidget *window1;
GtkWidget *table1;
GtkWidget *table3;
GtkWidget *table5;
GtkWidget *button4;
GtkWidget *popupbutton;
GtkWidget *label4;
GtkWidget *reference_button;
GtkWidget *hseparator1;
GtkWidget *table9;
GtkWidget *label8;
GtkWidget *entry1;
GtkWidget *button3;
GtkWidget *button1;
GtkWidget *hseparator2;
GtkWidget *table10;
GtkWidget *frame8;
GtkWidget *scrolledwindow8;
GtkWidget *clist1;
GtkWidget *label9;
GtkWidget *myNotebook;
GtkWidget *scrolledwindow12;
GtkWidget *text1;
GtkWidget *label57;
GtkTooltips *tooltips;
tooltips = gtk_tooltips_new ();
window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (window1), "window1", window1);
gtk_widget_set_usize (window1, 320, 240);
gtk_window_set_title (GTK_WINDOW (window1), _("mydict"));
table1 = gtk_table_new (5, 1, FALSE);
gtk_widget_ref (table1);
gtk_object_set_data_full (GTK_OBJECT (window1), "table1", table1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table1);
gtk_container_add (GTK_CONTAINER (window1), table1);
gtk_container_set_border_width (GTK_CONTAINER (table1), 2);
table3 = gtk_table_new (1, 1, FALSE);
gtk_widget_ref (table3);
gtk_object_set_data_full (GTK_OBJECT (window1), "table3", table3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table3);
gtk_table_attach (GTK_TABLE (table1), table3, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
table5 = gtk_table_new (1, 4, FALSE);
gtk_widget_ref (table5);
gtk_object_set_data_full (GTK_OBJECT (window1), "table5", table5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table5);
gtk_table_attach (GTK_TABLE (table3), table5, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
button4 = gtk_button_new_with_label (_(" Quit "));
gtk_widget_ref (button4);
gtk_object_set_data_full (GTK_OBJECT (window1), "button4", button4,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (button4);
gtk_table_attach (GTK_TABLE (table5), button4, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_tooltips_set_tip (tooltips, button4, _("Give me comments"), NULL);
popupbutton = gtk_button_new_with_label (_("Popup Recite"));
gtk_widget_ref (popupbutton);
gtk_object_set_data_full (GTK_OBJECT (window1), "popupbutton", popupbutton,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (popupbutton);
gtk_table_attach (GTK_TABLE (table5), popupbutton, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label4 = gtk_label_new (_(" MyDict , Powered by brains. "));
gtk_widget_ref (label4);
gtk_object_set_data_full (GTK_OBJECT (window1), "label4", label4,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table5), label4, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label4), 0, 7);
reference_button = gtk_button_new_with_label (_("Reference"));
gtk_widget_ref (reference_button);
gtk_object_set_data_full (GTK_OBJECT (window1), "reference_button", reference_button,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (reference_button);
gtk_table_attach (GTK_TABLE (table5), reference_button, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_container_set_border_width (GTK_CONTAINER (reference_button), 1);
hseparator1 = gtk_hseparator_new ();
gtk_widget_ref (hseparator1);
gtk_object_set_data_full (GTK_OBJECT (window1), "hseparator1", hseparator1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator1);
gtk_table_attach (GTK_TABLE (table1), hseparator1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
table9 = gtk_table_new (1, 4, FALSE);
gtk_widget_ref (table9);
gtk_object_set_data_full (GTK_OBJECT (window1), "table9", table9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table9);
gtk_table_attach (GTK_TABLE (table1), table9, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
label8 = gtk_label_new (_(" What is: "));
gtk_widget_ref (label8);
gtk_object_set_data_full (GTK_OBJECT (window1), "label8", label8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label8);
gtk_table_attach (GTK_TABLE (table9), label8, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label8), 0, 5);
entry1 = gtk_entry_new ();
gtk_widget_ref (entry1);
gtk_object_set_data_full (GTK_OBJECT (window1), "entry1", entry1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (entry1);
gtk_table_attach (GTK_TABLE (table9), entry1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_tooltips_set_tip (tooltips, entry1, _("Click Right button to clear the entry"), NULL);
button3 = gtk_button_new_with_label (_(" Search "));
gtk_widget_ref (button3);
gtk_object_set_data_full (GTK_OBJECT (window1), "button3", button3,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (button3);
gtk_table_attach (GTK_TABLE (table9), button3, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_tooltips_set_tip (tooltips, button3, _("Look up "), NULL);
button1 = gtk_button_new_with_label (_("Add"));
gtk_widget_ref (button1);
gtk_object_set_data_full (GTK_OBJECT (window1), "button1", button1,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (button1);
gtk_table_attach (GTK_TABLE (table9), button1, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_container_set_border_width (GTK_CONTAINER (button1), 2);
gtk_tooltips_set_tip (tooltips, button1, _("Need to remember"), NULL);
hseparator2 = gtk_hseparator_new ();
gtk_widget_ref (hseparator2);
gtk_object_set_data_full (GTK_OBJECT (window1), "hseparator2", hseparator2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator2);
gtk_table_attach (GTK_TABLE (table1), hseparator2, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
/* */
table10 = gtk_table_new (1, 2, FALSE);
gtk_widget_ref (table10);
gtk_object_set_data_full (GTK_OBJECT (window1), "table10", table10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table10);
gtk_table_attach (GTK_TABLE (table1), table10, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
frame8 = gtk_frame_new (_("Relative Words"));
gtk_widget_ref (frame8);
gtk_object_set_data_full (GTK_OBJECT (window1), "frame8", frame8,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (frame8);
gtk_table_attach (GTK_TABLE (table10), frame8, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_usize (frame8, 130, -2);
gtk_container_set_border_width (GTK_CONTAINER (frame8), 1);
gtk_frame_set_label_align (GTK_FRAME (frame8), 0.61, 0.5);
scrolledwindow8 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow8);
gtk_object_set_data_full (GTK_OBJECT (window1), "scrolledwindow8", scrolledwindow8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow8);
gtk_container_add (GTK_CONTAINER (frame8), scrolledwindow8);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow8), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
clist1 = gtk_clist_new (1);
gtk_widget_ref (clist1);
gtk_object_set_data_full (GTK_OBJECT (window1), "clist1", clist1,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (clist1);
gtk_container_add (GTK_CONTAINER (scrolledwindow8), clist1);
gtk_clist_set_column_width (GTK_CLIST (clist1), 0, 80);
gtk_clist_column_titles_hide (GTK_CLIST (clist1));
gtk_clist_set_shadow_type (GTK_CLIST (clist1), GTK_SHADOW_ETCHED_IN);
label9 = gtk_label_new (_("label9"));
gtk_widget_ref (label9);
gtk_object_set_data_full (GTK_OBJECT (window1), "label9", label9,
(GtkDestroyNotify) gtk_widget_unref);
// gtk_widget_show (label9);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 0, label9);
myNotebook = gtk_notebook_new ();
gtk_widget_ref (myNotebook);
gtk_object_set_data_full (GTK_OBJECT (window1), "myNotebook", myNotebook,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (myNotebook);
gtk_table_attach (GTK_TABLE (table10), myNotebook, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (myNotebook), TRUE);
scrolledwindow12 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow12);
gtk_object_set_data_full (GTK_OBJECT (window1), "scrolledwindow12", scrolledwindow12,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow12);
gtk_container_add (GTK_CONTAINER (myNotebook), scrolledwindow12);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow12), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* */
text1 = gtk_text_new (NULL, NULL);
gtk_widget_ref (text1);
gtk_object_set_data_full (GTK_OBJECT (window1), "text1", text1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (text1);
gtk_container_add (GTK_CONTAINER (scrolledwindow12), text1);
gtk_text_insert (GTK_TEXT (text1), NULL, NULL, NULL,
_("\nWelcome to gnuDict framework - mydict-client Gtk version\n\n\n\n\n\nNow check the plugins ......."), -1);
label57 = gtk_label_new (_("Welcome to mydict"));
gtk_widget_ref (label57);
gtk_object_set_data_full (GTK_OBJECT (window1), "label57", label57,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label57);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (myNotebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (myNotebook), 0), label57);
gtk_signal_connect (GTK_OBJECT (window1), "destroy",
GTK_SIGNAL_FUNC (on_window1_destroy),
NULL);
gtk_signal_connect (GTK_OBJECT (button4), "clicked",
GTK_SIGNAL_FUNC (on_button4_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (popupbutton), "clicked",
GTK_SIGNAL_FUNC (on_popupbutton_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (reference_button), "clicked",
GTK_SIGNAL_FUNC (on_reference_button_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (entry1), "key_press_event",
GTK_SIGNAL_FUNC (on_entry1_key_press_event),
NULL);
gtk_signal_connect (GTK_OBJECT (entry1), "button_press_event",
GTK_SIGNAL_FUNC (on_entry1_button_press_event),
NULL);
gtk_signal_connect (GTK_OBJECT (button3), "clicked",
GTK_SIGNAL_FUNC (on_button3_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button1), "clicked",
GTK_SIGNAL_FUNC (on_button1_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (clist1), "select_row",
GTK_SIGNAL_FUNC (on_clist1_select_row),
NULL);
gtk_signal_connect (GTK_OBJECT (clist1), "key_release_event",
GTK_SIGNAL_FUNC (on_clist1_key_release_event),
clist1);
gtk_signal_connect (GTK_OBJECT (myNotebook), "button_release_event",
GTK_SIGNAL_FUNC (on_myNotebook_button_press_event),
NULL);
gtk_object_set_data (GTK_OBJECT (window1), "tooltips", tooltips);
gtk_widget_grab_focus(entry1);
return window1;
}
void GUI_CreateSpeedDialWindow(void)
{
int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
SortColumn *sColumn;
GtkWidget *menubar;
GtkWidget *main_vbox;
GtkWidget *toolbar;
GtkWidget *clistScrolledWindow;
register gint i;
gchar *titles[3] = { _("Key"), _("Name"), _("Number") };
InitMainMenu();
GUI_SpeedDialWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass(GTK_WINDOW(GUI_SpeedDialWindow), "SpeedDialWindow", "Xgnokii");
gtk_window_set_title(GTK_WINDOW(GUI_SpeedDialWindow), _("Speed Dial"));
gtk_widget_set_usize(GTK_WIDGET(GUI_SpeedDialWindow), 350, 220);
//gtk_container_set_border_width (GTK_CONTAINER (GUI_SpeedDialWindow), 10);
gtk_signal_connect(GTK_OBJECT(GUI_SpeedDialWindow), "delete_event",
GTK_SIGNAL_FUNC(DeleteEvent), NULL);
gtk_widget_realize(GUI_SpeedDialWindow);
accel_group = gtk_accel_group_new();
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
gtk_window_add_accel_group(GTK_WINDOW(GUI_SpeedDialWindow), accel_group);
/* Finally, return the actual menu bar created by the item factory. */
menubar = gtk_item_factory_get_widget(item_factory, "<main>");
main_vbox = gtk_vbox_new(FALSE, 1);
gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
gtk_container_add(GTK_CONTAINER(GUI_SpeedDialWindow), main_vbox);
gtk_widget_show(main_vbox);
gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, FALSE, 0);
gtk_widget_show(menubar);
/* Create the toolbar */
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Read from phone"), NULL,
NewPixmap(Read_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) ReadSpeedDial, NULL);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Save to phone"), NULL,
NewPixmap(Send_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) SaveSpeedDial, NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Import from file"), NULL,
NewPixmap(Open_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) ImportSpeedDial, NULL);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Export to file"), NULL,
NewPixmap(Save_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) ExportSpeedDial, NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Edit entry"), NULL,
NewPixmap(Edit_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) EditKey, NULL);
gtk_box_pack_start(GTK_BOX(main_vbox), toolbar, FALSE, FALSE, 0);
gtk_widget_show(toolbar);
clist = gtk_clist_new_with_titles(3, titles);
gtk_clist_set_shadow_type(GTK_CLIST(clist), GTK_SHADOW_OUT);
// gtk_clist_set_compare_func (GTK_CLIST (clist), CListCompareFunc);
gtk_clist_set_sort_column(GTK_CLIST(clist), 0);
gtk_clist_set_sort_type(GTK_CLIST(clist), GTK_SORT_ASCENDING);
gtk_clist_set_auto_sort(GTK_CLIST(clist), FALSE);
//gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
gtk_clist_set_column_width(GTK_CLIST(clist), 1, 150);
gtk_clist_set_column_width(GTK_CLIST(clist), 2, 115);
gtk_clist_set_column_justification(GTK_CLIST(clist), 0, GTK_JUSTIFY_CENTER);
// gtk_clist_set_column_visibility (GTK_CLIST (clist), 3, xgnokiiConfig.callerGroupsSupported);
for (i = 0; i < 3; i++) {
if ((sColumn = g_malloc(sizeof(SortColumn))) == NULL) {
g_print(_("Error: %s: line %d: Can't allocate memory!\n"), __FILE__, __LINE__);
gtk_main_quit();
}
sColumn->clist = clist;
sColumn->column = i;
gtk_signal_connect(GTK_OBJECT(GTK_CLIST(clist)->column[i].button), "clicked",
GTK_SIGNAL_FUNC(SetSortColumn), (gpointer) sColumn);
}
gtk_signal_connect(GTK_OBJECT(clist), "select_row", GTK_SIGNAL_FUNC(ClickEntry), NULL);
clistScrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(clistScrolledWindow), clist);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clistScrolledWindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(main_vbox), clistScrolledWindow, TRUE, TRUE, 0);
gtk_widget_show(clist);
gtk_widget_show(clistScrolledWindow);
questMark.pixmap = gdk_pixmap_create_from_xpm_d(GUI_SpeedDialWindow->window,
&questMark.mask,
&GUI_SpeedDialWindow->style->
bg[GTK_STATE_NORMAL], quest_xpm);
CreateErrorDialog(&errorDialog, GUI_SpeedDialWindow);
CreateInfoDialog(&infoDialog, GUI_SpeedDialWindow);
speedDialInitialized = FALSE;
}
int main( int argc,
gchar *argv[] )
{
GtkWidget *window;
GtkWidget *vbox, *hbox;
GtkWidget *scrolled_window, *clist;
GtkWidget *button_add, *button_clear, *button_hide_show;
gchar *titles[2] = { "Ingredients", "Amount" };
gtk_init(&argc, &argv);
window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (GTK_WIDGET (window), 300, 150);
gtk_window_set_title (GTK_WINDOW (window), "GtkCList Example");
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
vbox=gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
/* Create a scrolled window to pack the CList widget into */
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
/* Create the CList. For this example we use 2 columns */
clist = gtk_clist_new_with_titles (2, titles);
/* When a selection is made, we want to know about it. The callback
* used is selection_made, and its code can be found further down */
g_signal_connect (G_OBJECT (clist), "select_row",
G_CALLBACK (selection_made),
NULL);
/* It isn't necessary to shadow the border, but it looks nice :) */
gtk_clist_set_shadow_type (GTK_CLIST (clist), GTK_SHADOW_OUT);
/* What however is important, is that we set the column widths as
* they will never be right otherwise. Note that the columns are
* numbered from 0 and up (to 1 in this case).
*/
gtk_clist_set_column_width (GTK_CLIST (clist), 0, 150);
/* Add the CList widget to the vertical box and show it. */
gtk_container_add (GTK_CONTAINER (scrolled_window), clist);
gtk_widget_show (clist);
/* Create the buttons and add them to the window. See the button
* tutorial for more examples and comments on this.
*/
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
gtk_widget_show (hbox);
button_add = gtk_button_new_with_label ("Add List");
button_clear = gtk_button_new_with_label ("Clear List");
button_hide_show = gtk_button_new_with_label ("Hide/Show titles");
gtk_box_pack_start (GTK_BOX (hbox), button_add, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button_clear, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button_hide_show, TRUE, TRUE, 0);
/* Connect our callbacks to the three buttons */
g_signal_connect_swapped (G_OBJECT (button_add), "clicked",
G_CALLBACK (button_add_clicked),
clist);
g_signal_connect_swapped (G_OBJECT (button_clear), "clicked",
G_CALLBACK (button_clear_clicked),
clist);
g_signal_connect_swapped (G_OBJECT (button_hide_show), "clicked",
G_CALLBACK (button_hide_show_clicked),
clist);
gtk_widget_show (button_add);
gtk_widget_show (button_clear);
gtk_widget_show (button_hide_show);
/* The interface is completely set up so we show the window and
* enter the gtk_main loop.
*/
gtk_widget_show (window);
gtk_main();
return 0;
}
static void
gnc_query_list_init_clist (GNCQueryList *list)
{
GtkCList *clist = GTK_CLIST (list);
GtkStyle *style;
GList *node;
gchar **titles;
gint i;
/* compute the number of columns and fill in the rest of the list */
list->num_columns = g_list_length(list->column_params);
list->title_arrows = g_new0(GtkWidget*, list->num_columns);
list->title_widths = g_new0(gint, list->num_columns);
/* build an array of titles */
titles = g_new0(gchar*, list->num_columns);
for (i = 0, node = list->column_params; node; node = node->next, i++)
{
GNCSearchParam *param = node->data;
titles[i] = (gchar *)param->title;
}
gtk_clist_column_titles_show (clist);
gtk_clist_set_shadow_type (clist, GTK_SHADOW_IN);
/* build all the column titles */
for (i = 0; i < list->num_columns; i++)
gnc_query_list_column_title(list, i, titles[i]);
/* set the column justification */
for (i = 0, node = list->column_params; node; node = node->next, i++)
{
GNCSearchParam *param = node->data;
gtk_clist_set_column_justification (clist, i, param->justify);
if (param->passive)
gtk_clist_column_title_passive (clist, i);
if (param->non_resizeable)
gtk_clist_set_column_resizeable (clist, i, FALSE);
}
g_signal_connect (clist, "click_column",
G_CALLBACK(gnc_query_list_click_column_cb),
NULL);
g_signal_connect (clist, "size_allocate",
G_CALLBACK(gnc_query_list_size_allocate_cb),
NULL);
style = gtk_widget_get_style (GTK_WIDGET(list));
#if 0
{
GdkFont *font = NULL;
gint width;
font = style->font;
if (font != NULL)
{
for (i = 0, node = list->column_params; node; node = node->next, i++)
{
GNCSearchParam *param = node->data;
width = gdk_string_width (font, titles[i]) + 5;
if (!param->passive)
width += ARROW_SIZE;
gtk_clist_set_column_min_width (clist, i, width);
list->title_widths[i] = width;
}
}
}
#endif
g_free(titles);
}
void
create_loglist(void)
{
GtkWidget *mvb,*sw,*dhb,*dhw[30];
GdkBitmap *mask;
GdkPixmap *myicon;
GtkStyle *style;
GList *pt;
int i;
applet=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(applet),780,510);
gtk_window_set_title (GTK_WINDOW (applet), "YAWMPPP Connection Log");
gtk_window_set_wmclass(GTK_WINDOW(applet),"yawmppp","log");
gtk_container_set_border_width(GTK_CONTAINER(applet),4);
gtk_widget_show (applet);
style=gtk_widget_get_style(applet);
myicon = gdk_pixmap_create_from_xpm_d (applet->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) stepphone_xpm);
gdk_window_set_icon (applet->window, NULL, myicon, mask);
gdk_window_set_icon_name(applet->window,"The Log");
mvb=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(applet),mvb);
dhb=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(mvb),dhb,FALSE,TRUE,0);
/* data */
dhw[0]=gtk_label_new("Show summary for:");
gtk_box_pack_start(GTK_BOX(dhb),dhw[0],FALSE,FALSE,4);
dhw[1]=gtk_option_menu_new();
gtk_box_pack_start(GTK_BOX(dhb),dhw[1],FALSE,FALSE,2);
dhw[2]=gtk_menu_new();
for(i=0;i<10;i++) {
dhw[3]=gtk_menu_item_new_with_label(resumeo[i]);
gtk_signal_connect(GTK_OBJECT(dhw[3]),"activate",
GTK_SIGNAL_FUNC(time_menu),&nsrc[i]);
gtk_menu_append(GTK_MENU(dhw[2]),dhw[3]);
gtk_widget_show(dhw[3]);
}
gtk_option_menu_set_menu(GTK_OPTION_MENU(dhw[1]),dhw[2]);
dhw[12]=gtk_label_new("include entries from");
gtk_box_pack_start(GTK_BOX(dhb),dhw[12],FALSE,FALSE,4);
dhw[13]=gtk_option_menu_new();
gtk_box_pack_start(GTK_BOX(dhb),dhw[13],FALSE,FALSE,2);
dhw[14]=gtk_menu_new();
for(i=0,pt=isps;pt!=NULL;pt=g_list_next(pt),i++) {
dhw[3]=gtk_menu_item_new_with_label((char *)(pt->data));
gtk_signal_connect(GTK_OBJECT(dhw[3]),"activate",
GTK_SIGNAL_FUNC(isp_menu),&nsrc[i]);
gtk_menu_append(GTK_MENU(dhw[14]),dhw[3]);
gtk_widget_show(dhw[3]);
}
gtk_option_menu_set_menu(GTK_OPTION_MENU(dhw[13]),dhw[14]);
dhw[15]=gtk_label_new("include connections as");
gtk_box_pack_start(GTK_BOX(dhb),dhw[15],FALSE,FALSE,4);
dhw[16]=gtk_option_menu_new();
gtk_box_pack_start(GTK_BOX(dhb),dhw[16],FALSE,FALSE,2);
dhw[17]=gtk_menu_new();
for(i=0,pt=users;pt!=NULL;pt=g_list_next(pt),i++) {
dhw[3]=gtk_menu_item_new_with_label((char *)(pt->data));
gtk_signal_connect(GTK_OBJECT(dhw[3]),"activate",
GTK_SIGNAL_FUNC(user_menu),&nsrc[i]);
gtk_menu_append(GTK_MENU(dhw[17]),dhw[3]);
gtk_widget_show(dhw[3]);
}
gtk_option_menu_set_menu(GTK_OPTION_MENU(dhw[16]),dhw[17]);
dhw[5]=gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(mvb),dhw[5],FALSE,FALSE,3);
dhw[3]=gtk_hbox_new(FALSE,4);
gtk_box_pack_start(GTK_BOX(mvb),dhw[3],FALSE,TRUE,3);
dhw[4]=lresume[0]=gtk_label_new("\n\n\n\n\n");
dhw[6]=lresume[1]=gtk_label_new("\n\n\n\n\n");
for(i=0;i<2;i++)
gtk_label_set_justify(GTK_LABEL(lresume[i]),GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(dhw[3]),dhw[4],FALSE,TRUE,4);
gtk_box_pack_start(GTK_BOX(dhw[3]),dhw[6],FALSE,TRUE,4);
hgraph=dhw[7]=gtk_drawing_area_new();
gtk_drawing_area_size(GTK_DRAWING_AREA(dhw[7]),24*9+2,120);
gtk_widget_set_events(dhw[7],GDK_EXPOSURE_MASK);
gtk_box_pack_start(GTK_BOX(dhw[3]),dhw[7],FALSE,FALSE,4);
wgraph=dhw[8]=gtk_drawing_area_new();
gtk_drawing_area_size(GTK_DRAWING_AREA(dhw[8]),7*20+2,120);
gtk_widget_set_events(dhw[8],GDK_EXPOSURE_MASK);
gtk_box_pack_start(GTK_BOX(dhw[3]),dhw[8],FALSE,FALSE,4);
dhw[11]=gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(mvb),dhw[11],FALSE,FALSE,4);
dhw[9]=gtk_hbox_new(FALSE,2);
dhw[10]=gtk_label_new("Raw log listing (unfiltered):");
gtk_box_pack_start(GTK_BOX(mvb),dhw[9],FALSE,FALSE,4);
gtk_box_pack_start(GTK_BOX(dhw[9]),dhw[10],FALSE,FALSE,2);
/* list */
sw=gtk_scrolled_window_new(NULL,NULL);
gtk_box_pack_start(GTK_BOX(mvb),sw,TRUE,TRUE,4);
gtk_widget_show(sw);
gtk_container_set_border_width(GTK_CONTAINER(sw),0);
loglist=gtk_clist_new(8);
gtk_clist_set_shadow_type(GTK_CLIST(loglist),GTK_SHADOW_IN);
gtk_clist_set_selection_mode(GTK_CLIST(loglist),GTK_SELECTION_SINGLE);
for(i=0;i<8;i++) {
gtk_clist_set_column_title(GTK_CLIST(loglist),i,titles[i]);
gtk_clist_set_column_width(GTK_CLIST(loglist),i,colsize[i]);
}
gtk_clist_column_titles_passive(GTK_CLIST(loglist));
gtk_clist_column_titles_show(GTK_CLIST(loglist));
gtk_clist_set_row_height(GTK_CLIST(loglist),16);
gtk_clist_set_column_auto_resize(GTK_CLIST(loglist),1,FALSE);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(sw),loglist);
gtk_widget_show(loglist);
/* bottom */
dhw[18]=gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(mvb),dhw[18],FALSE,FALSE,4);
dhw[19]=gtk_table_new(1,6,TRUE);
dhw[21]=gtk_button_new_with_label(" About... ");
dhw[22]=gtk_button_new_with_label(" Close ");
dhw[23]=gtk_hbox_new(TRUE,6);
gtk_box_pack_start(GTK_BOX(mvb),dhw[19],FALSE,FALSE,4);
gtk_table_attach_defaults(GTK_TABLE(dhw[19]),dhw[23],4,6,0,1);
gtk_box_pack_start(GTK_BOX(dhw[23]),dhw[21],FALSE,TRUE,4);
gtk_box_pack_start(GTK_BOX(dhw[23]),dhw[22],FALSE,TRUE,4);
for(i=0;i<24;i++)
if (i!=20)
gtk_widget_show(dhw[i]);
gtk_widget_show(dhb);
gtk_widget_show(mvb);
iconmap[0] = gdk_pixmap_create_from_xpm_d (applet->window, &maskmap[0],
&style->bg[GTK_STATE_NORMAL],
(gchar **) status_ok_xpm);
iconmap[1] = gdk_pixmap_create_from_xpm_d (applet->window, &maskmap[1],
&style->bg[GTK_STATE_NORMAL],
(gchar **) status_error_xpm);
iconmap[2] = gdk_pixmap_create_from_xpm_d (applet->window, &maskmap[2],
&style->bg[GTK_STATE_NORMAL],
(gchar **) status_crash_xpm);
/* signal plumbing */
gtk_signal_connect (GTK_OBJECT (applet), "delete_event",
GTK_SIGNAL_FUNC (applet_kill), NULL);
gtk_signal_connect (GTK_OBJECT (applet), "destroy",
GTK_SIGNAL_FUNC (applet_destroy), NULL);
gtk_signal_connect (GTK_OBJECT (hgraph), "expose_event",
GTK_SIGNAL_FUNC (hgra_expose), NULL);
gtk_signal_connect (GTK_OBJECT (hgraph), "configure_event",
GTK_SIGNAL_FUNC (hgra_configure), NULL);
gtk_signal_connect (GTK_OBJECT (wgraph), "expose_event",
GTK_SIGNAL_FUNC (wgra_expose), NULL);
gtk_signal_connect (GTK_OBJECT (wgraph), "configure_event",
GTK_SIGNAL_FUNC (wgra_configure), NULL);
gtk_signal_connect (GTK_OBJECT (dhw[21]), "clicked",
GTK_SIGNAL_FUNC (applet_about),
(gpointer)GTK_WINDOW(applet));
gtk_signal_connect (GTK_OBJECT (dhw[22]), "clicked",
GTK_SIGNAL_FUNC (applet_destroy), NULL);
}
/**
* TBD
*/
void create_hist_list( void ) {
static char *title[1] = { "History" };
GtkStyle *style, *new_style;
gint sz, max_sz;
int n;
char tmp[80];
GtkWidget *scrolled_win;
GdkFont *private_font;
hist_list = gtk_clist_new_with_titles( 1, title );
/*
* When a selection is made, we want to know about it. The callback *
* used is selection_made, and its code can be found further down
*/
select_hist_handler_id =
gtk_signal_connect( GTK_OBJECT( hist_list ), "select_row", GTK_SIGNAL_FUNC( hist_list_selected ), NULL );
/*
* It isn't necessary to shadow the border, but it looks nice :)
*/
gtk_clist_set_shadow_type( GTK_CLIST( hist_list ), GTK_SHADOW_OUT );
/*
* Make sure titles are being shown
*/
gtk_clist_column_titles_show( GTK_CLIST( hist_list ) );
/*
* What however is important, is that we set the column widths as * they
* will never be right otherwise. Note that the columns are * numbered
* from 0 and up.
*/
style = gtk_widget_get_style( hist_list );
new_style = gtk_style_copy( style );
if ( ( private_font = gdk_font_load( "*courier-*-r*140*" ) ) == NULL )
if ( ( private_font = gdk_font_load( "*courier-*-r*120*" ) ) == NULL )
private_font = gtk_style_get_font( style );
gtk_style_set_font( style, private_font );
gtk_widget_set_style( hist_list, new_style );
for ( max_sz = 0, n = 0; n < 10; n++ ) {
sprintf( tmp, "%d: %s: %c%d",
RANDOM( 1, 60 ), ( rand( ) % 2 ) ? "Black" : "White", RANDOM( 0, 7 ) + 'A', RANDOM( 1, 8 ) );
sz = gdk_string_width( private_font, tmp );
if ( sz > max_sz )
max_sz = sz;
}
gtk_clist_set_column_width( GTK_CLIST( hist_list ), 0, max_sz );
/*
* --- Set the column justifications ---
*/
gtk_clist_set_column_justification( GTK_CLIST( hist_list ), 0, GTK_JUSTIFY_LEFT );
gtk_clist_column_titles_passive( GTK_CLIST( hist_list ) );
/*
* --- Selection mode ---
*/
gtk_clist_set_selection_mode( GTK_CLIST( hist_list ), GTK_SELECTION_BROWSE );
/*
* Add the GtkCList widget to the vertical box and show it.
*/
gtk_widget_show( hist_list );
scrolled_win = gtk_scrolled_window_new( NULL, NULL );
gtk_container_add( GTK_CONTAINER( scrolled_win ), hist_list );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolled_win ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
gtk_box_pack_start( GTK_BOX( main_hbox ), scrolled_win, FALSE, FALSE, 0 );
gtk_widget_show( scrolled_win );
} // create_hist_list
