/* shows how many armies you can move after an attack */
void tropas_window( int src, int dst, int cant )
{
GtkWidget *label;
GtkWidget *table;
GtkWidget *frame;
GtkWidget *vbox_dia,*vbox;
GtkWidget *hbox;
GtkAdjustment *adj;
char buf[200];
tropas_src = src;
tropas_dst = dst;
if( tropas_dialog != NULL ) {
gdk_window_show( tropas_dialog->window);
gdk_window_raise( tropas_dialog->window);
return ;
}
tropas_cant = 0;
// tropas_dialog = gnome_dialog_new(_("A country was conquered"),GNOME_STOCK_BUTTON_OK,NULL);
tropas_dialog = teg_dialog_new(_("A country was conquered"),_("A country was conquered"));
gnome_dialog_append_button( GNOME_DIALOG(tropas_dialog),GNOME_STOCK_BUTTON_OK);
gnome_dialog_set_parent (GNOME_DIALOG (tropas_dialog),
GTK_WINDOW (main_window));
gtk_signal_connect (GTK_OBJECT (tropas_dialog), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed), &tropas_dialog);
if( cant > 0 )
gnome_dialog_button_connect(GNOME_DIALOG(tropas_dialog), 0, GTK_SIGNAL_FUNC(tropas_ok_cb), NULL);
else
gnome_dialog_button_connect(GNOME_DIALOG(tropas_dialog), 0, GTK_SIGNAL_FUNC(tropas_close_cb), NULL);
vbox_dia = GNOME_DIALOG(tropas_dialog)->vbox;
table = gtk_table_new (2, 2, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), GNOME_PAD);
gtk_table_set_row_spacings (GTK_TABLE (table), GNOME_PAD);
gtk_table_set_col_spacings (GTK_TABLE (table), GNOME_PAD);
gtk_box_pack_start( GTK_BOX( vbox_dia), table, TRUE, TRUE, 0);
frame = gtk_frame_new (_("A new country"));
gtk_container_border_width (GTK_CONTAINER (frame), 0);
vbox = gtk_vbox_new (TRUE, 0);
gtk_container_border_width (GTK_CONTAINER (vbox), GNOME_PAD);
snprintf(buf,sizeof(buf)-1,_("You conquered '%s' in your attack from '%s'!!\n"), countries_get_name(dst), countries_get_name(src) );
buf[ sizeof(buf) -1 ] = 0;
label = gtk_label_new(buf);
gtk_box_pack_start( GTK_BOX( vbox), label, TRUE, TRUE, 0);
if( cant > 0) {
hbox = gtk_hbox_new( FALSE, 0);
gtk_container_add( GTK_CONTAINER( vbox ), hbox );
label = gtk_label_new(_("Armies to move"));
gtk_box_pack_start( GTK_BOX( hbox), label, TRUE, TRUE, 0);
adj = (GtkAdjustment *) gtk_adjustment_new( (gfloat) cant, 0.0, (gfloat) (cant + 1), 1.0, 1.0, 1.0 );
// tropas_spinner_cant = gtk_spin_button_new( adj, 0.0, 0);
tropas_hscale_cant = gtk_hscale_new( adj);
gtk_box_pack_start( GTK_BOX( hbox), tropas_hscale_cant, TRUE, TRUE, 0);
gtk_scale_set_digits(GTK_SCALE(tropas_hscale_cant), 0);
gtk_scale_set_draw_value(GTK_SCALE(tropas_hscale_cant),1);
/* gtk_range_draw_trough(GTK_RANGE(tropas_hscale_cant)); */
snprintf(buf, sizeof(buf) -1, _("[Note: The server moved 1 army to '%s' for you.\nChoose how many more armies you want to move]"), countries_get_name(dst) );
buf[ sizeof(buf) -1 ] = 0;
label = gtk_label_new(buf);
gtk_box_pack_start( GTK_BOX( vbox), label, TRUE, TRUE, 0);
}
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 0, 1, GTK_EXPAND |
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
if (!GTK_WIDGET_VISIBLE (tropas_dialog))
gtk_widget_show_all (tropas_dialog);
else
gtk_widget_destroy (tropas_dialog);
}
LayerOptionsDialog *
layer_options_dialog_new (GimpImage *image,
GimpLayer *layer,
GimpContext *context,
GtkWidget *parent,
const gchar *layer_name,
GimpFillType layer_fill_type,
const gchar *title,
const gchar *role,
const gchar *icon_name,
const gchar *desc,
const gchar *help_id)
{
LayerOptionsDialog *options;
GimpViewable *viewable;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *label;
GtkObject *adjustment;
GtkWidget *spinbutton;
GtkWidget *frame;
GtkWidget *button;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (layer == NULL || GIMP_IS_LAYER (layer), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL);
options = g_slice_new0 (LayerOptionsDialog);
options->image = image;
options->context = context;
options->layer = layer;
options->fill_type = layer_fill_type;
if (layer)
viewable = GIMP_VIEWABLE (layer);
else
viewable = GIMP_VIEWABLE (image);
options->dialog =
gimp_viewable_dialog_new (viewable, context,
title, role, icon_name, desc,
parent,
gimp_standard_help_func, help_id,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_object_weak_ref (G_OBJECT (options->dialog),
(GWeakNotify) layer_options_dialog_free, options);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (options->dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_set_spacing (GTK_BOX (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (options->dialog))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
table = gtk_table_new (layer ? 1 : 3, 2, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 6);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
/* The name label and entry */
options->name_entry = gtk_entry_new ();
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Layer _name:"), 0.0, 0.5,
options->name_entry, 1, FALSE);
gtk_entry_set_activates_default (GTK_ENTRY (options->name_entry), TRUE);
gtk_entry_set_text (GTK_ENTRY (options->name_entry), layer_name);
if (! layer)
{
gdouble xres;
gdouble yres;
gimp_image_get_resolution (image, &xres, &yres);
/* The size labels */
label = gtk_label_new (_("Width:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_widget_show (label);
label = gtk_label_new (_("Height:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_widget_show (label);
/* The size sizeentry */
spinbutton = gimp_spin_button_new (&adjustment,
1, 1, 1, 1, 10, 0,
1, 2);
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
options->size_se = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a",
TRUE, TRUE, FALSE, 10,
GIMP_SIZE_ENTRY_UPDATE_SIZE);
gtk_table_set_col_spacing (GTK_TABLE (options->size_se), 1, 4);
gtk_table_set_row_spacing (GTK_TABLE (options->size_se), 0, 2);
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (options->size_se),
GTK_SPIN_BUTTON (spinbutton), NULL);
gtk_table_attach_defaults (GTK_TABLE (options->size_se), spinbutton,
1, 2, 0, 1);
gtk_widget_show (spinbutton);
gtk_table_attach (GTK_TABLE (table), options->size_se, 1, 2, 1, 3,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (options->size_se);
gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (options->size_se),
GIMP_UNIT_PIXEL);
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 0,
xres, FALSE);
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 1,
yres, FALSE);
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 0,
GIMP_MIN_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE);
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 1,
GIMP_MIN_IMAGE_SIZE,
GIMP_MAX_IMAGE_SIZE);
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 0,
0, gimp_image_get_width (image));
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 1,
0, gimp_image_get_height (image));
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 0,
gimp_image_get_width (image));
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 1,
gimp_image_get_height (image));
/* The radio frame */
frame = gimp_enum_radio_frame_new_with_range (GIMP_TYPE_FILL_TYPE,
GIMP_FOREGROUND_FILL,
GIMP_TRANSPARENT_FILL,
gtk_label_new (_("Layer Fill Type")),
G_CALLBACK (gimp_radio_button_update),
&options->fill_type,
&button);
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button),
options->fill_type);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
}
else
{
GimpContainer *filters;
GtkWidget *frame;
GtkWidget *view;
/* For text layers add a toggle to control "auto-rename" */
if (gimp_item_is_text_layer (GIMP_ITEM (layer)))
{
options->rename_toggle =
gtk_check_button_new_with_mnemonic (_("Set name from _text"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->rename_toggle),
GIMP_TEXT_LAYER (layer)->auto_rename);
gtk_table_attach (GTK_TABLE (table), options->rename_toggle, 1, 2, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (options->rename_toggle);
g_signal_connect (options->rename_toggle, "toggled",
G_CALLBACK (layer_options_dialog_toggle_rename),
options);
}
frame = gimp_frame_new ("Active Filters");
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
filters = gimp_drawable_get_filters (GIMP_DRAWABLE (layer));
view = gimp_container_tree_view_new (filters, context,
GIMP_VIEW_SIZE_SMALL, 0);
gtk_container_add (GTK_CONTAINER (frame), view);
gtk_widget_show (view);
}
return options;
}
int module_init_win(HIME_module_main_functions *funcs)
{
gmf = *funcs;
// dbg("module_init_win\n");
gmf.mf_set_tsin_pho_mode();
gmf.mf_set_win1_cb((cb_selec_by_idx_t)select_idx, prev_page, next_page);
if (win_anthy)
return TRUE;
if (anthy_init() == -1) {
GtkWidget *dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Cannot init anthy. Please install anthy.");
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
return FALSE;
}
ac = anthy_create_context();
if (!ac) {
printf("anthy_create_context err\n");
return FALSE;
}
anthy_context_set_encoding(ac, ANTHY_UTF8_ENCODING);
win_anthy = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(win_anthy), FALSE);
gtk_window_set_default_size(GTK_WINDOW (win_anthy), 40, 50);
gtk_widget_realize (win_anthy);
gmf.mf_set_no_focus(win_anthy);
event_box_anthy = gtk_event_box_new();
gtk_event_box_set_visible_window (GTK_EVENT_BOX(event_box_anthy), FALSE);
gtk_container_add(GTK_CONTAINER(win_anthy), event_box_anthy);
GtkWidget *hbox_top = gtk_hbox_new (FALSE, 0);
gtk_container_add(GTK_CONTAINER(event_box_anthy), hbox_top);
g_signal_connect(G_OBJECT(event_box_anthy),"button-press-event",
G_CALLBACK(mouse_button_callback), NULL);
if (!seg) {
int n=sizeof(SEG)*MAX_SEG_N;
seg=malloc(n);
bzero(seg, n);
}
int i;
for(i=0; i < MAX_SEG_N; i++) {
seg[i].label = gtk_label_new(NULL);
gtk_widget_show(seg[i].label);
gtk_box_pack_start (GTK_BOX (hbox_top), seg[i].label, FALSE, FALSE, 0);
}
gtk_widget_show_all(win_anthy);
gmf.mf_init_tsin_selection_win();
module_change_font_size();
if (!gmf.mf_phkbm->selkeyN)
gmf.mf_load_tab_pho_file();
module_hide_win();
return TRUE;
}
// modified this to have 3 columns so we can display variable type
void FreeVarsWindowInitGtk( )
{
GtkWidget * hboxfreevars[ NBR_FREE_VAR_SPY ], *vboxMain;
char * VarName= NULL;
long ColumnVar;
int NumVarSpy,NumEntry,i=NBR_FREE_VAR_SPY;
GList *DisplayFormatItems = NULL;
SpyFreeVarsWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title ((GtkWindow *)SpyFreeVarsWindow, "Watch Window");
vboxMain = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (SpyFreeVarsWindow), vboxMain);
gtk_widget_show (vboxMain);
DisplayFormatItems = g_list_append(DisplayFormatItems,"Dec");
DisplayFormatItems = g_list_append(DisplayFormatItems,"Hex");
DisplayFormatItems = g_list_append(DisplayFormatItems,"Bin");
if ( NBR_WORDS < NBR_FREE_VAR_SPY) { i=NBR_WORDS ;}
for(NumVarSpy=0; NumVarSpy<i; NumVarSpy++)
{
hboxfreevars[ NumVarSpy ] = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (vboxMain), hboxfreevars[ NumVarSpy ]);
gtk_widget_show (hboxfreevars[ NumVarSpy ]);
for(ColumnVar=0; ColumnVar<3; ColumnVar++)
{
NumEntry = NumVarSpy+ColumnVar*NBR_FREE_VAR_SPY;
if ( ColumnVar==0)
{
LabelFreeVars[NumEntry] = gtk_label_new(NULL);
gtk_widget_set_usize((GtkWidget *)LabelFreeVars[NumEntry],100,0);
gtk_box_pack_start (GTK_BOX (hboxfreevars[ NumVarSpy ]), LabelFreeVars[NumEntry], FALSE, FALSE, 0);
gtk_widget_show (LabelFreeVars[NumEntry]);
}
if ( ColumnVar==1)
{
EntryVarSpy[ NumEntry ] = gtk_entry_new();
gtk_widget_show(EntryVarSpy[NumEntry]);
gtk_box_pack_start (GTK_BOX( hboxfreevars[ NumVarSpy ] ), EntryVarSpy[ NumEntry ], TRUE, TRUE, 0);
gtk_widget_set_usize((GtkWidget *)EntryVarSpy[ NumEntry ],(ColumnVar==1)?80:110,0);
VarName = CreateVarName(VarSpy[NumVarSpy][0],VarSpy[NumVarSpy][1]);
TooltipsEntryVarSpy[ NumVarSpy ] = gtk_tooltips_new();
gtk_entry_set_text((GtkEntry *)EntryVarSpy[ NumEntry ],VarName);
gtk_signal_connect(GTK_OBJECT (EntryVarSpy[ NumEntry ]), "activate",
(GtkSignalFunc) EntryVarSpy_activate_event, (void *)(intptr_t)NumVarSpy);
}
if ( ColumnVar==2)
{
EntryVarSpy[ NumEntry ] = gtk_entry_new();
gtk_widget_show(EntryVarSpy[NumEntry]);
gtk_box_pack_start (GTK_BOX( hboxfreevars[ NumVarSpy ] ), EntryVarSpy[ NumEntry ], TRUE, TRUE, 0);
gtk_widget_set_usize((GtkWidget *)EntryVarSpy[ NumEntry ],(ColumnVar==2)?80:110,0);
}
}
DisplayFormatVarSpy[NumVarSpy] = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(DisplayFormatVarSpy[NumVarSpy]), TRUE /*val*/, FALSE /*ok_if_empty*/);
gtk_combo_set_popdown_strings(GTK_COMBO(DisplayFormatVarSpy[NumVarSpy]), DisplayFormatItems);
gtk_widget_set_usize((GtkWidget *)DisplayFormatVarSpy[NumVarSpy],65,0);
gtk_box_pack_start (GTK_BOX(hboxfreevars[ NumVarSpy ]), DisplayFormatVarSpy[NumVarSpy], FALSE, FALSE, 0);
gtk_widget_show(DisplayFormatVarSpy[NumVarSpy]);
}
gtk_signal_connect( GTK_OBJECT(SpyFreeVarsWindow), "delete_event",
(GtkSignalFunc)FreeVarsWindowDeleteEvent, 0 );
}
/**
* gimp_display_shell_rotate_dialog:
* @shell: the #GimpDisplayShell
*
* Constructs and displays a dialog allowing the user to enter a
* custom display rotate.
**/
void
gimp_display_shell_rotate_dialog (GimpDisplayShell *shell)
{
RotateDialogData *data;
GimpImage *image;
GtkWidget *toplevel;
GtkWidget *hbox;
GtkWidget *spin;
GtkWidget *label;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
if (shell->rotate_dialog)
{
gtk_window_present (GTK_WINDOW (shell->rotate_dialog));
return;
}
image = gimp_display_get_image (shell->display);
data = g_slice_new (RotateDialogData);
data->shell = shell;
shell->rotate_dialog =
gimp_viewable_dialog_new (GIMP_VIEWABLE (image),
gimp_get_user_context (shell->display->gimp),
_("Rotate View"), "display-rotate",
GIMP_STOCK_ROTATE_180,
_("Select Rotation Angle"),
GTK_WIDGET (shell),
gimp_standard_help_func,
GIMP_HELP_VIEW_ROTATE_OTHER,
GIMP_STOCK_RESET, RESPONSE_RESET,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell->rotate_dialog),
GTK_RESPONSE_OK,
RESPONSE_RESET,
-1);
g_object_weak_ref (G_OBJECT (shell->rotate_dialog),
(GWeakNotify) gimp_display_shell_rotate_dialog_free, data);
g_object_add_weak_pointer (G_OBJECT (shell->rotate_dialog),
(gpointer) &shell->rotate_dialog);
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (shell));
gtk_window_set_transient_for (GTK_WINDOW (shell->rotate_dialog),
GTK_WINDOW (toplevel));
gtk_window_set_destroy_with_parent (GTK_WINDOW (shell->rotate_dialog), TRUE);
g_signal_connect (shell->rotate_dialog, "response",
G_CALLBACK (gimp_display_shell_rotate_dialog_response),
data);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (shell->rotate_dialog))),
hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Angle:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
spin = gimp_spin_button_new ((GtkObject **) &data->rotate_adj,
shell->rotate_angle,
0.0, 360.0,
1, 15, 0, 1, 2);
gtk_entry_set_activates_default (GTK_ENTRY (spin), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spin), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), spin, TRUE, TRUE, 0);
gtk_widget_show (spin);
label = gtk_label_new (_("degrees"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_signal_connect (data->rotate_adj, "value-changed",
G_CALLBACK (rotate_adjustment_changed),
data);
g_signal_connect (shell, "rotated",
G_CALLBACK (display_shell_rotated),
data);
gtk_widget_show (shell->rotate_dialog);
}
GtkWidget *
gnome_prefs_window_new (const gchar *logo_name)
{
GnomePrefsWindow *gpw = NULL;
GtkTreeSelection *selection = NULL;
GtkCellRenderer *cell = NULL;
GtkTreeStore *model = NULL;
GtkTreeViewColumn *column = NULL;
GtkWidget *window = NULL;
GtkWidget *event_box = NULL;
GtkWidget *hbox = NULL;
GtkWidget *vbox = NULL;
GtkWidget *frame = NULL;
GtkWidget *pixmap = NULL;
GtkWidget *hsep = NULL;
GdkColor cwhite;
PangoAttrList *attrs = NULL;
PangoAttribute *attr = NULL;
/* Box inside the prefs window */
GtkWidget *dialog_vbox = NULL;
/* Build the window */
window = gtk_dialog_new ();
gpw = (GnomePrefsWindow *) g_malloc (sizeof (GnomePrefsWindow));
gpw->last_page = 1;
g_object_set_data_full (G_OBJECT (window), "gpw", (gpointer) gpw, g_free);
gtk_dialog_add_button (GTK_DIALOG (window), GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL);
/* The sections */
gpw->notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (gpw->notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (gpw->notebook), FALSE);
pixmap = gtk_image_new_from_file (logo_name);
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box),
GTK_WIDGET (pixmap));
cwhite.red = 0xff * 0x100;
cwhite.green = 0xff * 0x100;
cwhite.blue = 0xff * 0x100;
gdk_colormap_alloc_color(gdk_colormap_get_system (), &cwhite, FALSE, TRUE);
gtk_widget_modify_bg (GTK_WIDGET (event_box),
GTK_STATE_NORMAL, &cwhite);
gtk_notebook_prepend_page (GTK_NOTEBOOK (gpw->notebook), event_box, NULL);
/* The sections */
dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (window));
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_container_add (GTK_CONTAINER (dialog_vbox), hbox);
/* Build the TreeView on the left */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
model = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_INT);
gpw->sections_tree_view = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (gpw->sections_tree_view),
GTK_TREE_MODEL (model));
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (gpw->sections_tree_view));
gtk_container_add (GTK_CONTAINER (frame), gpw->sections_tree_view);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gpw->sections_tree_view),
FALSE);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (NULL, cell, "text", 0,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (gpw->sections_tree_view),
GTK_TREE_VIEW_COLUMN (column));
gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection),
GTK_SELECTION_BROWSE);
/* Some design stuff to put the notebook pages in it */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
gpw->section_label = gtk_label_new (NULL);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_misc_set_alignment (GTK_MISC (gpw->section_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (frame), gpw->section_label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
attrs = pango_attr_list_new ();
attr = pango_attr_scale_new (PANGO_SCALE_LARGE);
attr->start_index = 0;
attr->end_index = G_MAXUINT;
pango_attr_list_insert (attrs, attr);
attr = pango_attr_weight_new (PANGO_WEIGHT_HEAVY);
attr->start_index = 0;
attr->end_index = G_MAXUINT;
pango_attr_list_insert (attrs, attr);
gtk_label_set_attributes (GTK_LABEL (gpw->section_label), attrs);
pango_attr_list_unref (attrs);
gtk_widget_show (gpw->section_label);
hsep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), hsep, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), gpw->notebook, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (dialog_vbox));
gtk_widget_show_all (GTK_WIDGET (gpw->sections_tree_view));
g_signal_connect (selection, "changed",
G_CALLBACK (tree_selection_changed_cb),
gpw);
return window;
}
void updater_app_ui_init(UpdaterAppState *app_state)
{
GtkWidget *vbox;
GtkWidget *summary_label;
GtkWidget *description_label;
GtkWidget *frame;
llassert(app_state != NULL);
// set up window and main container
std::string window_title = LLTrans::getString("UpdaterWindowTitle");
app_state->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(app_state->window),
window_title.c_str());
gtk_window_set_resizable(GTK_WINDOW(app_state->window), FALSE);
gtk_window_set_position(GTK_WINDOW(app_state->window),
GTK_WIN_POS_CENTER_ALWAYS);
gtk_container_set_border_width(GTK_CONTAINER(app_state->window), 12);
g_signal_connect(G_OBJECT(app_state->window), "delete-event",
G_CALLBACK(on_window_closed), app_state);
vbox = gtk_vbox_new(FALSE, 6);
gtk_container_add(GTK_CONTAINER(app_state->window), vbox);
// set top label
std::ostringstream label_ostr;
label_ostr << "<big><b>"
<< LLTrans::getString("UpdaterNowUpdating")
<< "</b></big>";
summary_label = gtk_label_new(NULL);
gtk_label_set_use_markup(GTK_LABEL(summary_label), TRUE);
gtk_label_set_markup(GTK_LABEL(summary_label),
label_ostr.str().c_str());
gtk_misc_set_alignment(GTK_MISC(summary_label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), summary_label, FALSE, FALSE, 0);
// create the description label
description_label = gtk_label_new(LLTrans::getString("UpdaterUpdatingDescriptive").c_str());
gtk_label_set_line_wrap(GTK_LABEL(description_label), TRUE);
gtk_misc_set_alignment(GTK_MISC(description_label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), description_label, FALSE, FALSE, 0);
// If an image path has been set, load the background images
if (!app_state->image_dir.empty()) {
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
// load the first image
app_state->image = gtk_image_new_from_file
(next_image_filename(app_state->image_dir, *app_state->image_dir_iter).c_str());
gtk_widget_set_size_request(app_state->image, 340, 310);
gtk_container_add(GTK_CONTAINER(frame), app_state->image);
// rotate the images every 5 seconds
app_state->image_rotation_timeout_id = g_timeout_add
(ROTATE_IMAGE_TIMEOUT, rotate_image_cb, app_state);
}
// set up progress bar, and update it roughly every 1/10 of a second
app_state->progress_bar = gtk_progress_bar_new();
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(app_state->progress_bar),
LLTrans::getString("UpdaterProgressBarTextWithEllipses").c_str());
gtk_box_pack_start(GTK_BOX(vbox),
app_state->progress_bar, FALSE, TRUE, 0);
app_state->progress_update_timeout_id = g_timeout_add
(UPDATE_PROGRESS_TIMEOUT, progress_update_timeout, app_state);
app_state->update_progress_text_timeout_id = g_timeout_add
(UPDATE_PROGRESS_TEXT_TIMEOUT, update_progress_text_timeout, app_state);
gtk_widget_show_all(app_state->window);
}
/** update the device list */
void _lib_import_ui_devices_update(dt_lib_module_t *self)
{
dt_lib_import_t *d = (dt_lib_import_t*)self->data;
GList *citem;
/* cleanup of widgets in devices container*/
GList *item;
if((item=gtk_container_get_children(GTK_CONTAINER(d->devices)))!=NULL)
do
{
gtk_container_remove(GTK_CONTAINER(d->devices),GTK_WIDGET(item->data));
}
while((item=g_list_next(item))!=NULL);
/* add the rescan button */
GtkButton *scan = GTK_BUTTON(gtk_button_new_with_label(_("scan for devices")));
d->scan_devices = scan;
gtk_button_set_alignment(scan, 0.05, 0.5);
g_object_set(G_OBJECT(scan), "tooltip-text", _("scan for newly attached devices"), (char *)NULL);
g_signal_connect (G_OBJECT(scan), "clicked",G_CALLBACK (_lib_import_scan_devices_callback), self);
gtk_box_pack_start(GTK_BOX(d->devices),GTK_WIDGET(scan),TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(d->devices),GTK_WIDGET(gtk_label_new("")),TRUE,TRUE,0);
uint32_t count=0;
/* FIXME: Verify that it's safe to access camctl->cameras list here ? */
if( (citem = g_list_first (darktable.camctl->cameras))!=NULL)
{
// Add detected supported devices
char buffer[512]= {0};
do
{
dt_camera_t *camera=(dt_camera_t *)citem->data;
count++;
/* add camera label */
GtkWidget *label = GTK_WIDGET (dtgtk_label_new (camera->model,DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_LEFT));
gtk_box_pack_start (GTK_BOX (d->devices),label,TRUE,TRUE,0);
/* set camera summary if available */
if( camera->summary.text !=NULL && strlen(camera->summary.text) >0 )
{
g_object_set(G_OBJECT(label), "tooltip-text", camera->summary.text, (char *)NULL);
}
else
{
sprintf(buffer,_("device \"%s\" connected on port \"%s\"."),camera->model,camera->port);
g_object_set(G_OBJECT(label), "tooltip-text", buffer, (char *)NULL);
}
/* add camera actions buttons */
GtkWidget *ib=NULL,*tb=NULL;
GtkWidget *vbx=gtk_vbox_new(FALSE,5);
if( camera->can_import==TRUE )
{
gtk_box_pack_start (GTK_BOX (vbx),(ib=gtk_button_new_with_label (_("import from camera"))),FALSE,FALSE,0);
d->import_camera = GTK_BUTTON(ib);
}
if( camera->can_tether==TRUE )
{
gtk_box_pack_start (GTK_BOX (vbx),(tb=gtk_button_new_with_label (_("tethered shoot"))),FALSE,FALSE,0);
d->tethered_shoot = GTK_BUTTON(tb);
}
if( ib )
{
g_signal_connect (G_OBJECT (ib), "clicked",G_CALLBACK (_lib_import_from_camera_callback), camera);
gtk_button_set_alignment(GTK_BUTTON(ib), 0.05, 0.5);
}
if( tb )
{
g_signal_connect (G_OBJECT (tb), "clicked",G_CALLBACK (_lib_import_tethered_callback), camera);
gtk_button_set_alignment(GTK_BUTTON(tb), 0.05, 0.5);
}
gtk_box_pack_start (GTK_BOX (d->devices),vbx,FALSE,FALSE,0);
}
while ((citem=g_list_next (citem))!=NULL);
}
if( count == 0 )
{
// No supported devices is detected lets notice user..
gtk_box_pack_start(GTK_BOX(d->devices),gtk_label_new(_("no supported devices found")),TRUE,TRUE,0);
}
gtk_widget_show_all(GTK_WIDGET(d->devices));
}
static GtkWidget* _lib_import_get_extra_widget(dt_lib_import_metadata_t *data, gboolean import_folder)
{
// add extra lines to 'extra'. don't forget to destroy the widgets later.
GtkWidget *expander = gtk_expander_new(_("import options"));
gtk_expander_set_expanded(GTK_EXPANDER(expander), dt_conf_get_bool("ui_last/import_options_expanded"));
GtkWidget *frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_IN);
GtkWidget *alignment = gtk_alignment_new(1.0, 1.0, 1.0, 1.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 8, 8, 8, 8);
GtkWidget *event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(frame), event_box);
gtk_container_add(GTK_CONTAINER(event_box), alignment);
gtk_container_add(GTK_CONTAINER(alignment), expander);
GtkWidget *extra;
extra = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(expander), extra);
GtkWidget *recursive = NULL, *ignore_jpeg = NULL;
if(import_folder == TRUE)
{
// recursive opening.
recursive = gtk_check_button_new_with_label (_("import directories recursively"));
g_object_set(recursive, "tooltip-text", _("recursively import subdirectories. each directory goes into a new film roll."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (recursive), dt_conf_get_bool("ui_last/import_recursive"));
gtk_box_pack_start(GTK_BOX (extra), recursive, FALSE, FALSE, 0);
// ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.
ignore_jpeg = gtk_check_button_new_with_label (_("ignore JPEG files"));
g_object_set(ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are raw+JPEG in a directory."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs"));
gtk_box_pack_start(GTK_BOX (extra), ignore_jpeg, FALSE, FALSE, 0);
}
// default metadata
GtkWidget *apply_metadata;
GtkWidget *table, *label, *creator, *publisher, *rights, *tags;
apply_metadata = gtk_check_button_new_with_label (_("apply metadata on import"));
g_object_set(apply_metadata, "tooltip-text", _("apply some metadata to all newly imported images."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (apply_metadata), dt_conf_get_bool("ui_last/import_apply_metadata"));
gtk_box_pack_start(GTK_BOX (extra), apply_metadata, FALSE, FALSE, 0);
GValue value = {0, };
g_value_init(&value, G_TYPE_INT);
gtk_widget_style_get_property(apply_metadata, "indicator-size", &value);
gint indicator_size = g_value_get_int(&value);
// gtk_widget_style_get_property(apply_metadata, "indicator-spacing", &value);
// gint indicator_spacing = g_value_get_int(&value);
table = gtk_table_new(6, 3, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacings(GTK_TABLE(table), 5);
alignment = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 2*indicator_size, 0);
gtk_container_add(GTK_CONTAINER(alignment), table);
gtk_box_pack_start(GTK_BOX (extra), alignment, FALSE, FALSE, 0);
creator = gtk_entry_new();
gtk_widget_set_size_request(creator, 300, -1);
gtk_entry_set_text(GTK_ENTRY(creator), dt_conf_get_string("ui_last/import_last_creator"));
publisher = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(publisher), dt_conf_get_string("ui_last/import_last_publisher"));
rights = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(rights), dt_conf_get_string("ui_last/import_last_rights"));
tags = gtk_entry_new();
g_object_set(tags, "tooltip-text", _("comma separated list of tags"), NULL);
gtk_entry_set_text(GTK_ENTRY(tags), dt_conf_get_string("ui_last/import_last_tags"));
// presets from the metadata plugin
GtkCellRenderer *renderer;
GtkTreeIter iter;
GtkListStore *model = gtk_list_store_new(N_COLUMNS,
G_TYPE_STRING /*name*/,
G_TYPE_STRING /*creator*/,
G_TYPE_STRING /*publisher*/,
G_TYPE_STRING /*rights*/);
GtkWidget *presets = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(presets), renderer, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(presets), renderer, "text", NAME_COLUMN, NULL);
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params from presets where operation = \"metadata\"", -1, &stmt, NULL);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
void *op_params = (void *)sqlite3_column_blob(stmt, 1);
int32_t op_params_size = sqlite3_column_bytes(stmt, 1);
char *buf = (char* )op_params;
char *title = buf;
buf += strlen(title) + 1;
char *description = buf;
buf += strlen(description) + 1;
char *rights = buf;
buf += strlen(rights) + 1;
char *creator = buf;
buf += strlen(creator) + 1;
char *publisher = buf;
if(op_params_size == strlen(title) + strlen(description) + strlen(rights) + strlen(creator) + strlen(publisher) + 5)
{
gtk_list_store_append(model, &iter);
gtk_list_store_set (model, &iter,
NAME_COLUMN, (char *)sqlite3_column_text(stmt, 0),
CREATOR_COLUMN, creator,
PUBLISHER_COLUMN, publisher,
RIGHTS_COLUMN, rights,
-1);
}
}
sqlite3_finalize(stmt);
g_object_unref(model);
int line = 0;
label = gtk_label_new(_("preset"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), presets, 1, 2, line, line+1, GTK_FILL, 0, 0, 0);
line++;
label = gtk_label_new(_("creator"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), creator, 1, 2, line, line+1, GTK_FILL, 0, 0, 0);
line++;
label = gtk_label_new(_("publisher"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), publisher, 1, 2, line, line+1, GTK_FILL, 0, 0, 0);
line++;
label = gtk_label_new(_("rights"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), rights, 1, 2, line, line+1, GTK_FILL, 0, 0, 0);
line++;
label = gtk_label_new(_("tags"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), tags, 1, 2, line, line+1, GTK_FILL, 0, 0, 0);
gtk_widget_show_all(frame);
if(data != NULL)
{
data->frame = frame;
data->recursive = recursive;
data->ignore_jpeg = ignore_jpeg;
data->expander = expander;
data->apply_metadata = apply_metadata;
data->presets = presets;
data->creator = creator;
data->publisher = publisher;
data->rights = rights;
data->tags = tags;
}
g_signal_connect(apply_metadata, "toggled", G_CALLBACK (_lib_import_apply_metadata_toggled), table);
_lib_import_apply_metadata_toggled(apply_metadata, table); // needed since the apply_metadata starts being turned off,
// and setting it to off doesn't emit the 'toggled' signal ...
g_signal_connect(presets, "changed", G_CALLBACK(_lib_import_presets_changed), data);
g_signal_connect(GTK_ENTRY(creator), "changed", G_CALLBACK (_lib_import_metadata_changed), presets);
g_signal_connect(GTK_ENTRY(publisher), "changed", G_CALLBACK (_lib_import_metadata_changed), presets);
g_signal_connect(GTK_ENTRY(rights), "changed", G_CALLBACK (_lib_import_metadata_changed), presets);
return frame;
}
void
cal_notes_browser (GUI *appGUI)
{
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *scrolledwindow;
GtkWidget *hseparator;
GtkWidget *hbuttonbox;
GtkWidget *close_button;
GtkWidget *notes_tools_table;
GtkWidget *label;
GtkObject *notes_month_spinbutton_adj;
GtkObject *notes_year_spinbutton_adj;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
gchar tmpbuf[BUFFER_SIZE];
appGUI->cal->day_notes_list = NULL;
appGUI->cal->day_notes_list_store = NULL;
appGUI->cal->day_notes_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (appGUI->cal->day_notes_window), _("Calendar notes"));
gtk_window_set_position (GTK_WINDOW (appGUI->cal->day_notes_window), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_default_size (GTK_WINDOW(appGUI->cal->day_notes_window), config.cb_window_size_x, config.cb_window_size_y);
gtk_window_set_modal (GTK_WINDOW (appGUI->cal->day_notes_window), TRUE);
g_signal_connect (G_OBJECT (appGUI->cal->day_notes_window), "delete_event",
G_CALLBACK(day_notes_window_close_cb), appGUI);
gtk_window_set_transient_for(GTK_WINDOW(appGUI->cal->day_notes_window), GTK_WINDOW(appGUI->main_window));
gtk_container_set_border_width (GTK_CONTAINER (appGUI->cal->day_notes_window), 8);
g_signal_connect (G_OBJECT (appGUI->cal->day_notes_window), "key_press_event",
G_CALLBACK (day_notes_key_press_cb), appGUI);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (appGUI->cal->day_notes_window), vbox1);
notes_tools_table = gtk_table_new (6, 3, FALSE);
gtk_widget_show (notes_tools_table);
gtk_box_pack_start (GTK_BOX (vbox1), notes_tools_table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (notes_tools_table), 3);
gtk_table_set_col_spacings (GTK_TABLE (notes_tools_table), 2);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 2);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 2);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 2);
sprintf(tmpbuf, "<b>%s:</b>", _("Search"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (notes_tools_table), label, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_table_attach (GTK_TABLE (notes_tools_table), hbox1, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
notes_month_spinbutton_adj = gtk_adjustment_new (1, 1, 12, 1, 5, 0);
appGUI->cal->notes_month_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (notes_month_spinbutton_adj), 1, 0);
gtk_widget_show (appGUI->cal->notes_month_spinbutton);
gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->notes_month_spinbutton, TRUE, TRUE, 0);
g_signal_connect (appGUI->cal->notes_month_spinbutton, "value-changed",
G_CALLBACK (notes_filter_changed_cb), appGUI);
notes_year_spinbutton_adj = gtk_adjustment_new (utl_date_get_current_year (), 1, 9999, 1, 10, 0);
appGUI->cal->notes_year_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (notes_year_spinbutton_adj), 1, 0);
gtk_widget_show (appGUI->cal->notes_year_spinbutton);
gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->notes_year_spinbutton, TRUE, TRUE, 0);
g_signal_connect (appGUI->cal->notes_year_spinbutton, "value-changed",
G_CALLBACK (notes_filter_changed_cb), appGUI);
sprintf(tmpbuf, "<b>%s:</b>", _("Filter"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (notes_tools_table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->cal->notes_filter_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->cal->notes_filter_combobox);
g_signal_connect(G_OBJECT(appGUI->cal->notes_filter_combobox), "focus",
G_CALLBACK(notes_filter_combo_box_focus_cb), NULL);
g_signal_connect(G_OBJECT(appGUI->cal->notes_filter_combobox), "changed",
G_CALLBACK(notes_filter_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_filter_combobox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Current month"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected month"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Current year"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected year"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected month and year"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("All notes"));
gtk_combo_box_set_active(GTK_COMBO_BOX(appGUI->cal->notes_filter_combobox), config.day_notes_browser_filter);
appGUI->cal->n_items_label = gtk_label_new ("");
gtk_widget_show (appGUI->cal->n_items_label);
gtk_widget_set_size_request (appGUI->cal->n_items_label, 100, -1);
gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->n_items_label, 2, 3, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (appGUI->cal->n_items_label), TRUE);
appGUI->cal->notes_search_entry = gtk_entry_new ();
gtk_widget_show (appGUI->cal->notes_search_entry);
gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_search_entry, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect (G_OBJECT (appGUI->cal->notes_search_entry), "key_press_event",
G_CALLBACK (search_entry_key_press_cb), appGUI);
appGUI->cal->notes_search_checkbutton = gtk_check_button_new_with_mnemonic (_("Case sensitive"));
gtk_widget_show (appGUI->cal->notes_search_checkbutton);
GTK_WIDGET_UNSET_FLAGS(appGUI->cal->notes_search_checkbutton, GTK_CAN_FOCUS);
gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_search_checkbutton, 2, 3, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
appGUI->cal->past_notes_checkbutton = gtk_check_button_new_with_mnemonic (_("Strikethrough past day notes"));
GTK_WIDGET_UNSET_FLAGS(appGUI->cal->past_notes_checkbutton, GTK_CAN_FOCUS);
g_signal_connect (G_OBJECT (appGUI->cal->past_notes_checkbutton), "toggled",
G_CALLBACK (browser_past_notes_cb), appGUI);
gtk_widget_show (appGUI->cal->past_notes_checkbutton);
gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->past_notes_checkbutton, 0, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 2);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow);
gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->cal->day_notes_list_store = gtk_list_store_new(DAY_NOTES_NUM_COLUMNS,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_BOOLEAN);
appGUI->cal->day_notes_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->cal->day_notes_list_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->cal->day_notes_list), TRUE);
gtk_widget_show (appGUI->cal->day_notes_list);
GTK_WIDGET_SET_FLAGS (appGUI->cal->day_notes_list, GTK_CAN_DEFAULT);
gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->cal->day_notes_list);
g_signal_connect(G_OBJECT(appGUI->cal->day_notes_list), "button_press_event",
G_CALLBACK(day_notes_list_dbclick_cb), appGUI);
appGUI->cal->day_notes_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->cal->day_notes_list));
/* create columns */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Date"), renderer,
"text", DN_COLUMN_DATE,
"strikethrough", DN_COLUMN_DONE,
NULL);
gtk_tree_view_column_set_visible (column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Julian", renderer,
"text", DN_COLUMN_DATE_JULIAN,
"strikethrough", DN_COLUMN_DONE,
NULL);
gtk_tree_view_column_set_visible (column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column);
gtk_tree_view_column_set_sort_column_id (column, DN_COLUMN_DATE_JULIAN);
g_signal_emit_by_name(column, "clicked");
if (config.ascending_sorting_in_day_notes_browser == FALSE) {
g_signal_emit_by_name(column, "clicked");
}
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes(_("Note"), renderer,
"text", DN_COLUMN_NOTE_LINE,
"strikethrough", DN_COLUMN_DONE,
NULL);
gtk_tree_view_column_set_visible (column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
"text", DN_COLUMN_DONE,
NULL);
gtk_tree_view_column_set_visible (column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column);
refresh_notes_list (config.day_notes_browser_filter, NULL, appGUI);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);
hbuttonbox = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox), 4);
close_button = utl_gui_create_button (GTK_STOCK_CLOSE, OSMO_STOCK_BUTTON_CLOSE, _("Close"));
gtk_widget_show (close_button);
GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS);
g_signal_connect(close_button, "clicked", G_CALLBACK(button_day_notes_window_close_cb), appGUI);
gtk_container_add(GTK_CONTAINER(hbuttonbox), close_button);
gtk_widget_show(appGUI->cal->day_notes_window);
gtk_widget_grab_focus (appGUI->cal->day_notes_list);
}
static void
refresh_widget (NemoScriptConfigWidget *widget)
{
if (widget->scripts != NULL) {
g_list_free_full (widget->scripts, (GDestroyNotify) script_proxy_free);
widget->scripts = NULL;
}
nemo_config_base_widget_clear_list (NEMO_CONFIG_BASE_WIDGET (widget));
gchar *path = NULL;
path = nemo_get_scripts_directory_path ();
populate_from_directory (widget, path);
g_clear_pointer (&path, g_free);
if (widget->scripts == NULL) {
GtkWidget *empty_label = gtk_label_new (NULL);
gchar *markup = NULL;
markup = g_strdup_printf ("<i>%s</i>", _("No scripts found"));
gtk_label_set_markup (GTK_LABEL (empty_label), markup);
g_free (markup);
GtkWidget *empty_row = gtk_list_box_row_new ();
gtk_container_add (GTK_CONTAINER (empty_row), empty_label);
gtk_widget_show_all (empty_row);
gtk_container_add (GTK_CONTAINER (NEMO_CONFIG_BASE_WIDGET (widget)->listbox), empty_row);
gtk_widget_set_sensitive (GTK_WIDGET (NEMO_CONFIG_BASE_WIDGET (widget)->listbox), FALSE);
} else {
GList *l;
gchar **blacklist = g_settings_get_strv (nemo_plugin_preferences,
NEMO_PLUGIN_PREFERENCES_DISABLED_SCRIPTS);
for (l = widget->scripts; l != NULL; l=l->next) {
ScriptProxy *proxy = l->data;
gboolean active = TRUE;
gint i = 0;
for (i = 0; i < g_strv_length (blacklist); i++) {
if (g_strcmp0 (blacklist[i], proxy->name) == 0) {
active = FALSE;
break;
}
}
GtkWidget *w;
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *button = gtk_check_button_new ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), active);
g_signal_connect (button, "toggled", G_CALLBACK (on_check_toggled), proxy);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 2);
w = gtk_label_new (proxy->name);
gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 2);
GtkWidget *row = gtk_list_box_row_new ();
gtk_container_add (GTK_CONTAINER (row), box);
gtk_widget_show_all (row);
gtk_container_add (GTK_CONTAINER (NEMO_CONFIG_BASE_WIDGET (widget)->listbox), row);
}
gtk_widget_set_sensitive (GTK_WIDGET (NEMO_CONFIG_BASE_WIDGET (widget)->listbox), TRUE);
g_strfreev (blacklist);
}
nemo_config_base_widget_set_default_buttons_sensitive (NEMO_CONFIG_BASE_WIDGET (widget), widget->scripts != NULL);
}
void rozkor_r(class rozkor_data *rek_ras,GtkWidget *wpredok)
{
char strsql[512];
iceb_u_spisok repl_s;
class rozkor_r_data data;
data.rk=rek_ras;
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
sprintf(strsql,"%s %s",name_system,gettext("Оформить возврат"));
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(rozkor_r_key_press),&data);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(data.window), vbox);
data.label=gtk_label_new(gettext("Ждите !!!"));
gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0);
GtkWidget *label=gtk_label_new(gettext("Оформить возврат"));
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
data.view=gtk_text_view_new();
gtk_widget_set_usize(GTK_WIDGET(data.view),450,300);
gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango);
pango_font_description_free(font_pango);
data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view));
GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL);
//gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(sw),data.view);
data.bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2);
gtk_widget_show_all(data.window);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka=gtk_button_new_with_label(strsql);
GtkTooltips *tooltops=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(rozkor_r_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0);
gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2);
//gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна
//gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна
gtk_idle_add((GtkFunction)rozkor_r1,&data);
gtk_main();
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
if(data.metka_fil == 0)
iceb_rabfil(&data.imafil,&data.naimfil,"",0,wpredok);
}
int main(int argc, char **argv){
GtkWidget *window_main;
GtkWidget *box_main;
GtkWidget *box_base;
GtkWidget* box_input;
GtkWidget* box_input_b;
GtkWidget* box_input_t;
GtkWidget* box_output;
GtkWidget* box_output_b;
GtkWidget* box_output_t;
GtkWidget* button_clear;
GtkWidget* button_solve;
GtkWidget* button_for;
GtkWidget* button_bak;
GtkWidget* scr;
GtkWidget* scr2;
GtkWidget* image_header;
GtkWidget* label_out;
GtkWidget* label_in;
GtkWidget* label_out_2;
gtk_init(&argc, &argv);
window_main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window_main), "---Gauss-Jordan Elimination---");
gtk_window_set_default_size(GTK_WINDOW(window_main), 800, 400);
box_main = gtk_vbox_new (FALSE, 0);
box_base = gtk_hbox_new (FALSE, 0);
box_input = gtk_vbox_new (FALSE, 0);
box_input_b = gtk_hbutton_box_new ();
box_input_t = gtk_hbox_new (FALSE, 0);
box_output = gtk_vbox_new (FALSE, 0);
box_output_b = gtk_hbutton_box_new ();
box_output_t = gtk_hbox_new (FALSE, 0);
box_output_e = gtk_vbox_new (FALSE, 0);
button_clear = gtk_button_new_with_label ("clear");
button_solve = gtk_button_new_with_label ("solve");
button_for = gtk_button_new_with_label ("forword");
button_bak = gtk_button_new_with_label ("backword");
entry_out = gtk_entry_new();
image_header = gtk_image_new();
label_in = gtk_label_new("input");
label_out = gtk_label_new("output");
label_out_2 = gtk_label_new("steps");
gtk_button_box_set_layout(GTK_BUTTON_BOX(box_input_b), GTK_BUTTONBOX_CENTER);
gtk_box_set_spacing(GTK_BOX(box_input_b), 0);
gtk_button_box_set_layout(GTK_BUTTON_BOX(box_output_b), GTK_BUTTONBOX_CENTER);
gtk_box_set_spacing(GTK_BOX(box_output_b), 0);
gtk_image_set_from_file (GTK_IMAGE (image_header), "header.jpg");
gtk_box_pack_start (GTK_BOX (box_main), image_header, FALSE, FALSE, 1);
gtk_widget_show (image_header);
gtk_box_pack_start (GTK_BOX (box_input), label_in, FALSE, FALSE, 1);
gtk_widget_show (label_in);
gtk_signal_connect (GTK_OBJECT (button_clear), "clicked",
GTK_SIGNAL_FUNC (clear), NULL);
gtk_box_pack_start (GTK_BOX (box_input_b), button_clear, FALSE, FALSE, 1);
gtk_widget_show (button_clear);
gtk_signal_connect (GTK_OBJECT (button_solve), "clicked",
GTK_SIGNAL_FUNC (get), NULL);
gtk_box_pack_start (GTK_BOX (box_input_b), button_solve, FALSE, FALSE, 1);
gtk_widget_show (button_solve);
gtk_box_pack_start(GTK_BOX (box_input), box_input_b, FALSE, FALSE, 1);
gtk_widget_show (box_input_b);
text_rem = gtk_text_view_new();
scr = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scr), text_rem);
gtk_box_pack_start(GTK_BOX (box_input_t), scr, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX (box_input), box_input_t, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX (box_base), box_input, TRUE, TRUE, 1);
gtk_widget_show(scr);
gtk_widget_show(text_rem);
gtk_widget_show(box_input);
gtk_widget_show(box_input_t);
gtk_box_pack_start (GTK_BOX (box_output), label_out_2, FALSE, FALSE, 1);
gtk_widget_show (label_out_2);
gtk_signal_connect (GTK_OBJECT (button_bak), "clicked",
GTK_SIGNAL_FUNC (set_steps_back), NULL);
gtk_box_pack_start (GTK_BOX (box_output_b), button_bak, TRUE, TRUE, 1);
gtk_widget_show (button_bak);
gtk_signal_connect (GTK_OBJECT (button_for), "clicked",
GTK_SIGNAL_FUNC (set_steps), NULL);
gtk_box_pack_start (GTK_BOX (box_output_b), button_for, TRUE, TRUE, 1);
gtk_widget_show (button_for);
gtk_box_pack_start(GTK_BOX (box_output), box_output_b, FALSE, FALSE, 1);
gtk_widget_show (box_output_b);
text_step = gtk_text_view_new();
scr2 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scr2), text_step);
gtk_box_pack_start(GTK_BOX (box_output_t), scr2, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX (box_output), box_output_t, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX (box_base), box_output, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX (box_main), box_base, TRUE, TRUE, 1);
gtk_widget_show(scr2);
gtk_widget_show(text_step);
gtk_widget_show(box_output);
gtk_widget_show(box_output_t);
gtk_widget_show(box_base);
gtk_box_pack_start(GTK_BOX (box_output_e), label_out, FALSE, FALSE, 1);
gtk_widget_show(label_out);
gtk_box_pack_start(GTK_BOX (box_output_e), entry_out, FALSE, FALSE, 1);
gtk_widget_show(entry_out);
gtk_box_pack_start(GTK_BOX (box_main), box_output_e, FALSE, FALSE, 3);
gtk_widget_show(box_output_e);
gtk_container_add(GTK_CONTAINER (window_main), box_main);
gtk_widget_show(box_main);
gtk_widget_show(window_main);
gtk_main();
return 0;
}
/* window that shows armies to move in a regroup */
void reagrupe_window( int src, int dst, int cant )
{
GtkWidget *label;
GtkWidget *table;
GtkWidget *frame;
GtkWidget *vbox_dia,*vbox;
GtkWidget *hbox;
GtkAdjustment *adj;
char buf[200];
reagrupe_src = src;
reagrupe_dst = dst;
if( reagrupe_dialog != NULL ) {
gdk_window_show( reagrupe_dialog->window);
gdk_window_raise( reagrupe_dialog->window);
return ;
}
reagrupe_cant = 0;
// reagrupe_dialog = gnome_dialog_new(_("Regrouping armies"),GNOME_STOCK_BUTTON_OK,NULL);
reagrupe_dialog = teg_dialog_new(_("Regrouping armies"),_("Regroup your armies"));
// Make the dialog modal (=main window is deactivated while the dialog is open) to fix
// bug [689687]: Error, unexpected error in reagrupe_click().
gtk_window_set_modal( GTK_WINDOW( reagrupe_dialog ), TRUE );
gnome_dialog_append_button(GNOME_DIALOG(reagrupe_dialog), GNOME_STOCK_BUTTON_OK);
gnome_dialog_set_parent (GNOME_DIALOG (reagrupe_dialog),
GTK_WINDOW (main_window));
gtk_signal_connect (GTK_OBJECT (reagrupe_dialog), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed), &reagrupe_dialog);
// When ok gets pressed, call reagrupe_ok_cb().
gnome_dialog_button_connect(GNOME_DIALOG(reagrupe_dialog), 0, GTK_SIGNAL_FUNC(reagrupe_ok_cb), NULL);
vbox_dia = GNOME_DIALOG(reagrupe_dialog)->vbox;
table = gtk_table_new (2, 2, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), GNOME_PAD);
gtk_table_set_row_spacings (GTK_TABLE (table), GNOME_PAD);
gtk_table_set_col_spacings (GTK_TABLE (table), GNOME_PAD);
gtk_box_pack_start( GTK_BOX( vbox_dia), table, TRUE, TRUE, 0);
frame = gtk_frame_new (_("Regrouping"));
gtk_container_border_width (GTK_CONTAINER (frame), 0);
vbox = gtk_vbox_new (TRUE, 0);
gtk_container_border_width (GTK_CONTAINER (vbox), GNOME_PAD);
snprintf(buf, sizeof(buf) -1, _("Moving armies from '%s' to '%s'\n"), countries_get_name(src), countries_get_name(dst) );
buf[ sizeof(buf) -1 ] = 0;
label = gtk_label_new(buf);
gtk_box_pack_start( GTK_BOX( vbox), label, TRUE, TRUE, 0);
hbox = gtk_hbox_new( FALSE, 0);
gtk_container_add( GTK_CONTAINER( vbox ), hbox );
label = gtk_label_new(_("Armies to move"));
gtk_box_pack_start( GTK_BOX( hbox), label, TRUE, TRUE, 0);
adj = (GtkAdjustment *) gtk_adjustment_new( (gfloat) cant, 0.0, (gfloat) (cant + 1), 1.0, 1.0, 1.0 );
reagrupe_hscale_cant = gtk_hscale_new( adj);
gtk_box_pack_start( GTK_BOX( hbox), reagrupe_hscale_cant, TRUE, TRUE, 0);
gtk_scale_set_digits(GTK_SCALE(reagrupe_hscale_cant), 0);
gtk_scale_set_draw_value(GTK_SCALE(reagrupe_hscale_cant),1);
/* gtk_range_draw_trough(GTK_RANGE(reagrupe_hscale_cant)); */
snprintf(buf, sizeof(buf) -1,_("[Note: You can regroup as many times as you want,\nas long as you don't regroup an army that was\nregrouped before in this turn.]"));
buf[ sizeof(buf) -1 ] = 0;
label = gtk_label_new(buf);
gtk_box_pack_start( GTK_BOX( vbox), label, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 0, 1, GTK_EXPAND |
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
if (!GTK_WIDGET_VISIBLE (reagrupe_dialog))
gtk_widget_show_all (reagrupe_dialog);
else
gtk_widget_destroy (reagrupe_dialog);
}
static void
button_clicked (GtkButton *button, GNCSearchAccount *fi)
{
GNCSearchAccountPrivate *priv;
GtkDialog *dialog;
GtkWidget *account_tree;
GtkWidget *accounts_scroller;
GtkWidget *label;
char *desc;
GtkTreeSelection *selection;
/* Create the account tree */
account_tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(account_tree), FALSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(account_tree));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
/* Select the currently-selected accounts */
priv = _PRIVATE(fi);
if (priv->selected_accounts)
gnc_tree_view_account_set_selected_accounts (GNC_TREE_VIEW_ACCOUNT(account_tree),
priv->selected_accounts, FALSE);
/* Create the account scroller and put the tree in it */
accounts_scroller = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(accounts_scroller),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(accounts_scroller), account_tree);
gtk_widget_set_size_request(GTK_WIDGET(accounts_scroller), 300, 300);
/* Create the label */
label = gtk_label_new (_("Select Accounts to Match"));
/* Create the dialog */
dialog =
GTK_DIALOG(gtk_dialog_new_with_buttons(_("Select the Accounts to Compare"),
NULL,
0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL));
/* Put the dialog together */
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area (dialog), label,
FALSE, FALSE, 3);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area (dialog), accounts_scroller,
TRUE, TRUE, 3);
gtk_widget_show_all (GTK_WIDGET (dialog));
/* Now run the dialog */
if (gtk_dialog_run (dialog) == GTK_RESPONSE_OK)
{
if (priv->selected_accounts)
g_list_free (priv->selected_accounts);
priv->selected_accounts =
gnc_tree_view_account_get_selected_accounts (GNC_TREE_VIEW_ACCOUNT (account_tree));
desc = describe_button (fi);
gtk_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), desc);
}
gtk_widget_destroy (GTK_WIDGET (dialog));
}
void
properties_cb (GtkAction *action,
EyesApplet *eyes_applet)
{
GtkWidget *pbox, *hbox;
GtkWidget *vbox, *indent;
GtkWidget *categories_vbox;
GtkWidget *category_vbox, *control_vbox;
GtkWidget *tree;
GtkWidget *scrolled;
GtkWidget *label;
GtkListStore *model;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeSelection *selection;
GtkTreeIter iter;
DIR *dfd;
struct dirent *dp;
int i;
#ifdef PATH_MAX
gchar filename [PATH_MAX];
#else
gchar *filename;
#endif
gchar *title;
if (eyes_applet->prop_box.pbox) {
gtk_window_set_screen (
GTK_WINDOW (eyes_applet->prop_box.pbox),
gtk_widget_get_screen (GTK_WIDGET (eyes_applet->applet)));
gtk_window_present (GTK_WINDOW (eyes_applet->prop_box.pbox));
return;
}
pbox = gtk_dialog_new_with_buttons (_("Geyes Preferences"), NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
GTK_STOCK_HELP, GTK_RESPONSE_HELP,
NULL);
gtk_window_set_screen (GTK_WINDOW (pbox),
gtk_widget_get_screen (GTK_WIDGET (eyes_applet->applet)));
gtk_widget_set_size_request (GTK_WIDGET (pbox), 300, 200);
gtk_dialog_set_default_response(GTK_DIALOG (pbox), GTK_RESPONSE_CLOSE);
gtk_dialog_set_has_separator (GTK_DIALOG (pbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (pbox), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (pbox))), 2);
g_signal_connect (pbox, "response",
G_CALLBACK (presponse_cb),
eyes_applet);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (pbox))), vbox,
TRUE, TRUE, 0);
categories_vbox = gtk_vbox_new (FALSE, 18);
gtk_box_pack_start (GTK_BOX (vbox), categories_vbox, TRUE, TRUE, 0);
gtk_widget_show (categories_vbox);
category_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (categories_vbox), category_vbox, TRUE, TRUE, 0);
gtk_widget_show (category_vbox);
title = g_strconcat ("<span weight=\"bold\">", _("Themes"), "</span>", NULL);
label = gtk_label_new (_(title));
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (category_vbox), label, FALSE, FALSE, 0);
g_free (title);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (category_vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
indent = gtk_label_new (HIG_IDENTATION);
gtk_label_set_justify (GTK_LABEL (indent), GTK_JUSTIFY_LEFT);
gtk_box_pack_start (GTK_BOX (hbox), indent, FALSE, FALSE, 0);
gtk_widget_show (indent);
control_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), control_vbox, TRUE, TRUE, 0);
gtk_widget_show (control_vbox);
label = gtk_label_new_with_mnemonic (_("_Select a theme:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (control_vbox), label, FALSE, FALSE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
model = gtk_list_store_new (TOTAL_COLS, G_TYPE_STRING, G_TYPE_STRING);
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree), FALSE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), tree);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (scrolled), tree);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("not used", cell,
"text", COL_THEME_NAME, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
g_signal_connect (selection, "changed",
G_CALLBACK (theme_selected_cb),
eyes_applet);
if ( ! g_settings_is_writable (eyes_applet->settings, "theme-path")) {
gtk_widget_set_sensitive (tree, FALSE);
gtk_widget_set_sensitive (label, FALSE);
}
for (i = 0; i < NUM_THEME_DIRECTORIES; i++) {
if ((dfd = opendir (theme_directories[i])) != NULL) {
while ((dp = readdir (dfd)) != NULL) {
if (dp->d_name[0] != '.') {
gchar *theme_dir;
gchar *theme_name;
#ifdef PATH_MAX
strcpy (filename,
theme_directories[i]);
strcat (filename, dp->d_name);
#else
asprintf (&filename, theme_directories[i], dp->d_name);
#endif
theme_dir = g_strdup_printf ("%s/", filename);
theme_name = g_path_get_basename (filename);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
COL_THEME_DIR, &filename,
COL_THEME_NAME, theme_name,
-1);
if (!g_ascii_strncasecmp (eyes_applet->theme_dir, theme_dir, strlen (theme_dir))) {
GtkTreePath *path;
path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
&iter);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree),
path,
NULL,
FALSE);
gtk_tree_path_free (path);
}
g_free (theme_name);
g_free (theme_dir);
}
}
closedir (dfd);
}
}
#ifndef PATH_MAX
g_free (filename);
#endif
gtk_box_pack_start (GTK_BOX (control_vbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show_all (pbox);
eyes_applet->prop_box.pbox = pbox;
return;
}
GtkWidget *
gnome_prefs_string_option_menu_new (GtkWidget *table,
const gchar *label_txt,
const gchar **options,
const gchar *conf_key,
const gchar *tooltip,
int row,
const gchar *default_value)
{
GnomePrefsWindow *gpw = NULL;
GtkWidget *label = NULL;
GtkWidget *option_menu = NULL;
GtkListStore *list_store = NULL;
GtkCellRenderer *renderer = NULL;
GtkTreeIter iter;
gchar *conf_string = NULL;
gboolean writable = FALSE;
int history = -1;
int cpt = 0;
writable = gm_conf_is_key_writable (conf_key);
label = gtk_label_new (label_txt);
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (label), FALSE);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, row, row+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL),
0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
list_store = gtk_list_store_new (3,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
option_menu = gtk_combo_box_new_with_model (GTK_TREE_MODEL (list_store));
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (option_menu), FALSE);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (option_menu), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (option_menu), renderer,
"text", COLUMN_STRING_TRANSLATED,
"sensitive", COLUMN_SENSITIVE,
NULL);
g_object_set (G_OBJECT (renderer),
"ellipsize-set", TRUE,
"ellipsize", PANGO_ELLIPSIZE_END,
"width-chars", 45, NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), option_menu);
conf_string = gm_conf_get_string (conf_key);
if (conf_string == NULL)
conf_string = g_strdup (default_value);
while (options [cpt]) {
if (conf_string && !g_strcmp0 (conf_string, options [cpt]))
history = cpt;
gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
COLUMN_STRING_RAW, options [cpt],
COLUMN_STRING_TRANSLATED, gettext (options [cpt]),
COLUMN_SENSITIVE, TRUE,
-1);
cpt++;
}
if (history == -1) {
if (conf_string && g_strcmp0 (conf_string, "")) {
gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
COLUMN_STRING_RAW, conf_string,
COLUMN_STRING_TRANSLATED, gettext (conf_string),
COLUMN_SENSITIVE, FALSE,
-1);
history = cpt;
}
else
history = 0;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu), history);
gtk_table_attach (GTK_TABLE (table), option_menu, 1, 2, row, row+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL),
0, 0);
gpw = (GnomePrefsWindow *) g_object_get_data (G_OBJECT (table), "gpw");
if (gpw && tooltip)
gtk_widget_set_tooltip_text (option_menu, tooltip);
g_signal_connect (option_menu, "changed",
G_CALLBACK (string_option_menu_changed),
(gpointer) conf_key);
gm_conf_notifier_add (conf_key, string_option_menu_changed_nt,
(gpointer) option_menu);
g_free (conf_string);
gtk_widget_show_all (table);
return option_menu;
}
void Set_Menu_Container() {
GdkBitmap *mask ;
GdkPixmap *pixmap;
GtkStyle *style ;
FILE *fp, *detail ;
char data[400] ;
char temp[100] ;
char detail_filename[100] ;
int x = 0 ;
memset( data, '\0', 400 ) ;
memset( temp, '\0', 100 ) ;
memset( detail_filename, '\0', 100 ) ;
menu_Container = gtk_notebook_new() ;
gtk_notebook_set_tab_pos( GTK_NOTEBOOK( menu_Container ), GTK_POS_LEFT ) ;
z_Monster_Tag = gtk_label_new( "Monster" ) ;
gtk_widget_set_usize( z_Monster_Tag, 85, 75 ) ;
z_Information_Tag = gtk_label_new( "Monster Detail" ) ;
gtk_widget_set_usize( z_Information_Tag, 85, 75 ) ;
z_Battle_Log_Tag = gtk_label_new( "Battle Log" ) ;
gtk_widget_set_usize( z_Battle_Log_Tag, 85, 75 ) ;
z_Battle_Tag = gtk_label_new( "Battle!!" ) ;
gtk_widget_set_usize( z_Battle_Tag, 85, 75 ) ;
style = gtk_widget_get_style(main_Window ) ;
// for dektop linux
// z_Monster_Page = gtk_image_new_from_file( "DataBase/resource/123.jpg" ) ;
fp = fopen( gAccount, "r" ) ;
//*********************************
fscanf( fp, "%s", temp ) ;
strcat( data, temp ) ;
memset( temp, '\0', 100 ) ;
fscanf( fp, "%s", temp ) ;
strcpy( detail_filename, "DataBase/monster_detail/" ) ;
if ( temp[0] == '1' ) {
strcat( detail_filename, "a_monster" ) ;
pixmap = gdk_pixmap_create_from_xpm_d( main_Window->window,
&mask,&style->bg[GTK_STATE_NORMAL], (gchar **)a_XPM);
} // else if
else if ( temp[0] == '2' ) {
strcat( detail_filename, "b_monster" ) ;
pixmap = gdk_pixmap_create_from_xpm_d( main_Window->window,
&mask,&style->bg[GTK_STATE_NORMAL], (gchar **)b_XPM);
} // else if
else if ( temp[0] == '3' ) {
strcat( detail_filename, "c_monster" ) ;
pixmap = gdk_pixmap_create_from_xpm_d( main_Window->window,
&mask,&style->bg[GTK_STATE_NORMAL], (gchar **)c_XPM);
} // else if
z_Monster_Page = gtk_pixmap_new(pixmap,mask);
gProperty[0] = temp[0] ;
strcat( data, "\n\n" ) ;
detail = fopen( detail_filename, "r" ) ;
for ( x = strlen(data) ; !feof(detail); x++ ) fscanf( detail, "%c", &data[x] ) ;
z_Information_Page = gtk_label_new( data ) ;
//**********************************
memset( data, '\0', 400 ) ;
strcat( data, "Battle History\nRecord: " ) ;
memset( temp, '\0', 100 ) ;
fscanf( fp, "%s", temp ) ;
strcat( data, temp ) ;
strcat( data, " " ) ;
memset( temp, '\0', 100 ) ;
fscanf( fp, "%s", temp ) ;
strcat( data, temp ) ;
strcat( data, "\n\nMonster\t\tResult\n" ) ;
for ( x = strlen(data) ; !feof(fp) ; x++ ) fscanf( fp, "%c", &data[x] ) ;
z_Battle_Log_Page = gtk_label_new( data ) ;
// **********************************
z_Battle_Page = gtk_fixed_new() ;
fclose(fp) ;
fclose(detail) ;
z_Battle_IP_Entry = gtk_entry_new() ;
gtk_fixed_put( GTK_FIXED(z_Battle_Page), z_Battle_IP_Entry, 100, 150 ) ;
gtk_widget_set_usize( z_Battle_IP_Entry, 170,50 ) ;
gtk_entry_set_text( z_Battle_IP_Entry , "192.168.0.50" ) ;
z_Battle_Button = gtk_button_new_with_label( "Send!!" ) ;
gtk_widget_set_usize( z_Battle_Button, 70,50 ) ;
gtk_fixed_put( GTK_FIXED(z_Battle_Page), z_Battle_Button, 270, 150 ) ;
gtk_notebook_append_page( GTK_NOTEBOOK( menu_Container ),
z_Monster_Page, z_Monster_Tag ) ;
gtk_notebook_append_page( GTK_NOTEBOOK( menu_Container ),
z_Information_Page, z_Information_Tag ) ;
gtk_notebook_append_page( GTK_NOTEBOOK( menu_Container ),
z_Battle_Log_Page, z_Battle_Log_Tag ) ;
gtk_notebook_append_page( GTK_NOTEBOOK( menu_Container ),
z_Battle_Page, z_Battle_Tag ) ;
gtk_container_add( GTK_WINDOW( main_Window ), menu_Container ) ;
} // Set_Menu_Container()
void maintainr_projectbox_set_conf (MaintainrProjectbox *box, MaintainrProjectconf *conf)
{
int pos;
const gchar *name;
GList *iter;
GtkWidget *button;
GtkTreeModel *model;
MaintainrTodo *todo;
MaintainrService *service;
box->priv->conf = conf;
name = maintainr_projectconf_get_name (conf);
if (name != NULL) {
gtk_label_set_text (GTK_LABEL (box->priv->label), name);
gtk_entry_set_text (GTK_ENTRY (box->priv->project_name), name);
}
pos = maintainr_projectconf_get_priority (conf);
gtk_combo_box_set_active (GTK_COMBO_BOX (box->priv->priority), pos);
set_priority_icon (box, pos);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (box->priv->todos));
for (pos = 0, iter = maintainr_projectconf_get_todos (conf); iter; pos++, iter = iter->next) {
todo = iter->data;
gtk_list_store_insert_with_values (GTK_LIST_STORE (model), NULL, G_MAXINT,
0, maintainr_todo_get_done (todo),
1, maintainr_todo_get_string (todo),
2, pos, -1);
}
for (iter = maintainr_projectconf_get_services (conf); iter; iter = iter->next) {
service = iter->data;
name = maintainr_service_get_name (service);
gtk_notebook_append_page (GTK_NOTEBOOK (box->priv->services_confs), maintainr_service_config_panel (service), gtk_label_new (name));
gtk_notebook_append_page (GTK_NOTEBOOK (box), do_service_action_panel (box, service), NULL);
button = gtk_button_new_with_label (name);
gtk_widget_set_no_show_all (button, TRUE);
gtk_box_pack_start (GTK_BOX (box->priv->services_buttons), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", G_CALLBACK (activate_service), box);
if (maintainr_service_get_active (service))
gtk_widget_show (button);
else
gtk_widget_hide (button);
g_signal_connect_swapped (service, "require-main-screen", G_CALLBACK (show_main), box);
}
if (g_signal_handler_find (box->priv->todos, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, G_CALLBACK (check_if_sorted), box) == 0)
g_signal_connect (box->priv->todos, "drag-end", G_CALLBACK (check_if_sorted), box);
todo_aging_color (box);
g_signal_connect_swapped (conf, "on-top", G_CALLBACK (todo_aging_color), box);
gtk_widget_show_all (GTK_WIDGET (box));
}
static GtkWidget *
create_gl_toggle_button (GdkGLConfig *glconfig)
{
GtkWidget *vbox;
GtkWidget *drawing_area;
GtkWidget *label;
GtkWidget *button;
/*
* VBox.
*/
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
/*
* Drawing area for drawing OpenGL scene.
*/
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, 200, 200);
/* Set OpenGL-capability to the widget. */
gtk_widget_set_gl_capability (drawing_area,
glconfig,
NULL,
TRUE,
GDK_GL_RGBA_TYPE);
g_signal_connect_after (G_OBJECT (drawing_area), "realize",
G_CALLBACK (realize), NULL);
g_signal_connect (G_OBJECT (drawing_area), "configure_event",
G_CALLBACK (configure_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "expose_event",
G_CALLBACK (expose_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "unrealize",
G_CALLBACK (unrealize), NULL);
g_signal_connect (G_OBJECT (drawing_area), "map_event",
G_CALLBACK (map_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "unmap_event",
G_CALLBACK (unmap_event), NULL);
g_signal_connect (G_OBJECT (drawing_area), "visibility_notify_event",
G_CALLBACK (visibility_notify_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
/*
* Label.
*/
label = gtk_label_new ("Toggle Animation");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 10);
gtk_widget_show (label);
/*
* Toggle button.
*/
button = gtk_toggle_button_new ();
g_signal_connect_swapped (G_OBJECT (button), "toggled",
G_CALLBACK (toggle_animation), drawing_area);
/* Add VBox. */
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (button), vbox);
return button;
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *table;
GtkWidget *label;
GtkWidget *pixmap;
GtkWidget *button;
GdkPixbuf *drag_icon;
test_init ();
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
table = gtk_table_new (2, 2, FALSE);
gtk_container_add (GTK_CONTAINER (window), table);
drag_icon = gdk_pixbuf_new_from_xpm_data (drag_icon_xpm);
trashcan_open = gdk_pixbuf_new_from_xpm_data (trashcan_open_xpm);
trashcan_closed = gdk_pixbuf_new_from_xpm_data (trashcan_closed_xpm);
label = gtk_label_new ("Drop Here\n");
gtk_drag_dest_set (label,
GTK_DEST_DEFAULT_ALL,
target_table, n_targets - 1, /* no rootwin */
GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect (label, "drag_data_received",
G_CALLBACK( label_drag_data_received), NULL);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
label = gtk_label_new ("Popup\n");
gtk_drag_dest_set (label,
GTK_DEST_DEFAULT_ALL,
target_table, n_targets - 1, /* no rootwin */
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
g_signal_connect (label, "drag_motion",
G_CALLBACK (popsite_motion), NULL);
g_signal_connect (label, "drag_leave",
G_CALLBACK (popsite_leave), NULL);
pixmap = gtk_image_new_from_pixbuf (trashcan_closed);
gtk_drag_dest_set (pixmap, 0, NULL, 0, 0);
gtk_table_attach (GTK_TABLE (table), pixmap, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
g_signal_connect (pixmap, "drag_leave",
G_CALLBACK (target_drag_leave), NULL);
g_signal_connect (pixmap, "drag_motion",
G_CALLBACK (target_drag_motion), NULL);
g_signal_connect (pixmap, "drag_drop",
G_CALLBACK (target_drag_drop), NULL);
g_signal_connect (pixmap, "drag_data_received",
G_CALLBACK (target_drag_data_received), NULL);
/* Drag site */
button = gtk_button_new_with_label ("Drag Here\n");
gtk_drag_source_set (button, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
target_table, n_targets,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_source_set_icon_pixbuf (button, drag_icon);
g_object_unref (drag_icon);
gtk_table_attach (GTK_TABLE (table), button, 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
g_signal_connect (button, "drag_data_get",
G_CALLBACK (source_drag_data_get), NULL);
g_signal_connect (button, "drag_data_delete",
G_CALLBACK (source_drag_data_delete), NULL);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
void DownloadUI::CreateDownloadUI(void)
{
m_downloadUI = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(m_downloadUI), BRANDING" - DownloadManager");
gtk_signal_connect(GTK_OBJECT(m_downloadUI), "destroy",
GTK_SIGNAL_FUNC(toggle_vis_internal), this);
gtk_container_set_border_width(GTK_CONTAINER(m_downloadUI), 5);
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(m_downloadUI), vbox);
gtk_widget_set_usize(vbox, 400, 400);
gtk_widget_show(vbox);
GtkWidget *text = gtk_label_new(NULL);
gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
if (!strncasecmp(BRANDING_COMPANY, "EMusic", 6))
gtk_label_set_text(GTK_LABEL(text), szEMusicText);
else
gtk_label_set_text(GTK_LABEL(text), szFreeAmpText);
gtk_label_set_justify(GTK_LABEL(text), GTK_JUSTIFY_FILL);
gtk_misc_set_alignment(GTK_MISC(text), (gfloat)0.0, (gfloat)0.0);
gtk_box_pack_start(GTK_BOX(vbox), text, FALSE, FALSE, 2);
gtk_widget_set_usize(text, 400, 46);
gtk_widget_show(text);
GtkWidget *emusic_button;
if (!strncasecmp(BRANDING_COMPANY, "EMusic", 6))
emusic_button = gtk_button_new_with_label(szEMusicURLText);
else
emusic_button = gtk_button_new_with_label(szFreeAmpURLText);
gtk_box_pack_start(GTK_BOX(vbox), emusic_button, FALSE, FALSE, 2);
gtk_signal_connect(GTK_OBJECT(emusic_button), "clicked",
GTK_SIGNAL_FUNC(emusic_click), this);
gtk_widget_show(emusic_button);
GtkWidget *listwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(listwindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), listwindow, TRUE, TRUE, 0);
gtk_widget_set_usize(listwindow, 400, 140);
gtk_widget_show(listwindow);
GtkWidget *table = gtk_table_new(7, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
gtk_widget_show(table);
GtkWidget *label = gtk_label_new("Artist:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
artist = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(artist), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), artist, 1, 2, 0, 1);
gtk_widget_show(artist);
label = gtk_label_new("Album:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
album = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(album), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), album, 1, 2, 1, 2);
gtk_widget_show(album);
label = gtk_label_new("Title:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
title = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(title), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), title, 1, 2, 2, 3);
gtk_widget_show(title);
label = gtk_label_new("Genre:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
genre = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(genre), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), genre, 1, 2, 3, 4);
gtk_widget_show(genre);
label = gtk_label_new("Playlist:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
playlist = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(playlist), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), playlist, 1, 2, 4, 5);
gtk_widget_show(playlist);
label = gtk_label_new("File Name:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 5, 6, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
name = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(name), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), name, 1, 2, 5, 6);
gtk_widget_show(name);
label = gtk_label_new("File Size:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 6, 7, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
size = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(size), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), size, 1, 2, 6, 7);
gtk_widget_show(size);
CreateDownloadList(listwindow);
GtkWidget *sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, TRUE, 2);
gtk_widget_show(sep);
m_closeComplete = gtk_check_button_new_with_label("Close the Download Manager when all downloads finish");
gtk_box_pack_start(GTK_BOX(vbox), m_closeComplete, FALSE, FALSE, 1);
bool set = false;
m_prefs->GetPrefBoolean(kCloseDLMOnCompletePref, &set);
if (set)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_closeComplete), TRUE);
gtk_widget_show(m_closeComplete);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, TRUE, 5);
gtk_widget_show(sep);
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
m_CancelButton = gtk_button_new_with_label(" Cancel ");
gtk_box_pack_start(GTK_BOX(hbox), m_CancelButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_CancelButton), "clicked",
GTK_SIGNAL_FUNC(cancel_internal), this);
gtk_widget_show(m_CancelButton);
m_PauseButton = gtk_button_new_with_label(" Pause ");
gtk_box_pack_start(GTK_BOX(hbox), m_PauseButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_PauseButton), "clicked",
GTK_SIGNAL_FUNC(pause_internal), this);
gtk_widget_show(m_PauseButton);
m_ResumeButton = gtk_button_new();
m_ResumeLabel = gtk_label_new(" Resume ");
gtk_container_add(GTK_CONTAINER(m_ResumeButton), m_ResumeLabel);
gtk_box_pack_start(GTK_BOX(hbox), m_ResumeButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_ResumeButton), "clicked",
GTK_SIGNAL_FUNC(resume_internal), this);
gtk_widget_show(m_ResumeLabel);
gtk_widget_show(m_ResumeButton);
sep = gtk_vseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), sep, TRUE, FALSE, 5);
gtk_widget_show(sep);
m_CloseButton = gtk_button_new_with_label(" Close ");
gtk_box_pack_end(GTK_BOX(hbox), m_CloseButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_CloseButton), "clicked",
GTK_SIGNAL_FUNC(close_internal), this);
gtk_widget_show(m_CloseButton);
m_helpButton = gtk_button_new_with_label(" Help ");
gtk_box_pack_end(GTK_BOX(hbox), m_helpButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_helpButton), "clicked",
GTK_SIGNAL_FUNC(help_button_click), this);
gtk_widget_show(m_helpButton);
gtk_widget_show(m_downloadUI);
}
void user_install_dialog_create(UserInstallCallback callback)
{
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *ebox;
GtkWidget *table;
GtkWidget *darea;
GtkWidget *page;
GtkWidget *sep;
PangoFontDescription *large_font_desc;
gchar* Version_S = g_strdup_printf("%d.%d.%d",MAJOR_VERSION,MINOR_VERSION,MICRO_VERSION);
gchar* temp = NULL;
dialog = user_install_dialog = gtk_dialog_new ();
gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_CENTER);
gtk_window_set_title(>K_DIALOG(dialog)->window,_("Gabedit User Installation"));
gtk_widget_realize (dialog);
set_icone(GTK_WIDGET(dialog));
action_area = gtk_hbox_new(FALSE, 8);
gtk_box_set_homogeneous(GTK_BOX(action_area), FALSE);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), action_area);
/* B/W Style for the page contents */
page_style = gtk_style_copy(gtk_widget_get_default_style());
colormap = gtk_widget_get_colormap(dialog);
black_color.red = 0;
black_color.green = 0;
black_color.blue = 0;
gdk_colormap_alloc_color (colormap, &black_color, FALSE, TRUE);
white_color.red = 65535;
white_color.green = 65535;
white_color.blue = 65535;
gdk_colormap_alloc_color (colormap, &white_color, FALSE, TRUE);
page_style->fg[GTK_STATE_NORMAL] = black_color;
page_style->text[GTK_STATE_NORMAL] = black_color;
page_style->bg[GTK_STATE_NORMAL] = white_color;
/*
gdk_font_unref(page_style->font);
page_style->font = dialog->style->font;
gdk_font_ref(page_style->font);
*/
/* B/Colored Style for the page title */
title_style = gtk_style_copy(page_style);
if (gdk_color_parse("royal blue", &title_color) && gdk_colormap_alloc_color(colormap, &title_color, FALSE, TRUE))
{
title_style->bg[GTK_STATE_NORMAL] = title_color;
}
large_font_desc = pango_font_description_from_string ("sans bold 20");
if (large_font_desc)
{
title_style->font_desc = large_font_desc;
}
/* W/W GC for the corner */
white_gc = gdk_gc_new(dialog->window);
gdk_gc_set_foreground(white_gc, &white_color);
TITLE_STYLE(dialog);
footer_label = gtk_label_new(NULL);
PAGE_STYLE(footer_label);
gtk_label_set_justify(GTK_LABEL(footer_label), GTK_JUSTIFY_RIGHT);
gtk_box_pack_start(GTK_BOX(action_area), footer_label, FALSE, FALSE, 8);
gtk_widget_show(footer_label);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), vbox);
ebox = gtk_event_box_new();
TITLE_STYLE(ebox);
gtk_widget_set_events(ebox, GDK_EXPOSURE_MASK);
gtk_widget_set_size_request(ebox, WILBER_WIDTH + 16, -1);
gtk_box_pack_start(GTK_BOX(vbox), ebox, FALSE, FALSE, 0);
gtk_widget_show(ebox);
hbox = gtk_hbox_new(FALSE, 8);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
gtk_container_add(GTK_CONTAINER(ebox), hbox);
gtk_widget_show(hbox);
title_pixmap = create_pixmap(dialog,gabedit_xpm);
gtk_box_pack_start(GTK_BOX(hbox), title_pixmap, FALSE, FALSE, 8);
gtk_widget_show(title_pixmap);
title_label = gtk_label_new(NULL);
TITLE_STYLE(title_label);
gtk_label_set_justify(GTK_LABEL(title_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(hbox), title_label, FALSE, FALSE, 0);
gtk_widget_show(title_label);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
ebox = gtk_event_box_new();
TITLE_STYLE(ebox);
gtk_widget_set_size_request(ebox, 16, -1);
gtk_box_pack_start(GTK_BOX(hbox), ebox, FALSE, FALSE, 0);
gtk_widget_show(ebox);
ebox = gtk_event_box_new();
PAGE_STYLE(ebox);
gtk_box_pack_start(GTK_BOX(hbox), ebox, TRUE, TRUE, 0);
gtk_widget_show(ebox);
table = gtk_table_new(3, 3, FALSE);
gtk_table_set_col_spacing(GTK_TABLE(table), 1, 8);
gtk_container_add(GTK_CONTAINER(ebox), table);
gtk_widget_show(table);
darea = gtk_drawing_area_new();
TITLE_STYLE(darea);
gtk_widget_set_size_request(GTK_WIDGET(darea), 16, 16);
g_signal_connect_after(G_OBJECT(darea), "expose_event",
(GCallback)user_install_corner_expose,
(gpointer)GTK_CORNER_TOP_LEFT);
gtk_table_attach(GTK_TABLE(table), darea, 0,1, 0,1,
GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show(darea);
darea = gtk_drawing_area_new();
TITLE_STYLE(darea);
gtk_widget_set_size_request(GTK_WIDGET(darea), 16, 16);
g_signal_connect_after(G_OBJECT(darea), "expose_event",
(GCallback)user_install_corner_expose,
(gpointer)GTK_CORNER_BOTTOM_LEFT);
gtk_table_attach(GTK_TABLE(table), darea, 0,1, 2,3,
GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show(darea);
notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
gtk_table_attach_defaults(GTK_TABLE(table), notebook, 1,2, 1,2);
gtk_widget_show(notebook);
gtk_widget_show(vbox);
/* Page 1 */
temp = g_strdup_printf("Welcome to The GABEDIT %s User Installation",Version_S);
g_free(Version_S);
page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
temp,
_("Click \"Continue\" to enter the GABEDIT user installation."));
add_label(GTK_BOX(page),
_(
"Gabedit is a Graphical User Interface to FireFly, Gamess-US, Gaussian, Molcas, Molpro, \nMopac, MPQC , NWChem, Orca, Psicode and Q-Chem\n"
"computational chemistry packages.\n"
"It can display a variety of calculation results including support for most major molecular file formats.\n"
"The advanced 'Molecule Builder' allows to rapidly sketch in molecules and examine them in 3D\n"
"Graphics can be exported to various formats, including animations\n"
"\n"
"Gabedit can creates input file for the computational chemistry packages(CCP) cited above.\n"
"Gabedit can graphically display a variety of the CCP calculation results\n"
"Gabedit can display UV-Vis, IR and Raman computed spectra.\n"
"Gabedit can generate a povray file for geometry, surfaces, contours, planes colorcoded.\n"
"Gabedit can save picture in BMP, JPEG, PNG, PPM, PDF and PS format.\n"
"It can generate automatically a series of pictures for animation(vibration, geometry convergence, ....).\n"
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show(sep);
add_label(GTK_BOX(page),
_(
"Copyright (c) 2002-2013 Abdul-Rahman Allouche.\n"
"All rights reserved.\n"
"\nGabedit is free.\n"
)
);
/* Page 2 */
{
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *notebook2;
GtkWidget *page2;
GtkWidget *label;
GtkTreeIter main_node;
GtkTreeIter sub_node;
gchar *str;
GtkTreeStore *store;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget* treeView;
GtkTreeSelection *select;
gint i;
gchar *node[1];
set_pixbuf();
page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("Personal GABEDIT Directory"),
_(
"Click \"Continue\" to create "
"your personal GABEDIT directory.")
);
hbox = gtk_hbox_new(FALSE, 8);
gtk_box_pack_start(GTK_BOX(page), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
store = gtk_tree_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
model = GTK_TREE_MODEL (store);
treeView = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeView), FALSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeView), FALSE);
PAGE_STYLE(treeView);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, " ");
gtk_tree_view_column_set_reorderable(column, FALSE);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", LIST_PIXBUF);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_add_attribute (column, renderer, "text", LIST_NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), column);
gtk_box_pack_start(GTK_BOX(hbox), treeView, FALSE, FALSE, 0);
gtk_widget_show(treeView);
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show(vbox);
str = g_strdup_printf(_("For a proper GABEDIT installation, a subdirectory named\n"
"%s needs to be created."), gabedit_directory());
add_label(GTK_BOX(vbox), str);
g_free(str);
add_label(GTK_BOX(vbox),
_(
"This subdirectory will contain a number of important files.\n"
"Click on one of the files or subdirectories in the tree\n"
"to get more information about the selected item."
)
);
notebook2 = gtk_notebook_new();
gtk_container_set_border_width(GTK_CONTAINER(notebook2), 8);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook2), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook2), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), notebook2, TRUE, TRUE, 0);
gtk_widget_show(notebook2);
/* empty page */
page2 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(page2);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook2), page2, NULL);
node[0] = (gchar *)gabedit_directory();
gtk_tree_store_append(store, &main_node, NULL);
gtk_tree_store_set (store, &main_node, LIST_NAME, node[0], -1);
gtk_tree_store_set (store, &main_node, LIST_PIXBUF, bookPixbuf, -1);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeView));
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (select), "changed", G_CALLBACK (user_install_treeview_select_row), notebook2);
for (i = 0; i < num_tree_items; i++)
{
node[0] = tree_items[i].text;
if (tree_items[i].directory)
{
gtk_tree_store_append(store, &sub_node, &main_node);
gtk_tree_store_set (store, &sub_node, LIST_NAME, node[0], -1);
gtk_tree_store_set (store, &sub_node, LIST_PIXBUF, bookPixbuf, -1);
} else
{
gtk_tree_store_append(store, &sub_node, &main_node);
gtk_tree_store_set (store, &sub_node, LIST_NAME, node[0], -1);
gtk_tree_store_set (store, &sub_node, LIST_PIXBUF, pagePixbuf, -1);
}
page2 = gtk_vbox_new(FALSE, 0);
label = gtk_label_new(tree_items[i].description);
PAGE_STYLE(label);
PAGE_STYLE(label);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(page2), label, TRUE, TRUE, 0);
gtk_widget_show(label);
gtk_widget_show(page2);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook2), page2, NULL);
}
{
GtkTreePath *path = gtk_tree_path_new_from_string ("0");
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(treeView), path);
gtk_tree_path_free(path);
}
}
/* Page 3 */
page = log_page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("Creation of Directories"),
NULL);
/* Page 4 */
page = prop_page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Atoms Properties"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(page),_("Setting for atoms properties."));
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show(sep);
/* Page 5 */
page = commands_network_page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Commands/Network"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(commands_network_page),
_(
"To execute FireFly, Gamess-US, Gaussian, Molcas, Molpro, \nMopac, MPQC, NWChem, Orca, Psicode and Q-Chem program, "
"GABEDIT needs to know commands system.\n"
"GABEDIT needs to know network protocols.\n"
"You can change them after installation (Settings/Preferences)."
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
/* Page 6 */
page = fontscolors_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Fonts/Colors setting"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(fontscolors_page),
_(
"Setting for Text Font and Text Colors, "
"GABEDIT needs to know the defaults Fonts/Colors for Data and Result editors."
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
/* Page 7 */
page = colorsurfaces_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Color Surfaces setting"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(colorsurfaces_page),
_("Setting for color surfaces, "
"GABEDIT needs to know the defaults Color for surfaces(density,Orbitals,....)."
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
/* Page 8 */
page = molpro_basis_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of molpro basis list file"),
_("Click \"Continue\" for next page."));
add_label(GTK_BOX(molpro_basis_page),
_(
"If the libmol program (delivered with molpro) is not installed on your local host,\n"
"GABEDIT uses this file for get the list of basis(only the names of basis)supported by molpro.\n"
"Please note that this file contains the list of basis supported by molpro2002.6."
)
);
/* Page 9 */
page = molcas_basis_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of molcas basis list file"),
_("Click \"Continue\" for next page."));
add_label(GTK_BOX(molcas_basis_page),
_(
"GABEDIT uses this file for get the list of basis(only the names of basis)supported by molcas.\n"
"Please note that this file contains the list of basis supported by Molcas7."
)
);
/* Page 10 */
page = mpqc_basis_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of mpqc basis list file"),
_("Click \"Continue\" for next page."));
add_label(GTK_BOX(mpqc_basis_page),
_(
"GABEDIT uses this file for get the list of basis(only the names of basis)supported by MPQC.\n"
"Please note that this file contains the list of basis supported by MPQC2.2.2."
)
);
/* Page 11 */
page = mm_file_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of Molecular Mechanics file"),
_("Click \"Continue\" to start GABEDIT."));
add_label(GTK_BOX(mm_file_page),
_("Gabedit use this file for load molecular mechanics parameters "));
/* EEK page */
page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("Aborting Installation..."),
NULL);
user_install_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
create_buttons_dialog(dialog,callback);
gtk_widget_show_all(dialog);
}
LPSTR
create_keyval (HWND hwnd, LPCSTR attrs, BOOL *verify_conn)
{
GtkWidget *gensetup, *dialog_vbox1, *fixed1;
GtkWidget *l_comment, *scrolledwindow1, *clist1;
GtkWidget *l_key, *l_value, *t_keyword, *t_value, *l_copyright;
GtkWidget *vbuttonbox1, *b_add, *b_update, *l_keyword, *l_valeur;
GtkWidget *dialog_action_area1, *hbuttonbox1, *b_ok, *b_cancel;
GtkWidget *cb_verify;
guint button_key;
GtkAccelGroup *accel_group;
TGENSETUP gensetup_t;
char buff[1024];
if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
return (LPSTR) attrs;
accel_group = gtk_accel_group_new ();
gensetup = gtk_dialog_new ();
gtk_object_set_data (GTK_OBJECT (gensetup), "gensetup", gensetup);
gtk_window_set_title (GTK_WINDOW (gensetup), "Advanced File DSN Creation Settings");
gtk_window_set_position (GTK_WINDOW (gensetup), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (gensetup), TRUE);
gtk_window_set_policy (GTK_WINDOW (gensetup), FALSE, FALSE, FALSE);
#if GTK_CHECK_VERSION(2,0,0)
gtk_widget_show (gensetup);
#endif
dialog_vbox1 = GTK_DIALOG (gensetup)->vbox;
gtk_object_set_data (GTK_OBJECT (gensetup), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
fixed1 = gtk_fixed_new ();
gtk_widget_ref (fixed1);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "fixed1", fixed1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fixed1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), fixed1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (fixed1), 6);
l_comment = gtk_label_new ("If you know the driver-specific keywords for this data source, you can type them and their values here. For more information on driver-specific keywords, please consult your ODBC driver documentation.");
gtk_widget_ref (l_comment);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_comment", l_comment,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_comment);
gtk_fixed_put (GTK_FIXED (fixed1), l_comment, 8, 7);
gtk_widget_set_uposition (l_comment, 8, 7);
gtk_widget_set_usize (l_comment, 330, 70);
gtk_label_set_justify (GTK_LABEL (l_comment), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (GTK_LABEL (l_comment), TRUE);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "scrolledwindow1",
scrolledwindow1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_fixed_put (GTK_FIXED (fixed1), scrolledwindow1, 8, 88);
gtk_widget_set_uposition (scrolledwindow1, 8, 88);
gtk_widget_set_usize (scrolledwindow1, 320, 184);
clist1 = gtk_clist_new (2);
gtk_widget_ref (clist1);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "clist1", clist1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (clist1);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), clist1);
gtk_clist_set_column_width (GTK_CLIST (clist1), 0, 137);
gtk_clist_set_column_width (GTK_CLIST (clist1), 1, 80);
gtk_clist_column_titles_show (GTK_CLIST (clist1));
l_key = gtk_label_new (szKeysColumnNames[0]);
gtk_widget_ref (l_key);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_key", l_key,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_key);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 0, l_key);
l_value = gtk_label_new (szKeysColumnNames[1]);
gtk_widget_ref (l_value);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_value", l_value,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_value);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 1, l_value);
t_keyword = gtk_entry_new ();
gtk_widget_ref (t_keyword);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "t_keyword", t_keyword,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (t_keyword);
gtk_fixed_put (GTK_FIXED (fixed1), t_keyword, 80, 288);
gtk_widget_set_uposition (t_keyword, 80, 288);
gtk_widget_set_usize (t_keyword, 158, 22);
t_value = gtk_entry_new ();
gtk_widget_ref (t_value);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "t_value", t_value,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (t_value);
gtk_fixed_put (GTK_FIXED (fixed1), t_value, 80, 320);
gtk_widget_set_uposition (t_value, 80, 320);
gtk_widget_set_usize (t_value, 158, 22);
vbuttonbox1 = gtk_vbutton_box_new ();
gtk_widget_ref (vbuttonbox1);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "vbuttonbox1", vbuttonbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbuttonbox1);
gtk_fixed_put (GTK_FIXED (fixed1), vbuttonbox1, 248, 280);
gtk_widget_set_uposition (vbuttonbox1, 248, 280);
gtk_widget_set_usize (vbuttonbox1, 85, 69);
b_add = gtk_button_new_with_label ("");
button_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_add)->child),
szKeysButtons[0]);
gtk_widget_add_accelerator (b_add, "clicked", accel_group,
button_key, GDK_MOD1_MASK, 0);
gtk_widget_ref (b_add);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_add", b_add,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_add);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), b_add);
GTK_WIDGET_SET_FLAGS (b_add, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (b_add, "clicked", accel_group,
'A', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
b_update = gtk_button_new_with_label ("");
button_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_update)->child),
szKeysButtons[1]);
gtk_widget_add_accelerator (b_update, "clicked", accel_group,
button_key, GDK_MOD1_MASK, 0);
gtk_widget_ref (b_update);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_update", b_update,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_update);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), b_update);
GTK_WIDGET_SET_FLAGS (b_update, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (b_update, "clicked", accel_group,
'U', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_set_sensitive (b_update, FALSE);
l_keyword = gtk_label_new ("Keyword : ");
gtk_widget_ref (l_keyword);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_keyword", l_keyword,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_keyword);
gtk_fixed_put (GTK_FIXED (fixed1), l_keyword, 8, 290);
gtk_widget_set_uposition (l_keyword, 8, 290);
gtk_widget_set_usize (l_keyword, 69, 16);
gtk_label_set_justify (GTK_LABEL (l_keyword), GTK_JUSTIFY_LEFT);
l_valeur = gtk_label_new ("Value : ");
gtk_widget_ref (l_valeur);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_valeur", l_valeur,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_valeur);
gtk_fixed_put (GTK_FIXED (fixed1), l_valeur, 8, 323);
gtk_widget_set_uposition (l_valeur, 8, 323);
gtk_widget_set_usize (l_valeur, 51, 16);
gtk_label_set_justify (GTK_LABEL (l_valeur), GTK_JUSTIFY_LEFT);
cb_verify = gtk_check_button_new_with_label ("Verify this connection(recommended)");
gtk_widget_ref (cb_verify);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "cb_verify",
cb_verify, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (cb_verify);
gtk_fixed_put (GTK_FIXED (fixed1), cb_verify, 8, 350);
gtk_widget_set_uposition (cb_verify, 8, 350);
gtk_widget_set_usize (cb_verify, 230, 24);
dialog_action_area1 = GTK_DIALOG (gensetup)->action_area;
gtk_object_set_data (GTK_OBJECT (gensetup), "dialog_action_area1",
dialog_action_area1);
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 5);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_ref (hbuttonbox1);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "hbuttonbox1", hbuttonbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE,
0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10);
b_ok = gtk_button_new_with_label ("");
button_key =
gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_ok)->child), "_Ok");
gtk_widget_add_accelerator (b_ok, "clicked", accel_group, button_key,
GDK_MOD1_MASK, 0);
gtk_widget_ref (b_ok);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_ok", b_ok,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_ok);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_ok);
GTK_WIDGET_SET_FLAGS (b_ok, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (b_ok, "clicked", accel_group,
'O', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
b_cancel = gtk_button_new_with_label ("");
button_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_cancel)->child),
"_Cancel");
gtk_widget_add_accelerator (b_cancel, "clicked", accel_group,
button_key, GDK_MOD1_MASK, 0);
gtk_widget_ref (b_cancel);
gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_cancel", b_cancel,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_cancel);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_cancel);
GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (b_cancel, "clicked", accel_group,
'C', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
/* Ok button events */
gtk_signal_connect (GTK_OBJECT (b_ok), "clicked",
GTK_SIGNAL_FUNC (gensetup_ok_clicked), &gensetup_t);
/* Cancel button events */
gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked",
GTK_SIGNAL_FUNC (gensetup_cancel_clicked), &gensetup_t);
/* Add button events */
gtk_signal_connect (GTK_OBJECT (b_add), "clicked",
GTK_SIGNAL_FUNC (gensetup_add_clicked), &gensetup_t);
/* Update button events */
gtk_signal_connect (GTK_OBJECT (b_update), "clicked",
GTK_SIGNAL_FUNC (gensetup_update_clicked), &gensetup_t);
/* Close window button events */
gtk_signal_connect (GTK_OBJECT (gensetup), "delete_event",
GTK_SIGNAL_FUNC (delete_event), &gensetup_t);
gtk_signal_connect (GTK_OBJECT (gensetup), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
/* List events */
gtk_signal_connect (GTK_OBJECT (clist1), "select_row",
GTK_SIGNAL_FUNC (gensetup_list_select), &gensetup_t);
gtk_signal_connect (GTK_OBJECT (clist1), "unselect_row",
GTK_SIGNAL_FUNC (gensetup_list_unselect), &gensetup_t);
gtk_window_add_accel_group (GTK_WINDOW (gensetup), accel_group);
gensetup_t.dsn_entry = NULL;
gensetup_t.key_list = clist1;
gensetup_t.bupdate = b_update;
gensetup_t.key_entry = t_keyword;
gensetup_t.value_entry = t_value;
gensetup_t.mainwnd = gensetup;
gensetup_t.verify_conn_cb = cb_verify;
gensetup_t.verify_conn = *verify_conn;
gtk_toggle_button_set_active(cb_verify, *verify_conn);
/* Parse the attributes line */
parse_attribute_line (&gensetup_t, NULL, attrs, TRUE);
gtk_widget_show_all (gensetup);
gtk_main ();
*verify_conn = gensetup_t.verify_conn;
return gensetup_t.connstr;
}
/**
* \fn void color_options(GtkWidget *widget, BrailleMusicEditor *editor)
* \brief Color options callback
* \param editor The GUI structure .
*
* This function shows a dialog which allows user to customize the colors
* used in the lexical highlighting.
*/
void color_options(GtkWidget *widget, BrailleMusicEditor *editor) {
GtkWidget* dialog;
// Creation of a dialog window
dialog = gtk_dialog_new_with_buttons("Lexical Highlighting",
GTK_WINDOW(editor->window),
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
gtk_window_set_default_size(GTK_WINDOW(dialog), 220, -1);
init_colors();
GtkWidget *buttons[NB_TYPES];
GtkWidget *labels[NB_TYPES];
GtkTextBuffer *buffer;
int i;
GtkWidget *box = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
for(i = 0; i < NB_TYPES; i++) {
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_set_homogeneous(GTK_BOX(hbox), TRUE);
labels[i] = gtk_label_new(type_table[i]);
//buttons[i] = gtk_button_new_with_label(type_table[i]);
buttons[i] = gtk_color_button_new_with_color(&color_table[i]);
gtk_box_pack_start(GTK_BOX(hbox), labels[i], TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), buttons[i], TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 0);
gtk_widget_modify_fg(labels[i], GTK_STATE_NORMAL, &color_table[i]);
}
gtk_widget_show_all(box);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview));
// run the dialog window
switch (gtk_dialog_run(GTK_DIALOG(dialog)))
{
case GTK_RESPONSE_OK:
for(i = 0; i < NB_TYPES; i++) {
gtk_color_button_get_color(GTK_COLOR_BUTTON(buttons[i]),
&color_table[i]);
}
//updating the coloration
set_tags(buffer);
coloration_update(widget, editor);
break;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_NONE:
default:
break;
}
// Destruction of the dialog window
gtk_widget_destroy((GtkWidget *) dialog);
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *frame1;
GtkWidget *table2;
GtkWidget *label4;
GtkWidget *label5;
GtkWidget *hscaleBrightness;
GtkWidget *hscaleSaturation;
GtkWidget *hscaleContrast;
GtkWidget *label3;
GtkWidget *label1;
GtkWidget *frame2;
GtkWidget *table3;
GtkWidget *label6;
GtkWidget *hscaleGamma;
GtkWidget *hscaleGammaR;
GtkWidget *label8;
GtkWidget *hscaleGammaG;
GtkWidget *label9;
GtkWidget *label10;
GtkWidget *label7;
GtkWidget *hscaleGammaB;
GtkWidget *hscaleGammaWeight;
GtkWidget *label2;
GtkWidget *hscale1;
GtkWidget *drawingarea1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_container_set_border_width (GTK_CONTAINER (dialog1), 6);
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("MPlayer eq2"));
gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (hbox1), frame1, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE);
table2 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame1), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 12);
gtk_table_set_row_spacings (GTK_TABLE (table2), 6);
gtk_table_set_col_spacings (GTK_TABLE (table2), 12);
label4 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Brigh_tness:"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table2), label4, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
label5 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Saturation:"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
hscaleBrightness = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -1, 1, 0.05, 1, 0)));
gtk_widget_show (hscaleBrightness);
gtk_table_attach (GTK_TABLE (table2), hscaleBrightness, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleBrightness, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleBrightness), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleBrightness), 2);
hscaleSaturation = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleSaturation);
gtk_table_attach (GTK_TABLE (table2), hscaleSaturation, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleSaturation, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleSaturation), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleSaturation), 2);
hscaleContrast = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, -2, 2, 0.05, 1, 0)));
gtk_widget_show (hscaleContrast);
gtk_table_attach (GTK_TABLE (table2), hscaleContrast, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleContrast, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleContrast), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleContrast), 2);
label3 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Contrast:"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table2), label3, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label1 = gtk_label_new ("");
gtk_widget_show (label1);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label1);
gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (hbox1), frame2, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE);
table3 = gtk_table_new (5, 2, FALSE);
gtk_widget_show (table3);
gtk_container_add (GTK_CONTAINER (frame2), table3);
gtk_container_set_border_width (GTK_CONTAINER (table3), 12);
gtk_table_set_row_spacings (GTK_TABLE (table3), 6);
gtk_table_set_col_spacings (GTK_TABLE (table3), 12);
label6 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Initial:"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table3), label6, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
hscaleGamma = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGamma);
gtk_table_attach (GTK_TABLE (table3), hscaleGamma, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGamma, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGamma), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGamma), 2);
hscaleGammaR = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaR);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaR, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaR, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaR), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaR), 2);
label8 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Red:"));
gtk_widget_show (label8);
gtk_table_attach (GTK_TABLE (table3), label8, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5);
hscaleGammaG = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaG);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaG, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaG, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaG), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaG), 2);
label9 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Green:"));
gtk_widget_show (label9);
gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5);
label10 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Blue:"));
gtk_widget_show (label10);
gtk_table_attach (GTK_TABLE (table3), label10, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5);
label7 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Weight:"));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table3), label7, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
hscaleGammaB = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaB);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaB, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaB, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaB), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaB), 2);
hscaleGammaWeight = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 1, 0.05, 1, 0)));
gtk_widget_show (hscaleGammaWeight);
gtk_table_attach (GTK_TABLE (table3), hscaleGammaWeight, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_widget_set_size_request (hscaleGammaWeight, 144, 0);
gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaWeight), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscaleGammaWeight), 2);
label2 = gtk_label_new (QT_TR_NOOP("<b>Gamma</b>"));
gtk_widget_show (label2);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label2);
gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 1, 0)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
gtk_label_set_mnemonic_widget (GTK_LABEL (label4), hscaleBrightness);
gtk_label_set_mnemonic_widget (GTK_LABEL (label5), hscaleSaturation);
gtk_label_set_mnemonic_widget (GTK_LABEL (label3), hscaleContrast);
gtk_label_set_mnemonic_widget (GTK_LABEL (label6), hscaleGamma);
gtk_label_set_mnemonic_widget (GTK_LABEL (label8), hscaleGammaR);
gtk_label_set_mnemonic_widget (GTK_LABEL (label9), hscaleGammaG);
gtk_label_set_mnemonic_widget (GTK_LABEL (label10), hscaleGammaB);
gtk_label_set_mnemonic_widget (GTK_LABEL (label7), hscaleGammaWeight);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, frame1, "frame1");
GLADE_HOOKUP_OBJECT (dialog1, table2, "table2");
GLADE_HOOKUP_OBJECT (dialog1, label4, "label4");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT (dialog1, hscaleBrightness, "hscaleBrightness");
GLADE_HOOKUP_OBJECT (dialog1, hscaleSaturation, "hscaleSaturation");
GLADE_HOOKUP_OBJECT (dialog1, hscaleContrast, "hscaleContrast");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2");
GLADE_HOOKUP_OBJECT (dialog1, table3, "table3");
GLADE_HOOKUP_OBJECT (dialog1, label6, "label6");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGamma, "hscaleGamma");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaR, "hscaleGammaR");
GLADE_HOOKUP_OBJECT (dialog1, label8, "label8");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaG, "hscaleGammaG");
GLADE_HOOKUP_OBJECT (dialog1, label9, "label9");
GLADE_HOOKUP_OBJECT (dialog1, label10, "label10");
GLADE_HOOKUP_OBJECT (dialog1, label7, "label7");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaB, "hscaleGammaB");
GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaWeight, "hscaleGammaWeight");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
void showchange(char *title, Trptr t, GtkSignalFunc func)
{
GtkWidget *main_vbox;
GtkWidget *ok_hbox;
GtkWidget *hbox;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *label;
GtkWidget *button;
GtkWidget *separator;
GSList *group;
GtkWidget *frame1, *frame2;
cleanup=func;
tcache=t;
flags=t->flags;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_grab_add(window);
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC(destroy_callback),
NULL);
gtk_window_set_title (GTK_WINDOW (window), title);
gtk_container_border_width (GTK_CONTAINER (window), 0);
main_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_border_width (GTK_CONTAINER (main_vbox), 1);
gtk_widget_show (main_vbox);
label=gtk_label_new(t->name);
gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (main_vbox), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbox), 5);
gtk_widget_show (hbox);
box2 = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (box2), 5);
gtk_widget_show (box2);
button1 = gtk_radio_button_new_with_label (NULL, "Hex");
gtk_box_pack_start (GTK_BOX (box2), button1, TRUE, TRUE, 0);
if(flags&TR_HEX) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button1), TRUE);
gtk_widget_show (button1);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button1));
button2 = gtk_radio_button_new_with_label(group, "Decimal");
gtk_box_pack_start (GTK_BOX (box2), button2, TRUE, TRUE, 0);
if(flags&TR_DEC) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button2), TRUE);
gtk_widget_show (button2);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button2));
button5 = gtk_radio_button_new_with_label(group, "Signed Decimal");
gtk_box_pack_start (GTK_BOX (box2), button5, TRUE, TRUE, 0);
if(flags&TR_SIGNED) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button5), TRUE);
gtk_widget_show (button5);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button5));
button3 = gtk_radio_button_new_with_label(group, "Binary");
gtk_box_pack_start (GTK_BOX (box2), button3, TRUE, TRUE, 0);
if(flags&TR_BIN) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button3), TRUE);
gtk_widget_show (button3);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button3));
button4 = gtk_radio_button_new_with_label(group, "Octal");
gtk_box_pack_start (GTK_BOX (box2), button4, TRUE, TRUE, 0);
if(flags&TR_OCT) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button4), TRUE);
gtk_widget_show (button4);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button4));
button6 = gtk_radio_button_new_with_label(group, "ASCII");
gtk_box_pack_start (GTK_BOX (box2), button6, TRUE, TRUE, 0);
if(flags&TR_ASCII) gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button6), TRUE);
gtk_widget_show (button6);
frame2 = gtk_frame_new ("Base");
gtk_container_border_width (GTK_CONTAINER (frame2), 3);
gtk_container_add (GTK_CONTAINER (frame2), box2);
gtk_widget_show (frame2);
gtk_box_pack_start(GTK_BOX (hbox), frame2, TRUE, TRUE, 0);
/****************************************************************************************************/
box1 = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (box1), 5);
gtk_widget_show (box1);
frame1 = gtk_frame_new ("Attributes");
gtk_container_border_width (GTK_CONTAINER (frame1), 3);
gtk_container_add (GTK_CONTAINER (frame1), box1);
gtk_box_pack_start(GTK_BOX (hbox), frame1, TRUE, TRUE, 0);
gtk_widget_show (frame1);
toggle1=gtk_check_button_new_with_label("Right Justify");
gtk_box_pack_start (GTK_BOX (box1), toggle1, TRUE, TRUE, 0);
if(flags&TR_RJUSTIFY)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle1), TRUE);
gtk_widget_show (toggle1);
gtk_signal_connect (GTK_OBJECT (toggle1), "toggled", GTK_SIGNAL_FUNC(toggle1_callback), NULL);
toggle2=gtk_check_button_new_with_label("Invert");
gtk_box_pack_start (GTK_BOX (box1), toggle2, TRUE, TRUE, 0);
if(flags&TR_INVERT)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle2), TRUE);
gtk_widget_show (toggle2);
gtk_signal_connect (GTK_OBJECT (toggle2), "toggled", GTK_SIGNAL_FUNC(toggle2_callback), NULL);
toggle3=gtk_check_button_new_with_label("Reverse");
gtk_box_pack_start (GTK_BOX (box1), toggle3, TRUE, TRUE, 0);
if(flags&TR_REVERSE)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle3), TRUE);
gtk_widget_show (toggle3);
gtk_signal_connect (GTK_OBJECT (toggle3), "toggled", GTK_SIGNAL_FUNC(toggle3_callback), NULL);
toggle4=gtk_check_button_new_with_label("Exclude");
gtk_box_pack_start (GTK_BOX (box1), toggle4, TRUE, TRUE, 0);
if(flags&TR_EXCLUDE)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle4), TRUE);
gtk_widget_show (toggle4);
gtk_signal_connect (GTK_OBJECT (toggle4), "toggled", GTK_SIGNAL_FUNC(toggle4_callback), NULL);
gtk_container_add (GTK_CONTAINER (main_vbox), hbox);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (main_vbox), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
/****************************************************************************************************/
ok_hbox = gtk_hbox_new (FALSE, 1);
gtk_container_border_width (GTK_CONTAINER (ok_hbox), 1);
gtk_widget_show (ok_hbox);
button = gtk_button_new_with_label ("Cancel");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(destroy_callback),
GTK_OBJECT (window));
gtk_box_pack_end (GTK_BOX (ok_hbox), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
gtk_container_add (GTK_CONTAINER (main_vbox), ok_hbox);
button = gtk_button_new_with_label (" OK ");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(enter_callback),
GTK_OBJECT (window));
gtk_signal_connect_object (GTK_OBJECT (button),
"realize",
(GtkSignalFunc) gtk_widget_grab_default,
GTK_OBJECT (button));
gtk_box_pack_end (GTK_BOX (ok_hbox), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
/****************************************************************************************************/
gtk_container_add (GTK_CONTAINER (window), main_vbox);
gtk_widget_show (window);
}
static GtkWidget *create_custom_widget(GtkPrintOperation *operation, gpointer user_data)
{ /* copied from interface.c */
GtkWidget *page;
GtkWidget *frame33;
GtkWidget *alignment36;
GtkWidget *vbox30;
GtkWidget *hbox10;
GtkWidget *label203;
PrintWidgets *w = user_data;
gtk_print_operation_set_custom_tab_label(operation, _("Document Setup"));
page = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(page), 5);
w->check_print_linenumbers = gtk_check_button_new_with_mnemonic(_("Print line numbers"));
gtk_box_pack_start(GTK_BOX(page), w->check_print_linenumbers, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_linenumbers, _("Add line numbers to the printed page"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_linenumbers), printing_prefs.print_line_numbers);
w->check_print_pagenumbers = gtk_check_button_new_with_mnemonic(_("Print page numbers"));
gtk_box_pack_start(GTK_BOX(page), w->check_print_pagenumbers, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_pagenumbers, _("Add page numbers at the bottom of each page. It takes 2 lines of the page."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pagenumbers), printing_prefs.print_page_numbers);
w->check_print_pageheader = gtk_check_button_new_with_mnemonic(_("Print page header"));
gtk_box_pack_start(GTK_BOX(page), w->check_print_pageheader, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_pageheader, _("Add a little header to every page containing the page number, the filename and the current date (see below). It takes 3 lines of the page."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pageheader), printing_prefs.print_page_header);
g_signal_connect(w->check_print_pageheader, "toggled", G_CALLBACK(on_page_header_toggled), w);
frame33 = gtk_frame_new(NULL);
gtk_box_pack_start(GTK_BOX(page), frame33, FALSE, FALSE, 0);
gtk_frame_set_label_align(GTK_FRAME(frame33), 0, 0);
gtk_frame_set_shadow_type(GTK_FRAME(frame33), GTK_SHADOW_NONE);
alignment36 = gtk_alignment_new(0, 0.5, 1, 1);
gtk_container_add(GTK_CONTAINER(frame33), alignment36);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment36), 0, 0, 12, 0);
vbox30 = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(alignment36), vbox30);
w->check_print_basename = gtk_check_button_new_with_mnemonic(_("Use the basename of the printed file"));
gtk_box_pack_start(GTK_BOX(vbox30), w->check_print_basename, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_basename, _("Print only the basename(without the path) of the printed file"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_basename), printing_prefs.page_header_basename);
hbox10 = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox30), hbox10, TRUE, TRUE, 0);
label203 = gtk_label_new(_("Date format:"));
gtk_box_pack_start(GTK_BOX(hbox10), label203, FALSE, FALSE, 0);
w->entry_print_dateformat = gtk_entry_new();
ui_entry_add_clear_icon(GTK_ENTRY(w->entry_print_dateformat));
gtk_box_pack_start(GTK_BOX(hbox10), w->entry_print_dateformat, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(w->entry_print_dateformat, _("Specify a format for the date and time stamp which is added to the page header on each page. You can use any conversion specifiers which can be used with the ANSI C strftime function."));
gtk_entry_set_text(GTK_ENTRY(w->entry_print_dateformat), printing_prefs.page_header_datefmt);
on_page_header_toggled(GTK_TOGGLE_BUTTON(w->check_print_pageheader), w);
gtk_widget_show_all(page);
return page;
}
MedSLTPatWindow::MedSLTPatWindow(MedSLTPatWindowObserver& 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)
{
ACE_TRACE("[MedSLTPatWindow::MedSLTPatWindow()]");
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 20");
font2 = pango_font_description_from_string("Monospace Bold 16");
// Styles
style = gtk_style_new();
style->font_desc = font1;
gdk_color_parse ("red", &(style->fg[GTK_STATE_NORMAL]));
// Lists
m_list = gtk_clist_new(1);
gtk_widget_set_size_request(GTK_WIDGET(m_list), 550, 130);
gtk_widget_modify_font(m_list, font1);
/*gchar* text[3][1] = { {"où avez vous mal?"},
{"avez vous mal sous le devant de la tête?"},
{"la douleur survient elle le matin?"}}; */
gchar* text[3][1] = { {"sí mucho"},
{"no sé"},
{"la cabeza"}};
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;
gtk_clist_select_row((GtkCList*)m_list, 0, 0);
// 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, 50);
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);
gtk_widget_set_style (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, 50);
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_question = gtk_label_new("Question");
m_translation = gtk_label_new("Translation");
gtk_widget_modify_font(m_understood, font2);
gtk_widget_modify_font(m_question, 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_question), 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_question), 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_question, 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, appimage, 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;
}
/* TODO - separate widget from config so it can be re-used */
void gui_siesta_widget(GtkWidget *box, gpointer config)
{
gchar *text;
GSList *list, *list1;
GtkWidget *notebook, *vbox, *hbox, *label, *textbox;
GtkWidget *page, *left, *right;
struct siesta_pak *siesta;
g_assert(box != NULL);
g_assert(config != NULL);
siesta = config_data(config);
/* true false (default) list */
list1 = NULL;
list1 = g_slist_prepend(list1, "False");
list1 = g_slist_prepend(list1, "True");
list1 = g_slist_prepend(list1, "");
/* build widget */
notebook = gtk_notebook_new();
gtk_container_add(GTK_CONTAINER(box), notebook);
/* file write page */
page = gtk_vbox_new(FALSE, 0);
label = gtk_label_new(" File I/O ");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);
vbox = gui_frame_vbox(NULL, FALSE, FALSE, page);
gui_text_entry("System Label ", &siesta->system_label, TRUE, TRUE, vbox);
/*
vbox = gui_frame_vbox("Mesh potential", FALSE, FALSE, page);
gui_text_entry("Density of states ", &siesta->density_of_states, TRUE, FALSE, vbox);
gui_text_entry("Density on mesh ", &siesta->density_on_mesh, TRUE, FALSE, vbox);
gui_text_entry("Electrostatic pot on mesh ", &siesta->electrostatic_pot_on_mesh, TRUE, FALSE, vbox);
*/
hbox = gui_frame_hbox(NULL, FALSE, FALSE, page);
left = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), left, TRUE, TRUE, 0);
right = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), right, TRUE, TRUE, 0);
/* left */
gui_pd_new("Use saved data", &siesta->use_saved_data, list1, left);
gui_pd_new("Long output ", &siesta->long_output, list1, left);
gui_pd_new("Write coordinates", &siesta->write_coor_step, list1, left);
gui_pd_new("Write cerius coordinates", &siesta->write_coor_cerius, list1, left);
gui_pd_new("Write xmol coordinates", &siesta->write_coor_xmol, list1, left);
gui_pd_new("Write xmol animation", &siesta->write_md_xmol, list1, left);
gui_pd_new("Write trajectory history", &siesta->write_md_history, list1, left);
gui_pd_new("Write forces", &siesta->write_forces, list1, left);
/* right */
gui_pd_new("Write wavefunctions", &siesta->write_wavefunctions, list1, right);
gui_pd_new("Write density matrix", &siesta->write_dm, list1, right);
gui_pd_new("Write k points", &siesta->write_kpoints, list1, right);
gui_pd_new("Write eigenvalues", &siesta->write_eigenvalues, list1, right);
gui_pd_new("Write k bands", &siesta->write_kbands, list1, right);
gui_pd_new("Write bands", &siesta->write_bands, list1, right);
gui_pd_new("Write Mulliken population", &siesta->write_mullikenpop, list1, right);
/* electronic page */
page = gtk_vbox_new(FALSE, 0);
label = gtk_label_new("Electronic");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), hbox, TRUE, TRUE, 0);
left = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), left, TRUE, TRUE, 0);
right = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), right, TRUE, TRUE, 0);
/* basis set */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, left);
list = NULL;
list = g_slist_prepend(list, "nonodes");
list = g_slist_prepend(list, "nodes");
list = g_slist_prepend(list, "splitgauss");
list = g_slist_prepend(list, "split");
list = g_slist_prepend(list, "");
gui_pd_new("Basis type", &siesta->basis_type, list, vbox);
g_slist_free(list);
list = NULL;
list = g_slist_prepend(list, "DZP");
list = g_slist_prepend(list, "SZP");
list = g_slist_prepend(list, "DZ");
list = g_slist_prepend(list, "SZ");
list = g_slist_prepend(list, "");
gui_pd_new("Basis size", &siesta->basis_size, list, vbox);
g_slist_free(list);
/* custom zeta ie %block PAO.basis */
/*
gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
gui_text_entry("Zeta level ", &siesta->custom_zeta, TRUE, FALSE, vbox);
gui_text_entry("Polarisation level ", &siesta->custom_zeta_polarisation, TRUE, FALSE, vbox);
*/
/* functional */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, left);
list = NULL;
list = g_slist_prepend(list, "LDA");
list = g_slist_prepend(list, "GGA");
list = g_slist_prepend(list, "");
gui_pd_new("X-C functional", &siesta->xc_functional, list, vbox);
g_slist_free(list);
list = NULL;
list = g_slist_prepend(list, "LYP");
list = g_slist_prepend(list, "RPBE");
list = g_slist_prepend(list, "revPBE");
list = g_slist_prepend(list, "PBE");
list = g_slist_prepend(list, "PW92");
list = g_slist_prepend(list, "CA");
list = g_slist_prepend(list, "");
gui_pd_new("X-C authors", &siesta->xc_authors, list, vbox);
g_slist_free(list);
gui_pd_new("Harris functional", &siesta->harris_functional, list1, vbox);
/* spin */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, left);
gui_pd_new("Spin polarised", &siesta->spin_polarised, list1, vbox);
gui_pd_new("Non co-linear spin", &siesta->non_collinear_spin, list1, vbox);
gui_pd_new("Fixed spin", &siesta->fixed_spin, list1, vbox);
list = NULL;
list = g_slist_prepend(list, "0.5");
list = g_slist_prepend(list, "1.0");
list = g_slist_prepend(list, "1.5");
list = g_slist_prepend(list, "2.0");
list = g_slist_prepend(list, "");
gui_pd_new("Total spin", &siesta->total_spin, list, vbox);
g_slist_free(list);
gui_pd_new("Single excitation", &siesta->single_excitation, list1, vbox);
/* SCF options */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, right);
gui_text_entry("Number of SCF cycles ", &siesta->no_of_cycles, TRUE, FALSE, vbox);
gui_text_entry("Mixing weight ", &siesta->mixing_weight, TRUE, FALSE, vbox);
gui_text_entry("Number of Pulay matrices ", &siesta->no_of_pulay_matrices, TRUE, FALSE, vbox);
/* other options */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, right);
gui_text_entry("Energy shift (Ryd)", &siesta->energy_shift, TRUE, FALSE, vbox);
gui_text_entry("Split zeta norm", &siesta->split_zeta_norm, TRUE, FALSE, vbox);
gui_text_entry("Mesh cutoff (Ryd)", &siesta->mesh_cutoff, TRUE, FALSE, vbox);
gui_text_entry("kgrid cutoff ", &siesta->kgrid_cutoff, TRUE, FALSE, vbox);
/* speed hacks left/right */
/*
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), hbox, TRUE, TRUE, 0);
left = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), left, TRUE, TRUE, 0);
right = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), right, TRUE, TRUE, 0);
*/
/* speed hacks */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, left);
list = NULL;
list = g_slist_prepend(list, "orderN");
list = g_slist_prepend(list, "diagon");
list = g_slist_prepend(list, "");
gui_pd_new("Solution method", &siesta->solution_method, list, vbox);
g_slist_free(list);
/* NEW */
list = NULL;
list = g_slist_prepend(list, "MP");
list = g_slist_prepend(list, "FD");
list = g_slist_prepend(list, "");
gui_pd_new("Occupation function", &siesta->occupation_function, list, vbox);
g_slist_free(list);
list = NULL;
list = g_slist_prepend(list, "Files");
list = g_slist_prepend(list, "Ordejon-Mauri");
list = g_slist_prepend(list, "Kim");
list = g_slist_prepend(list, "");
gui_pd_new("Order N functional", &siesta->ordern_functional, list, vbox);
g_slist_free(list);
vbox = gui_frame_vbox(NULL, FALSE, FALSE, right);
gui_text_entry("Electronic temperature", &siesta->electronic_temperature, TRUE, FALSE, vbox);
gui_text_entry("Occupation MP order ", &siesta->occupation_mp_order, TRUE, FALSE, vbox);
gui_text_entry("Order N iterations ", &siesta->ordern_iterations, TRUE, FALSE, vbox);
gui_text_entry("Order N energy tolerance ", &siesta->ordern_energy_tolerance, TRUE, FALSE, vbox);
gui_text_entry("Order N eta ", &siesta->ordern_eta, TRUE, FALSE, vbox);
gui_text_entry("Order N eta_alpha ", &siesta->ordern_eta_alpha, TRUE, FALSE, vbox);
gui_text_entry("Order N eta_beta ", &siesta->ordern_eta_beta, TRUE, FALSE, vbox);
/* Run page */
page = gtk_vbox_new(FALSE, 0);
label = gtk_label_new("Geometric");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);
/* split pane */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), hbox, TRUE, TRUE, 0);
left = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), left, TRUE, TRUE, 0);
right = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), right, TRUE, TRUE, 0);
/* main setup */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, left);
list = NULL;
list = g_slist_prepend(list, "Phonon");
list = g_slist_prepend(list, "FC");
list = g_slist_prepend(list, "Anneal");
list = g_slist_prepend(list, "NoseParrinelloRahman");
list = g_slist_prepend(list, "ParrinelloRahman");
list = g_slist_prepend(list, "Nose");
list = g_slist_prepend(list, "Verlet");
list = g_slist_prepend(list, "Broyden");
list = g_slist_prepend(list, "CG");
list = g_slist_prepend(list, "");
gui_pd_new("Run type", &siesta->md_type_of_run, list, vbox);
g_slist_free(list);
gui_pd_new("Variable cell", &siesta->md_variable_cell, list1, vbox);
/* MD steps */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, left);
gui_text_entry("Initial time step ", &siesta->md_initial_time_step, TRUE, FALSE, vbox);
gui_text_entry("Final time step ", &siesta->md_final_time_step, TRUE, FALSE, vbox);
gui_text_entry("Length of time step ", &siesta->md_length_time_step, TRUE, FALSE, vbox);
/* CG steps */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, left);
gui_text_entry("Max CG steps", &siesta->md_num_cg_steps, TRUE, FALSE, vbox);
gui_text_entry("Max CG displacement", &siesta->md_max_cg_displacement, TRUE, FALSE, vbox);
gui_text_entry("Max force tolerance", &siesta->md_max_force_tol, TRUE, FALSE, vbox);
gui_text_entry("Max stress tolerance", &siesta->md_max_stress_tol, TRUE, FALSE, vbox);
/* temperature */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, right);
gui_text_entry("Initial temperature ", &siesta->md_initial_temperature, TRUE, FALSE, vbox);
gui_text_entry("Target temperature ", &siesta->md_target_temperature,TRUE, FALSE, vbox);
gui_text_entry("Target pressure", &siesta->md_target_pressure, TRUE, FALSE, vbox);
//gui_text_entry("Number of Steps ", &siesta->number_of_steps, TRUE, FALSE, vbox);
/* additional options */
vbox = gui_frame_vbox("Target stress tensor", FALSE, FALSE, right);
gui_text_entry("xx", &siesta->md_target_stress[0], TRUE, FALSE, vbox);
gui_text_entry("yy", &siesta->md_target_stress[1], TRUE, FALSE, vbox);
gui_text_entry("zz", &siesta->md_target_stress[2], TRUE, FALSE, vbox);
gui_text_entry("xy", &siesta->md_target_stress[3], TRUE, FALSE, vbox);
gui_text_entry("xz", &siesta->md_target_stress[4], TRUE, FALSE, vbox);
gui_text_entry("yz", &siesta->md_target_stress[5], TRUE, FALSE, vbox);
//vbox = gui_frame_vbox("Differencing", FALSE, FALSE, geompage);
//gui_direct_spin("Finite Difference step size ", &siesta->finite_diff_step_size, 0.1, 10.0, 0.1, NULL, NULL, vbox);
/* unprocessed lines */
page = gtk_vbox_new(FALSE, 0);
label = gtk_label_new (" Unprocessed ");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);
vbox = gui_frame_vbox(NULL, TRUE, TRUE, page);
text = config_unparsed_get(config);
/* FIXME - allowing this to be edited -> core dump */
textbox = gui_text_window(&text, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), textbox, TRUE, TRUE, 0);
/* cleanup */
g_slist_free(list1);
gui_relation_update(NULL);
}
