gint main (gint argc, gchar *argv[])
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *vbox;
gtk_init (&argc, &argv);
//window = gtk_window_new(GTK_WINDOW_POPUP);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window),200,200);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
gtk_window_set_title(GTK_WINDOW(window),"GPU FS");
g_signal_connect ( G_OBJECT (window), "destroy",
G_CALLBACK (closeApp), NULL);
radiobutton1 = gtk_radio_button_new(NULL);
radiobutton2 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(radiobutton1));
radiobutton3 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(radiobutton1));
radiobutton4 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(radiobutton1));
radiobutton5 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(radiobutton1));
radiobutton6 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(radiobutton1));
hseparator=gtk_hseparator_new ();
vbox = gtk_vbox_new (TRUE, 4);
add_widget_with_label (GTK_CONTAINER(vbox), "100%:",radiobutton1);
add_widget_with_label (GTK_CONTAINER(vbox), "75%:", radiobutton2);
add_widget_with_label (GTK_CONTAINER(vbox), "50%:", radiobutton3);
add_widget_with_label (GTK_CONTAINER(vbox), "33%:", radiobutton4);
add_widget_with_label (GTK_CONTAINER(vbox), NULL, hseparator);
add_widget_with_label (GTK_CONTAINER(vbox), "Auto:", radiobutton5);
add_widget_with_label (GTK_CONTAINER(vbox), "PowerSaver:", radiobutton6);
g_signal_connect(G_OBJECT(radiobutton1), "toggled",
G_CALLBACK(radio_button_clicked1), NULL);
g_signal_connect(G_OBJECT(radiobutton2), "toggled",
G_CALLBACK(radio_button_clicked2), NULL);
g_signal_connect(G_OBJECT(radiobutton3), "toggled",
G_CALLBACK(radio_button_clicked3), NULL);
g_signal_connect(G_OBJECT(radiobutton4), "toggled",
G_CALLBACK(radio_button_clicked4), NULL);
g_signal_connect(G_OBJECT(radiobutton5), "toggled",
G_CALLBACK(radio_button_clicked5), NULL);
g_signal_connect(G_OBJECT(radiobutton6), "toggled",
G_CALLBACK(radio_button_clicked6), NULL);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show_all(window);
gtk_main ();
return 0;
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkRadioButton_gtk_1radio_1button_1new_1from_1widget
(
JNIEnv* env,
jclass cls,
jlong _radioGroupMember
)
{
GtkWidget* result;
jlong _result;
GtkRadioButton* radioGroupMember;
// convert parameter radioGroupMember
radioGroupMember = (GtkRadioButton*) _radioGroupMember;
// call function
result = gtk_radio_button_new_from_widget(radioGroupMember);
// cleanup parameter radioGroupMember
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, TRUE);
}
// and finally
return _result;
}
static GSList *
aw_map_view_get_filters (AwTreeView *view)
{
struct {
const char *label;
void (*callback) ();
} filters[] = {
{ _("Distance"), aw_map_view_sort_by_distance_cb },
{ _("Name"), aw_map_view_sort_by_name_cb },
{ _("ID"), aw_map_view_sort_by_id_cb },
{ _("Level"), aw_map_view_sort_by_level_cb },
};
gpointer button = NULL;
int i;
for (i = G_N_ELEMENTS (filters) - 1; i >= 0; --i)
{
button = gtk_radio_button_new_from_widget (button);
gtk_button_set_label (button, filters[i].label);
gtk_toggle_button_set_mode (button, FALSE);
g_signal_connect_swapped (button, "toggled",
filters[i].callback, view);
gtk_widget_show (button);
}
return gtk_radio_button_get_group (button);
}
void
gdm_extension_list_add_extension (GdmExtensionList *extension_list,
GdmLoginExtension *extension)
{
GtkWidget *image;
GtkWidget *button;
GIcon *icon;
char *description;
if (extension_list->priv->extensions == NULL) {
button = gtk_radio_button_new (NULL);
} else {
GdmLoginExtension *previous_extension;
GtkRadioButton *previous_button;
previous_extension = GDM_LOGIN_EXTENSION (extension_list->priv->extensions->data);
previous_button = GTK_RADIO_BUTTON (g_object_get_data (G_OBJECT (previous_extension), "gdm-extension-list-button"));
button = gtk_radio_button_new_from_widget (previous_button);
}
g_object_set_data (G_OBJECT (extension), "gdm-extension-list-button", button);
g_object_set (G_OBJECT (button), "draw-indicator", FALSE, NULL);
g_object_set_data (G_OBJECT (button), "gdm-extension", extension);
g_signal_connect_swapped (button, "toggled",
G_CALLBACK (on_extension_toggled),
extension_list);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
gtk_widget_set_sensitive (button, gdm_login_extension_is_enabled (extension));
g_signal_connect_swapped (G_OBJECT (extension), "enabled",
G_CALLBACK (on_extension_enabled),
extension_list);
g_signal_connect_swapped (G_OBJECT (extension), "disabled",
G_CALLBACK (on_extension_disabled),
extension_list);
icon = gdm_login_extension_get_icon (extension);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_SMALL_TOOLBAR);
g_object_unref (icon);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (button), image);
description = gdm_login_extension_get_description (extension);
gtk_widget_set_tooltip_text (button, description);
g_free (description);
gtk_widget_show (button);
gtk_container_add (GTK_CONTAINER (extension_list->priv->box), button);
extension_list->priv->extensions = g_list_append (extension_list->priv->extensions,
g_object_ref (extension));
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) {
g_signal_emit (extension_list, signals[ACTIVATED], 0, extension);
}
}
static GtkWidget*
create_button(VALUE group, VALUE label, VALUE use_underline)
{
GtkWidget* widget = NULL;
if (TYPE(label) == T_STRING){
if (NIL_P(use_underline) || RVAL2CBOOL(use_underline)){
widget = gtk_radio_button_new_with_mnemonic_from_widget(_GROUP(group), RVAL2CSTR(label));
} else {
widget = gtk_radio_button_new_with_label_from_widget(_GROUP(group), RVAL2CSTR(label));
}
} else if (TYPE(label) == T_SYMBOL){
widget = gtk_radio_button_new_with_label_from_widget(_GROUP(group), rb_id2name(SYM2ID(label)));
gtk_button_set_use_stock(GTK_BUTTON(widget), TRUE);
} else if (NIL_P(label)){
widget = gtk_radio_button_new_from_widget(_GROUP(group));
} else {
rb_raise(rb_eArgError, "invalid argument %s (expect Symbol(Gtk::Stock constants) or String)",
rb_class2name(CLASS_OF(label)));
}
return widget;
}
/**** Radio button constructor ****/
int
clip_GTK_RADIOBUTTONNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
C_widget *cgrp = _fetch_cwidget(cm,_clip_spar(cm, 2));
char * label = _clip_parc(cm, 3);
GtkWidget *wid = NULL;
C_widget *cwid;
GtkRadioButton *rb = NULL;
CHECKOPT(1,MAP_t);
CHECKOPT2(2,MAP_t,NUMERIC_t);
CHECKOPT(3,CHARACTER_t);
if (cgrp && cgrp->type != GTK_WIDGET_RADIO_GROUP) goto err;
if (cgrp && cgrp->data) rb = ((GSList*)(cgrp->data))->data;
if (_clip_parinfo(cm,3) == CHARACTER_t)
{
LOCALE_TO_UTF(label);
wid = gtk_radio_button_new_with_label_from_widget(rb,label);
if (cgrp && !cgrp->data) cgrp->data = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wid));
FREE_TEXT(label);
}
else
{
wid = gtk_radio_button_new_from_widget(rb);
if (cgrp && !cgrp->data) cgrp->data = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wid));
}
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
static void on_insert_numbers_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED
gpointer gdata)
{
InsertNumbersDialog d;
GtkWidget *vbox, *label, *upper, *space, *button;
GtkGrid *grid;
GtkComboBoxText *combo;
const char *case_tip = _("For base 11 and above");
gchar *base_text;
gint result;
d.dialog = gtk_dialog_new_with_buttons(_("Insert Numbers"),
GTK_WINDOW(geany->main_widgets->window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
vbox = ui_dialog_vbox_new(GTK_DIALOG(d.dialog));
gtk_box_set_spacing(GTK_BOX(vbox), 9);
#if GTK_CHECK_VERSION(3, 0, 0)
grid = GTK_GRID(gtk_grid_new());
#else
grid = GTK_TABLE(gtk_table_new(3, 6, FALSE));
#endif
gtk_grid_set_row_spacing(grid, 6);
gtk_grid_set_column_spacing(grid, 6);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(grid), TRUE, TRUE, 0);
label = gtk_label_new_with_mnemonic(_("_Start:"));
gtk_grid_attach(grid, label, 0, 0, 1, 1);
d.start = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1);
set_entry(d.start, RANGE_LEN, label, RANGE_TOOLTIP);
gtk_grid_attach(grid, d.start, 1, 0, 2, 1);
label = gtk_label_new_with_mnemonic(_("S_tep:"));
gtk_grid_attach(grid, label, 3, 0, 1, 1);
d.step = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1);
set_entry(d.step, RANGE_LEN, label, RANGE_TOOLTIP);
gtk_grid_attach(grid, d.step, 4, 0, 2, 1);
label = gtk_label_new_with_mnemonic(_("_Base:"));
gtk_grid_attach(grid, label, 0, 1, 1, 1),
combo = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new_with_entry());
d.base = gtk_bin_get_child(GTK_BIN(combo));
set_entry(d.base, 2, label, "2..36");
g_signal_connect(d.base, "insert-text", G_CALLBACK(on_base_insert_text), NULL);
gtk_combo_box_text_append_text(combo, "2");
gtk_combo_box_text_append_text(combo, "8");
gtk_combo_box_text_append_text(combo, "10");
gtk_combo_box_text_append_text(combo, "16");
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_grid_attach(grid, GTK_WIDGET(combo), 1, 1, 2, 1);
gtk_widget_set_hexpand(GTK_WIDGET(combo), TRUE);
#else
gtk_table_attach(grid, GTK_WIDGET(combo), 1, 3, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0);
#endif
label = gtk_label_new(_("Letters:"));
gtk_widget_set_tooltip_text(label, case_tip);
gtk_grid_attach(grid, label, 3, 1, 1, 1);
upper = gtk_radio_button_new_with_mnemonic(NULL, _("_Upper"));
gtk_widget_set_tooltip_text(upper, case_tip);
gtk_grid_attach(grid, upper, 4, 1, 1, 1);
d.lower = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(upper));
gtk_widget_set_tooltip_text(label, case_tip);
label = gtk_label_new_with_mnemonic(_("_Lower"));
gtk_widget_set_tooltip_text(label, case_tip);
gtk_container_add(GTK_CONTAINER(d.lower), label);
gtk_grid_attach(grid, d.lower, 5, 1, 1, 1);
d.prefix = gtk_check_button_new_with_mnemonic(_("Base _prefix"));
gtk_widget_set_tooltip_text(d.prefix,
_("0 for octal, 0x for hex, + for positive decimal"));
gtk_grid_attach(grid, d.prefix, 1, 2, 2, 1);
label = gtk_label_new(_("Padding:"));
gtk_grid_attach(grid, label, 3, 2, 1, 1);
space = gtk_radio_button_new_with_mnemonic(NULL, _("Sp_ace"));
gtk_grid_attach(grid, space, 4, 2, 1, 1);
d.zero = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(space));
label = gtk_label_new_with_mnemonic(_("_Zero"));
gtk_container_add(GTK_CONTAINER(d.zero), label);
gtk_grid_attach(grid, d.zero, 5, 2, 1, 1);
button = gtk_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect(button, "clicked", G_CALLBACK(on_insert_numbers_ok_clicked), &d);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(d.dialog))), button,
TRUE, TRUE, 0);
#if GTK_CHECK_VERSION(2, 18, 0)
gtk_widget_set_can_default(button, TRUE);
#else
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
#endif
gtk_widget_grab_default(button);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.start), start_value);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.step), step_value);
base_text = g_strdup_printf("%d", base_value);
gtk_entry_set_text(GTK_ENTRY(d.base), base_text);
g_free(base_text);
gtk_button_clicked(GTK_BUTTON(lower_case ? d.lower : upper));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d.prefix), base_prefix);
gtk_button_clicked(GTK_BUTTON(pad_zeros ? d.zero : space));
gtk_widget_show_all(d.dialog);
result = gtk_dialog_run(GTK_DIALOG(d.dialog));
if (result == GTK_RESPONSE_ACCEPT)
{
if (can_insert_numbers())
{
if (end_line - start_line < 1000)
{
/* quick version */
gtk_widget_hide(d.dialog);
insert_numbers(NULL);
}
else
{
gboolean cancel = FALSE;
gtk_widget_set_sensitive(GTK_WIDGET(grid), FALSE);
gtk_widget_set_sensitive(button, FALSE);
update_display();
g_signal_connect(d.dialog, "response",
G_CALLBACK(on_insert_numbers_response), &cancel);
insert_numbers(&cancel);
}
}
else
plugin_beep(); /* reloaded or something */
}
gtk_widget_destroy(d.dialog);
}
static int gtkToggleMapMethod(Ihandle* ih)
{
Ihandle* radio = iupRadioFindToggleParent(ih);
char *value;
int is3state = 0;
if (!ih->parent)
return IUP_ERROR;
if (radio)
ih->data->radio = 1;
value = iupAttribGet(ih, "IMAGE");
if (value)
ih->data->type = IUP_TOGGLE_IMAGE;
else
ih->data->type = IUP_TOGGLE_TEXT;
if (radio)
{
GtkRadioButton* last_tg = (GtkRadioButton*)iupAttribGet(radio, "_IUPGTK_LASTRADIOBUTTON");
if (last_tg)
ih->handle = gtk_radio_button_new_from_widget(last_tg);
else
ih->handle = gtk_radio_button_new(NULL);
iupAttribSetStr(radio, "_IUPGTK_LASTRADIOBUTTON", (char*)ih->handle);
}
else
{
if (ih->data->type == IUP_TOGGLE_TEXT)
{
ih->handle = gtk_check_button_new();
if (iupAttribGetInt(ih, "3STATE"))
is3state = 1;
}
else
ih->handle = gtk_toggle_button_new();
}
if (!ih->handle)
return IUP_ERROR;
if (ih->data->type == IUP_TOGGLE_TEXT)
{
gtk_button_set_image((GtkButton*)ih->handle, gtk_label_new(NULL));
gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, TRUE);
}
else
{
gtk_button_set_image((GtkButton*)ih->handle, gtk_image_new());
gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, FALSE);
}
/* add to the parent, all GTK controls must call this. */
iupgtkBaseAddToParent(ih);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
g_signal_connect(G_OBJECT(ih->handle), "toggled", G_CALLBACK(gtkToggleToggled), ih);
if (ih->data->type == IUP_TOGGLE_IMAGE || is3state)
{
g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(gtkToggleButtonEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(gtkToggleButtonEvent), ih);
}
if (is3state)
{
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkToggleKeyEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-release-event", G_CALLBACK(gtkToggleKeyEvent), ih);
}
gtk_widget_realize(ih->handle);
return IUP_NOERROR;
}
GtkWidget *
glade_tool_item_group_editor_new (GladeWidgetAdaptor *adaptor,
GladeEditable *embed)
{
GladeToolItemGroupEditor *group_editor;
GladeEditorProperty *eprop;
GtkWidget *table, *frame, *label, *hbox;
gchar *str;
gint row = 0;
g_return_val_if_fail (GLADE_IS_WIDGET_ADAPTOR (adaptor), NULL);
g_return_val_if_fail (GLADE_IS_EDITABLE (embed), NULL);
group_editor = g_object_new (GLADE_TYPE_TOOL_ITEM_GROUP_EDITOR, NULL);
group_editor->embed = GTK_WIDGET (embed);
/* Pack the parent on top... */
gtk_box_pack_start (GTK_BOX (group_editor), GTK_WIDGET (embed), FALSE, FALSE, 0);
str = g_strdup_printf ("<b>%s</b>", _("Group Header"));
label = gtk_label_new (str);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
g_free (str);
frame = gtk_frame_new (NULL);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_box_pack_start (GTK_BOX (group_editor), frame, FALSE, FALSE, 0);
table = gtk_grid_new ();
gtk_widget_set_margin_top (table, 6);
gtk_widget_set_margin_start (table, 12);
gtk_orientable_set_orientation (GTK_ORIENTABLE (table),
GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
/* label */
eprop =
glade_widget_adaptor_create_eprop_by_name (adaptor, "label", FALSE,
TRUE);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
group_editor->label_radio = gtk_radio_button_new (NULL);
gtk_box_pack_start (GTK_BOX (hbox), group_editor->label_radio, FALSE, FALSE,
2);
gtk_box_pack_start (GTK_BOX (hbox), glade_editor_property_get_item_label (eprop), TRUE, TRUE, 2);
table_attach (table, hbox, 0, row);
table_attach (table, GTK_WIDGET (eprop), 1, row++);
group_editor->properties = g_list_prepend (group_editor->properties, eprop);
/* label-widget ... */
eprop =
glade_widget_adaptor_create_eprop_by_name (adaptor, "label-widget",
FALSE, TRUE);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
group_editor->label_widget_radio = gtk_radio_button_new_from_widget
(GTK_RADIO_BUTTON (group_editor->label_radio));
gtk_box_pack_start (GTK_BOX (hbox), group_editor->label_widget_radio, FALSE,
FALSE, 2);
gtk_box_pack_start (GTK_BOX (hbox), glade_editor_property_get_item_label (eprop), TRUE, TRUE, 2);
table_attach (table, hbox, 0, row);
table_attach (table, GTK_WIDGET (eprop), 1, row++);
group_editor->properties = g_list_prepend (group_editor->properties, eprop);
g_signal_connect (G_OBJECT (group_editor->label_widget_radio), "toggled",
G_CALLBACK (label_widget_toggled), group_editor);
g_signal_connect (G_OBJECT (group_editor->label_radio), "toggled",
G_CALLBACK (label_toggled), group_editor);
gtk_widget_show_all (GTK_WIDGET (group_editor));
return GTK_WIDGET (group_editor);
}
static int gtkToggleMapMethod(Ihandle* ih)
{
Ihandle* radio = iupRadioFindToggleParent(ih);
char *value;
int is3state = 0;
if (!ih->parent)
return IUP_ERROR;
value = iupAttribGet(ih, "IMAGE");
if (value)
ih->data->type = IUP_TOGGLE_IMAGE;
else
ih->data->type = IUP_TOGGLE_TEXT;
if (radio)
{
GtkRadioButton* last_tg = (GtkRadioButton*)iupAttribGet(radio, "_IUPGTK_LASTRADIOBUTTON");
if (last_tg)
ih->handle = gtk_radio_button_new_from_widget(last_tg);
else
ih->handle = gtk_radio_button_new(NULL);
iupAttribSet(radio, "_IUPGTK_LASTRADIOBUTTON", (char*)ih->handle);
/* make sure it has at least one name */
if (!iupAttribGetHandleName(ih))
iupAttribSetHandleName(ih);
ih->data->is_radio = 1;
}
else
{
if (ih->data->type == IUP_TOGGLE_TEXT)
{
ih->handle = gtk_check_button_new();
if (iupAttribGetBoolean(ih, "3STATE"))
is3state = 1;
}
else
ih->handle = gtk_toggle_button_new();
}
if (!ih->handle)
return IUP_ERROR;
if (ih->data->type == IUP_TOGGLE_TEXT)
{
gtk_button_set_image((GtkButton*)ih->handle, gtk_label_new(NULL));
gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, TRUE);
}
else
{
gtk_button_set_image((GtkButton*)ih->handle, gtk_image_new());
gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, FALSE);
}
iupgtkClearSizeStyleCSS(ih->handle);
/* add to the parent, all GTK controls must call this. */
iupgtkAddToParent(ih);
if (!iupAttribGetBoolean(ih, "CANFOCUS"))
iupgtkSetCanFocus(ih->handle, 0);
if (ih->data->type == IUP_TOGGLE_IMAGE && ih->data->flat)
{
gtk_button_set_relief((GtkButton*)ih->handle, GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(gtkToggleEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(gtkToggleEnterLeaveEvent), ih);
}
else
{
g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
}
g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
g_signal_connect(G_OBJECT(ih->handle), "toggled", G_CALLBACK(gtkToggleToggled), ih);
if (ih->data->type == IUP_TOGGLE_IMAGE || is3state)
{
g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(gtkToggleButtonEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(gtkToggleButtonEvent), ih);
}
if (is3state)
{
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkToggleKeyEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-release-event", G_CALLBACK(gtkToggleKeyEvent), ih);
}
gtk_widget_realize(ih->handle);
/* update a mnemonic in a label if necessary */
iupgtkUpdateMnemonic(ih);
return IUP_NOERROR;
}
/** \brief Create and initialise time controller widgets.
* \param module The parent GtkSatModule
*
*/
void tmg_create (GtkSatModule *mod)
{
GtkWidget *vbox, *hbox, *table;
GtkWidget *image;
GtkWidget *label;
gchar *title;
gchar *buff;
/* make sure controller is not already active */
if (mod->tmgActive) {
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: Time Controller for %s is already active"),
__FUNCTION__, mod->name);
/* try to make window visible in case it is covered
by something else */
gtk_window_present (GTK_WINDOW (mod->tmgWin));
return;
}
/* create hbox containing the controls
the controls are implemented as radiobuttons in order
to inherit the mutual exclusion behaviour
*/
hbox = gtk_hbox_new (FALSE, 0);
/* FWD */
mod->tmgFwd = gtk_radio_button_new (NULL);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgFwd), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mod->tmgFwd), TRUE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_FORWARD, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgFwd), image);
gtk_widget_set_tooltip_text (mod->tmgFwd, _("Play forward"));
g_signal_connect (mod->tmgFwd, "toggled", G_CALLBACK (tmg_fwd), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgFwd, FALSE, FALSE, 0);
/* STOP */
mod->tmgStop = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (mod->tmgFwd));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgStop), FALSE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgStop), image);
gtk_widget_set_tooltip_text (mod->tmgStop, _("Stop"));
g_signal_connect (mod->tmgStop, "toggled", G_CALLBACK (tmg_stop), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgStop, FALSE, FALSE, 0);
/* BWD */
mod->tmgBwd = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (mod->tmgFwd));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgBwd), FALSE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_REWIND, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgBwd), image);
gtk_widget_set_tooltip_text (mod->tmgBwd, _("Play backwards"));
g_signal_connect (mod->tmgBwd, "toggled", G_CALLBACK (tmg_bwd), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgBwd, FALSE, FALSE, 0);
/* reset time */
mod->tmgReset = gtk_button_new_with_label (_("Reset"));
gtk_widget_set_tooltip_text (mod->tmgReset, _("Reset to current date and time"));
g_signal_connect (mod->tmgReset, "clicked", G_CALLBACK (tmg_reset), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgReset, FALSE, FALSE, 10);
/* status label */
mod->tmgState = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (mod->tmgState), 0.0, 0.5);
gtk_label_set_markup (GTK_LABEL (mod->tmgState), _("<b>Real-Time</b>"));
gtk_box_pack_start (GTK_BOX (hbox), mod->tmgState, TRUE, TRUE, 10);
/* create table containing the date and time widgets */
table = gtk_table_new (5, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 0);
mod->tmgCal = gtk_calendar_new ();
gtk_calendar_set_display_options (GTK_CALENDAR (mod->tmgCal),
GTK_CALENDAR_SHOW_HEADING |
GTK_CALENDAR_SHOW_DAY_NAMES |
GTK_CALENDAR_WEEK_START_MONDAY);
g_signal_connect (mod->tmgCal, "day-selected",
G_CALLBACK (tmg_time_set), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgCal,
0, 1, 0, 5, GTK_SHRINK, GTK_SHRINK,
0, 0);
/* Time controllers.
Note that the controllers for hours, minutes, and seconds have ranges;
however, they can wrap around their limits in order to ensure a smooth
and continuous control of the time
*/
/* hour */
label = gtk_label_new (_(" Hour:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgHour = gtk_spin_button_new_with_range (0, 23, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgHour), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgHour),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgHour), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgHour), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgHour), 2);
gtk_widget_set_tooltip_text (mod->tmgHour,
_("Use this control to set the hour"));
g_signal_connect (mod->tmgHour, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgHour, "wrapped", G_CALLBACK (tmg_hour_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgHour,
2, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* minutes */
label = gtk_label_new (_(" Min:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgMin = gtk_spin_button_new_with_range (0, 59, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgMin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgMin),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgMin), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgMin), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMin), 2);
gtk_widget_set_tooltip_text (mod->tmgMin,
_("Use this control to set the minutes"));
g_signal_connect (mod->tmgMin, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgMin, "wrapped", G_CALLBACK (tmg_min_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgMin,
2, 3, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* seconds */
label = gtk_label_new (_(" Sec:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgSec = gtk_spin_button_new_with_range (0, 59, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgSec), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgSec),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgSec), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgSec), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgSec), 2);
gtk_widget_set_tooltip_text (mod->tmgSec,
_("Use this control to set the seconds"));
g_signal_connect (mod->tmgSec, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgSec, "wrapped", G_CALLBACK (tmg_sec_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgSec,
2, 3, 2, 3, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* milliseconds */
label = gtk_label_new (_(" Msec:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 3, 4, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgMsec = gtk_spin_button_new_with_range (0, 999, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgMsec), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgMsec),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgMsec), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgMsec), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMsec), 2);
gtk_widget_set_tooltip_text (mod->tmgMsec,
_("Use this control to set the milliseconds"));
g_signal_connect (mod->tmgMsec, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgMsec, "wrapped", G_CALLBACK (tmg_msec_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgMsec,
2, 3, 3, 4, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* time throttle */
label = gtk_label_new (_("Throttle:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 4, 5, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgFactor = gtk_spin_button_new_with_range (1, 100, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgFactor), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgFactor),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgFactor), 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgFactor), 1);
gtk_widget_set_tooltip_text (mod->tmgFactor,
_("Time throttle / compression factor"));
g_signal_connect (mod->tmgFactor, "value-changed",
G_CALLBACK (tmg_throttle), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgFactor,
2, 3, 4, 5, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* add slider */
mod->tmgSlider = gtk_hscale_new_with_range (-0.1, +0.1, 0.0001); // +/- 2.5 hr
/*gtk_widget_set_tooltip_text (mod->tmgSlider,
_("Drag the slider to change the time up to +/- 2.5 hours.\n"\
"Resolution is ~ 8 seconds."));*/
gtk_scale_set_draw_value (GTK_SCALE (mod->tmgSlider), FALSE);
gtk_range_set_value (GTK_RANGE (mod->tmgSlider), 0.0);
g_signal_connect (mod->tmgSlider, "value-changed",
G_CALLBACK (slider_moved), mod);
/* create the vertical box */
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), mod->tmgSlider, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* create main window */
mod->tmgWin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
title = g_strconcat (_("Time Controller"), " / ", mod->name, NULL);
gtk_window_set_title (GTK_WINDOW (mod->tmgWin), title);
g_free (title);
gtk_window_set_transient_for (GTK_WINDOW (mod->tmgWin),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (mod))));
g_signal_connect (G_OBJECT (mod->tmgWin), "delete_event",
G_CALLBACK (tmg_delete), mod);
g_signal_connect (G_OBJECT (mod->tmgWin), "destroy",
G_CALLBACK (tmg_destroy), mod);
/* window icon */
buff = icon_file_name ("gpredict-clock.png");
gtk_window_set_icon_from_file (GTK_WINDOW (mod->tmgWin), buff, NULL);
g_free (buff);
gtk_container_add (GTK_CONTAINER (mod->tmgWin), vbox);
gtk_widget_show_all (mod->tmgWin);
mod->tmgActive = TRUE;
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: Time Controller for %s launched"),
__FUNCTION__, mod->name);
}
GtkWidget* bimp_watermark_gui_new(watermark_settings settings)
{
GtkWidget *gui, *hbox_text_entry, *hbox_text_font, *hbox_text_color, *hbox_opacity, *frame_position, *table_position;
GtkWidget *align_radio_text, *align_radio_image;
GtkWidget *label_text, *label_font, *label_color, *label_opacity, *label_percent;
gui = gtk_vbox_new(FALSE, 5);
align_radio_text = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_radio_text), 0, 5, 10, 0);
radio_text = gtk_radio_button_new_with_label(NULL, _("Text watermark"));
vbox_text = gtk_vbox_new(FALSE, 5);
hbox_text_entry = gtk_hbox_new(FALSE, 5);
label_text = gtk_label_new(g_strconcat(_("Text"), ":", NULL));
gtk_widget_set_size_request (label_text, LABEL_W, LABEL_H);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_text), settings->mode);
entry_text = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry_text), 50);
gtk_entry_set_text(GTK_ENTRY(entry_text), settings->text);
gtk_widget_set_size_request (entry_text, INPUT_W, INPUT_H);
hbox_text_font = gtk_hbox_new(FALSE, 5);
label_font = gtk_label_new(g_strconcat(_("Font"), ":", NULL));
gtk_widget_set_size_request (label_font, LABEL_W, LABEL_H);
chooser_font = gtk_font_button_new_with_font(pango_font_description_to_string(settings->font));
gtk_widget_set_size_request (chooser_font, INPUT_W, INPUT_H);
hbox_text_color = gtk_hbox_new(FALSE, 5);
label_color = gtk_label_new(g_strconcat(_("Color"), ":", NULL));
gtk_widget_set_size_request (label_color, LABEL_W, LABEL_H);
chooser_color = gtk_color_button_new_with_color(&(settings->color));
gtk_widget_set_size_request (chooser_color, INPUT_W, INPUT_H);
align_radio_image = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_radio_image), 0, 5, 10, 0);
radio_image = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON(radio_text), _("Image watermark"));
vbox_image = gtk_vbox_new(FALSE, 5);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_image), !settings->mode);
chooser_image = gtk_file_chooser_button_new(_("Select image"), GTK_FILE_CHOOSER_ACTION_OPEN);
/* set image chooser's filters */
GtkFileFilter *filter_all, *supported[5];
filter_all = gtk_file_filter_new();
gtk_file_filter_set_name(filter_all, _("All supported types"));
supported[0] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[0], "Bitmap (*.bmp)");
gtk_file_filter_add_pattern (supported[0], "*.bmp");
gtk_file_filter_add_pattern (filter_all, "*.bmp");
supported[1] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[1], "JPEG (*.jpg, *.jpeg, *jpe)");
gtk_file_filter_add_pattern (supported[1], "*.jpg");
gtk_file_filter_add_pattern (supported[1], "*.jpeg");
gtk_file_filter_add_pattern (supported[1], "*.jpe");
gtk_file_filter_add_pattern (filter_all, "*.jpg");
gtk_file_filter_add_pattern (filter_all, "*.jpeg");
gtk_file_filter_add_pattern (filter_all, "*.jpe");
supported[2] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[2], "GIF (*.gif)");
gtk_file_filter_add_pattern (supported[2], "*.gif");
gtk_file_filter_add_pattern (filter_all, "*.gif");
supported[3] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[3], "PNG (*.png)");
gtk_file_filter_add_pattern (supported[3], "*.png");
gtk_file_filter_add_pattern (filter_all, "*.png");
supported[4] = gtk_file_filter_new();
gtk_file_filter_set_name(supported[4], "TIFF (*tif, *.tiff)");
gtk_file_filter_add_pattern (supported[4], "*.tiff");
gtk_file_filter_add_pattern (supported[4], "*.tif");
gtk_file_filter_add_pattern (filter_all, "*.tiff");
gtk_file_filter_add_pattern (filter_all, "*.tif");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser_image), filter_all);
int i;
for(i = 0; i < 5; i++) {
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser_image), supported[i]);
}
if (settings->image_file != NULL) {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(chooser_image), settings->image_file);
}
gtk_widget_set_size_request (chooser_image, INPUT_W, INPUT_H);
hbox_opacity = gtk_hbox_new(FALSE, 5);
label_opacity = gtk_label_new(g_strconcat(_("Opacity"), ":", NULL));
gtk_widget_set_size_request (label_opacity, LABEL_TRANSP_W, LABEL_TRANSP_H);
gtk_misc_set_alignment(GTK_MISC(label_opacity), 0.5, 0.8);
scale_opacity = gtk_hscale_new_with_range(1, 100, 1);
gtk_range_set_value(GTK_RANGE(scale_opacity), settings->opacity);
gtk_widget_set_size_request (scale_opacity, SCALE_TRANSP_W, SCALE_TRANSP_H);
label_percent = gtk_label_new("%");
gtk_widget_set_size_request (label_percent, LABEL_PERCENT_W, LABEL_PERCENT_H);
gtk_misc_set_alignment(GTK_MISC(label_percent), 0.5, 0.8);
frame_position = gtk_frame_new(g_strconcat(_("Position on the image"), ":", NULL));
gtk_widget_set_size_request (frame_position, FRAME_POSITION_W, FRAME_POSITION_H);
table_position = gtk_table_new(3, 3, TRUE);
button_tl = gtk_radio_button_new (NULL);
gtk_button_set_image(GTK_BUTTON(button_tl), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_postl, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_tl, watermark_pos_get_string(WM_POS_TL));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_tl), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_tl), settings->position == WM_POS_TL);
gtk_widget_set_size_request (button_tl, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_tl, 0, 1, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_tc = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_tc), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_postc, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_tc, watermark_pos_get_string(WM_POS_TC));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_tc), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_tc), settings->position == WM_POS_TC);
gtk_widget_set_size_request (button_tc, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_tc, 1, 2, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_tr = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_tr), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_postr, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_tr, watermark_pos_get_string(WM_POS_TR));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_tr), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_tr), settings->position == WM_POS_TR);
gtk_widget_set_size_request (button_tr, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_tr, 2, 3, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_cl = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_cl), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_poscl, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_cl, watermark_pos_get_string(WM_POS_CL));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_cl), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_cl), settings->position == WM_POS_CL);
gtk_widget_set_size_request (button_cl, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_cl, 0, 1, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_cc = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_cc), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_poscc, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_cc, watermark_pos_get_string(WM_POS_CC));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_cc), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_cc), settings->position == WM_POS_CC);
gtk_widget_set_size_request (button_cc, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_cc, 1, 2, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_cr = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_cr), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_poscr, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_cr, watermark_pos_get_string(WM_POS_CR));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_cr), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_cr), settings->position == WM_POS_CR);
gtk_widget_set_size_request (button_cr, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_cr, 2, 3, 1, 2, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_bl = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_bl), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_posbl, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_bl, watermark_pos_get_string(WM_POS_BL));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_bl), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_bl), settings->position == WM_POS_BL);
gtk_widget_set_size_request (button_bl, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_bl, 0, 1, 2, 3, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_bc = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_bc), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_posbc, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_bc, watermark_pos_get_string(WM_POS_BC));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_bc), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_bc), settings->position == WM_POS_BC);
gtk_widget_set_size_request (button_bc, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_bc, 1, 2, 2, 3, GTK_EXPAND, GTK_EXPAND, 0, 0);
button_br = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON(button_tl));
gtk_button_set_image(GTK_BUTTON(button_br), gtk_image_new_from_pixbuf(gdk_pixbuf_from_pixdata(&pixdata_posbr, TRUE, NULL)));
gtk_widget_set_tooltip_text (button_br, watermark_pos_get_string(WM_POS_BR));
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button_br), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_br), settings->position == WM_POS_BR);
gtk_widget_set_size_request (button_br, BUTTON_POSITION_W, BUTTON_POSITION_H);
gtk_table_attach(GTK_TABLE(table_position), button_br, 2, 3, 2, 3, GTK_EXPAND, GTK_EXPAND, 0, 0);
gtk_box_pack_start(GTK_BOX(gui), radio_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_entry), label_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_entry), entry_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_font), label_font, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_font), chooser_font, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_color), label_color, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_text_color), chooser_color, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_text), hbox_text_entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_text), hbox_text_font, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_text), hbox_text_color, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align_radio_text), vbox_text);
gtk_box_pack_start(GTK_BOX(gui), align_radio_text, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), radio_image, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_image), chooser_image, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align_radio_image), vbox_image);
gtk_box_pack_start(GTK_BOX(gui), align_radio_image, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_opacity), label_opacity, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_opacity), scale_opacity, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_opacity), label_percent, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), hbox_opacity, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame_position), table_position);
gtk_box_pack_start(GTK_BOX(gui), frame_position, FALSE, FALSE, 0);
toggle_group(NULL, NULL);
g_signal_connect(G_OBJECT(radio_text), "toggled", G_CALLBACK(toggle_group), NULL);
return gui;
}
void ant_menu(GtkWidget *parent) {
int i;
parent_window=parent;
dialog=gtk_dialog_new();
gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(parent_window));
gtk_window_set_decorated(GTK_WINDOW(dialog),FALSE);
GdkRGBA color;
color.red = 1.0;
color.green = 1.0;
color.blue = 1.0;
color.alpha = 1.0;
gtk_widget_override_background_color(dialog,GTK_STATE_FLAG_NORMAL,&color);
GtkWidget *content=gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget *grid=gtk_grid_new();
gtk_grid_set_column_spacing (GTK_GRID(grid),10);
//gtk_grid_set_row_spacing (GTK_GRID(grid),10);
//gtk_grid_set_row_homogeneous(GTK_GRID(grid),TRUE);
//gtk_grid_set_column_homogeneous(GTK_GRID(grid),TRUE);
GtkWidget *close_b=gtk_button_new_with_label("Close ANT");
g_signal_connect (close_b, "pressed", G_CALLBACK(close_cb), NULL);
gtk_grid_attach(GTK_GRID(grid),close_b,0,0,1,1);
if(protocol==ORIGINAL_PROTOCOL || protocol==NEW_PROTOCOL) {
GtkWidget *rx_ant_label=gtk_label_new("Receive");
//gtk_widget_override_font(rx_ant_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(rx_ant_label);
gtk_grid_attach(GTK_GRID(grid),rx_ant_label,0,1,1,1);
GtkWidget *rx1_label=gtk_label_new("1");
//gtk_widget_override_font(rx1_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(rx1_label);
gtk_grid_attach(GTK_GRID(grid),rx1_label,1,1,1,1);
GtkWidget *rx2_label=gtk_label_new("2");
//gtk_widget_override_font(rx2_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(rx2_label);
gtk_grid_attach(GTK_GRID(grid),rx2_label,2,1,1,1);
GtkWidget *rx3_label=gtk_label_new("3");
//gtk_widget_override_font(rx3_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(rx3_label);
gtk_grid_attach(GTK_GRID(grid),rx3_label,3,1,1,1);
GtkWidget *ext1_label=gtk_label_new("EXT1");
//gtk_widget_override_font(ext1_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(ext1_label);
gtk_grid_attach(GTK_GRID(grid),ext1_label,4,1,1,1);
GtkWidget *ext2_label=gtk_label_new("EXT2");
//gtk_widget_override_font(ext2_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(ext2_label);
gtk_grid_attach(GTK_GRID(grid),ext2_label,5,1,1,1);
GtkWidget *xvtr_label=gtk_label_new("XVTR");
//gtk_widget_override_font(xvtr_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(xvtr_label);
gtk_grid_attach(GTK_GRID(grid),xvtr_label,6,1,1,1);
GtkWidget *tx_ant_label=gtk_label_new("Transmit");
//gtk_widget_override_font(tx_ant_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(tx_ant_label);
gtk_grid_attach(GTK_GRID(grid),tx_ant_label,7,1,1,1);
GtkWidget *tx1_label=gtk_label_new("1");
//gtk_widget_override_font(tx1_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(tx1_label);
gtk_grid_attach(GTK_GRID(grid),tx1_label,8,1,1,1);
GtkWidget *tx2_label=gtk_label_new("2");
//gtk_widget_override_font(tx2_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(tx2_label);
gtk_grid_attach(GTK_GRID(grid),tx2_label,9,1,1,1);
GtkWidget *tx3_label=gtk_label_new("3");
//gtk_widget_override_font(tx3_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(tx3_label);
gtk_grid_attach(GTK_GRID(grid),tx3_label,10,1,1,1);
for(i=0;i<HAM_BANDS;i++) {
BAND *band=band_get_band(i);
GtkWidget *band_label=gtk_label_new(band->title);
//gtk_widget_override_font(band_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(band_label);
gtk_grid_attach(GTK_GRID(grid),band_label,0,i+2,1,1);
GtkWidget *rx1_b=gtk_radio_button_new(NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rx1_b), band->alexRxAntenna==0);
gtk_widget_show(rx1_b);
gtk_grid_attach(GTK_GRID(grid),rx1_b,1,i+2,1,1);
g_signal_connect(rx1_b,"pressed",G_CALLBACK(rx_ant_cb),(gpointer)((i<<4)+0));
GtkWidget *rx2_b=gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(rx1_b));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rx2_b), band->alexRxAntenna==1);
gtk_widget_show(rx2_b);
gtk_grid_attach(GTK_GRID(grid),rx2_b,2,i+2,1,1);
g_signal_connect(rx2_b,"pressed",G_CALLBACK(rx_ant_cb),(gpointer)((i<<4)+1));
GtkWidget *rx3_b=gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(rx2_b));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rx3_b), band->alexRxAntenna==2);
gtk_widget_show(rx3_b);
gtk_grid_attach(GTK_GRID(grid),rx3_b,3,i+2,1,1);
g_signal_connect(rx3_b,"pressed",G_CALLBACK(rx_ant_cb),(gpointer)((i<<4)+2));
GtkWidget *ext1_b=gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(rx3_b));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ext1_b), band->alexRxAntenna==3);
gtk_widget_show(ext1_b);
gtk_grid_attach(GTK_GRID(grid),ext1_b,4,i+2,1,1);
g_signal_connect(ext1_b,"pressed",G_CALLBACK(rx_ant_cb),(gpointer)((i<<4)+3));
GtkWidget *ext2_b=gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(ext1_b));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ext2_b), band->alexRxAntenna==4);
gtk_widget_show(ext2_b);
gtk_grid_attach(GTK_GRID(grid),ext2_b,5,i+2,1,1);
g_signal_connect(ext2_b,"pressed",G_CALLBACK(rx_ant_cb),(gpointer)((i<<4)+4));
GtkWidget *xvtr_b=gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(ext2_b));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (xvtr_b), band->alexRxAntenna==5);
gtk_widget_show(xvtr_b);
gtk_grid_attach(GTK_GRID(grid),xvtr_b,6,i+2,1,1);
g_signal_connect(xvtr_b,"pressed",G_CALLBACK(rx_ant_cb),(gpointer)((i<<4)+5));
GtkWidget *ant_band_label=gtk_label_new(band->title);
//gtk_widget_override_font(ant_band_label, pango_font_description_from_string("Arial 18"));
gtk_widget_show(ant_band_label);
gtk_grid_attach(GTK_GRID(grid),ant_band_label,7,i+2,1,1);
GtkWidget *tx1_b=gtk_radio_button_new(NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tx1_b), band->alexTxAntenna==0);
gtk_widget_show(tx1_b);
gtk_grid_attach(GTK_GRID(grid),tx1_b,8,i+2,1,1);
GtkWidget *tx2_b=gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(tx1_b));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tx2_b), band->alexTxAntenna==1);
gtk_widget_show(tx2_b);
gtk_grid_attach(GTK_GRID(grid),tx2_b,9,i+2,1,1);
g_signal_connect(tx2_b,"pressed",G_CALLBACK(tx_ant_cb),(gpointer)((i<<4)+1));
GtkWidget *tx3_b=gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(tx2_b));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tx3_b), band->alexTxAntenna==2);
gtk_widget_show(tx3_b);
gtk_grid_attach(GTK_GRID(grid),tx3_b,10,i+2,1,1);
g_signal_connect(tx3_b,"pressed",G_CALLBACK(tx_ant_cb),(gpointer)((i<<4)+2));
}
}
#ifdef LIMESDR
if(protocol==LIMESDR_PROTOCOL) {
BAND *band=band_get_current_band();
GtkWidget *rx1_none=gtk_radio_button_new_with_label(NULL,"RX 1: NONE");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rx1_none), band->alexRxAntenna==0);
gtk_widget_show(rx1_none);
gtk_grid_attach(GTK_GRID(grid),rx1_none,0,1,1,1);
g_signal_connect(rx1_none,"pressed",G_CALLBACK(rx_lime_ant_cb),(gpointer)0);
GtkWidget *rx1_lnah=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(rx1_none),"RX1: LNAH");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rx1_lnah), band->alexRxAntenna==1);
gtk_widget_show(rx1_lnah);
gtk_grid_attach(GTK_GRID(grid),rx1_lnah,0,2,1,1);
g_signal_connect(rx1_lnah,"pressed",G_CALLBACK(rx_lime_ant_cb),(gpointer)+1);
GtkWidget *rx1_lnal=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(rx1_lnah),"RX1: LNAL");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rx1_lnal), band->alexRxAntenna==2);
gtk_widget_show(rx1_lnal);
gtk_grid_attach(GTK_GRID(grid),rx1_lnal,0,3,1,1);
g_signal_connect(rx1_lnal,"pressed",G_CALLBACK(rx_lime_ant_cb),(gpointer)2);
GtkWidget *rx1_lnaw=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(rx1_lnal),"RX1: LNAW");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rx1_lnaw), band->alexRxAntenna==3);
gtk_widget_show(rx1_lnaw);
gtk_grid_attach(GTK_GRID(grid),rx1_lnaw,0,4,1,1);
g_signal_connect(rx1_lnaw,"pressed",G_CALLBACK(rx_lime_ant_cb),(gpointer)3);
}
#endif
gtk_container_add(GTK_CONTAINER(content),grid);
sub_menu=dialog;
gtk_widget_show_all(dialog);
}
int music_build_element_widgets () {
int i = 0;
for (i = 0; i < 9; i++) {
label_music_info[i] = gtk_label_new(NULL);
gtk_label_set_width_chars(GTK_LABEL(label_music_info[i]), 15);
gtk_label_set_max_width_chars(GTK_LABEL(label_music_info[i]), 150);
gtk_label_set_line_wrap(GTK_LABEL(label_music_info[i]), TRUE);
}
separator_music_info = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
for (i = 0; i < 9; i++) {
label_music_lyric[i] = gtk_label_new(NULL);
gtk_label_set_max_width_chars(GTK_LABEL(label_music_lyric[i]), 305);
// gtk_label_set_line_wrap(GTK_LABEL(label_music_lyric[i]), TRUE);
}
gtk_label_set_selectable(GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_use_underline (GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_use_markup (GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_pattern (GTK_LABEL(label_music_lyric[4]), "________");
separator_music_lyric1 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
separator_music_lyric2 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
button_music_start_server = gtk_button_new_with_label("启动服务器");
// set_button_music_start_server(button_music_start_server);
button_music_exit_server = gtk_button_new_with_label("关闭服务器");
// set_button_music_exit_server(button_music_exit_server);
button_music_play = gtk_button_new();
// box_music_play = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png");
// box_music_pause = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png");
image_music_play = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png");
image_music_play_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play_light.png");
image_music_pause = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png");
image_music_pause_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause_light.png");
gtk_button_set_relief(GTK_BUTTON(button_music_play), GTK_RELIEF_NONE);
set_button_music_play(button_music_play);
button_music_pause = gtk_button_new_with_label("暂停");
// set_button_music_pause(button_music_pause);
button_music_unpause = gtk_button_new_with_label("取消暂停");
// set_button_music_unpause(button_music_unpause);
// button_music_stop = gtk_button_new_with_label("停止");
button_music_stop = gtk_button_new();
image_music_stop = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop.png");
image_music_stop_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop_light.png");
gtk_button_set_image(GTK_BUTTON(button_music_stop), image_music_stop);
gtk_button_set_relief(GTK_BUTTON(button_music_stop), GTK_RELIEF_NONE);
set_button_music_stop(button_music_stop);
// button_music_next = gtk_button_new_with_label("下一首");
button_music_next = gtk_button_new();
image_music_next = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next.png");
image_music_next_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next_light.png");
gtk_button_set_image(GTK_BUTTON(button_music_next), image_music_next);
gtk_button_set_relief(GTK_BUTTON(button_music_next), GTK_RELIEF_NONE);
set_button_music_next(button_music_next);
// button_music_pre = gtk_button_new_with_label("上一首");
button_music_pre = gtk_button_new();
image_music_pre = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre.png");
image_music_pre_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre_light.png");
gtk_button_set_image (GTK_BUTTON(button_music_pre), image_music_pre);
gtk_button_set_relief(GTK_BUTTON(button_music_pre), GTK_RELIEF_NONE);
set_button_music_pre(button_music_pre);
// button_music_volume_up = gtk_button_new_with_label("音量+");
// set_button_music_volume_up(button_music_volume_up);
// button_music_volume_silence = gtk_button_new_with_label("静音");
button_music_silence = gtk_button_new();
image_music_silence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence.png");
image_music_silence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence_light.png");
image_music_unsilence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence.png");
image_music_unsilence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence_light.png");
gtk_button_set_image (GTK_BUTTON(button_music_silence), image_music_silence);
gtk_button_set_relief(GTK_BUTTON(button_music_silence), GTK_RELIEF_NONE);
set_button_music_silence(button_music_silence);
button_music_volume = gtk_volume_button_new();
set_button_music_volume( button_music_volume);
button_music_reset_list = gtk_button_new_with_label("重设列表");
set_button_music_reset_list(button_music_reset_list);
// button_music_choose_path = gtk_button_new_with_label("添加路径");
// set_button_music_choose_path(button_music_choose_path);
// music_path_dialog = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
music_path_dialog = gtk_file_chooser_dialog_new ("test_title", NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "test_button_text", NULL);
button_music_choose_path = gtk_file_chooser_button_new_with_dialog (music_path_dialog);
gtk_file_chooser_button_set_title (GTK_FILE_CHOOSER_BUTTON(button_music_choose_path), "添加路径");
// gtk_file_chooser_set_select_multiple (music_path_dialog, TRUE);
button_music_delete_path = gtk_button_new_with_label("删除当前路径");
set_button_music_delete_path(button_music_delete_path);
scale_music_process = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
set_scale_music_process(scale_music_process);
label_music_cur_time = gtk_label_new ("--:--:--");
label_music_total_time = gtk_label_new ("--:--:--");
switch_music_autonext = gtk_switch_new ();
set_switch_music_autonext ();
label_music_autonext = gtk_label_new ("AutoNext: ");
switch_music_repeat = gtk_switch_new ();
set_switch_music_repeat ();
label_music_repeat = gtk_label_new ("Repeat: ");
switch_music_shuffle = gtk_switch_new ();
set_switch_music_shuffle ();
label_music_shuffle = gtk_label_new ("Shuffle: ");
radio_button_music_mode_shuffle = gtk_radio_button_new (NULL);
label_music_mode_shuffle = gtk_label_new ("随机:");
radio_button_music_mode_loop_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_loop_list = gtk_label_new ("列表循环:");
radio_button_music_mode_play_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_play_list = gtk_label_new ("播放列表:");
radio_button_music_mode_loop_one = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_loop_one = gtk_label_new ("单曲:");
spinner_music_mode_changing = gtk_spinner_new ();
set_radio_button_music_mode ();
store_music_dir_list = gtk_tree_store_new(dir_n_columns, G_TYPE_STRING);
tree_view_music_dir_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_dir_list));
text_renderer_music_dir_list = gtk_cell_renderer_text_new ();
column_music_dir_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_dir_list, "text", dir_name, NULL);
gtk_tree_view_column_set_fixed_width(column_music_dir_list, 100);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_dir_list), column_music_dir_list);
music_dir_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50);
music_dir_list_sw = gtk_scrolled_window_new(NULL, music_dir_list_sw_adj_h);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_dir_list_sw), 330);
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_dir_list_sw), 100);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_SHADOW_NONE);
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(music_dir_list_sw), tree_view_music_dir_list);
selection_music_dir_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_dir_list));
set_tree_view_music_dir_list ();
store_music_list = gtk_tree_store_new(list_n_columns, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
// char file_index[BUFSIZ];
// printf("music_list_num is: %s\n", music_list_num);
// while (i < music_list_num) {
// // printf("%d: %s\n", i, music_list[i]);
// sprintf(file_index, "%d", i + 1);
// gtk_tree_store_append(store_music_list, &iter_music_list, NULL);
// gtk_tree_store_set (store_music_list, &iter_music_list, list_index, file_index, list_title, music_list[i], list_total_sec, "03:00", -1);
// i++;
// }
//
tree_view_music_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_list));
text_renderer_music_list = gtk_cell_renderer_text_new ();
column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_index, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
gtk_tree_view_column_set_title(column_music_list, "序号");
text_renderer_music_list = gtk_cell_renderer_text_new ();
column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_title, NULL);
gtk_tree_view_column_set_fixed_width(column_music_list, 100);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
// text_renderer_music_list = gtk_cell_renderer_text_new ();
// column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_total_sec, NULL);
// gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
music_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50);
music_list_sw = gtk_scrolled_window_new(NULL, music_list_sw_adj_h);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_list_sw), 370);
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_list_sw), 200);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_list_sw), GTK_SHADOW_NONE);
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(music_list_sw), tree_view_music_list);
selection_music_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_list));
set_tree_view_music_list ();
return 1;
}
GtkWidget *createMainWindow( void )
{
GtkWidget *app;//!< Main container
GtkWidget *buttonCalc, *buttonClose;
GtkWidget *labelHeader;
GtkWidget *label;
GtkWidget *boxResistors, *boxConnType;
GtkWidget *hbox, *vbox;
// Create new Gnome application
app = gnome_app_new("gnome1","Menus, menus, menus");
// Set window properties
gtk_window_set_title(GTK_WINDOW(app), "Den mest fantastiska elektronikkalkylatorn");
gtk_window_set_position(GTK_WINDOW(app), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(app), 300, 200);
gnome_app_create_menus( GNOME_APP(app), menubar);
// Labels
labelHeader = gtk_label_new("Räkna ut resistansen v1.0");
label = gtk_label_new("Typ av koppling:");
// Entry
entryNr = gtk_spin_button_new_with_range(1,3,1);
entryV = gtk_spin_button_new_with_range(56.34,10000,0.01);
entryR1 = gtk_spin_button_new_with_range(1234.5 ,1000000000,0.1);
entryR2 = gtk_spin_button_new_with_range(4321.0,1000000000,0.1);
entryR3 = gtk_spin_button_new_with_range(5555.5,1000000000,0.1);
// Buttons
buttonCalc = gtk_button_new_with_label("Räkna ut");
buttonClose = gtk_button_new_with_label("Avsluta");
radioSerial = gtk_radio_button_new(NULL);
radioParalell = gtk_radio_button_new_from_widget( GTK_RADIO_BUTTON( radioSerial ));
// Set callback functions
g_signal_connect( GTK_OBJECT (app), "destroy", GTK_SIGNAL_FUNC (closeApp), NULL );
g_signal_connect( GTK_OBJECT (buttonCalc), "clicked", GTK_SIGNAL_FUNC (buttonClicked), NULL );
g_signal_connect( GTK_OBJECT (buttonClose), "clicked", GTK_SIGNAL_FUNC (closeApp), NULL );
// Boxes
boxResistors = gtk_vbox_new(FALSE, 5);
boxConnType = gtk_vbox_new(TRUE, 5);
hbox = gtk_hbox_new(TRUE, 5);
vbox = gtk_vbox_new(FALSE, 10);
// Packing boxes and adding labels
gtk_box_pack_start(GTK_BOX(boxConnType), label, TRUE, FALSE, 5);
addWidgetWithLabel( GTK_CONTAINER( boxConnType ), "Seriell", radioSerial );
addWidgetWithLabel( GTK_CONTAINER( boxConnType ), "Parallell", radioParalell );
addWidgetWithLabel( GTK_CONTAINER( boxConnType ), "Spänning (V):", entryV );
gtk_box_pack_start(GTK_BOX(boxConnType), buttonClose, TRUE, FALSE, 5);
addWidgetWithLabel( GTK_CONTAINER(boxResistors), "Antal resistorer:", entryNr);
addWidgetWithLabel( GTK_CONTAINER(boxResistors), "Resistor #1:", entryR1);
addWidgetWithLabel( GTK_CONTAINER(boxResistors), "Resistor #2:", entryR2);
addWidgetWithLabel( GTK_CONTAINER(boxResistors), "Resistor #3:", entryR3);
gtk_box_pack_start(GTK_BOX(boxResistors), buttonCalc, TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), boxConnType, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), boxResistors, FALSE, FALSE, 5);
// Add containers to gnome application
gnome_app_set_contents( GNOME_APP(app), hbox);
// Return Gnome app
return app;
}
static void mp3_configure(void)
{
gint i;
if (!configure_win) {
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 (configure_win, "destroy", (GCallback)
gtk_widget_destroyed, & configure_win);
gtk_window_set_title(GTK_WINDOW(configure_win),
_("MP3 Configuration"));
gtk_window_set_position(GTK_WINDOW(configure_win),
GTK_WIN_POS_MOUSE);
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);
notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
/* Quality */
quality_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(quality_vbox), 5);
quality_hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(quality_vbox), quality_hbox1, FALSE,
FALSE, 0);
/* Algorithm Quality */
alg_quality_frame = gtk_frame_new(_("Algorithm Quality:"));
gtk_container_set_border_width(GTK_CONTAINER(alg_quality_frame),
5);
gtk_box_pack_start(GTK_BOX(quality_hbox1), alg_quality_frame,
FALSE, FALSE, 0);
alg_quality_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(alg_quality_hbox),
10);
gtk_container_add(GTK_CONTAINER(alg_quality_frame),
alg_quality_hbox);
alg_quality_adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 9, 1, 1, 0);
alg_quality_spin =
gtk_spin_button_new(GTK_ADJUSTMENT(alg_quality_adj), 8, 0);
gtk_box_pack_start(GTK_BOX(alg_quality_hbox), alg_quality_spin,
TRUE, TRUE, 0);
g_signal_connect (alg_quality_adj, "value-changed", (GCallback)
algo_qual, NULL);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(alg_quality_spin),
algo_quality_val);
/* Output Samplerate */
samplerate_frame = gtk_frame_new(_("Output Samplerate:"));
gtk_container_set_border_width(GTK_CONTAINER(samplerate_frame), 5);
gtk_box_pack_start(GTK_BOX(quality_hbox1), samplerate_frame, FALSE,
FALSE, 0);
samplerate_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(samplerate_hbox), 10);
gtk_container_add(GTK_CONTAINER(samplerate_frame),
samplerate_hbox);
GtkWidget * combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, _("Auto"));
if (! out_samplerate_val)
gtk_combo_box_set_active ((GtkComboBox *) combo, 0);
for (i = 0; i < G_N_ELEMENTS (available_samplerates); i ++)
{
gchar buf[10];
snprintf (buf, sizeof buf, "%d", available_samplerates[i]);
gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, buf);
if (out_samplerate_val == available_samplerates[i])
gtk_combo_box_set_active ((GtkComboBox *) combo, 1 + i);
}
gtk_box_pack_start ((GtkBox *) samplerate_hbox, combo, FALSE, FALSE, 0);
g_signal_connect (combo, "changed", (GCallback) samplerate_changed, NULL);
samplerate_label = gtk_label_new(_("(Hz)"));
gtk_misc_set_alignment(GTK_MISC(samplerate_label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(samplerate_hbox), samplerate_label,
FALSE, FALSE, 0);
/* Encoder Quality */
enc_quality_frame = gtk_frame_new(_("Bitrate / Compression ratio:"));
gtk_container_set_border_width(GTK_CONTAINER(enc_quality_frame),
5);
gtk_box_pack_start(GTK_BOX(quality_vbox), enc_quality_frame, FALSE,
FALSE, 0);
// vbox sorrounding hbox1 and hbox2
enc_quality_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(enc_quality_vbox), 10);
// pack vbox to frame
gtk_container_add(GTK_CONTAINER(enc_quality_frame), enc_quality_vbox);
// hbox1 for bitrate
hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(enc_quality_vbox), hbox1);
// radio 1
enc_radio1 = gtk_radio_button_new(NULL);
if (enc_toggle_val == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enc_radio1), TRUE);
gtk_box_pack_start(GTK_BOX(hbox1), enc_radio1, FALSE, FALSE, 0);
// label 1
enc_quality_label1 = gtk_label_new(_("Bitrate (kbps):"));
gtk_box_pack_start(GTK_BOX(hbox1), enc_quality_label1, FALSE, FALSE, 0);
// bitrate menu
combo = gtk_combo_box_text_new ();
for (i = 0; i < G_N_ELEMENTS (available_bitrates); i ++)
{
gchar buf[10];
snprintf (buf, sizeof buf, "%d", available_bitrates[i]);
gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, buf);
if (bitrate_val == available_bitrates[i])
gtk_combo_box_set_active ((GtkComboBox *) combo, i);
}
gtk_box_pack_start ((GtkBox *) hbox1, combo, FALSE, FALSE, 0);
g_signal_connect (combo, "changed", (GCallback) bitrate_changed, NULL);
// hbox2 for compression ratio
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(enc_quality_vbox), hbox2);
// radio 2
enc_radio2 = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(enc_radio1));
if (enc_toggle_val == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enc_radio2),
TRUE);
// pack radio 2
gtk_box_pack_start(GTK_BOX(hbox2), enc_radio2, FALSE, FALSE, 0);
// label
enc_quality_label2 = gtk_label_new(_("Compression ratio:"));
gtk_box_pack_start(GTK_BOX(hbox2), enc_quality_label2, FALSE, FALSE, 0);
// comp-ratio spin
compression_adj = (GtkAdjustment *) gtk_adjustment_new (11, 0, 100, 1,
1, 0);
compression_spin =
gtk_spin_button_new(GTK_ADJUSTMENT(compression_adj), 8, 0);
gtk_box_pack_end(GTK_BOX(hbox2), compression_spin, FALSE, FALSE, 0);
g_signal_connect (compression_adj, "value-changed", (GCallback)
compression_change, NULL);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(compression_spin),
compression_val);
// radio button signale connect
g_signal_connect (enc_radio1, "toggled", (GCallback) encoding_toggle,
GINT_TO_POINTER (0));
g_signal_connect (enc_radio2, "toggled", (GCallback) encoding_toggle,
GINT_TO_POINTER (1));
/* Audio Mode */
mode_frame = gtk_frame_new(_("Audio Mode:"));
gtk_container_set_border_width(GTK_CONTAINER(mode_frame), 5);
gtk_box_pack_start(GTK_BOX(quality_vbox), mode_frame, FALSE, FALSE,
0);
mode_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(mode_hbox), 10);
gtk_container_add(GTK_CONTAINER(mode_frame), mode_hbox);
combo = gtk_combo_box_text_new ();
for (i = 0; i < MODES; i ++)
{
gtk_combo_box_text_append_text ((GtkComboBoxText *) combo,
_(mode_names[i]));
if (audio_mode_val == modes[i])
gtk_combo_box_set_active ((GtkComboBox *) combo, i);
}
gtk_box_pack_start ((GtkBox *) mode_hbox, combo, FALSE, FALSE, 0);
g_signal_connect (combo, "changed", (GCallback) mode_changed, NULL);
/* Misc */
misc_frame = gtk_frame_new(_("Misc:"));
gtk_container_set_border_width(GTK_CONTAINER(misc_frame), 5);
gtk_box_pack_start(GTK_BOX(quality_vbox), misc_frame, FALSE, FALSE,
0);
misc_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(misc_vbox), 5);
gtk_container_add(GTK_CONTAINER(misc_frame), misc_vbox);
enforce_iso_toggle =
gtk_check_button_new_with_label
(_("Enforce strict ISO complience"));
gtk_box_pack_start(GTK_BOX(misc_vbox), enforce_iso_toggle, TRUE,
TRUE, 2);
g_signal_connect (enforce_iso_toggle, "toggled", (GCallback)
toggle_enforce_iso, NULL);
if (enforce_iso_val == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(enforce_iso_toggle), TRUE);
error_protection_toggle =
gtk_check_button_new_with_label(_("Error protection"));
gtk_box_pack_start(GTK_BOX(misc_vbox), error_protection_toggle,
TRUE, TRUE, 2);
g_signal_connect (error_protection_toggle, "toggled", (GCallback)
toggle_error_protect, NULL);
if (error_protect_val == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(error_protection_toggle), TRUE);
/* Add the Notebook */
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), quality_vbox,
gtk_label_new(_("Quality")));
/* VBR/ABR */
vbr_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbr_vbox), 5);
/* Toggle VBR */
vbr_toggle = gtk_check_button_new_with_label(_("Enable VBR/ABR"));
gtk_box_pack_start(GTK_BOX(vbr_vbox), vbr_toggle, FALSE, FALSE, 2);
g_signal_connect (vbr_toggle, "toggled", (GCallback) toggle_vbr, NULL);
vbr_options_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(vbr_vbox), vbr_options_vbox);
gtk_widget_set_sensitive(vbr_options_vbox, FALSE);
/* Choose VBR/ABR */
vbr_type_frame = gtk_frame_new(_("Type:"));
gtk_container_set_border_width(GTK_CONTAINER(vbr_type_frame), 5);
gtk_box_pack_start(GTK_BOX(vbr_options_vbox), vbr_type_frame,
FALSE, FALSE, 2);
vbr_type_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbr_type_hbox), 5);
gtk_container_add(GTK_CONTAINER(vbr_type_frame), vbr_type_hbox);
vbr_type_radio1 = gtk_radio_button_new_with_label(NULL, "VBR");
gtk_box_pack_start(GTK_BOX(vbr_type_hbox), vbr_type_radio1, TRUE,
TRUE, 2);
if (vbr_type == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(vbr_type_radio1), TRUE);
vbr_type_radio2 =
gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON
(vbr_type_radio1),
"ABR");
gtk_box_pack_start(GTK_BOX(vbr_type_hbox), vbr_type_radio2, TRUE,
TRUE, 2);
if (vbr_type == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(vbr_type_radio2), TRUE);
g_signal_connect (vbr_type_radio1, "toggled", (GCallback)
vbr_abr_toggle, "VBR");
g_signal_connect (vbr_type_radio2, "toggled", (GCallback)
vbr_abr_toggle, "ABR");
/* VBR Options */
vbr_frame = gtk_frame_new(_("VBR Options:"));
gtk_container_set_border_width(GTK_CONTAINER(vbr_frame), 5);
gtk_box_pack_start(GTK_BOX(vbr_options_vbox), vbr_frame, FALSE,
FALSE, 2);
vbr_options_vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbr_options_vbox2),
5);
gtk_container_add(GTK_CONTAINER(vbr_frame), vbr_options_vbox2);
vbr_options_hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbr_options_hbox1),
5);
gtk_container_add(GTK_CONTAINER(vbr_options_vbox2),
vbr_options_hbox1);
vbr_min_label = gtk_label_new(_("Minimum bitrate (kbps):"));
gtk_misc_set_alignment(GTK_MISC(vbr_min_label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbr_options_hbox1), vbr_min_label, TRUE,
TRUE, 0);
combo = gtk_combo_box_text_new ();
for (i = 0; i < G_N_ELEMENTS (available_bitrates); i ++)
{
gchar buf[10];
snprintf (buf, sizeof buf, "%d", available_bitrates[i]);
gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, buf);
if (vbr_min_val == available_bitrates[i])
gtk_combo_box_set_active ((GtkComboBox *) combo, i);
}
gtk_box_pack_start ((GtkBox *) vbr_options_hbox1, combo, FALSE, FALSE,
0);
g_signal_connect (combo, "changed", (GCallback) vbr_min_changed, NULL);
vbr_options_hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbr_options_hbox2),
5);
gtk_container_add(GTK_CONTAINER(vbr_options_vbox2),
vbr_options_hbox2);
vbr_max_label = gtk_label_new(_("Maximum bitrate (kbps):"));
gtk_misc_set_alignment(GTK_MISC(vbr_max_label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbr_options_hbox2), vbr_max_label, TRUE,
TRUE, 0);
combo = gtk_combo_box_text_new ();
for (i = 0; i < G_N_ELEMENTS (available_bitrates); i ++)
{
gchar buf[10];
snprintf (buf, sizeof buf, "%d", available_bitrates[i]);
gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, buf);
if (vbr_max_val == available_bitrates[i])
gtk_combo_box_set_active ((GtkComboBox *) combo, i);
}
gtk_box_pack_start ((GtkBox *) vbr_options_hbox2, combo, FALSE, FALSE,
0);
g_signal_connect (combo, "changed", (GCallback) vbr_max_changed, NULL);
enforce_min_toggle =
gtk_check_button_new_with_label
(_("Strictly enforce minimum bitrate"));
gtk_box_pack_start(GTK_BOX(vbr_options_vbox2), enforce_min_toggle,
FALSE, FALSE, 2);
g_signal_connect (enforce_min_toggle, "toggled", (GCallback)
toggle_enforce_min, NULL);
if (enforce_min_val == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(enforce_min_toggle), TRUE);
/* ABR Options */
abr_frame = gtk_frame_new(_("ABR Options:"));
gtk_container_set_border_width(GTK_CONTAINER(abr_frame), 5);
gtk_box_pack_start(GTK_BOX(vbr_options_vbox), abr_frame, FALSE,
FALSE, 2);
gtk_widget_set_sensitive(abr_frame, FALSE);
abr_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(abr_hbox), 5);
gtk_container_add(GTK_CONTAINER(abr_frame), abr_hbox);
abr_label = gtk_label_new(_("Average bitrate (kbps):"));
gtk_misc_set_alignment(GTK_MISC(abr_label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(abr_hbox), abr_label, TRUE, TRUE, 0);
combo = gtk_combo_box_text_new ();
for (i = 0; i < G_N_ELEMENTS (available_bitrates); i ++)
{
gchar buf[10];
snprintf (buf, sizeof buf, "%d", available_bitrates[i]);
gtk_combo_box_text_append_text ((GtkComboBoxText *) combo, buf);
if (abr_val == available_bitrates[i])
gtk_combo_box_set_active ((GtkComboBox *) combo, i);
}
gtk_box_pack_start ((GtkBox *) abr_hbox, combo, FALSE, FALSE,
0);
g_signal_connect (combo, "changed", (GCallback) abr_changed, NULL);
/* Quality Level */
vbr_options_hbox3 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbr_options_hbox3),
5);
gtk_container_add(GTK_CONTAINER(vbr_options_vbox),
vbr_options_hbox3);
vbr_quality_label = gtk_label_new(_("VBR quality level:"));
gtk_misc_set_alignment(GTK_MISC(vbr_quality_label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbr_options_hbox3), vbr_quality_label,
TRUE, TRUE, 0);
vbr_quality_adj = (GtkAdjustment *) gtk_adjustment_new (4, 0, 9, 1, 1, 0);
vbr_quality_spin =
gtk_spin_button_new(GTK_ADJUSTMENT(vbr_quality_adj), 8, 0);
gtk_box_pack_start(GTK_BOX(vbr_options_hbox3), vbr_quality_spin,
TRUE, TRUE, 0);
g_signal_connect (vbr_quality_adj, "value-changed", (GCallback)
vbr_qual, NULL);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(vbr_quality_spin),
vbr_quality_val);
/* Xing Header */
xing_header_toggle =
gtk_check_button_new_with_label(_("Don't write Xing VBR header"));
gtk_box_pack_start(GTK_BOX(vbr_options_vbox), xing_header_toggle,
FALSE, FALSE, 2);
g_signal_connect (xing_header_toggle, "toggled", (GCallback)
toggle_xing, NULL);
if (toggle_xing_val == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(xing_header_toggle), TRUE);
/* Add the Notebook */
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbr_vbox,
gtk_label_new(_("VBR/ABR")));
/* Tags */
tags_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(tags_vbox), 5);
/* Frame Params */
tags_frames_frame = gtk_frame_new(_("Frame params:"));
gtk_container_set_border_width(GTK_CONTAINER(tags_frames_frame),
5);
gtk_box_pack_start(GTK_BOX(tags_vbox), tags_frames_frame, FALSE,
FALSE, 2);
tags_frames_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(tags_frames_hbox), 5);
gtk_container_add(GTK_CONTAINER(tags_frames_frame),
tags_frames_hbox);
tags_copyright_toggle =
gtk_check_button_new_with_label(_("Mark as copyright"));
gtk_box_pack_start(GTK_BOX(tags_frames_hbox),
tags_copyright_toggle, FALSE, FALSE, 2);
g_signal_connect (tags_copyright_toggle, "toggled", (GCallback)
toggle_copyright, NULL);
if (mark_copyright_val == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(tags_copyright_toggle), TRUE);
tags_original_toggle =
gtk_check_button_new_with_label(_("Mark as original"));
gtk_box_pack_start(GTK_BOX(tags_frames_hbox), tags_original_toggle,
FALSE, FALSE, 2);
g_signal_connect (tags_original_toggle, "toggled", (GCallback)
toggle_original, NULL);
if (mark_original_val == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(tags_original_toggle), TRUE);
/* ID3 Params */
tags_id3_frame = gtk_frame_new(_("ID3 params:"));
gtk_container_set_border_width(GTK_CONTAINER(tags_id3_frame), 5);
gtk_box_pack_start(GTK_BOX(tags_vbox), tags_id3_frame, FALSE,
FALSE, 2);
tags_id3_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(tags_id3_vbox), 5);
gtk_container_add(GTK_CONTAINER(tags_id3_frame), tags_id3_vbox);
tags_force_id3v2_toggle =
gtk_check_button_new_with_label
(_("Force addition of version 2 tag"));
gtk_box_pack_start(GTK_BOX(tags_id3_vbox), tags_force_id3v2_toggle,
FALSE, FALSE, 2);
g_signal_connect (tags_force_id3v2_toggle, "toggled", (GCallback)
force_v2_toggle, NULL);
tags_id3_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(tags_id3_vbox), tags_id3_hbox);
tags_only_v1_toggle =
gtk_check_button_new_with_label(_("Only add v1 tag"));
gtk_box_pack_start(GTK_BOX(tags_id3_hbox), tags_only_v1_toggle,
FALSE, FALSE, 2);
g_signal_connect (tags_only_v1_toggle, "toggled", (GCallback)
id3_only_version, "v1");
tags_only_v2_toggle =
gtk_check_button_new_with_label(_("Only add v2 tag"));
gtk_box_pack_start(GTK_BOX(tags_id3_hbox), tags_only_v2_toggle,
FALSE, FALSE, 2);
g_signal_connect (tags_only_v2_toggle, "toggled", (GCallback)
id3_only_version, "v2");
if (force_v2_val == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(tags_force_id3v2_toggle), TRUE);
if (only_v1_val == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(tags_only_v1_toggle), TRUE);
if (only_v2_val == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON
(tags_only_v2_toggle), TRUE);
/* Add the Notebook */
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), tags_vbox,
gtk_label_new(_("Tags")));
/* The Rest */
/* Buttons */
configure_bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(configure_bbox),
GTK_BUTTONBOX_END);
gtk_box_pack_start(GTK_BOX(vbox), configure_bbox, FALSE, FALSE, 0);
configure_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect_swapped (configure_cancel, "clicked", (GCallback)
gtk_widget_destroy, configure_win);
gtk_box_pack_start(GTK_BOX(configure_bbox), configure_cancel, TRUE,
TRUE, 0);
configure_ok = gtk_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect (configure_ok, "clicked", (GCallback) configure_ok_cb,
NULL);
gtk_box_pack_start(GTK_BOX(configure_bbox), configure_ok, TRUE,
TRUE, 0);
gtk_widget_show(configure_ok);
/* Set States */
if (vbr_on == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(vbr_toggle),
TRUE);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(vbr_toggle),
FALSE);
/* Show it! */
gtk_widget_show_all(configure_win);
}
}
