static EditorVerboseData *editor_verbose_window(EditorData *ed, const gchar *text)
{
EditorVerboseData *vd;
GtkWidget *scrolled;
GtkWidget *hbox;
gchar *buf;
vd = g_new0(EditorVerboseData, 1);
vd->gd = file_util_gen_dlg(_("Edit command results"), "editor_results",
NULL, FALSE,
NULL, ed);
buf = g_strdup_printf(_("Output of %s"), text);
generic_dialog_add_message(vd->gd, NULL, buf, NULL, TRUE);
g_free(buf);
vd->button_stop = generic_dialog_add_button(vd->gd, GTK_STOCK_STOP, NULL,
editor_verbose_window_stop, FALSE);
gtk_widget_set_sensitive(vd->button_stop, FALSE);
vd->button_close = generic_dialog_add_button(vd->gd, GTK_STOCK_CLOSE, NULL,
editor_verbose_window_close, TRUE);
gtk_widget_set_sensitive(vd->button_close, FALSE);
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);
gtk_box_pack_start(GTK_BOX(vd->gd->vbox), scrolled, TRUE, TRUE, 5);
gtk_widget_show(scrolled);
vd->text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(vd->text), FALSE);
gtk_widget_set_size_request(vd->text, EDITOR_WINDOW_WIDTH, EDITOR_WINDOW_HEIGHT);
gtk_container_add(GTK_CONTAINER(scrolled), vd->text);
gtk_widget_show(vd->text);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vd->gd->vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
vd->progress = gtk_progress_bar_new();
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(vd->progress), 0.0);
gtk_box_pack_start(GTK_BOX(hbox), vd->progress, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(vd->progress), "");
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(vd->progress), TRUE);
#endif
gtk_widget_show(vd->progress);
vd->spinner = spinner_new(NULL, SPINNER_SPEED);
gtk_box_pack_start(GTK_BOX(hbox), vd->spinner, FALSE, FALSE, 0);
gtk_widget_show(vd->spinner);
gtk_widget_show(vd->gd->dialog);
ed->vd = vd;
return vd;
}
PraghaScanner *
pragha_scanner_new()
{
PraghaScanner *scanner;
PraghaStatusbar *statusbar;
GtkWidget *hbox, *progress_bar, *button, *image;
scanner = g_slice_new0(PraghaScanner);
/* Create widgets */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
progress_bar = gtk_progress_bar_new();
gtk_widget_set_size_request(progress_bar, PROGRESS_BAR_WIDTH, -1);
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR(progress_bar), TRUE);
button = gtk_button_new ();
image = gtk_image_new_from_icon_name ("process-stop", GTK_ICON_SIZE_MENU);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
gtk_container_add (GTK_CONTAINER (button), image);
g_signal_connect(G_OBJECT (button),
"clicked",
G_CALLBACK(scanner_cancel_click_handler),
scanner);
gtk_box_pack_start (GTK_BOX (hbox), progress_bar, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
/* Init the rest and save references */
scanner->progress_bar = progress_bar;
scanner->hbox = hbox;
scanner->tracks_table = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_object_unref);
scanner->files_scanned = 0;
g_mutex_init (&scanner->files_scanned_mutex);
scanner->no_files = 0;
g_mutex_init (&scanner->no_files_mutex);
scanner->cancellable = g_cancellable_new ();
scanner->update_timeout = 0;
/* Append the widget */
statusbar = pragha_statusbar_get ();
pragha_statusbar_add_widget(statusbar, hbox);
g_object_unref(G_OBJECT(statusbar));
return scanner;
}
static void g_file_copy_progress_handler(goffset current_num_bytes,
goffset total_num_bytes, gpointer user_data)
{
GtkProgressBar *progress_bar = GTK_PROGRESS_BAR(user_data);
gchar buf[1024] = { 0 };
g_sprintf(buf, "%ld KB / %ld KB", current_num_bytes / 1024,
total_num_bytes / 1024);
gtk_progress_bar_set_show_text(progress_bar,TRUE);
gtk_progress_bar_set_text(progress_bar, buf);
gtk_progress_bar_set_fraction(progress_bar, (gdouble)current_num_bytes / (gdouble)total_num_bytes);
}
void get_stop()
{
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(progress_bar), FALSE);
gtk_widget_set_sensitive(button_add, TRUE);
gtk_widget_set_sensitive(button_convert, TRUE);
gtk_widget_set_sensitive(button_stop, FALSE);
gtk_widget_set_sensitive(button_choose_dir, TRUE);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress_bar), 0.0);
printf("Stop\n");
}
void get_convert()
{
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(progress_bar), TRUE);
gtk_widget_set_sensitive(button_add, FALSE);
gtk_widget_set_sensitive(button_convert, FALSE);
gtk_widget_set_sensitive(button_stop, TRUE);
gtk_widget_set_sensitive(button_choose_dir, FALSE);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress_bar), 0.3);
printf("%s\n", "Convert");
}
static void g_file_copy_async_finish_handler(GObject *source_object,
GAsyncResult *res, gpointer user_data)
{
GtkProgressBar *progress_bar = GTK_PROGRESS_BAR(user_data);
COPY_ASYNC_FINISH = g_file_copy_finish(G_FILE(source_object), res, NULL);
gtk_progress_bar_set_show_text(progress_bar,TRUE);
gtk_progress_bar_set_text(progress_bar, "Finished");
gtk_progress_bar_set_fraction(progress_bar, 1.0);
g_debug("_copy_files_async_true Finished");
GtkWidget *parent = gtk_widget_get_parent((GtkWidget *)progress_bar);
gtk_widget_destroy((GtkWidget *)progress_bar);
gtk_widget_destroy(parent);
}
static void _out_rate(Progress * p)
{
gdouble fraction;
GtkProgressBar * bar = GTK_PROGRESS_BAR(p->progress);
char buf[16];
if(p->prefs->length == 0 || p->cnt == 0)
{
p->pulse = 1;
return;
}
fraction = p->cnt;
fraction /= p->prefs->length;
if(gtk_progress_bar_get_fraction(bar) == fraction)
return;
gtk_progress_bar_set_fraction(bar, fraction);
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(p->progress), TRUE);
#endif
snprintf(buf, sizeof(buf), "%.1f%%", fraction * 100);
gtk_progress_bar_set_text(bar, buf);
}
static int _copy(Prefs * prefs, unsigned int filec, char * filev[])
{
static Copy copy;
GtkWidget * vbox;
GtkWidget * hbox;
GtkSizeGroup * left;
GtkSizeGroup * right;
GtkWidget * widget;
PangoFontDescription * bold;
if(filec < 2 || filev == NULL)
return 1; /* FIXME report error */
copy.prefs = prefs;
copy.filec = filec;
copy.filev = filev;
copy.cur = 0;
/* graphical interface */
copy.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_icon_name(GTK_WINDOW(copy.window), "stock_copy");
gtk_window_set_resizable(GTK_WINDOW(copy.window), FALSE);
gtk_window_set_title(GTK_WINDOW(copy.window), _("Copy file(s)"));
g_signal_connect(G_OBJECT(copy.window), "delete-event", G_CALLBACK(
_copy_on_closex), NULL);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
right = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
/* current argument */
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
widget = gtk_label_new(_("Copying: "));
bold = pango_font_description_new();
pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD);
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
copy.filename = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(copy.filename), FALSE);
gtk_size_group_add_widget(right, copy.filename);
gtk_box_pack_start(GTK_BOX(hbox), copy.filename, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* progress bar */
copy.progress = gtk_progress_bar_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(copy.progress), TRUE);
#endif
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(copy.progress), "");
gtk_box_pack_start(GTK_BOX(vbox), copy.progress, TRUE, TRUE, 0);
/* file copy */
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
widget = gtk_label_new(_("Filename: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
copy.flabel = gtk_label_new("");
gtk_label_set_ellipsize(GTK_LABEL(copy.flabel), PANGO_ELLIPSIZE_START);
gtk_label_set_width_chars(GTK_LABEL(copy.flabel), 25);
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(copy.flabel, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(copy.flabel), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, copy.flabel);
gtk_box_pack_start(GTK_BOX(hbox), copy.flabel, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* file copy speed */
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
widget = gtk_label_new(_("Copied: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
copy.fspeed = gtk_label_new("");
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(copy.fspeed, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(copy.fspeed), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, copy.fspeed);
gtk_box_pack_start(GTK_BOX(hbox), copy.fspeed, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* file copy remaining */
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
widget = gtk_label_new(_("Remaining: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
copy.fremaining = gtk_label_new("");
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(copy.fremaining, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(copy.fremaining), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, copy.fremaining);
gtk_box_pack_start(GTK_BOX(hbox), copy.fremaining, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* file progress bar */
copy.fprogress = gtk_progress_bar_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(copy.fprogress), TRUE);
#endif
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(copy.fprogress), "");
gtk_box_pack_start(GTK_BOX(vbox), copy.fprogress, TRUE, TRUE, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
widget = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect_swapped(G_OBJECT(widget), "clicked", G_CALLBACK(
_copy_on_cancel), NULL);
gtk_box_pack_end(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(copy.window), 4);
gtk_container_add(GTK_CONTAINER(copy.window), vbox);
g_idle_add(_copy_idle_first, ©);
_copy_refresh(©);
gtk_widget_show_all(copy.window);
pango_font_description_free(bold);
return 0;
}
GtkWidget *
create_dialog (void)
{
GtkWidget *dlg;
GtkWidget *hbox, *vbox, *hbox2, *bbox;
GtkWidget *image;
GtkWidget *text;
GtkWidget *main_widget = NULL;
GtkWidget *topb = NULL;
/* create dialog window */
dlg = gtk_dialog_new ();
if (options.data.splash)
gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);
else
gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_NORMAL);
gtk_window_set_title (GTK_WINDOW (dlg), options.data.dialog_title);
gtk_widget_set_name (dlg, "yad-dialog-window");
#ifndef G_OS_WIN32
if (options.parent)
{
gdk_window_set_transient_for (gtk_widget_get_window (dlg),
gdk_x11_window_foreign_new_for_display (gdk_display_get_default (),
options.parent));
}
#endif
if (options.data.no_escape)
g_signal_connect (G_OBJECT (dlg), "close", G_CALLBACK (ignore_close_cb) , NULL);
/* get buttons container */
bbox = gtk_dialog_get_action_area (GTK_DIALOG (dlg));
/* set window icon */
if (options.data.window_icon)
{
if (g_file_test (options.data.window_icon, G_FILE_TEST_EXISTS))
gtk_window_set_icon_from_file (GTK_WINDOW (dlg), options.data.window_icon, NULL);
else
gtk_window_set_icon_name (GTK_WINDOW (dlg), options.data.window_icon);
}
/* set window borders */
if (options.data.borders == -1)
options.data.borders = (gint) gtk_container_get_border_width (GTK_CONTAINER (dlg));
gtk_container_set_border_width (GTK_CONTAINER (dlg), (guint) options.data.borders);
/* set window size and position */
if (!options.data.geometry && !options.data.maximized && !options.data.fullscreen)
{
gtk_window_set_default_size (GTK_WINDOW (dlg), options.data.width, options.data.height);
if (options.data.center)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER);
else if (options.data.mouse)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
}
/* set window behavior */
if (options.data.sticky)
gtk_window_stick (GTK_WINDOW (dlg));
gtk_window_set_keep_above (GTK_WINDOW (dlg), options.data.ontop);
gtk_window_set_decorated (GTK_WINDOW (dlg), !options.data.undecorated);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
gtk_window_set_skip_pager_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
/* create timeout indicator widget */
if (options.data.timeout)
{
if (G_LIKELY (options.data.to_indicator) && g_ascii_strcasecmp (options.data.to_indicator, "none"))
{
topb = gtk_progress_bar_new ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (topb), 1.0);
gtk_widget_set_name (topb, "yad-timeout-indicator");
}
}
/* add top label widgets */
#if !GTK_CHECK_VERSION(3,0,0)
hbox = hbox2 = gtk_hbox_new (FALSE, 0);
#else
hbox = hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), hbox, TRUE, TRUE, 5);
#if !GTK_CHECK_VERSION(3,0,0)
vbox = gtk_vbox_new (FALSE, 0);
#else
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#endif
/* add timeout indicator */
if (topb)
{
if (g_ascii_strcasecmp (options.data.to_indicator, "top") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_LEFT_TO_RIGHT);
#endif
gtk_box_pack_start (GTK_BOX (vbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "bottom") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_LEFT_TO_RIGHT);
#endif
gtk_box_pack_end (GTK_BOX (vbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "left") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_BOTTOM_TO_TOP);
#endif
gtk_box_pack_start (GTK_BOX (hbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "right") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_BOTTOM_TO_TOP);
#endif
gtk_box_pack_end (GTK_BOX (hbox), topb, FALSE, FALSE, 2);
}
if (settings.show_remain)
{
gchar *lbl = g_strdup_printf (_("%d sec"), options.data.timeout);
#if GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (topb), TRUE);
#endif
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (topb), lbl);
g_free (lbl);
}
}
/* must be after indicator! */
gtk_box_pack_end (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
if (options.data.image_on_top)
{
#if !GTK_CHECK_VERSION(3,0,0)
hbox2 = gtk_hbox_new (FALSE, 0);
#else
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 0);
}
if (options.data.dialog_image)
{
GdkPixbuf *pb = NULL;
pb = get_pixbuf (options.data.dialog_image, YAD_BIG_ICON);
image = gtk_image_new_from_pixbuf (pb);
if (pb)
g_object_unref (pb);
gtk_widget_set_name (image, "yad-dialog-image");
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox2), image, FALSE, FALSE, 2);
}
if (options.data.dialog_text)
{
/* for dnd's tooltip we don't need text label */
if (options.mode != YAD_MODE_DND || !options.dnd_data.tooltip)
{
gchar *buf = g_strcompress (options.data.dialog_text);
text = gtk_label_new (NULL);
if (!options.data.no_markup)
gtk_label_set_markup (GTK_LABEL (text), buf);
else
gtk_label_set_text (GTK_LABEL (text), buf);
g_free (buf);
gtk_widget_set_name (text, "yad-dialog-label");
gtk_label_set_line_wrap (GTK_LABEL (text), TRUE);
gtk_label_set_selectable (GTK_LABEL (text), options.data.selectable_labels);
gtk_label_set_justify (GTK_LABEL (text), options.data.text_align);
switch (options.data.text_align)
{
case GTK_JUSTIFY_LEFT:
case GTK_JUSTIFY_FILL:
gtk_misc_set_alignment (GTK_MISC (text), 0.0, 0.5);
break;
case GTK_JUSTIFY_CENTER:
gtk_misc_set_alignment (GTK_MISC (text), 0.5, 0.5);
break;
case GTK_JUSTIFY_RIGHT:
gtk_misc_set_alignment (GTK_MISC (text), 1.0, 0.5);
break;
}
if (options.data.image_on_top)
gtk_box_pack_start (GTK_BOX (hbox2), text, TRUE, TRUE, 2);
else
gtk_box_pack_start (GTK_BOX (vbox), text, FALSE, FALSE, 2);
#if !GTK_CHECK_VERSION(3,0,0)
if (!options.data.fixed)
g_signal_connect (G_OBJECT (text), "size-allocate", G_CALLBACK (text_size_allocate_cb), NULL);
#endif
}
}
/* add main widget */
switch (options.mode)
{
case YAD_MODE_CALENDAR:
main_widget = calendar_create_widget (dlg);
break;
case YAD_MODE_COLOR:
main_widget = color_create_widget (dlg);
break;
case YAD_MODE_DND:
dnd_init (dlg);
break;
case YAD_MODE_ENTRY:
main_widget = entry_create_widget (dlg);
break;
case YAD_MODE_FILE:
main_widget = file_create_widget (dlg);
break;
case YAD_MODE_FONT:
main_widget = font_create_widget (dlg);
break;
case YAD_MODE_FORM:
main_widget = form_create_widget (dlg);
break;
#ifdef HAVE_HTML
case YAD_MODE_HTML:
main_widget = html_create_widget (dlg);
break;
#endif
case YAD_MODE_ICONS:
main_widget = icons_create_widget (dlg);
break;
case YAD_MODE_LIST:
main_widget = list_create_widget (dlg);
break;
case YAD_MODE_MULTI_PROGRESS:
main_widget = multi_progress_create_widget (dlg);
break;
case YAD_MODE_NOTEBOOK:
main_widget = notebook_create_widget (dlg);
break;
case YAD_MODE_PANED:
main_widget = paned_create_widget (dlg);
break;
case YAD_MODE_PROGRESS:
main_widget = progress_create_widget (dlg);
break;
case YAD_MODE_SCALE:
main_widget = scale_create_widget (dlg);
break;
case YAD_MODE_TEXTINFO:
main_widget = text_create_widget (dlg);
break;
default:
;
}
if (main_widget)
{
if (options.data.expander)
{
GtkWidget *exp;
exp = gtk_expander_new_with_mnemonic (options.data.expander);
gtk_expander_set_expanded (GTK_EXPANDER (exp), FALSE);
gtk_container_add (GTK_CONTAINER (exp), main_widget);
gtk_box_pack_start (GTK_BOX (vbox), exp, TRUE, TRUE, 2);
}
else
gtk_box_pack_start (GTK_BOX (vbox), main_widget, TRUE, TRUE, 2);
}
/* add buttons */
if (!options.data.no_buttons)
{
if (options.data.buttons)
{
GSList *tmp = options.data.buttons;
do
{
GtkWidget *btn;
YadButton *b = (YadButton *) tmp->data;
btn = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (btn), get_label (b->name, 2));
gtk_button_set_alignment (GTK_BUTTON (btn), 0.5, 0.5);
g_object_set_data (G_OBJECT (btn), "resp", GINT_TO_POINTER (b->response));
g_signal_connect (G_OBJECT (btn), "clicked", G_CALLBACK (btn_cb), b->cmd);
gtk_box_pack_start (GTK_BOX (bbox), btn, FALSE, FALSE, 0);
tmp = tmp->next;
}
while (tmp != NULL);
}
else
{
if (options.mode == YAD_MODE_PROGRESS || options.mode == YAD_MODE_MULTI_PROGRESS)
gtk_dialog_add_buttons (GTK_DIALOG (dlg), GTK_STOCK_CLOSE, YAD_RESPONSE_OK, NULL);
else
{
if (gtk_alternative_dialog_button_order (NULL))
gtk_dialog_add_buttons (GTK_DIALOG (dlg),
GTK_STOCK_OK, YAD_RESPONSE_OK, GTK_STOCK_CANCEL, YAD_RESPONSE_CANCEL, NULL);
else
gtk_dialog_add_buttons (GTK_DIALOG (dlg),
GTK_STOCK_CANCEL, YAD_RESPONSE_CANCEL, GTK_STOCK_OK, YAD_RESPONSE_OK, NULL);
}
gtk_dialog_set_default_response (GTK_DIALOG (dlg), YAD_RESPONSE_OK);
}
gtk_button_box_set_layout (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dlg))),
options.data.buttons_layout);
}
/* show widgets */
gtk_widget_show_all (gtk_dialog_get_content_area (GTK_DIALOG (dlg)));
if (options.data.no_buttons)
gtk_widget_hide (bbox);
/* parse geometry, if given. must be after showing widget */
if (options.data.geometry && !options.data.maximized && !options.data.fullscreen)
{
gtk_widget_realize (dlg);
gtk_window_parse_geometry (GTK_WINDOW (dlg), options.data.geometry);
}
gtk_widget_show (dlg);
/* set maximized or fixed size after showing widget */
if (options.data.maximized)
gtk_window_maximize (GTK_WINDOW (dlg));
else if (options.data.fullscreen)
gtk_window_fullscreen (GTK_WINDOW (dlg));
else
{
gtk_window_set_resizable (GTK_WINDOW (dlg), !options.data.fixed);
if (options.data.fixed)
gtk_widget_set_size_request (dlg, options.data.width, options.data.height);
}
/* set timeout */
if (options.data.timeout)
{
g_timeout_add_seconds (options.data.timeout, timeout_cb, dlg);
g_timeout_add_seconds (1, timeout_indicator_cb, topb);
}
#ifndef G_OS_WIN32
/* print xid */
if (options.print_xid)
{
fprintf (stderr, "0x%lX", GDK_WINDOW_XID (gtk_widget_get_window (dlg)));
fflush (stderr);
}
#endif
return dlg;
}
static gboolean
csm_logout_dialog_timeout (gpointer data)
{
CsmLogoutDialog *logout_dialog;
char *seconds_warning;
char *secondary_text;
logout_dialog = (CsmLogoutDialog *) data;
if (!logout_dialog->priv->timeout && logout_dialog->priv->delay_toggle) {
gtk_dialog_response (GTK_DIALOG (logout_dialog),
logout_dialog->priv->default_response);
return FALSE;
}
switch (logout_dialog->priv->type) {
case CSM_DIALOG_LOGOUT_TYPE_LOGOUT:
/* This string is shared with csm-fail-whale-dialog.c */
seconds_warning = ngettext ("You will be automatically logged "
"out in %d second.",
"You will be logged "
"out in %d seconds.",
logout_dialog->priv->timeout);
break;
case CSM_DIALOG_LOGOUT_TYPE_SHUTDOWN:
seconds_warning = ngettext ("This system will be automatically "
"shut down in %d second.",
"This system will be "
"shut down in %d seconds.",
logout_dialog->priv->timeout);
break;
case CSM_DIALOG_LOGOUT_TYPE_REBOOT:
seconds_warning = ngettext ("This system will be automatically "
"restarted in %d second.",
"This system will be "
"restarted in %d seconds.",
logout_dialog->priv->timeout);
break;
default:
g_assert_not_reached ();
}
if (!csm_system_is_login_session (logout_dialog->priv->system)) {
char *name;
name = g_locale_to_utf8 (g_get_real_name (), -1, NULL, NULL, NULL);
if (!name || name[0] == '\0' || strcmp (name, "Unknown") == 0) {
name = g_locale_to_utf8 (g_get_user_name (), -1 , NULL, NULL, NULL);
}
if (!name) {
name = g_strdup (g_get_user_name ());
}
secondary_text = g_strdup_printf (_("You are currently logged in as \"%s\"."), name);
g_free (name);
}
gdouble delay;
delay = (gdouble)logout_dialog->priv->delay;
seconds_warning = g_strdup_printf (seconds_warning, logout_dialog->priv->timeout);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (logout_dialog->priv->progressbar), logout_dialog->priv->timeout / delay);
gtk_progress_bar_set_show_text( GTK_PROGRESS_BAR(logout_dialog->priv->progressbar), TRUE );
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (logout_dialog->priv->progressbar), seconds_warning);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (logout_dialog),
secondary_text,
NULL);
logout_dialog->priv->timeout--;
g_free (secondary_text);
g_free (seconds_warning);
return TRUE;
}
int main (int argc, char *argv[])
{
//const std::string creatureDB[]={"pidgeot","gardevoir"}; - For creature catalog~~
//std::cout<<creatureDB[0];
/* Initialize GTK+ */
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);
gtk_init (&argc, &argv);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
/* Main window configuration */
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (win), false);
gtk_widget_set_size_request(win,windowWidth,windowHeight);
gtk_container_set_border_width (GTK_CONTAINER (win), 0);
gtk_window_set_title (GTK_WINDOW (win), "Pokemon");
gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
gtk_widget_realize (win);
g_signal_connect (win, "destroy", gtk_main_quit, NULL);
gtk_window_set_icon_from_file(GTK_WINDOW(win),"images/winIcon.png",NULL);
//gtk_window_set_decorated (GTK_WINDOW(win),FALSE); //Óáèðàåò ñòàíäàðòíîå îôîðìëåíèå îêíà windows
/* Initializing objects */
zeBigContainer = gtk_box_new (GTK_ORIENTATION_VERTICAL,0);
zeBigContainerOverlay = gtk_overlay_new();
topPart = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,0);
topPartCenter = gtk_alignment_new (0.5,0.5,1,1);
topPartLeft = gtk_box_new (GTK_ORIENTATION_VERTICAL,0);
topPartCenter = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,0);
topPartRight = gtk_box_new (GTK_ORIENTATION_VERTICAL,0);
bottomPart = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,0);
buttons = gtk_grid_new ();
dialogScrollFrame = gtk_scrolled_window_new(NULL,NULL);
dialogText = gtk_text_view_new ();
dialogBuffer = gtk_text_buffer_new (NULL);
button1 = gtk_button_new ();
button2 = gtk_button_new ();
button3 = gtk_button_new ();
button4 = gtk_button_new_with_label ("Restart");
button5 = gtk_button_new_with_label ("Back to choosing screen");
topMidPart = gtk_image_new_from_file ("images/topPic.jpg");
IMGBackground = gtk_image_new_from_file ("images/pokeBackground.jpg");
leftImage = gtk_image_new_from_file ("images/filler.PNG");
rightImage = gtk_image_new_from_file ("images/filler.PNG");
leftBar = gtk_progress_bar_new ();
rightBar = gtk_progress_bar_new ();
/* Setting dialogText */
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(dialogText), GTK_TEXT_WINDOW_LEFT, 5);
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(dialogText), GTK_TEXT_WINDOW_BOTTOM, 20);
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(dialogText), GTK_TEXT_WINDOW_TOP, 5);
gtk_text_view_set_editable(GTK_TEXT_VIEW(dialogText), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(dialogText), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(dialogText),GTK_WRAP_WORD);
/* Setting progress bars */
gtk_progress_bar_set_inverted(GTK_PROGRESS_BAR(rightBar),TRUE);
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(leftBar),TRUE);
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(rightBar),TRUE);
/* Various initializations */
gtk_box_set_homogeneous((GtkBox*)topPartCenter,TRUE);
gtk_box_set_homogeneous((GtkBox*)topPart,TRUE);
gtk_box_set_homogeneous((GtkBox*)bottomPart,TRUE);
gtk_box_set_homogeneous((GtkBox*)zeBigContainer,TRUE);
gtk_grid_set_row_homogeneous((GtkGrid*)buttons,TRUE);
gtk_grid_set_column_homogeneous((GtkGrid*)buttons,TRUE);
gtk_grid_set_row_spacing((GtkGrid*)buttons,12);
gtk_grid_set_column_spacing((GtkGrid*)buttons,12);
g_object_set (buttons,"margin",12,NULL);
g_object_set (topPart,"margin",12,NULL);
gtk_container_set_border_width(GTK_CONTAINER(dialogScrollFrame),5);
//gtk_box_set_child_packing((GtkBox*)zeBigContainer,bottomPart,gTRUE,gTRUE,100,GTK_PACK_START);
gtk_text_view_set_buffer (GTK_TEXT_VIEW(dialogText), dialogBuffer);
gtk_text_buffer_set_text(dialogBuffer, "", -1);
//gtk_text_buffer_get_iter_at_offset (dialogBuffer, &lastCharIter, -1);
gtk_text_buffer_get_end_iter(dialogBuffer, &endIter);
fontDesc = pango_font_description_from_string("Consolas");
gtk_widget_override_font(dialogText,fontDesc);
endMark = gtk_text_mark_new ("endMark",FALSE);
endMark = gtk_text_buffer_get_mark(dialogBuffer,"insert");
gtk_button_set_always_show_image(GTK_BUTTON(button1),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(button2),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(button3),TRUE);
/* Building objects */
gtk_container_add (GTK_CONTAINER(win),zeBigContainerOverlay);
gtk_overlay_add_overlay(GTK_OVERLAY(zeBigContainerOverlay),zeBigContainer);
gtk_container_add (GTK_CONTAINER(zeBigContainerOverlay),IMGBackground);
gtk_container_add (GTK_CONTAINER(zeBigContainer),topPart);
gtk_container_add (GTK_CONTAINER(zeBigContainer),bottomPart);
gtk_container_add (GTK_CONTAINER(topPart),topPartLeft); // Â topPartLeft âñòàâëÿòü ëåâûé áàð
gtk_container_add (GTK_CONTAINER(topPartLeft),leftBar);
gtk_container_add (GTK_CONTAINER(topPartLeft),leftImage);
gtk_container_add (GTK_CONTAINER(topPart),topPartCenter);
gtk_container_add (GTK_CONTAINER(topPart),topPartRight); // â topPartRight - ïðàâûé...
gtk_container_add (GTK_CONTAINER(topPartRight),rightBar);
gtk_container_add (GTK_CONTAINER(topPartRight),rightImage);
gtk_container_add (GTK_CONTAINER(topPartCenter),topMidPart);
gtk_container_add (GTK_CONTAINER(bottomPart),dialogScrollFrame);
gtk_container_add (GTK_CONTAINER(dialogScrollFrame),dialogText);
gtk_container_add (GTK_CONTAINER(bottomPart),buttons);
gtk_grid_attach (GTK_GRID(buttons),button1, 1,1,1,1);
gtk_grid_attach (GTK_GRID(buttons),button2, 1,2,1,1);
gtk_grid_attach (GTK_GRID(buttons),button3, 1,3,1,1);
gtk_grid_attach (GTK_GRID(buttons),button4, 1,4,1,1);
gtk_grid_attach (GTK_GRID(buttons),button5, 1,5,1,1);
/* Signal connects and some shiatd */
g_signal_connect(G_OBJECT(button1), "clicked", Cast1, NULL);
g_signal_connect(G_OBJECT(button2), "clicked", Cast2, NULL);
g_signal_connect(G_OBJECT(button3), "clicked", Cast3, NULL);
g_signal_connect(G_OBJECT(button4), "clicked", combatStart, NULL);
g_signal_connect(G_OBJECT(button5), "clicked", backToChoosingScreen,NULL);
/* Creature chooser window configuration */ // TO BE CONTINUED..........................................................................
/* Window creation/configuration (win2) */
win2win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (win2win), false);
gtk_widget_set_size_request(win2win,windowWidth,windowHeight);
gtk_window_set_title (GTK_WINDOW (win2win), "Pokemon creature chooser");
gtk_window_set_position (GTK_WINDOW (win2win), GTK_WIN_POS_CENTER);
gtk_widget_realize (win2win);
g_signal_connect (win2win, "destroy", gtk_main_quit, NULL);
gtk_window_set_icon_from_file(GTK_WINDOW(win2win),"images/winIcon.png",NULL);
/* Initializing objects (win2) */
win2topLabel = gtk_image_new_from_file("images/logo.png");
//win2topLabel = gtk_label_new("");
//gtk_label_set_markup(GTK_LABEL(win2topLabel),"<small>Small</small><big>Bold</big>");
win2BigContainer = gtk_grid_new();
win2BigContainerOverlay = gtk_overlay_new ();
win2TopPart = gtk_grid_new ();
win2MiddlePart = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,0);
win2BottomPart = gtk_grid_new();
win2BackgroundIMG = gtk_image_new_from_file ("images/pokeBackground.jpg");
win2button1 = gtk_button_new_with_label(">>Switch Screens<<");
win2button2 = gtk_button_new_with_label("Exit");
win2buttonReset = gtk_button_new_with_label("Reset");
win2creatureIcon1 = gtk_button_new();
win2creatureIcon2 = gtk_button_new();
win2creatureIcon3 = gtk_button_new();
win2creatureIcon4 = gtk_button_new();
win2creatureIcon5 = gtk_button_new();
win2creatureIcon1IMG = gtk_image_new_from_file("images/ImagePidgeotSmall.png");
win2creatureIcon2IMG = gtk_image_new_from_file("images/ImageGardevoirSmall.png");
win2creatureIcon3IMG = gtk_image_new_from_file("images/ImageArcanineSmall.png");
win2creatureIcon4IMG = gtk_image_new_from_file("images/ImagePikachuSmall.png");
win2creatureIcon5IMG = gtk_image_new_from_file("images/ImageFishSmall.png");
win2ImageVersus = gtk_image_new_from_file ("images/versus.png");
win2MiddleFirst = gtk_image_new_from_file ("images/facelessVoid.png");
win2MiddleSecond = gtk_image_new_from_file ("images/facelessVoid.png");
/* Various initializations (win2) */
gtk_grid_set_row_homogeneous((GtkGrid*)win2BigContainer,TRUE);
gtk_grid_set_column_homogeneous((GtkGrid*)win2BigContainer,TRUE);
gtk_grid_set_row_spacing((GtkGrid*)win2BigContainer,12);
gtk_grid_set_column_spacing((GtkGrid*)win2BigContainer,12);
//g_object_set (win2BigContainer,"margin",12,NULL);
gtk_grid_set_row_homogeneous((GtkGrid*)win2BottomPart,TRUE);
gtk_grid_set_column_homogeneous((GtkGrid*)win2BottomPart,TRUE);
gtk_grid_set_row_spacing((GtkGrid*)win2BottomPart,12);
gtk_grid_set_column_spacing((GtkGrid*)win2BottomPart,12);
g_object_set (win2BottomPart,"margin",12,NULL);
gtk_grid_set_row_homogeneous((GtkGrid*)win2TopPart,TRUE);
gtk_grid_set_column_homogeneous((GtkGrid*)win2TopPart,TRUE);
gtk_grid_set_row_spacing((GtkGrid*)win2TopPart,12);
gtk_grid_set_column_spacing((GtkGrid*)win2TopPart,12);
g_object_set (win2TopPart,"margin",12,NULL);
gtk_box_set_homogeneous(GTK_BOX(win2MiddlePart),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(win2creatureIcon1),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(win2creatureIcon2),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(win2creatureIcon3),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(win2creatureIcon4),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(win2creatureIcon5),TRUE);
gtk_button_set_image(GTK_BUTTON(win2creatureIcon1),win2creatureIcon1IMG);
gtk_button_set_image(GTK_BUTTON(win2creatureIcon2),win2creatureIcon2IMG);
gtk_button_set_image(GTK_BUTTON(win2creatureIcon3),win2creatureIcon3IMG);
gtk_button_set_image(GTK_BUTTON(win2creatureIcon4),win2creatureIcon4IMG);
gtk_button_set_image(GTK_BUTTON(win2creatureIcon5),win2creatureIcon5IMG);
/* Building objects (win2) */
gtk_container_add (GTK_CONTAINER(win2win),win2BigContainerOverlay);
gtk_overlay_add_overlay(GTK_OVERLAY(win2BigContainerOverlay),win2BigContainer);
gtk_container_add (GTK_CONTAINER(win2BigContainerOverlay),win2BackgroundIMG);
gtk_grid_attach(GTK_GRID(win2BigContainer),win2topLabel,1,1,1,2);//1
gtk_grid_attach(GTK_GRID(win2BigContainer),win2TopPart,1,2,1,3);//3
gtk_grid_attach(GTK_GRID(win2TopPart),win2creatureIcon1,1,1,1,1);
gtk_grid_attach(GTK_GRID(win2TopPart),win2creatureIcon2,2,1,1,1);
gtk_grid_attach(GTK_GRID(win2TopPart),win2creatureIcon3,3,1,1,1);
gtk_grid_attach(GTK_GRID(win2TopPart),win2creatureIcon4,4,1,1,1);
gtk_grid_attach(GTK_GRID(win2TopPart),win2creatureIcon5,5,1,1,1);
gtk_grid_attach(GTK_GRID(win2BigContainer),win2MiddlePart,1,5,1,3);//3
gtk_grid_attach(GTK_GRID(win2BigContainer),win2BottomPart,1,8,1,3);//3
gtk_container_add (GTK_CONTAINER(win2MiddlePart),win2MiddleFirst);
gtk_container_add (GTK_CONTAINER(win2MiddlePart),win2ImageVersus);
gtk_container_add (GTK_CONTAINER(win2MiddlePart),win2MiddleSecond);
gtk_grid_attach (GTK_GRID(win2BottomPart),win2button1, 1,1,3,1);
gtk_grid_attach (GTK_GRID(win2BottomPart),win2buttonReset,4,1,1,1);
gtk_grid_attach (GTK_GRID(win2BottomPart),win2button2, 5,1,1,1);
/* Signal connects (win2) */
g_signal_connect (G_OBJECT(win2button1),"clicked",win2StartGame,NULL);
g_signal_connect (G_OBJECT(win2button2),"clicked",gtk_main_quit,NULL);
g_signal_connect (G_OBJECT(win2creatureIcon1),"clicked",win2pidgeotSelect,NULL);
g_signal_connect (G_OBJECT(win2creatureIcon2),"clicked",win2gardevoirSelect,NULL);
g_signal_connect (G_OBJECT(win2creatureIcon3),"clicked",win2arcanineSelect,NULL);
g_signal_connect (G_OBJECT(win2creatureIcon4),"clicked",win2pikachuSelect,NULL);
g_signal_connect (G_OBJECT(win2creatureIcon5),"clicked",win2mightyfishSelect,NULL);
g_signal_connect (G_OBJECT(win2buttonReset),"clicked",win2CharReset,NULL);
/* Other stuff */
srand(time(NULL));
write ("___________________________________________________\n");
/* Enter the main loop */
gtk_widget_show_all (win2win);
gtk_main ();
return 0;
};
static GtkWidget *
gsm_get_dialog (GsmDialogLogoutType type,
GdkScreen *screen,
guint32 activate_time)
{
GsmLogoutDialog *logout_dialog;
GtkWidget *dialog_image;
GtkWidget *hbox;
const char *primary_text;
const char *icon_name;
if (current_dialog != NULL) {
gtk_widget_destroy (GTK_WIDGET (current_dialog));
}
logout_dialog = g_object_new (GSM_TYPE_LOGOUT_DIALOG, NULL);
current_dialog = logout_dialog;
gtk_window_set_title (GTK_WINDOW (logout_dialog), "");
logout_dialog->priv->type = type;
icon_name = NULL;
primary_text = NULL;
switch (type) {
case GSM_DIALOG_LOGOUT_TYPE_LOGOUT:
icon_name = GSM_ICON_LOGOUT;
primary_text = _("Log out of this system now?");
logout_dialog->priv->default_response = GSM_LOGOUT_RESPONSE_LOGOUT;
if (gsm_logout_supports_switch_user (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Switch User"),
GSM_LOGOUT_RESPONSE_SWITCH_USER);
}
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Log Out"),
GSM_LOGOUT_RESPONSE_LOGOUT);
break;
case GSM_DIALOG_LOGOUT_TYPE_SHUTDOWN:
icon_name = GSM_ICON_SHUTDOWN;
primary_text = _("Shut down this system now?");
logout_dialog->priv->default_response = GSM_LOGOUT_RESPONSE_SHUTDOWN;
if (gsm_logout_supports_system_suspend (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("S_uspend"),
GSM_LOGOUT_RESPONSE_SLEEP);
}
if (gsm_logout_supports_system_hibernate (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Hibernate"),
GSM_LOGOUT_RESPONSE_HIBERNATE);
}
if (gsm_logout_supports_reboot (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Restart"),
GSM_LOGOUT_RESPONSE_REBOOT);
}
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
if (gsm_logout_supports_shutdown (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Shut Down"),
GSM_LOGOUT_RESPONSE_SHUTDOWN);
}
break;
default:
g_assert_not_reached ();
}
dialog_image = gtk_message_dialog_get_image (GTK_MESSAGE_DIALOG (logout_dialog));
#if GTK_CHECK_VERSION (3, 0, 0)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new (FALSE, 0);
#endif
logout_dialog->priv->progressbar = gtk_progress_bar_new ();
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (logout_dialog->priv->progressbar), TRUE);
#endif
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (logout_dialog->priv->progressbar), 1.0);
gtk_box_pack_start (GTK_BOX (hbox),
logout_dialog->priv->progressbar,
TRUE, TRUE, 12);
gtk_widget_show_all (hbox);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (logout_dialog))), hbox);
gtk_image_set_from_icon_name (GTK_IMAGE (dialog_image),
icon_name, GTK_ICON_SIZE_DIALOG);
gtk_window_set_icon_name (GTK_WINDOW (logout_dialog), icon_name);
gtk_window_set_position (GTK_WINDOW (logout_dialog), GTK_WIN_POS_CENTER_ALWAYS);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (logout_dialog), primary_text);
gtk_dialog_set_default_response (GTK_DIALOG (logout_dialog),
logout_dialog->priv->default_response);
gtk_window_set_screen (GTK_WINDOW (logout_dialog), screen);
return GTK_WIDGET (logout_dialog);
}
static void
stlink_gui_build_ui (STlinkGUI *gui) {
GtkBuilder *builder;
GtkListStore *devmem_store;
GtkListStore *filemem_store;
gchar *ui_file = STLINK_UI_DIR "/stlink-gui.ui";
if (!g_file_test (ui_file, G_FILE_TEST_EXISTS)) {
ui_file = "stlink-gui.ui";
}
builder = gtk_builder_new ();
if (!gtk_builder_add_from_file (builder, ui_file, NULL)) {
g_printerr ("Failed to load UI file: %s\n", ui_file);
exit (1);
}
gui->window = GTK_WINDOW (gtk_builder_get_object (builder, "window"));
g_signal_connect (G_OBJECT (gui->window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
/* set up toolutton clicked callbacks */
gui->open_button =
GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "open_button"));
g_signal_connect (G_OBJECT (gui->open_button), "clicked",
G_CALLBACK (open_button_cb), gui);
gui->connect_button =
GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "connect_button"));
g_signal_connect (G_OBJECT (gui->connect_button), "clicked",
G_CALLBACK (connect_button_cb), gui);
gui->disconnect_button =
GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "disconnect_button"));
g_signal_connect (G_OBJECT (gui->disconnect_button), "clicked",
G_CALLBACK (disconnect_button_cb), gui);
gui->flash_button =
GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "flash_button"));
g_signal_connect (G_OBJECT (gui->flash_button), "clicked",
G_CALLBACK (flash_button_cb), gui);
gui->devmem_treeview =
GTK_TREE_VIEW (gtk_builder_get_object (builder, "devmem_treeview"));
gtk_tree_view_set_rules_hint (gui->devmem_treeview, TRUE);
mem_view_init_headers (gui->devmem_treeview);
devmem_store = gtk_list_store_new (5,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_tree_view_set_model (gui->devmem_treeview, GTK_TREE_MODEL (devmem_store));
g_object_unref (devmem_store);
gui->filemem_treeview =
GTK_TREE_VIEW (gtk_builder_get_object (builder, "filemem_treeview"));
gtk_tree_view_set_rules_hint (gui->filemem_treeview, TRUE);
mem_view_init_headers (gui->filemem_treeview);
filemem_store = gtk_list_store_new (5,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_tree_view_set_model (gui->filemem_treeview, GTK_TREE_MODEL (filemem_store));
g_object_unref (filemem_store);
gui->core_id_label =
GTK_LABEL (gtk_builder_get_object (builder, "core_id_value"));
gui->chip_id_label =
GTK_LABEL (gtk_builder_get_object (builder, "chip_id_value"));
gui->flash_size_label =
GTK_LABEL (gtk_builder_get_object (builder, "flash_size_value"));
gui->ram_size_label =
GTK_LABEL (gtk_builder_get_object (builder, "ram_size_value"));
gui->device_frame =
GTK_FRAME (gtk_builder_get_object (builder, "device_frame"));
gui->notebook =
GTK_NOTEBOOK (gtk_builder_get_object (builder, "mem_notebook"));
g_signal_connect (gui->notebook, "switch-page",
G_CALLBACK (notebook_switch_page_cb), gui);
gui->devmem_box =
GTK_BOX (gtk_builder_get_object (builder, "devmem_box"));
gui->filemem_box =
GTK_BOX (gtk_builder_get_object (builder, "filemem_box"));
gui->devmem_jmp_entry =
GTK_ENTRY (gtk_builder_get_object (builder, "devmem_jmp_entry"));
g_signal_connect (gui->devmem_jmp_entry, "activate",
G_CALLBACK (devmem_jmp_cb), gui);
gui->filemem_jmp_entry =
GTK_ENTRY (gtk_builder_get_object (builder, "filemem_jmp_entry"));
g_signal_connect (gui->filemem_jmp_entry, "activate",
G_CALLBACK (filemem_jmp_cb), gui);
gtk_editable_set_editable (GTK_EDITABLE (gui->filemem_jmp_entry), TRUE);
gui->progress.bar =
GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "progressbar"));
gtk_progress_bar_set_show_text (gui->progress.bar, TRUE);
gui->progress.timer = g_timeout_add (100,
(GSourceFunc) progress_pulse_timeout,
gui);
gui->statusbar =
GTK_STATUSBAR (gtk_builder_get_object (builder, "statusbar"));
gui->infobar =
GTK_INFO_BAR (gtk_builder_get_object (builder, "infobar"));
gtk_info_bar_add_button (gui->infobar, GTK_STOCK_OK, GTK_RESPONSE_OK);
gui->infolabel = GTK_LABEL (gtk_label_new (""));
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (gui->infobar)),
GTK_WIDGET (gui->infolabel));
g_signal_connect (gui->infobar, "response", G_CALLBACK (gtk_widget_hide), NULL);
/* flash dialog */
gui->flash_dialog =
GTK_DIALOG (gtk_builder_get_object (builder, "flash_dialog"));
g_signal_connect_swapped (gui->flash_dialog, "response",
G_CALLBACK (gtk_widget_hide), gui->flash_dialog);
gui->flash_dialog_ok =
GTK_BUTTON (gtk_builder_get_object (builder, "flash_dialog_ok_button"));
gui->flash_dialog_cancel =
GTK_BUTTON (gtk_builder_get_object (builder, "flash_dialog_cancel_button"));
gui->flash_dialog_entry =
GTK_ENTRY (gtk_builder_get_object (builder, "flash_dialog_entry"));
/* make it so */
gtk_widget_show_all (GTK_WIDGET (gui->window));
gtk_widget_hide (GTK_WIDGET (gui->infobar));
gtk_widget_hide (GTK_WIDGET (gui->progress.bar));
stlink_gui_set_disconnected (gui);
}
GtkWidget *
progress_create_widget (GtkWidget * dlg)
{
GtkWidget *w;
GIOChannel *channel;
// fix it when vertical specified
#if GTK_CHECK_VERSION(3,0,0)
w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#else
w = gtk_vbox_new (FALSE, 0);
#endif
progress_bar = gtk_progress_bar_new ();
gtk_widget_set_name (progress_bar, "yad-progress-widget");
if (options.progress_data.log_on_top)
gtk_box_pack_end (GTK_BOX (w), progress_bar, FALSE, FALSE, 0);
else
gtk_box_pack_start (GTK_BOX (w), progress_bar, FALSE, FALSE, 0);
if (options.progress_data.percentage > 100)
options.progress_data.percentage = 100;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), options.progress_data.percentage / 100.0);
if (options.progress_data.progress_text)
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress_bar), options.progress_data.progress_text);
#if GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (progress_bar), options.progress_data.rtl);
#else
if (options.progress_data.rtl)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (progress_bar), GTK_PROGRESS_RIGHT_TO_LEFT);
#endif
if (options.progress_data.log)
{
GtkWidget *ex, *sw;
ex = gtk_expander_new (options.progress_data.log);
gtk_expander_set_spacing (GTK_EXPANDER (ex), 2);
gtk_expander_set_expanded (GTK_EXPANDER (ex), options.progress_data.log_expanded);
gtk_box_pack_start (GTK_BOX (w), ex, TRUE, TRUE, 2);
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), options.hscroll_policy, options.vscroll_policy);
gtk_container_add (GTK_CONTAINER (ex), sw);
progress_log = gtk_text_view_new ();
gtk_widget_set_name (progress_log, "yad-text-widget");
gtk_widget_set_size_request (progress_log, -1, options.progress_data.log_height);
gtk_container_add (GTK_CONTAINER (sw), progress_log);
log_buffer = gtk_text_buffer_new (NULL);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (progress_log), log_buffer);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (progress_log), 5);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (progress_log), 5);
gtk_text_view_set_editable (GTK_TEXT_VIEW (progress_log), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (progress_log), FALSE);
}
#if GTK_CHECK_VERSION(3,0,0)
else
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (progress_bar), TRUE);
#endif
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel, G_IO_IN | G_IO_HUP, handle_stdin, dlg);
return w;
}
//____________________________________________________
SliderDemoWidget::SliderDemoWidget( void )
{
// main widget
GtkWidget* mainWidget( gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ) );
gtk_box_set_spacing( GTK_BOX( mainWidget ), 5 );
setWidget( mainWidget );
// setup
setName( "Sliders" );
setComments( "Shows the appearance of sliders, progress bars and scrollbars" );
setIconName( "measure" );
realize();
// horizontal sliders
{
// frame
GtkWidget* frame( gtk_frame_new( "Horizontal" ) );
gtk_box_pack_start( GTK_BOX( mainWidget ), frame, true, true, 0 );
gtk_widget_show( frame );
// container
GtkWidget* box( gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 ) );
gtk_container_set_border_width( GTK_CONTAINER( box ), 5 );
gtk_box_set_spacing( GTK_BOX( box ), 2 );
gtk_widget_show( box );
gtk_container_add( GTK_CONTAINER( frame ), box );
// scale
_horizontalSliders._scale = gtk_scale_new_with_range( GTK_ORIENTATION_HORIZONTAL, 0, 100, 1 );
gtk_scale_set_draw_value( GTK_SCALE( _horizontalSliders._scale ), false );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._scale, false, true, 0 );
gtk_widget_show( _horizontalSliders._scale );
// progress entry
_horizontalSliders._progressEntry = gtk_entry_new();
gtk_entry_set_text( GTK_ENTRY( _horizontalSliders._progressEntry ), "Progress Bar Entry" );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._progressEntry, false, true, 0 );
gtk_widget_show( _horizontalSliders._progressEntry );
// progress bar
_horizontalSliders._progressBar = gtk_progress_bar_new();
gtk_progress_bar_set_show_text( GTK_PROGRESS_BAR( _horizontalSliders._progressBar ), true );
gtk_orientable_set_orientation( GTK_ORIENTABLE( _horizontalSliders._progressBar ), GTK_ORIENTATION_HORIZONTAL );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._progressBar, false, true, 0 );
gtk_widget_show( _horizontalSliders._progressBar );
// pulse progressBar
_pulseProgressBar = gtk_progress_bar_new();
gtk_orientable_set_orientation( GTK_ORIENTABLE( _pulseProgressBar ), GTK_ORIENTATION_HORIZONTAL );
gtk_progress_bar_set_pulse_step( GTK_PROGRESS_BAR( _pulseProgressBar ), 0.01 );
gtk_box_pack_start( GTK_BOX( box ), _pulseProgressBar, false, true, 0 );
gtk_widget_show( _pulseProgressBar );
// scrollbar
GtkAdjustment* adjustment( GTK_ADJUSTMENT( gtk_adjustment_new( 25, 0, 110, 1, 1, 10 ) ) );
_horizontalSliders._scrollBar = gtk_scrollbar_new( GTK_ORIENTATION_HORIZONTAL, adjustment );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._scrollBar, false, true, 0 );
gtk_widget_show( _horizontalSliders._scrollBar );
}
// vertical sliders
{
// frame
GtkWidget* frame( gtk_frame_new( "Vertical" ) );
gtk_box_pack_start( GTK_BOX( mainWidget ), frame, false, true, 0 );
gtk_widget_show( frame );
// container
GtkWidget* box( gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ) );
gtk_container_set_border_width( GTK_CONTAINER( box ), 5 );
gtk_box_set_spacing( GTK_BOX( box ), 5 );
gtk_widget_show( box );
gtk_container_add( GTK_CONTAINER( frame ), box );
// scale
_verticalSliders._scale = gtk_scale_new_with_range( GTK_ORIENTATION_VERTICAL, 0, 100, 1 );
gtk_scale_set_draw_value( GTK_SCALE( _verticalSliders._scale ), false );
gtk_box_pack_start( GTK_BOX( box ), _verticalSliders._scale, false, true, 0 );
gtk_widget_show( _verticalSliders._scale );
// progress bar
_verticalSliders._progressBar = gtk_progress_bar_new();
gtk_progress_bar_set_show_text( GTK_PROGRESS_BAR( _verticalSliders._progressBar ), true );
gtk_orientable_set_orientation( GTK_ORIENTABLE( _verticalSliders._progressBar ), GTK_ORIENTATION_VERTICAL );
gtk_box_pack_start( GTK_BOX( box ), _verticalSliders._progressBar, false, true, 0 );
gtk_widget_show( _verticalSliders._progressBar );
// scrollbar
GtkAdjustment* adjustment( GTK_ADJUSTMENT( gtk_adjustment_new( 25, 0, 110, 1, 1, 10 ) ) );
_verticalSliders._scrollBar = gtk_scrollbar_new( GTK_ORIENTATION_VERTICAL, adjustment );
gtk_box_pack_start( GTK_BOX( box ), _verticalSliders._scrollBar, false, true, 0 );
gtk_widget_show( _verticalSliders._scrollBar );
}
// connections
connect( G_OBJECT( _horizontalSliders._scale ), "value-changed", GCallback( valueChanged ), this );
connect( G_OBJECT( _horizontalSliders._scrollBar ), "value-changed", GCallback( valueChanged ), this );
connect( G_OBJECT( _verticalSliders._scale ), "value-changed", GCallback( valueChanged ), this );
connect( G_OBJECT( _verticalSliders._scrollBar ), "value-changed", GCallback( valueChanged ), this );
// Initialize all
gtk_range_set_value( GTK_RANGE( _verticalSliders._scale ), 25 );
}
void start_GUI() {
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), "telerobot client");
gtk_window_set_icon_from_file(GTK_WINDOW(main_window), "icons/PlayStation_3_gamepad.svg", NULL);
/* gdk_window_set_icon_list(GTK_WINDOW(main_window), NULL); */
gtk_window_set_default_size(GTK_WINDOW(main_window), 973, 309); /* actually 1024, 254 */
gtk_window_set_position(GTK_WINDOW(main_window), GTK_WIN_POS_CENTER);
/* gtk_widget_show(main_window); */
left_table = gtk_table_new(6, 3, TRUE);
gtk_table_set_row_spacings(GTK_TABLE(left_table), 2);
gtk_table_set_col_spacings(GTK_TABLE(left_table), 2);
provider = gtk_css_provider_new();
/* gtk_css_provider_load_from_path(cssProvider,"./style.css", NULL); */
gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider), "GtkProgressBar {\n"
"min-height: 30px;\n"
"}\n", -1, NULL);
display = gdk_display_get_default();
screen = gdk_display_get_default_screen(display);
gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref(provider);
progress1 = gtk_progress_bar_new();
//gtk_progress_bar_set_inverted(progress1, TRUE);
/* this would invert progressbar direction */
gtk_progress_bar_set_text(progress1, "L2:");
gtk_progress_bar_set_show_text(progress1, TRUE);
/*g_object_set(progress1, "min-height", 30, NULL);*/
gtk_table_attach(GTK_TABLE(left_table), progress1, 0, 3, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress1), GTK_ALIGN_CENTER);
progress2 = gtk_progress_bar_new();
gtk_progress_bar_set_text(progress2, "R2:");
gtk_progress_bar_set_show_text(progress2, TRUE);
/*g_object_set(progress2, "min-height", 30, NULL);*/
gtk_table_attach(GTK_TABLE(left_table), progress2, 0, 3, 1, 2, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress2), GTK_ALIGN_CENTER);
progress3 = gtk_progress_bar_new();
gtk_progress_bar_set_show_text(progress3, TRUE);
gtk_table_attach(GTK_TABLE(left_table), progress3, 0, 3, 2, 3, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress3), GTK_ALIGN_CENTER);
progress4 = gtk_progress_bar_new();
gtk_progress_bar_set_show_text(progress4, TRUE);
gtk_table_attach(GTK_TABLE(left_table), progress4, 0, 3, 3, 4, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress4), GTK_ALIGN_CENTER);
progress5 = gtk_progress_bar_new();
gtk_progress_bar_set_show_text(progress5, TRUE);
gtk_table_attach(GTK_TABLE(left_table), progress5, 0, 3, 4, 5, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress5), GTK_ALIGN_CENTER);
/* feedback labels */
label_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
label_roll = gtk_label_new("roll (\u00B0)");
gtk_box_pack_start(GTK_WIDGET(label_box), label_roll, FALSE, FALSE, 10);
label_pitch = gtk_label_new("pitch (\u00B0)");
gtk_box_pack_start(GTK_WIDGET(label_box), label_pitch, FALSE, FALSE, 10);
label_alt = gtk_label_new("altitude (m)");
gtk_box_pack_start(GTK_WIDGET(label_box), label_alt, FALSE, FALSE, 10);
gtk_table_attach(GTK_TABLE(left_table), label_box, 0, 3, 5, 6, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(label_box), GTK_ALIGN_CENTER);
left_frame = gtk_aspect_frame_new(NULL, /* label */
0.5, /* horizontal position */
0.0, /* vertical position */
1, /* xsize/ysize = 1 */
FALSE /* ignore child's aspect */);
drawing_area_frame = gtk_aspect_frame_new(NULL, 0.5, 0.0, 1, TRUE /* ignore child's aspect */);
gtk_frame_set_shadow_type(GTK_FRAME(drawing_area_frame), GTK_SHADOW_ETCHED_IN);
GtkWidget *text_area_frame;
text_area_frame = gtk_aspect_frame_new(NULL, 0.5, 0.0, 1, TRUE);
gtk_frame_set_shadow_type(GTK_FRAME(text_area_frame), GTK_SHADOW_ETCHED_IN);
drawing_area = gtk_drawing_area_new();
gtk_widget_set_size_request(drawing_area, 320, 320);
gtk_container_add(GTK_CONTAINER(drawing_area_frame), drawing_area);
g_signal_connect(G_OBJECT(drawing_area), "draw", G_CALLBACK(on_draw_event), NULL);
g_signal_connect(main_window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_frame_set_shadow_type(GTK_FRAME(left_frame), GTK_SHADOW_ETCHED_IN);
/* draws a frame */
gtk_container_add(GTK_CONTAINER(left_frame), left_table);
/* places the widget inside frame */
main_table = gtk_table_new(1, 3, FALSE);
/* creates three column table */
gtk_table_attach_defaults(GTK_TABLE(main_table), left_frame, 0, 1, 0, 1);
/* places the widget inside leftmost cell of the table */
gtk_table_attach_defaults(GTK_TABLE(main_table), drawing_area_frame, 1, 2, 0, 1);
/* places the video/artificial horizon widget inside middle cell */
/* prawa komórka głównej tabeli */
// grid method
// right_table = gtk_grid_new();
// table method
right_table = gtk_table_new(3, 3, TRUE);
/* prawa ramka */
right_frame = gtk_aspect_frame_new(NULL, /* label */
0.5, /* wyrównanie w poziomie */
0.0, /* wyrównanie w pionie */
1, /* xsize/ysize = 1 */
FALSE /* ignore child's aspect */);
/* zamiast "0" może być NULL - wtedy pole jest puste */
label_x1 = gtk_label_new("");
label_y1 = gtk_label_new("");
label_x2 = gtk_label_new("");
label_y2 = gtk_label_new("");
/* 0 - pierwsza kolumna, 1 - druga kolumna następna (numerowane od zera) */
/* umieszcza wskaźniki w polach tabeli */
gtk_label_set_justify(label_x1, GTK_JUSTIFY_RIGHT);
gtk_label_set_justify(label_y1, GTK_JUSTIFY_RIGHT);
/* "0,2,Y,Y" oznacza że zajmują dwie komórki tabeli */
/* typ obwiedni */
gtk_frame_set_shadow_type(GTK_FRAME(right_frame), GTK_SHADOW_ETCHED_IN);
/* umieszcza right_table w wskazniki */
gtk_container_add(GTK_CONTAINER(right_frame), right_table);
gtk_table_attach_defaults(GTK_TABLE(main_table), right_frame, 2, 3, 0, 1);
/* umieszcza ramkę wskazniki w prawej (2,3) komórce głównej tabeli */
/* tworzy przycisk wyłączający serwer */
/*
GtkWidget *quit_icon;
GtkWidget *quit_button;
quit_icon = gtk_image_new_from_file("icons/system-shutdown.svg");
quit_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(quit_button), quit_icon);
g_signal_connect(quit_button, "pressed", G_CALLBACK(wyslij_przycisk_13_on), NULL);
g_signal_connect(quit_button, "released", G_CALLBACK(wyslij_przycisk_13_off), NULL);
gtk_button_set_relief(quit_button, GTK_RELIEF_NONE);
*/
/* Sets whether the button will grab focus when it is clicked with the mouse.
Making mouse clicks not grab focus is useful in places like toolbars
where you don't want the keyboard focus removed from the main area of the application. */
/* gtk_button_set_focus_on_click(quit_button, 0); */
/* regulator & servo controller buttons */
servocontroller_enable_button = gtk_button_new_with_label("enable\nUSC-16");
gtk_button_set_relief(servocontroller_enable_button, GTK_RELIEF_NONE);
gtk_table_attach_defaults(GTK_TABLE(right_table), servocontroller_enable_button, 0, 1, 2, 3);
servocontroller_disable_button = gtk_button_new_with_label("disable\nUSC-16");
gtk_button_set_relief(servocontroller_disable_button, GTK_RELIEF_NONE);
gtk_table_attach_defaults(GTK_TABLE(right_table), servocontroller_disable_button, 0, 1, 2, 3);
check_button_regulator = gtk_check_button_new_with_label("50 Hz");
gtk_toggle_button_set_active(check_button_regulator, FALSE);
gtk_table_attach_defaults(GTK_TABLE(right_table), check_button_regulator, 1, 2, 2, 3);
/* record buttons */
record_start_icon = gtk_image_new_from_file("icons/media-record.svg");
record_start_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(record_start_button), record_start_icon);
gtk_table_attach_defaults(GTK_TABLE(right_table), record_start_button, 2, 3, 1, 2);
gtk_button_set_relief(GTK_BUTTON(record_start_button), GTK_RELIEF_NONE);
record_stop_icon = gtk_image_new_from_file("icons/media-playback-stop.svg");
record_stop_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(record_stop_button), record_stop_icon);
gtk_table_attach_defaults(GTK_TABLE(right_table), record_stop_button, 2, 3, 1, 2);
gtk_button_set_relief(GTK_BUTTON(record_stop_button), GTK_RELIEF_NONE);
/* fullscreen buttons */
fullscreen_enable_icon = gtk_image_new_from_file("icons/view-fullscreen.svg");
fullscreen_enable_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(fullscreen_enable_button), fullscreen_enable_icon);
g_signal_connect(fullscreen_enable_button, "clicked", G_CALLBACK(enable_Fullscreen), NULL);
gtk_button_set_relief(fullscreen_enable_button, GTK_RELIEF_NONE);
fullscreen_disable_icon = gtk_image_new_from_file("icons/view-windowed.svg");
fullscreen_disable_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(fullscreen_disable_button), fullscreen_disable_icon);
g_signal_connect(fullscreen_disable_button, "clicked", G_CALLBACK(disable_Fullscreen), NULL);
gtk_button_set_relief(fullscreen_disable_button, GTK_RELIEF_NONE);
/* joystick button */
// https://commons.wikimedia.org/wiki/File:PlayStation_3_gamepad.svg
joystick_icon = gtk_image_new_from_file("icons/PlayStation_3_gamepad.svg");
check_button_joystick = gtk_check_button_new();
/* gtk_container_add (GTK_CONTAINER (check_button_joystick), joystick_icon); */
/* łączenie sygnału przeniesione za pierwsze wykrycie joysticka */
/* video button */
video_icon = gtk_image_new_from_file("icons/camera-web.svg");
check_button_video = gtk_check_button_new();
gtk_toggle_button_set_active(check_button_video, TRUE);
/* reconnect button */
reconnect_icon = gtk_image_new_from_file("icons/gnome-modem.svg");
reconnect_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(reconnect_button), reconnect_icon);
gtk_button_set_relief(reconnect_button, GTK_RELIEF_NONE);
/* table method */
gtk_table_attach_defaults(GTK_TABLE(right_table), label_x1, 0, 1, 0, 1);
gtk_table_attach(GTK_TABLE(right_table), label_y1, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 20);
gtk_table_attach_defaults(GTK_TABLE(right_table), label_x2, 1, 2, 0, 1);
gtk_table_attach(GTK_TABLE(right_table), label_y2, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 20);
gtk_table_attach_defaults(GTK_TABLE(right_table), reconnect_button, 2, 3, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), fullscreen_enable_button, 2, 3, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(right_table), fullscreen_disable_button, 2, 3, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(right_table), video_icon, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), check_button_video, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), joystick_icon, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), check_button_joystick, 0, 1, 3, 4);
/* grid method */
// FIXME: works only with GTK+ 3.0
/*
gtk_grid_attach(GTK_GRID(right_table), label_x, 0, 0, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), label_y, 0, 1, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), label_x2, 1, 0, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), label_y2, 1, 1, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), fullscreen_enable_button, 2, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), fullscreen_disable_button, 2, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), video_icon, 1, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_video, 1, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), joystick_icon, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_joystick, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_serwokontroler, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_regulator, 1, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), quit_button, 2, 3, 1, 1);
*/
statusbar = gtk_statusbar_new();
context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "Statusbar example");
/* pakowanie głównych elementów okna programu: */
vbox = gtk_vbox_new(FALSE, 2);
/* ustawianie szerokości marginesu wokół elementu */
gtk_box_pack_start(GTK_BOX(vbox), main_table, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
gtk_container_set_border_width(GTK_CONTAINER(main_table), 5);
gtk_container_add(GTK_CONTAINER(main_window), vbox);
}
