static void _settings_window(GPS * gps)
{
GtkWidget * vbox;
GtkWidget * hbox;
GtkWidget * widget;
gps->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(gps->window), 4);
gtk_window_set_default_size(GTK_WINDOW(gps->window), 200, 300);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(gps->window), "gnome-settings");
#endif
gtk_window_set_title(GTK_WINDOW(gps->window), "GPS");
g_signal_connect(gps->window, "delete-event", G_CALLBACK(
gtk_widget_hide), NULL);
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
#else
vbox = gtk_vbox_new(FALSE, 4);
#endif
/* controls */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
hbox = gtk_hbutton_box_new();
#endif
widget = gtk_button_new_with_label("Start");
g_signal_connect_swapped(widget, "clicked",
G_CALLBACK(_gps_on_settings_start), gps);
gtk_container_add(GTK_CONTAINER(hbox), widget);
widget = gtk_button_new_with_label("Stop");
g_signal_connect_swapped(widget, "clicked",
G_CALLBACK(_gps_on_settings_stop), gps);
gtk_container_add(GTK_CONTAINER(hbox), widget);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
/* button box */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
hbox = gtk_hbutton_box_new();
#endif
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), 4);
widget = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect_swapped(widget, "clicked", G_CALLBACK(
_gps_on_settings_close), gps);
gtk_container_add(GTK_CONTAINER(hbox), widget);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(gps->window), vbox);
gtk_widget_show_all(vbox);
}
void
html_diag_finish(Thtml_diag * dg, GCallback ok_func)
{
GtkWidget *align, *hbox;
align = gtk_alignment_new(0.5, 1.0, 1.0, 0.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align), 12, 0, 0, 0);
#if GTK_CHECK_VERSION(3,0,0)
hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
hbox = gtk_hbutton_box_new();
#endif
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), 12);
gtk_container_add(GTK_CONTAINER(align), hbox);
dg->obut = bf_stock_ok_button(ok_func, dg);
dg->cbut = bf_stock_cancel_button(G_CALLBACK(html_diag_cancel_clicked_cb), dg);
gtk_box_pack_start(GTK_BOX(hbox), dg->cbut, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), dg->obut, FALSE, FALSE, 0);
gtk_window_set_default(GTK_WINDOW(dg->dialog), dg->obut);
gtk_box_pack_start(GTK_BOX(dg->vbox), align, FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(dg->dialog));
}
/**
* gdaui_bar_add_button_from_stock:
* @bar: a #GdauiBar
* @stock_id: the stock name of the button to add
*
* Returns: (transfer none): the created #GtkButton
*/
GtkWidget *
gdaui_bar_add_button_from_stock (GdauiBar *bar, const gchar *stock_id)
{
g_return_val_if_fail (GDAUI_IS_BAR (bar), NULL);
g_return_val_if_fail (stock_id && *stock_id, NULL);
GtkWidget *vb, *button, *img;
vb = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vb), GTK_BUTTONBOX_CENTER);
gtk_box_pack_start (GTK_BOX (bar->priv->action_area), vb, FALSE, FALSE, 0);
button = gtk_button_new ();
img = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (button), img);
gtk_box_pack_start (GTK_BOX (vb), button, FALSE, FALSE, 0);
g_object_set (G_OBJECT (button), "label", NULL, NULL);
/* CSS theming */
GtkStyleContext *context;
context = gtk_widget_get_style_context (vb);
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar_button");
context = gtk_widget_get_style_context (button);
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar_button");
context = gtk_widget_get_style_context (img);
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar_button");
gtk_widget_show_all (vb);
return button;
}
/**
* gdaui_bar_add_search_entry:
* @bar: a #GdauiBar
*
* Returns: (transfer none): the created #GtkEntry
*/
GtkWidget *
gdaui_bar_add_search_entry (GdauiBar *bar)
{
g_return_val_if_fail (GDAUI_IS_BAR (bar), NULL);
GtkWidget *vb, *entry;
vb = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vb), GTK_BUTTONBOX_CENTER);
gtk_box_pack_start (GTK_BOX (bar->priv->action_area), vb, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vb), entry, FALSE, FALSE, 0);
/* CSS theming */
GtkStyleContext *context;
context = gtk_widget_get_style_context (vb);
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar_entry");
context = gtk_widget_get_style_context (entry);
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar_entry");
gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
GTK_STOCK_CLEAR);
g_signal_connect (entry, "icon-press",
G_CALLBACK (find_icon_pressed_cb), NULL);
gtk_widget_show_all (vb);
return entry;
}
/* static */
wxSize wxButtonBase::GetDefaultSize()
{
static wxSize size = wxDefaultSize;
if (size == wxDefaultSize)
{
// NB: Default size of buttons should be same as size of stock
// buttons as used in most GTK+ apps. Unfortunately it's a little
// tricky to obtain this size: stock button's size may be smaller
// than size of button in GtkButtonBox and vice versa,
// GtkButtonBox's minimal button size may be smaller than stock
// button's size. We have to retrieve both values and combine them.
GtkWidget *wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget *box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
GtkWidget *btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_container_add(GTK_CONTAINER(box), btn);
gtk_container_add(GTK_CONTAINER(wnd), box);
GtkRequisition req;
gtk_widget_get_preferred_size(btn, NULL, &req);
gint minwidth, minheight;
gtk_widget_style_get(box,
"child-min-width", &minwidth,
"child-min-height", &minheight,
NULL);
size.x = wxMax(minwidth, req.width);
size.y = wxMax(minheight, req.height);
gtk_widget_destroy(wnd);
}
return size;
}
static GtkWidget*
dialog_contents (void)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *action_area;
GtkWidget *label;
GtkWidget *image;
GtkWidget *button;
vbox = gtk_vbox_new (FALSE, 0);
#if GTK_CHECK_VERSION (3, 0, 0)
action_area = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
#else
action_area = gtk_hbutton_box_new ();
#endif
gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area),
GTK_BUTTONBOX_END);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_box_pack_end (GTK_BOX (action_area),
button,
FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox), action_area,
FALSE, TRUE, 0);
update_spacings (vbox, action_area);
label = gtk_label_new (_("This is a sample message in a sample dialog"));
image = gtk_image_new_from_icon_name ("dialog-information",
GTK_ICON_SIZE_DIALOG);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_halign (image, GTK_ALIGN_CENTER);
gtk_widget_set_valign (image, GTK_ALIGN_START);
#else
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
#endif
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), image,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label,
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox),
hbox,
FALSE, FALSE, 0);
gtk_widget_show_all (vbox);
return vbox;
}
void _fcitx_ui_widget_load(FcitxUIWidget* self, const gchar* uiname)
{
FcitxMainWindow* mainwindow = FCITX_MAIN_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET(self)));
FcitxAddon* addon = find_addon_by_name(mainwindow->addons, uiname);
if (!addon)
return;
gchar* config_desc_name = g_strdup_printf("%s.desc", addon->name);
FcitxConfigFileDesc* cfdesc = get_config_desc(config_desc_name);
g_free(config_desc_name);
gboolean configurable = (gboolean)(cfdesc != NULL || strlen(addon->subconfig) != 0);
if (!configurable) {
gchar* text = g_strdup_printf(_("No configuration option for %s."), addon->generalname);
gtk_label_set_text(GTK_LABEL(self->label), text);
g_free(text);
}
else {
gtk_container_remove(GTK_CONTAINER(self), self->label);
self->label = NULL;
gchar* config_file_name = g_strdup_printf("%s.config", addon->name);
FcitxConfigWidget* config_widget = fcitx_config_widget_new(cfdesc, "conf", config_file_name, addon->subconfig);
g_free(config_file_name);
gtk_box_pack_start(GTK_BOX(self), GTK_WIDGET(config_widget), TRUE, TRUE, 0);
g_object_set(G_OBJECT(config_widget), "margin", 5, NULL);
GtkWidget* hbuttonbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(self), hbuttonbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(hbuttonbox), "margin", 5, NULL);
GtkWidget* applybutton = gtk_button_new_from_stock(GTK_STOCK_APPLY);
gtk_box_pack_start(GTK_BOX(hbuttonbox), applybutton, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(applybutton), "clicked", G_CALLBACK(_fcitx_ui_widget_apply_button_clicked), config_widget);
gtk_widget_show_all(GTK_WIDGET(self));
}
}
void tooltip_window_create( GtkWidget* dock_window )
{
eric_window* w = eric_window_create( 10, 10, "" );
gtk_window_move( GTK_WINDOW( w->window ), 0, 1040 );
gtk_window_set_type_hint( GTK_WINDOW( w->window ), GDK_WINDOW_TYPE_HINT_DIALOG );
gtk_window_set_decorated( GTK_WINDOW( w->window ), FALSE );
gtk_window_set_skip_pager_hint( GTK_WINDOW( w->window ), TRUE );
gtk_window_set_transient_for( GTK_WINDOW( w->window ), GTK_WINDOW( dock_window ) );
gtk_window_set_keep_above( GTK_WINDOW( w->window ), TRUE );
gtk_widget_add_events( w->window, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK );
g_signal_connect( G_OBJECT( w->window ), "focus-out-event", G_CALLBACK(tooltip_window_lose_focus), NULL );
//Add Dock icon box
pager_items_box = gtk_button_box_new( GTK_ORIENTATION_VERTICAL );
gtk_button_box_set_layout( GTK_BUTTON_BOX( pager_items_box ), GTK_BUTTONBOX_CENTER );
//gtk_button_box_set_child_non_homogeneous( GTK_BUTTON_BOX( dock_icons_box ), TRUE );
gtk_container_add( GTK_CONTAINER( w->window ), pager_items_box );
gtk_widget_show( pager_items_box );
//Pango stuff
char fontdesc[80];
pango_context = gtk_widget_create_pango_context( w->window );
sprintf( fontdesc, "Source Sans Pro Regular %ipx", (int)(SCALE_VALUE( 16 )) );
PangoFontDescription* font = pango_font_description_from_string( fontdesc );
pango_context_set_font_description( pango_context, font );
tooltip_window = w;
}
static VALUE
rg_initialize(VALUE self, VALUE orientation)
{
RBGTK_INITIALIZE(self, gtk_button_box_new(RVAL2GTKORIENTATION(orientation)));
return Qnil;
}
static void vorbis_configure(void)
{
GtkWidget *vbox, *bbox;
GtkWidget *button;
if (configure_win == NULL)
{
configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(configure_win), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT(configure_win), "destroy", G_CALLBACK(gtk_widget_destroyed), NULL);
gtk_window_set_title(GTK_WINDOW(configure_win), _("Vorbis Encoder Configuration"));
gtk_container_set_border_width(GTK_CONTAINER(configure_win), 5);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(configure_win), vbox);
/* quality options */
quality_frame = gtk_frame_new(_("Quality"));
gtk_container_set_border_width(GTK_CONTAINER(quality_frame), 5);
gtk_box_pack_start(GTK_BOX(vbox), quality_frame, FALSE, FALSE, 2);
quality_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(quality_vbox), 10);
gtk_container_add(GTK_CONTAINER(quality_frame), quality_vbox);
/* quality option: vbr level */
quality_hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(quality_hbox1), 10);
gtk_container_add(GTK_CONTAINER(quality_vbox), quality_hbox1);
quality_label = gtk_label_new(_("Quality level (0 - 10):"));
gtk_misc_set_alignment(GTK_MISC(quality_label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(quality_hbox1), quality_label, TRUE, TRUE, 0);
quality_adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 10, 0.1, 1, 0);
quality_spin = gtk_spin_button_new(GTK_ADJUSTMENT(quality_adj), 1, 2);
gtk_box_pack_start(GTK_BOX(quality_hbox1), quality_spin, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(quality_adj), "value-changed", G_CALLBACK(quality_change), NULL);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(quality_spin), (v_base_quality * 10));
/* buttons */
bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect_swapped (button, "clicked", (GCallback)
gtk_widget_hide, configure_win);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(configure_ok_cb), NULL);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
}
gtk_widget_show_all(configure_win);
}
static void
gcr_viewer_window_constructed (GObject *obj)
{
GcrViewerWindow *self = GCR_VIEWER_WINDOW (obj);
GtkWidget *bbox;
GtkWidget *box;
GtkWidget *button;
G_OBJECT_CLASS (gcr_viewer_window_parent_class)->constructed (obj);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_set_spacing (GTK_BOX (bbox), 12);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
gtk_widget_show (bbox);
self->pv->import = gcr_import_button_new (_("Import"));
g_signal_connect_object (self->pv->import, "importing",
G_CALLBACK (on_import_button_importing),
self, 0);
g_signal_connect_object (self->pv->import, "imported",
G_CALLBACK (on_import_button_imported),
self, 0);
gtk_widget_show (GTK_WIDGET (self->pv->import));
button = gtk_button_new_with_mnemonic (_("_Close"));
g_signal_connect_object (button, "clicked",
G_CALLBACK (on_close_clicked),
self, 0);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (bbox), GTK_WIDGET (self->pv->import), FALSE, TRUE, 0);
gtk_widget_set_halign (bbox, 0.5);
gtk_widget_set_valign (bbox, 0.5);
#if GTK_CHECK_VERSION (3, 12, 0)
gtk_widget_set_margin_end (bbox, 12);
#else
gtk_widget_set_margin_right (bbox, 12);
#endif
self->pv->viewer = gcr_viewer_widget_new ();
g_object_bind_property (self->pv->viewer, "display-name",
self, "title", G_BINDING_SYNC_CREATE);
g_signal_connect_object (self->pv->viewer, "added",
G_CALLBACK (on_viewer_renderer_added),
self, 0);
gtk_widget_show (GTK_WIDGET (self->pv->viewer));
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (box);
gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (self->pv->viewer), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), bbox, FALSE, FALSE, 6);
gtk_container_add (GTK_CONTAINER (self), box);
gtk_window_set_default_size (GTK_WINDOW (self), 250, 400);
}
static void configure(void)
{
GtkWidget *hbox, *label, *scale, *button, *bbox;
GtkAdjustment * adjustment;
if (conf_dialog != NULL)
return;
conf_dialog = gtk_dialog_new();
g_signal_connect (conf_dialog, "destroy", (GCallback)
gtk_widget_destroyed, & conf_dialog);
gtk_window_set_title(GTK_WINDOW(conf_dialog), _("Configure Crystalizer"));
label = gtk_label_new(_("Effect intensity:"));
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area
((GtkDialog *) conf_dialog), label, TRUE, TRUE, 0);
gtk_widget_show(label);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area
((GtkDialog *) conf_dialog), hbox, TRUE, TRUE, 10);
gtk_widget_show(hbox);
adjustment = (GtkAdjustment *) gtk_adjustment_new (value, 0, 15 + 1,
0.1, 1, 1);
scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(adjustment));
gtk_box_pack_start(GTK_BOX(hbox), scale, TRUE, TRUE, 10);
gtk_widget_show(scale);
bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_action_area ((GtkDialog *)
conf_dialog), bbox, TRUE, TRUE, 0);
button = gtk_button_new_with_label(_("Ok"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_ok_cb, adjustment);
gtk_widget_grab_default(button);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Cancel"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_cancel_cb, NULL);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Apply"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_apply_cb,
adjustment);
gtk_widget_show(button);
gtk_widget_show(bbox);
gtk_widget_show(conf_dialog);
}
void audgui_jump_to_time (void)
{
if (! aud_drct_get_playing ())
return;
if (window)
{
gtk_window_present ((GtkWindow *) window);
return;
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", (GCallback) gtk_widget_destroyed,
& window);
gtk_window_set_type_hint ((GtkWindow *) window, GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title ((GtkWindow *) window, _("Jump to Time"));
gtk_window_set_resizable ((GtkWindow *) window, FALSE);
gtk_container_set_border_width ((GtkContainer *) window, 6);
audgui_destroy_on_escape (window);
GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add ((GtkContainer *) window, vbox);
GtkWidget * hbox_new = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox, hbox_new, FALSE, FALSE, 0);
GtkWidget * time_entry = gtk_entry_new ();
gtk_entry_set_activates_default ((GtkEntry *) time_entry, TRUE);
gtk_box_pack_start ((GtkBox *) hbox_new, time_entry, FALSE, FALSE, 0);
GtkWidget * label = gtk_label_new (_("mm:ss"));
gtk_box_pack_start ((GtkBox *) hbox_new, label, FALSE, FALSE, 0);
GtkWidget * bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start ((GtkBox *) vbox, bbox, TRUE, TRUE, 0);
gtk_button_box_set_layout ((GtkButtonBox *) bbox, GTK_BUTTONBOX_END);
gtk_box_set_spacing ((GtkBox *) bbox, 6);
GtkWidget * cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_container_add ((GtkContainer *) bbox, cancel);
g_signal_connect_swapped (cancel, "clicked", (GCallback) gtk_widget_destroy,
window);
GtkWidget * jump = gtk_button_new_from_stock (GTK_STOCK_JUMP_TO);
gtk_widget_set_can_default (jump, TRUE);
gtk_container_add ((GtkContainer *) bbox, jump);
g_signal_connect (jump, "clicked", (GCallback) jump_to_time_cb, time_entry);
unsigned int tindex = aud_drct_get_time () / 1000;
char time_str[10];
snprintf (time_str, sizeof time_str, "%u:%2.2u", tindex / 60, tindex % 60);
gtk_entry_set_text ((GtkEntry *) time_entry, time_str);
gtk_editable_select_region ((GtkEditable *) time_entry, 0, -1);
gtk_widget_show_all (window);
gtk_widget_grab_default (jump);
}
static void
gtr_context_panel_init (GtrContextPanel *panel)
{
GtrContextPanelPrivate *priv;
GtkWidget *button;
GtkTextBuffer *buffer;
panel->priv = GTR_CONTEXT_PANEL_GET_PRIVATE (panel);
priv = panel->priv;
priv->hovering_over_link = FALSE;
priv->hand_cursor = gdk_cursor_new (GDK_HAND2);
priv->regular_cursor = gdk_cursor_new (GDK_XTERM);
gtk_orientable_set_orientation (GTK_ORIENTABLE (panel),
GTK_ORIENTATION_VERTICAL);
/* Set up the scrolling window for the extracted context display */
priv->sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->sw),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (panel), priv->sw, TRUE, TRUE,
0);
gtk_widget_show (priv->sw);
/* Context text view */
priv->context = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (priv->context), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (priv->context), GTK_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (priv->sw),
GTK_WIDGET (priv->context));
gtk_widget_show (priv->context);
g_signal_connect (priv->context, "event-after",
G_CALLBACK (event_after), panel);
g_signal_connect (priv->context, "motion-notify-event",
G_CALLBACK (motion_notify_event), panel);
g_signal_connect (priv->context, "visibility-notify-event",
G_CALLBACK (visibility_notify_event), panel);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->context));
g_signal_connect (buffer, "end-user-action",
G_CALLBACK (buffer_end_user_action), panel);
/* Buttons */
priv->button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (priv->button_box), GTK_BUTTONBOX_END);
gtk_box_pack_start (GTK_BOX (panel), priv->button_box, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic (_("D_one"));
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (on_done_button_clicked), panel);
gtk_box_pack_start (GTK_BOX (priv->button_box), button, FALSE, FALSE, 0);
}
/*
,---config_box---------------------.
| |
|,-permission_box----------------. |
|| ,-buttons_box--. | |
|| |button | perm_status | |
|| |revoke_button | | |
|| `--------------' | |
|`-------------------------------' |
| |
|,-details_box------------------. |
||details_label_first | |
||url_button | |
||details_label_second | |
|`------------------------------' |
| |
|,-additional_details_box--------. |
||_______________________________| |
|__________________________________|
*/
static void *config_status_checker () {
GtkWidget *config_box;
GtkWidget *permission_box;
GtkWidget *buttons_box;
GtkWidget *details_box;
GtkWidget *additional_details_box;
config_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 15);
permission_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
buttons_box = gtk_button_box_new(GTK_ORIENTATION_VERTICAL);
details_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
additional_details_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 7);
button = gtk_button_new_with_mnemonic(_("C_heck Permission"));
revoke_button = gtk_button_new_with_mnemonic(_("_Revoke Permission"));
gtk_widget_set_sensitive(revoke_button, FALSE);
permission_status_icon = gtk_image_new();
permission_status_label = gtk_label_new("");
details_label_first = gtk_label_new ("");
url_button = gtk_link_button_new("");
details_label_second = gtk_label_new("");
gtk_widget_set_halign(details_label_first, GTK_ALIGN_CENTER);
gtk_widget_set_halign(url_button, GTK_ALIGN_CENTER);
gtk_widget_set_halign(details_label_second, GTK_ALIGN_CENTER);
// gtk_label_set_use_markup(GTK_LABEL(details_label), TRUE);
additional_details_icon = gtk_image_new();
additional_details_label = gtk_label_new("");
g_signal_connect (button, "clicked", G_CALLBACK (permission_checker), NULL);
g_signal_connect (revoke_button, "clicked", G_CALLBACK (revoke_permissions), NULL);
gtk_box_pack_start(GTK_BOX(permission_box), buttons_box, FALSE, FALSE, 20);
gtk_box_pack_start(GTK_BOX(permission_box), permission_status_icon, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(permission_box), permission_status_label, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(buttons_box), button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(buttons_box), revoke_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(details_box), details_label_first, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(details_box), url_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(details_box), details_label_second, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(additional_details_box), additional_details_icon, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(additional_details_box), additional_details_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(config_box), permission_box, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(config_box), details_box, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(config_box), additional_details_box, FALSE, FALSE, 0);
return config_box;
}
static GtkWidget*
dialog_contents (void)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *action_area;
GtkWidget *label;
GtkWidget *image;
GtkWidget *button;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
action_area = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area),
GTK_BUTTONBOX_END);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_box_pack_end (GTK_BOX (action_area),
button,
FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox), action_area,
FALSE, TRUE, 0);
update_spacings (vbox, action_area);
label = gtk_label_new (_("This is a sample message in a sample dialog"));
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO,
GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), image,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label,
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox),
hbox,
FALSE, FALSE, 0);
gtk_widget_show_all (vbox);
return vbox;
}
static GtkWidget *
create_setting_button_box(const char *group_name)
{
GtkWidget *setting_button_box;
GtkWidget *button;
#if GTK_CHECK_VERSION(3, 2, 0)
setting_button_box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
setting_button_box = gtk_hbutton_box_new();
#endif
gtk_button_box_set_layout(GTK_BUTTON_BOX(setting_button_box), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(setting_button_box), 8);
/* Defaults button */
button = gtk_button_new_with_mnemonic(_("_Defaults"));
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(defaults_button_clicked), (gpointer) group_name);
gtk_box_pack_start(GTK_BOX(setting_button_box), button, TRUE, TRUE, 8);
gtk_widget_set_tooltip_text(button, _("Revert all changes to default"));
/* Apply button */
pref_apply_button = gtk_button_new_from_stock(GTK_STOCK_APPLY);
g_signal_connect(G_OBJECT(pref_apply_button), "clicked",
G_CALLBACK(apply_button_clicked), (gpointer) group_name);
gtk_widget_set_sensitive(pref_apply_button, FALSE);
gtk_box_pack_start(GTK_BOX(setting_button_box), pref_apply_button, TRUE, TRUE, 8);
gtk_widget_set_tooltip_text(pref_apply_button, _("Apply all changes"));
/* Cancel button */
button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(quit_confirm), NULL);
gtk_box_pack_start(GTK_BOX(setting_button_box), button, TRUE, TRUE, 8);
gtk_widget_set_tooltip_text(button, _("Quit this application without applying changes"));
/* OK button */
pref_ok_button = gtk_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect(G_OBJECT(pref_ok_button), "clicked",
G_CALLBACK(ok_button_clicked), (gpointer) group_name);
gtk_box_pack_start(GTK_BOX(setting_button_box), pref_ok_button, TRUE, TRUE, 8);
#if USE_CHANGES_SENSITIVE_OK_BUTTON
gtk_widget_set_sensitive(pref_ok_button, FALSE);
#endif
gtk_widget_set_tooltip_text(pref_ok_button, _("Quit this application with applying changes"));
return setting_button_box;
}
static void activate(GtkApplication* app,
gpointer user_data)
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *button_rs;
GtkWidget *button_box;
GtkWidget *draw_area;
GtkWidget *fixed_container;
window = gtk_application_window_new(app);
gtk_window_set_title(GTK_WINDOW(window), "Five Son Chess");
gtk_window_set_default_size(GTK_WINDOW(window), 900, 900);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
fixed_container = gtk_fixed_new();
// Draw Area
draw_area = gtk_drawing_area_new();
gtk_widget_set_size_request(draw_area, CanvasWidth, CanvasWidth);
g_signal_connect(draw_area, "draw", G_CALLBACK(draw_cb), NULL);
g_signal_connect(draw_area, "configure-event", G_CALLBACK(configure_event_cb), NULL);
gtk_widget_add_events(draw_area, GDK_BUTTON_PRESS_MASK);
g_signal_connect(draw_area, "button_press_event", G_CALLBACK(PutPiece), draw_area);
gtk_fixed_put(GTK_FIXED(fixed_container), draw_area, 0, 0);
// Buttons
button_box = gtk_button_box_new(GTK_ORIENTATION_VERTICAL);
gtk_fixed_put(GTK_FIXED(fixed_container), button_box, CanvasWidth, 0);
button = gtk_button_new_with_label("从头再来");
g_signal_connect(button, "clicked", G_CALLBACK(init_cb), draw_area);
button_rs = gtk_button_new_with_label("随机开局");
g_signal_connect(button_rs, "clicked", G_CALLBACK(init_rs_cb), draw_area);
gtk_container_add(GTK_CONTAINER(button_box), button);
gtk_container_add(GTK_CONTAINER(button_box), button_rs);
gtk_container_add(GTK_CONTAINER(window), fixed_container);
gtk_widget_show_all(window);
// Game starts here!
InitializeGame();
}
void activate(GtkApplication *app, gpointer) {
GtkWidget *window = gtk_application_window_new(app);
gtk_window_set_title(GTK_WINDOW(window), "GTK+ App");
gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);
GtkWidget *button_box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_container_add(GTK_CONTAINER(window), button_box);
GtkWidget *button = gtk_button_new_with_label("Hello, World!!");
g_signal_connect(button, "clicked", G_CALLBACK(helloworld), NULL);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_widget_destroy), window);
gtk_container_add(GTK_CONTAINER(button_box), button);
gtk_widget_show_all(window);
}
static void activate (GtkApplication *app, gpointer user_data) {
GtkWidget *window;
GtkWidget *button;
GtkWidget *button_box;
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "MainWindow");
gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window), button_box);
button = gtk_button_new_with_label ("Hello World");
g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
gtk_container_add (GTK_CONTAINER (button_box), button);
gtk_widget_show_all (window);
}
void _fcitx_main_window_add_config_file_page(FcitxMainWindow* self)
{
GtkWidget* vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
FcitxConfigWidget* config_widget = fcitx_config_widget_new(
get_config_desc("config.desc"),
"",
"config",
NULL
);
g_object_set(G_OBJECT(config_widget), "margin", 5, NULL);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(config_widget), TRUE, TRUE, 0);
GtkWidget* hbuttonbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(hbuttonbox), "margin", 5, NULL);
g_signal_connect(config_widget, "changed", (GCallback) _fcitx_main_window_config_widget_changed, NULL);
_fcitx_main_window_add_page(self, _("Global Config"), vbox, GTK_STOCK_PREFERENCES);
}
void _fcitx_main_window_add_config_file_page(FcitxMainWindow* self)
{
GtkWidget* vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
FcitxConfigWidget* config_widget = fcitx_config_widget_new(
get_config_desc("config.desc"),
"",
"config",
NULL
);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(config_widget), TRUE, TRUE, 0);
GtkWidget* hbuttonbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0);
GtkWidget* applybutton = gtk_button_new_from_stock(GTK_STOCK_APPLY);
gtk_box_pack_start(GTK_BOX(hbuttonbox), applybutton, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(applybutton), "clicked", G_CALLBACK(_fcitx_main_window_apply_button_clicked), config_widget);
self->configpage = _fcitx_main_window_add_page(self, _("Global Config"), vbox, GTK_STOCK_PREFERENCES);
}
/****************************************************************
Create choice dialog
*****************************************************************/
GtkWidget *choice_dialog_start(GtkWindow *parent, const gchar *name,
const gchar *text)
{
GtkWidget *dshell, *dlabel, *vbox, *bbox;
dshell = gtk_window_new(GTK_WINDOW_TOPLEVEL);
setup_dialog(dshell, toplevel);
gtk_window_set_position (GTK_WINDOW(dshell), GTK_WIN_POS_MOUSE);
gtk_window_set_title(GTK_WINDOW(dshell), name);
gtk_window_set_transient_for(GTK_WINDOW(dshell), parent);
gtk_window_set_destroy_with_parent(GTK_WINDOW(dshell), TRUE);
vbox = gtk_grid_new();
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox),
GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing(GTK_GRID(vbox), 5);
gtk_container_add(GTK_CONTAINER(dshell),vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
dlabel = gtk_label_new(text);
gtk_container_add(GTK_CONTAINER(vbox), dlabel);
bbox = gtk_button_box_new(GTK_ORIENTATION_VERTICAL);
gtk_box_set_spacing(GTK_BOX(bbox), 2);
gtk_container_add(GTK_CONTAINER(vbox), bbox);
g_object_set_data(G_OBJECT(dshell), "bbox", bbox);
g_object_set_data(G_OBJECT(dshell), "nbuttons", GINT_TO_POINTER(0));
g_object_set_data(G_OBJECT(dshell), "hide", GINT_TO_POINTER(FALSE));
gtk_widget_show(vbox);
gtk_widget_show(dlabel);
return dshell;
}
static void activate(GtkApplication* app, gpointer user_data){
GtkWidget* window;
GtkWidget* button_box;
GtkWidget* button;
GtkWidget* aggresive_label;
window = gtk_application_window_new(app);
gtk_window_set_title(GTK_WINDOW(window), "Hello!");
gtk_window_set_default_size(GTK_WINDOW(window), 400, 400);
button_box = gtk_button_box_new(GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout((GtkButtonBox*) button_box, GTK_BUTTONBOX_CENTER);
gtk_container_add(GTK_CONTAINER(window), button_box);
button = gtk_button_new_with_label("Don't push me, friend!");
aggresive_label = gtk_label_new("You pushed a wrong button!!!11one");
g_signal_connect(button,
"clicked",
G_CALLBACK(on_agro_button_press),
&agro_button_state);
gtk_container_add(GTK_CONTAINER(button_box), button);
gtk_container_add(GTK_CONTAINER(button_box), aggresive_label);
gtk_widget_show_all(window);
gtk_widget_hide(aggresive_label);
agro_button_state.button = button;
agro_button_state.label = aggresive_label;
agro_button_state.is_aggresive = 0;
GdkWindow* win = gtk_widget_get_parent_window(button);
GdkCursor* watchCursor = gdk_cursor_new(GDK_WATCH);
gdk_window_set_cursor(win, watchCursor);
}
static GtkWidget *
create_main_window (void)
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *manager;
GtkWidget *button_box;
GtkWidget *button;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 6);
gtk_window_set_title (GTK_WINDOW (window), "Peas Demo");
gtk_window_set_has_resize_grip (GTK_WINDOW (window), FALSE);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (window), box);
manager = peas_gtk_plugin_manager_new (peas_engine_get_default ());
gtk_box_pack_start (GTK_BOX (box), manager, TRUE, TRUE, 0);
button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_set_spacing (GTK_BOX (button_box), 6);
gtk_button_box_set_layout (GTK_BUTTON_BOX (button_box), GTK_BUTTONBOX_END);
gtk_box_pack_start (GTK_BOX (box), button_box, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("New window");
g_signal_connect (button, "clicked", G_CALLBACK (create_new_window), NULL);
gtk_container_add (GTK_CONTAINER (button_box), button);
button = gtk_button_new_from_stock (GTK_STOCK_QUIT);
g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
gtk_container_add (GTK_CONTAINER (button_box), button);
return window;
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *hbox, *vbox;
GtkWidget *vbox2, *bbox;
GtkWidget *button;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkWidget *swindow;
GtkTreeModel *sample_model;
GdkContentFormats *targets;
gint i;
gtk_init ();
/* First initialize all the models for signal purposes */
left_tree_model = (GtkTreeModel *) gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
sample_model = (GtkTreeModel *) gtk_list_store_new (1, G_TYPE_STRING);
sample_tree_view_top = gtk_tree_view_new_with_model (sample_model);
sample_tree_view_bottom = gtk_tree_view_new_with_model (sample_model);
top_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_top));
bottom_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_bottom));
top_right_tree_view = gtk_tree_view_new_with_model (top_right_tree_model);
bottom_right_tree_view = gtk_tree_view_new_with_model (bottom_right_tree_model);
for (i = 0; i < 10; i++)
{
GtkTreeIter iter;
gchar *string = g_strdup_printf ("%d", i);
gtk_list_store_append (GTK_LIST_STORE (sample_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (sample_model), &iter, 0, string, -1);
g_free (string);
}
/* Set up the test windows. */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
gtk_window_set_title (GTK_WINDOW (window), "Top Window");
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), swindow);
gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_top);
gtk_widget_show (window);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
gtk_window_set_title (GTK_WINDOW (window), "Bottom Window");
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), swindow);
gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_bottom);
gtk_widget_show (window);
/* Set up the main window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 500, 300);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
/* Left Pane */
cell = gtk_cell_renderer_text_new ();
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
left_tree_view = gtk_tree_view_new_with_model (left_tree_model);
gtk_container_add (GTK_CONTAINER (swindow), left_tree_view);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (left_tree_view), -1,
"Unattached Columns", cell, "text", 0, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), left_tree_view);
column = gtk_tree_view_column_new_with_attributes ("Visible", cell, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (left_tree_view), column);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
gtk_box_pack_start (GTK_BOX (hbox), swindow);
/* Middle Pane */
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_box_pack_start (GTK_BOX (hbox), vbox2);
bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD);
gtk_box_pack_start (GTK_BOX (vbox2), bbox);
button = gtk_button_new_with_mnemonic ("<< (_Q)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), top_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (top_right_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button);
button = gtk_button_new_with_mnemonic (">> (_W)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), top_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button);
bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD);
gtk_box_pack_start (GTK_BOX (vbox2), bbox);
button = gtk_button_new_with_mnemonic ("<< (_E)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), bottom_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (bottom_right_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button);
button = gtk_button_new_with_mnemonic (">> (_R)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), bottom_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button);
/* Right Pane */
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_box_pack_start (GTK_BOX (hbox), vbox2);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (top_right_tree_view), FALSE);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (top_right_tree_view), -1,
NULL, cell, "text", 0, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), top_right_tree_view);
column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (top_right_tree_view), column);
gtk_container_add (GTK_CONTAINER (swindow), top_right_tree_view);
gtk_box_pack_start (GTK_BOX (vbox2), swindow);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (bottom_right_tree_view), FALSE);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (bottom_right_tree_view), -1,
NULL, cell, "text", 0, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), bottom_right_tree_view);
column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (bottom_right_tree_view), column);
gtk_container_add (GTK_CONTAINER (swindow), bottom_right_tree_view);
gtk_box_pack_start (GTK_BOX (vbox2), swindow);
/* Drag and Drop */
targets = gdk_content_formats_new (row_targets, G_N_ELEMENTS (row_targets));
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (left_tree_view),
GDK_BUTTON1_MASK,
targets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (left_tree_view),
targets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (top_right_tree_view),
GDK_BUTTON1_MASK,
targets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (top_right_tree_view),
targets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (bottom_right_tree_view),
GDK_BUTTON1_MASK,
targets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (bottom_right_tree_view),
targets,
GDK_ACTION_MOVE);
gdk_content_formats_unref (targets);
gtk_box_pack_start (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
button = gtk_button_new_with_mnemonic ("_Add new Column");
g_signal_connect (button, "clicked", G_CALLBACK (add_clicked), left_tree_model);
gtk_box_pack_start (GTK_BOX (hbox), button);
gtk_widget_show (window);
gtk_main ();
return 0;
}
static GtkWidget *
balsa_vevent_widget(LibBalsaVEvent * event, gboolean may_reply,
InternetAddress * sender)
{
GtkGrid *grid;
int row = 0;
LibBalsaIdentity *vevent_ident = NULL;
grid = GTK_GRID(gtk_grid_new());
gtk_grid_set_row_spacing(grid, 6);
gtk_grid_set_column_spacing(grid, 12);
GRID_ATTACH(grid, event->summary, _("Summary:"));
GRID_ATTACH_ADDRESS(grid, event->organizer, _("Organizer:"));
GRID_ATTACH_DATE(grid, event->start, _("Start:"));
GRID_ATTACH_DATE(grid, event->end, _("End:"));
GRID_ATTACH(grid, event->location, _("Location:"));
if (event->attendee) {
GList *att;
GString *all_atts = NULL;
for (att = event->attendee; att; att = att->next) {
LibBalsaAddress *lba = LIBBALSA_ADDRESS(att->data);
gchar *this_att = libbalsa_vcal_attendee_to_str(lba);
if (all_atts)
g_string_append_printf(all_atts, "\n%s", this_att);
else
all_atts = g_string_new(this_att);
g_free(this_att);
if (may_reply && libbalsa_vcal_attendee_rsvp(lba)) {
InternetAddress *ia =
internet_address_mailbox_new(NULL,
lba->address_list->data);
GList *list;
for (list = balsa_app.identities; list; list = list->next) {
LibBalsaIdentity *ident = list->data;
if (libbalsa_ia_rfc2821_equal(ident->ia, ia)) {
vevent_ident = ident;
break;
}
}
g_object_unref(ia);
}
}
GRID_ATTACH(grid, all_atts->str,
ngettext("Attendee:", "Attendees:",
g_list_length(event->attendee)));
g_string_free(all_atts, TRUE);
}
GRID_ATTACH_TEXT(grid, event->description, _("Description:"));
if (sender && vevent_ident) {
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
GtkWidget *label;
GtkWidget *bbox;
GtkWidget *button;
/* add the callback data to the event object */
g_object_ref(event);
g_object_ref(sender);
g_object_set_data_full(G_OBJECT(event), "ev:sender",
internet_address_to_string(sender, FALSE),
(GDestroyNotify) g_free);
g_object_set_data_full(G_OBJECT(event), "ev:ident",
g_object_ref(vevent_ident),
(GDestroyNotify) g_object_unref);
/* pack everything into a box */
gtk_container_add(GTK_CONTAINER(box), GTK_WIDGET(grid));
label =
gtk_label_new(_("The sender asks you for a reply to this request:"));
gtk_container_add(GTK_CONTAINER(box), label);
bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox),
GTK_BUTTONBOX_SPREAD);
gtk_container_add(GTK_CONTAINER(box), bbox);
button = gtk_button_new_with_label(_("Accept"));
g_object_set_data_full(G_OBJECT(button), "event", event,
(GDestroyNotify) g_object_unref);
g_object_set_data(G_OBJECT(button), "mode",
GINT_TO_POINTER(VCAL_PSTAT_ACCEPTED));
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(vevent_reply), bbox);
gtk_container_add(GTK_CONTAINER(bbox), button);
button = gtk_button_new_with_label(_("Accept tentatively"));
g_object_set_data(G_OBJECT(button), "event", event);
g_object_set_data(G_OBJECT(button), "mode",
GINT_TO_POINTER(VCAL_PSTAT_TENTATIVE));
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(vevent_reply), bbox);
gtk_container_add(GTK_CONTAINER(bbox), button);
button = gtk_button_new_with_label(_("Decline"));
g_object_set_data(G_OBJECT(button), "event", event);
g_object_set_data(G_OBJECT(button), "mode",
GINT_TO_POINTER(VCAL_PSTAT_DECLINED));
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(vevent_reply), bbox);
gtk_container_add(GTK_CONTAINER(bbox), button);
return box;
} else
return GTK_WIDGET(grid);
}
void i_fileinfo_gui( const gchar * filename_uri )
{
static GtkWidget *fileinfowin = NULL;
GtkWidget *fileinfowin_vbox, *fileinfowin_columns_hbox;
GtkWidget *midiinfoboxes_vbox, *miditextboxes_vbox, *miditextboxes_paned;
GtkWidget *title_hbox, *title_icon_image, *title_name_f_label, *title_name_v_entry;
GtkWidget *info_frame, *info_frame_tl, *info_grid;
GtkWidget *text_frame, *text_frame_tl, *text_tv, *text_tv_sw;
GtkWidget *lyrics_frame, *lyrics_tv, *lyrics_tv_sw;
GtkTextBuffer *text_tb, *lyrics_tb;
GtkWidget *footer_hbbox, *footer_bclose;
GdkPixbuf *title_icon_pixbuf;
PangoAttrList *pangoattrlist;
PangoAttribute *pangoattr;
GString *value_gstring;
gchar *title , *filename, *filename_utf8;
gint bpm = 0, wavg_bpm = 0;
midifile_t *mf;
if ( fileinfowin )
return;
mf = g_malloc(sizeof(midifile_t));
/****************** midifile parser ******************/
if ( !i_midi_parse_from_filename( filename_uri , mf ) )
return;
/* midifile is filled with information at this point,
bpm information is needed too */
i_midi_get_bpm( mf , &bpm , &wavg_bpm );
/*****************************************************/
fileinfowin = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_type_hint( GTK_WINDOW(fileinfowin), GDK_WINDOW_TYPE_HINT_DIALOG );
gtk_window_set_position( GTK_WINDOW(fileinfowin) , GTK_WIN_POS_CENTER );
g_signal_connect( G_OBJECT(fileinfowin) , "destroy" , G_CALLBACK(i_fileinfo_ev_destroy) , mf );
g_signal_connect( G_OBJECT(fileinfowin) , "destroy" , G_CALLBACK(gtk_widget_destroyed) , &fileinfowin );
gtk_container_set_border_width( GTK_CONTAINER(fileinfowin), 10 );
fileinfowin_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10 );
gtk_container_add( GTK_CONTAINER(fileinfowin) , fileinfowin_vbox );
/* pango attributes */
pangoattrlist = pango_attr_list_new();
pangoattr = pango_attr_weight_new( PANGO_WEIGHT_BOLD );
pangoattr->start_index = 0;
pangoattr->end_index = G_MAXINT;
pango_attr_list_insert( pangoattrlist , pangoattr );
/******************
*** TITLE LINE ***/
title_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5 );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , title_hbox , FALSE , FALSE , 0 );
title_icon_pixbuf = gdk_pixbuf_new_from_xpm_data( (const gchar **)amidiplug_xpm_midiicon );
title_icon_image = gtk_image_new_from_pixbuf( title_icon_pixbuf );
g_object_unref( title_icon_pixbuf );
gtk_misc_set_alignment( GTK_MISC(title_icon_image) , 0 , 0 );
gtk_box_pack_start( GTK_BOX(title_hbox) , title_icon_image , FALSE , FALSE , 0 );
title_name_f_label = gtk_label_new( _("Name:") );
gtk_label_set_attributes( GTK_LABEL(title_name_f_label) , pangoattrlist );
gtk_box_pack_start( GTK_BOX(title_hbox) , title_name_f_label , FALSE , FALSE , 0 );
title_name_v_entry = gtk_entry_new();
gtk_editable_set_editable( GTK_EDITABLE(title_name_v_entry) , FALSE );
gtk_widget_set_size_request( GTK_WIDGET(title_name_v_entry) , 200 , -1 );
gtk_box_pack_start(GTK_BOX(title_hbox) , title_name_v_entry , TRUE , TRUE , 0 );
fileinfowin_columns_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2 );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , fileinfowin_columns_hbox , TRUE , TRUE , 0 );
/*********************
*** MIDI INFO BOX ***/
midiinfoboxes_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2 );
/* pick the entire space if both comments and lyrics boxes are not displayed,
pick only required space if at least one of them is displayed */
if (( amidiplug_cfg_ap.ap_opts_comments_extract == 0 ) &&
( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 ))
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , midiinfoboxes_vbox , TRUE , TRUE , 0 );
else
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , midiinfoboxes_vbox , FALSE , FALSE , 0 );
info_frame_tl = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL(info_frame_tl) , _("<span size=\"smaller\"> MIDI Info </span>") );
gtk_box_pack_start( GTK_BOX(midiinfoboxes_vbox) , info_frame_tl , FALSE , FALSE , 0 );
info_frame = gtk_frame_new( NULL );
gtk_box_pack_start( GTK_BOX(midiinfoboxes_vbox) , info_frame , TRUE , TRUE , 0 );
info_grid = gtk_grid_new();
gtk_grid_set_row_spacing( GTK_GRID(info_grid) , 4 );
gtk_grid_set_column_spacing( GTK_GRID(info_grid) , 10 );
gtk_container_set_border_width( GTK_CONTAINER(info_grid) , 3 );
gtk_container_add( GTK_CONTAINER(info_frame) , info_grid );
value_gstring = g_string_new( "" );
/* midi format */
G_STRING_PRINTF( value_gstring , "type %i" , mf->format );
i_fileinfo_grid_add_entry( _("Format:") , value_gstring->str , info_grid , 0 , pangoattrlist );
/* midi length */
G_STRING_PRINTF( value_gstring , "%i" , (gint)(mf->length / 1000) );
i_fileinfo_grid_add_entry( _("Length (msec):") , value_gstring->str , info_grid , 1 , pangoattrlist );
/* midi num of tracks */
G_STRING_PRINTF( value_gstring , "%i" , mf->num_tracks );
i_fileinfo_grid_add_entry( _("No. of Tracks:") , value_gstring->str , info_grid , 2 , pangoattrlist );
/* midi bpm */
if ( bpm > 0 )
G_STRING_PRINTF( value_gstring , "%i" , bpm ); /* fixed bpm */
else
G_STRING_PRINTF( value_gstring , _("variable") ); /* variable bpm */
i_fileinfo_grid_add_entry( _("BPM:") , value_gstring->str , info_grid , 3 , pangoattrlist );
/* midi weighted average bpm */
if ( bpm > 0 )
G_STRING_PRINTF( value_gstring , "/" ); /* fixed bpm, don't care about wavg_bpm */
else
G_STRING_PRINTF( value_gstring , "%i" , wavg_bpm ); /* variable bpm, display wavg_bpm */
i_fileinfo_grid_add_entry( _("BPM (wavg):") , value_gstring->str , info_grid , 4 , pangoattrlist );
/* midi time division */
G_STRING_PRINTF( value_gstring , "%i" , mf->time_division );
i_fileinfo_grid_add_entry( _("Time Div:") , value_gstring->str , info_grid , 5 , pangoattrlist );
g_string_free( value_gstring , TRUE );
/**********************************
*** MIDI COMMENTS/LYRICS BOXES ***/
miditextboxes_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2 );
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , miditextboxes_vbox , TRUE , TRUE , 0 );
text_frame_tl = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL(text_frame_tl) ,
_("<span size=\"smaller\"> MIDI Comments and Lyrics </span>") );
gtk_box_pack_start( GTK_BOX(miditextboxes_vbox) , text_frame_tl , FALSE , FALSE , 0 );
miditextboxes_paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start( GTK_BOX(miditextboxes_vbox) , miditextboxes_paned , TRUE , TRUE , 0 );
text_frame = gtk_frame_new( NULL );
gtk_paned_pack1( GTK_PANED(miditextboxes_paned) , text_frame , TRUE , TRUE );
text_tv = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW(text_tv) , FALSE );
gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW(text_tv) , FALSE );
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(text_tv) , GTK_WRAP_WORD );
gtk_text_view_set_right_margin( GTK_TEXT_VIEW(text_tv) , 4 );
gtk_text_view_set_left_margin( GTK_TEXT_VIEW(text_tv) , 4 );
gtk_widget_set_size_request( text_tv , 300 , 113 );
text_tv_sw = gtk_scrolled_window_new( NULL , NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(text_tv_sw) ,
GTK_POLICY_AUTOMATIC , GTK_POLICY_ALWAYS );
gtk_container_add( GTK_CONTAINER(text_frame) , text_tv_sw );
gtk_container_add( GTK_CONTAINER(text_tv_sw) , text_tv );
lyrics_frame = gtk_frame_new( NULL );
gtk_paned_pack2( GTK_PANED(miditextboxes_paned) , lyrics_frame , TRUE , TRUE );
lyrics_tv = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW(lyrics_tv) , FALSE );
gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW(lyrics_tv) , FALSE );
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(lyrics_tv) , GTK_WRAP_WORD );
gtk_text_view_set_right_margin( GTK_TEXT_VIEW(lyrics_tv) , 4 );
gtk_text_view_set_left_margin( GTK_TEXT_VIEW(lyrics_tv) , 4 );
gtk_widget_set_size_request( lyrics_tv , 300 , 113 );
lyrics_tv_sw = gtk_scrolled_window_new( NULL , NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(lyrics_tv_sw) ,
GTK_POLICY_AUTOMATIC , GTK_POLICY_ALWAYS );
gtk_container_add( GTK_CONTAINER(lyrics_frame) , lyrics_tv_sw );
gtk_container_add( GTK_CONTAINER(lyrics_tv_sw) , lyrics_tv );
text_tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(text_tv) );
lyrics_tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(lyrics_tv) );
/* call the buffer fill routine if at least one between comments and lyrics is enabled */
if (( amidiplug_cfg_ap.ap_opts_comments_extract > 0 ) ||
( amidiplug_cfg_ap.ap_opts_lyrics_extract > 0 ))
i_fileinfo_text_fill( mf , text_tb , lyrics_tb );
if (( amidiplug_cfg_ap.ap_opts_comments_extract > 0 ) &&
( gtk_text_buffer_get_char_count( text_tb ) == 0 ))
{
GtkTextIter start, end;
GtkTextTag *tag = gtk_text_buffer_create_tag( text_tb , "italicstyle" ,
"style" , PANGO_STYLE_ITALIC , NULL );
/*gtk_text_view_set_justification( GTK_TEXT_VIEW(text_tv) , GTK_JUSTIFY_CENTER );*/
gtk_text_buffer_set_text( text_tb , _("* no comments available in this MIDI file *") , -1 );
gtk_text_buffer_get_iter_at_offset( text_tb , &start , 0 );
gtk_text_buffer_get_iter_at_offset( text_tb , &end , -1 );
gtk_text_buffer_apply_tag( text_tb , tag , &start , &end );
}
if (( amidiplug_cfg_ap.ap_opts_lyrics_extract > 0 ) &&
( gtk_text_buffer_get_char_count( lyrics_tb ) == 0 ))
{
GtkTextIter start, end;
GtkTextTag *tag = gtk_text_buffer_create_tag( lyrics_tb , "italicstyle" ,
"style" , PANGO_STYLE_ITALIC , NULL );
/*gtk_text_view_set_justification( GTK_TEXT_VIEW(lyrics_tv) , GTK_JUSTIFY_CENTER );*/
gtk_text_buffer_set_text( lyrics_tb , _("* no lyrics available in this MIDI file *") , -1 );
gtk_text_buffer_get_iter_at_offset( lyrics_tb , &start , 0 );
gtk_text_buffer_get_iter_at_offset( lyrics_tb , &end , -1 );
gtk_text_buffer_apply_tag( lyrics_tb , tag , &start , &end );
}
/* hide boxes for disabled options (comments and/or lyrics) */
if (( amidiplug_cfg_ap.ap_opts_comments_extract == 0 ) &&
( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 ))
{
gtk_widget_set_no_show_all( miditextboxes_vbox , TRUE );
gtk_widget_hide( miditextboxes_vbox );
}
else if ( amidiplug_cfg_ap.ap_opts_comments_extract == 0 )
{
gtk_widget_set_no_show_all( text_frame , TRUE );
gtk_widget_hide( text_frame );
}
else if ( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 )
{
gtk_widget_set_no_show_all( lyrics_frame , TRUE );
gtk_widget_hide( lyrics_frame );
}
/**************
*** FOOTER ***/
footer_hbbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout( GTK_BUTTON_BOX(footer_hbbox) , GTK_BUTTONBOX_END );
footer_bclose = gtk_button_new_from_stock( GTK_STOCK_CLOSE );
g_signal_connect( G_OBJECT(footer_bclose) , "clicked" , G_CALLBACK(i_fileinfo_ev_close) , fileinfowin );
gtk_container_add( GTK_CONTAINER(footer_hbbox) , footer_bclose );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , footer_hbbox , FALSE , FALSE , 0 );
/* utf8-ize filename and set window title */
filename = g_filename_from_uri( filename_uri , NULL , NULL );
if ( !filename )
filename = g_strdup( filename_uri );
filename_utf8 = g_strdup(g_filename_to_utf8( filename , -1 , NULL , NULL , NULL ));
if ( !filename_utf8 )
{
/* utf8 fallback */
gchar *chr , *convert_str = g_strdup( filename );
for ( chr = convert_str ; *chr ; chr++ )
{
if ( *chr & 0x80 )
*chr = '?';
}
filename_utf8 = g_strconcat( convert_str , _(" (invalid UTF-8)") , NULL );
g_free(convert_str);
}
title = g_path_get_basename (filename_utf8);
gtk_window_set_title( GTK_WINDOW(fileinfowin) , title);
g_free(title);
/* set the text for the filename header too */
gtk_entry_set_text( GTK_ENTRY(title_name_v_entry) , filename_utf8 );
gtk_editable_set_position( GTK_EDITABLE(title_name_v_entry) , -1 );
g_free(filename_utf8);
g_free(filename);
gtk_widget_grab_focus( GTK_WIDGET(footer_bclose) );
gtk_widget_show_all( fileinfowin );
}
static void
activate (GtkApplication* app,
gpointer user_data)
{
GtkWidget *window;
GtkWidget *bases, *keyLength, *errorBits, *errorTolerance, *playButton,
*mode, *peerIp, *eveRate, *eveStrategy, *channelNoise,
*genBias;
GtkWidget *windowBox, *optionGrid, *playGrid, *playBox;
GtkWidget *baseLabel, *keyLengthLabel, *errorBitsLabel,
*errorToleranceLabel, *peerIpLabel, *eveRateLabel,
*eveStrategyLabel, *channelNoiseLabel, *genBiasLabel;
GtkWidget *tty1;
GtkWidget *tty2;
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "Quantum Network Simulator");
gtk_window_set_default_size (GTK_WINDOW (window), 1280, 720);
windowBox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_container_add(GTK_CONTAINER(window), windowBox);
playBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(windowBox), playBox);
optionGrid = gtk_grid_new ();
gtk_container_add(GTK_CONTAINER(playBox), optionGrid);
playGrid = gtk_grid_new ();
gtk_grid_set_column_spacing(GTK_GRID(playGrid), 20);
gtk_container_add(GTK_CONTAINER(playBox), playGrid);
mode = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Superposition Tutorial");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Measurement Tutorial");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Classic BB84 Tutorial");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Polybase BB84 Tutorial");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Bias BB84 Tutorial");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Freestyle BB84");
gtk_grid_attach(GTK_GRID( optionGrid ), mode, 0, 0, 2, 1);
baseLabel = gtk_label_new("Number of bases");
bases = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), baseLabel , 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), bases , 1, 1, 1, 1);
keyLengthLabel = gtk_label_new("Key Length");
keyLength = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), keyLengthLabel , 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), keyLength, 1, 2, 1, 1);
errorBitsLabel = gtk_label_new("Number of error detection bits");
errorBits = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorBitsLabel , 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorBits , 1, 3, 1, 1);
errorToleranceLabel = gtk_label_new("Number of error bits to tolerate");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 0, 4, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 1, 4, 1, 1);
errorToleranceLabel = gtk_label_new("Peer IP");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 0, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 0, 1, 1);
errorToleranceLabel = gtk_label_new("Eve Eavesdrop Rate");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 1, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 1, 1, 1);
errorToleranceLabel = gtk_label_new("Eve Eavesdrop Strategy");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 2, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 2, 1, 1);
errorToleranceLabel = gtk_label_new("Generator Bias");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 3, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 3, 1, 1);
errorToleranceLabel = gtk_label_new("Channel Noise");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 4, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 4, 1, 1);
playButton = gtk_button_new_with_label("PLAY QUANTUM ALGORITHM");
g_signal_connect (playButton, "clicked", G_CALLBACK(playAlgorithm), playButton);
// g_signal_connect_swapped (playButton, "clicked", G_CALLBACK(gtk_widget_destroy), window);
gtk_grid_attach(GTK_GRID( optionGrid ), playButton, 0, 5, 4, 1);
char *startTerm[2] = {0,0};
startTerm[0] = vte_get_user_shell();
GPid pidTerm;
tty1 = vte_terminal_new();
vte_terminal_fork_command_full(VTE_TERMINAL(tty1),
VTE_PTY_DEFAULT,
NULL, //"/tmp",
startTerm,
NULL,
(GSpawnFlags)(G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH),
NULL,
NULL,
NULL,
NULL );
gtk_widget_set_size_request(tty1, 600, 400);
gtk_grid_attach(GTK_GRID (playGrid ), tty1, 0, 6, 4, 15);
gtk_widget_set_sensitive(tty1, FALSE);
tty2 = vte_terminal_new();
vte_terminal_fork_command_full(VTE_TERMINAL(tty2),
VTE_PTY_DEFAULT,
NULL, //"/tmp",
startTerm,
NULL,
(GSpawnFlags)(G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH),
NULL,
NULL,
NULL,
NULL );
gtk_widget_set_size_request(tty2, 600, 400);
gtk_grid_attach(GTK_GRID (playGrid ), tty2, 4, 6, 4, 15);
gtk_widget_set_sensitive(tty2, FALSE);
g_object_set_data(G_OBJECT(playButton), "tty1", VTE_TERMINAL(tty1));
g_object_set_data(G_OBJECT(playButton), "tty2", VTE_TERMINAL(tty2));
g_object_set_data(G_OBJECT(playButton), "in_mode", GTK_COMBO_BOX_TEXT(mode));
g_object_set_data(G_OBJECT(playButton), "in_bases", GTK_ENTRY(bases));
g_object_set_data(G_OBJECT(playButton), "in_keyLength", GTK_ENTRY(keyLength));
g_object_set_data(G_OBJECT(playButton), "in_errorBits", GTK_ENTRY(errorBits));
g_object_set_data(G_OBJECT(playButton), "in_errorTolerance", GTK_ENTRY(errorTolerance));
gtk_widget_show_all (window);
}
static void
set_font_size (GtkWidget *widget, gint size)
{
const gchar *class[3] = { "small-font", "medium-font", "large-font" };
gtk_style_context_add_class (gtk_widget_get_style_context (widget), class[size]);
}
int
main (int argc,
char **argv)
{
GtkWidget *window, *label, *entry, *button, *grid, *notebook;
GtkWidget *vbox, *hbox, *grid_hbox, *spin, *spin2, *toggle, *combo, *image;
GtkAdjustment *adjustment;
int i, j;
GtkCssProvider *provider;
gtk_init ();
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider,
".small-font { font-size: 5px; }"
".medium-font { font-size: 10px; }"
".large-font { font-size: 15px; }", -1);
gtk_style_context_add_provider_for_display (gdk_display_get_default (),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
notebook = gtk_notebook_new ();
gtk_container_add (GTK_CONTAINER (window), notebook);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox, gtk_label_new ("hboxes"));
for (j = 0; j < 2; j++)
{
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
char *aligns_names[] = { "FILL", "BASELINE" };
GtkAlign aligns[] = { GTK_ALIGN_FILL, GTK_ALIGN_BASELINE};
label = gtk_label_new (aligns_names[j]);
gtk_container_add (GTK_CONTAINER (hbox), label);
for (i = 0; i < 3; i++) {
label = gtk_label_new ("│XYyj,Ö...");
set_font_size (label, i);
gtk_widget_set_valign (label, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), label);
}
for (i = 0; i < 3; i++) {
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "│XYyj,Ö...");
set_font_size (entry, i);
gtk_widget_set_valign (entry, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), entry);
}
spin = gtk_spin_button_new (NULL, 0, 1);
gtk_orientable_set_orientation (GTK_ORIENTABLE (spin), GTK_ORIENTATION_VERTICAL);
gtk_widget_set_valign (spin, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), spin);
spin = gtk_spin_button_new (NULL, 0, 1);
gtk_widget_set_valign (spin, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), spin);
}
grid_hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[0]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[1]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[2]);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
gtk_container_add (GTK_CONTAINER (hbox), combo);
for (j = 0; j < 2; j++)
{
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (baseline_position_changed), hbox);
if (j == 0)
label = gtk_label_new ("Baseline:");
else
label = gtk_label_new ("Normal:");
gtk_container_add (GTK_CONTAINER (hbox), label);
for (i = 0; i < 3; i++)
{
button = gtk_button_new_with_label ("│Xyj,Ö");
set_font_size (button, i);
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
for (i = 0; i < 3; i++)
{
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("face-sad"));
gtk_container_add (GTK_CONTAINER (button), box);
set_font_size (button, i);
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 34);
if (j == 0)
gtk_widget_set_valign (image, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), image);
button = gtk_toggle_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
button = gtk_toggle_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
button = gtk_check_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
button = gtk_radio_button_new_with_label (NULL, "│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox, gtk_label_new ("grid"));
grid_hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Align me:");
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), label);
grid = gtk_grid_new ();
gtk_widget_set_valign (grid, GTK_ALIGN_BASELINE);
gtk_grid_set_column_spacing (GTK_GRID (grid), 8);
gtk_grid_set_row_spacing (GTK_GRID (grid), 8);
for (j = 0; j < 4; j++)
{
char *labels[] = { "Normal:", "Baseline (top):", "Baseline (center):", "Baseline (bottom):"};
label = gtk_label_new (labels[j]);
gtk_grid_attach (GTK_GRID (grid),
label,
0, j,
1, 1);
gtk_widget_set_vexpand (label, TRUE);
if (j != 0)
gtk_grid_set_row_baseline_position (GTK_GRID (grid),
j, (GtkBaselinePosition)(j-1));
for (i = 0; i < 3; i++)
{
label = gtk_label_new ("Xyjg,Ö.");
set_font_size (label, i);
if (j != 0)
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_grid_attach (GTK_GRID (grid),
label,
i+1, j,
1, 1);
}
for (i = 0; i < 3; i++)
{
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("face-sad"));
gtk_container_add (GTK_CONTAINER (button), box);
set_font_size (button, i);
if (j != 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_grid_attach (GTK_GRID (grid),
button,
i+4, j,
1, 1);
}
}
gtk_container_add (GTK_CONTAINER (hbox), grid);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
adjustment = gtk_adjustment_new (0.0, -1.0, 5.0, 1.0, 1.0, 0.0);
spin = gtk_spin_button_new (adjustment, 1.0, 0);
g_signal_connect (spin, "value-changed", (GCallback)baseline_row_value_changed, grid);
gtk_container_add (GTK_CONTAINER (hbox), spin);
toggle = gtk_toggle_button_new_with_label ("Homogeneous");
g_signal_connect (toggle, "toggled", (GCallback)homogeneous_changed, grid);
gtk_container_add (GTK_CONTAINER (hbox), toggle);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[0]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[1]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[2]);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (baseline_position_changed), grid_hbox);
gtk_container_add (GTK_CONTAINER (hbox), combo);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox, gtk_label_new ("button box"));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
adjustment = gtk_adjustment_new (34.0, 1.0, 64.0, 1.0, 1.0, 0.0);
spin = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_container_add (GTK_CONTAINER (hbox), spin);
adjustment = gtk_adjustment_new (16.0, 1.0, 64.0, 1.0, 1.0, 0.0);
spin2 = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_container_add (GTK_CONTAINER (hbox), spin2);
for (j = 0; j < 3; j++)
{
hbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
gtk_box_set_baseline_position (GTK_BOX (hbox), j);
label = gtk_label_new (baseline_pos_str[j]);
gtk_container_add (GTK_CONTAINER (hbox), label);
gtk_widget_set_vexpand (label, TRUE);
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 34);
gtk_container_add (GTK_CONTAINER (hbox), image);
g_signal_connect (spin, "value-changed", (GCallback)image_size_value_changed, image);
for (i = 0; i < 3; i++)
{
button = gtk_button_new_with_label ("│Xyj,Ö");
set_font_size (button, i);
if (i != 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
for (i = 0; i < 3; i++)
{
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 16);
gtk_container_add (GTK_CONTAINER (box), image);
gtk_container_add (GTK_CONTAINER (button), box);
if (i == 0)
g_signal_connect (spin2, "value-changed", (GCallback)image_size_value_changed, image);
set_font_size (button, i);
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
}
gtk_widget_show (window);
gtk_main ();
return 0;
}
