static app_t *
app_new (pixman_image_t *original)
{
GtkWidget *widget;
app_t *app = g_malloc (sizeof *app);
GError *err = NULL;
app->builder = gtk_builder_new ();
app->original = original;
if (!gtk_builder_add_from_file (app->builder, "scale.ui", &err))
g_error ("Could not read file scale.ui: %s", err->message);
app->scale_x_adjustment =
GTK_ADJUSTMENT (gtk_builder_get_object (app->builder, "scale_x_adjustment"));
app->scale_y_adjustment =
GTK_ADJUSTMENT (gtk_builder_get_object (app->builder, "scale_y_adjustment"));
app->rotate_adjustment =
GTK_ADJUSTMENT (gtk_builder_get_object (app->builder, "rotate_adjustment"));
app->subsample_adjustment =
GTK_ADJUSTMENT (gtk_builder_get_object (app->builder, "subsample_adjustment"));
g_signal_connect (app->scale_x_adjustment, "value_changed", G_CALLBACK (rescale), app);
g_signal_connect (app->scale_y_adjustment, "value_changed", G_CALLBACK (rescale), app);
g_signal_connect (app->rotate_adjustment, "value_changed", G_CALLBACK (rescale), app);
g_signal_connect (app->subsample_adjustment, "value_changed", G_CALLBACK (rescale), app);
widget = get_widget (app, "scale_x_scale");
gtk_scale_add_mark (GTK_SCALE (widget), 0.0, GTK_POS_LEFT, NULL);
g_signal_connect (widget, "format_value", G_CALLBACK (format_value), app);
widget = get_widget (app, "scale_y_scale");
gtk_scale_add_mark (GTK_SCALE (widget), 0.0, GTK_POS_LEFT, NULL);
g_signal_connect (widget, "format_value", G_CALLBACK (format_value), app);
widget = get_widget (app, "rotate_scale");
gtk_scale_add_mark (GTK_SCALE (widget), 0.0, GTK_POS_LEFT, NULL);
widget = get_widget (app, "drawing_area");
g_signal_connect (widget, "expose_event", G_CALLBACK (on_expose), app);
set_up_filter_box (app, "reconstruct_x_combo_box");
set_up_filter_box (app, "reconstruct_y_combo_box");
set_up_filter_box (app, "sample_x_combo_box");
set_up_filter_box (app, "sample_y_combo_box");
set_up_combo_box (
app, "repeat_combo_box", G_N_ELEMENTS (repeats), repeats);
g_signal_connect (
gtk_builder_get_object (app->builder, "lock_checkbutton"),
"toggled", G_CALLBACK (rescale), app);
rescale (NULL, app);
return app;
}
static void
update_scale_marks (GvcBalanceBar *bar)
{
gchar *str_lower = NULL,
*str_upper = NULL;
gdouble lower,
upper;
gtk_scale_clear_marks (GTK_SCALE (bar->priv->scale));
switch (bar->priv->btype) {
case BALANCE_TYPE_RL:
str_lower = g_strdup_printf ("<small>%s</small>", C_("balance", "Left"));
str_upper = g_strdup_printf ("<small>%s</small>", C_("balance", "Right"));
break;
case BALANCE_TYPE_FR:
str_lower = g_strdup_printf ("<small>%s</small>", C_("balance", "Rear"));
str_upper = g_strdup_printf ("<small>%s</small>", C_("balance", "Front"));
break;
case BALANCE_TYPE_LFE:
str_lower = g_strdup_printf ("<small>%s</small>", C_("balance", "Minimum"));
str_upper = g_strdup_printf ("<small>%s</small>", C_("balance", "Maximum"));
break;
}
lower = gtk_adjustment_get_lower (bar->priv->adjustment);
gtk_scale_add_mark (GTK_SCALE (bar->priv->scale),
lower,
GTK_POS_BOTTOM,
str_lower);
upper = gtk_adjustment_get_upper (bar->priv->adjustment);
gtk_scale_add_mark (GTK_SCALE (bar->priv->scale),
upper,
GTK_POS_BOTTOM,
str_upper);
g_free (str_lower);
g_free (str_upper);
if (bar->priv->btype != BALANCE_TYPE_LFE)
gtk_scale_add_mark (GTK_SCALE (bar->priv->scale),
(upper - lower) / 2 + lower,
GTK_POS_BOTTOM,
NULL);
}
static void
extra (GtkToggleButton *button)
{
gboolean value;
value = gtk_toggle_button_get_active (button);
if (value)
{
gtk_scale_add_mark (GTK_SCALE (extra_scale), extra_marks[0], GTK_POS_TOP, NULL);
gtk_scale_add_mark (GTK_SCALE (extra_scale), extra_marks[1], GTK_POS_TOP, NULL);
}
else
{
gtk_scale_clear_marks (GTK_SCALE (extra_scale));
gtk_scale_add_mark (GTK_SCALE (extra_scale), marks[0], GTK_POS_BOTTOM, NULL);
gtk_scale_add_mark (GTK_SCALE (extra_scale), marks[1], GTK_POS_BOTTOM, NULL);
gtk_scale_add_mark (GTK_SCALE (extra_scale), marks[2], GTK_POS_BOTTOM, NULL);
}
}
static void xhairs_length_add_marks (GtkScale *scale)
{
gint length, quarter_length;
GtkAdjustment *scale_model;
/* Get maximum dimension of screen */
length = MAX(gdk_screen_width(), gdk_screen_height());
scale_model = gtk_range_get_adjustment (GTK_RANGE (scale));
if (length < gtk_adjustment_get_upper(scale_model))
{
gtk_adjustment_set_upper (scale_model, length);
}
/* The crosshair is made up of four lines in pairs (top, bottom) and
(left, right). Stipulating: "quarter of the screen" means that the
length of one hair is 25% of the screen. */
quarter_length = length / 4;
gtk_scale_add_mark (scale, 0, GTK_POS_BOTTOM, C_("Distance", "Short"));
gtk_scale_add_mark (scale, quarter_length, GTK_POS_BOTTOM, C_("Distance", "¼ Screen"));
gtk_scale_add_mark (scale, quarter_length * 2 , GTK_POS_BOTTOM, C_("Distance", "½ Screen"));
gtk_scale_add_mark (scale, quarter_length * 3, GTK_POS_BOTTOM, C_("Distance", "¾ Screen"));
gtk_scale_add_mark (scale, length, GTK_POS_BOTTOM, C_("Distance", "Long"));
}
void gSlider::updateMark()
{
int i;
int step;
if (!_mark)
return;
gtk_scale_clear_marks(GTK_SCALE(widget));
step = _page_step;
while (step < ((_max - _min) / 20))
step *= 2;
for (i = _min; i <= _max; i += step)
gtk_scale_add_mark(GTK_SCALE(widget), i, isVertical() ? GTK_POS_TOP : GTK_POS_RIGHT, NULL);
}
static void widget_hscale_input_by_items(variable *var)
{
GList *element;
gchar *text;
gdouble value;
gint position, count;
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Entering.\n", __func__);
#endif
#if GTK_CHECK_VERSION(2,16,0)
g_assert(var->Attributes != NULL && var->Widget != NULL);
text = attributeset_get_first(&element, var->Attributes, ATTR_ITEM);
while (text) {
/* sscanf is good for the first two values */
if (sscanf(text, "%lf | %d", &value, &position) == 2) {
/* Now we'll position on the markup or the terminating zero */
count = 0;
while (*text != 0 && count < 2) {
if (*text == '|') count++;
text++;
}
#ifdef DEBUG_CONTENT
printf("%s: value=%.16f position=%i markup='%s'\n",
__func__, value, position, text);
#endif
gtk_scale_add_mark(GTK_SCALE(var->Widget), value, position, text);
}
text = attributeset_get_next(&element, var->Attributes, ATTR_ITEM);
}
#endif
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
}
static void
init_effects_slider (GtkRange *slider,
ZoomOptionsPrivate *priv,
gchar **keys,
GCallback notify_cb)
{
gchar **key;
gchar *signal;
g_object_set_data (G_OBJECT (slider), "settings-keys", keys);
effects_slider_set_value (slider, priv->settings);
for (key = keys; *key; key++)
{
signal = g_strdup_printf ("changed::%s", *key);
g_signal_connect (G_OBJECT (priv->settings), signal, notify_cb, priv);
g_free (signal);
}
g_signal_connect (G_OBJECT (slider), "value-changed",
G_CALLBACK (effects_slider_changed),
priv);
gtk_scale_add_mark (GTK_SCALE (slider), 0, GTK_POS_BOTTOM, NULL);
}
void Scale::addMark(double val, PositionType pos, std::string text)
{
GtkPositionType p;
switch(pos) {
case POS_LEFT:
p = GTK_POS_LEFT;
break;
case POS_RIGHT:
p = GTK_POS_RIGHT;
break;
case POS_TOP:
p = GTK_POS_TOP;
break;
case POS_BOTTOM:
p = GTK_POS_BOTTOM;
break;
default:
fprintf(stderr, "PositionType is incorrect\n");
p = GTK_POS_LEFT; // TODO: Error cond.
}
gtk_scale_add_mark(GTK_SCALE(widget), val, p, text.c_str());
}
static void
zoom_options_init (ZoomOptions *self)
{
ZoomOptionsPrivate *priv;
GtkWidget *w;
PangoAttrList *pango_attrs;
PangoAttribute *attr;
GError *err = NULL;
priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, ZOOM_TYPE_OPTIONS, ZoomOptionsPrivate);
priv->builder = gtk_builder_new ();
gtk_builder_set_translation_domain (priv->builder, GETTEXT_PACKAGE);
gtk_builder_add_from_file (priv->builder,
SAGARMATHACC_UI_DIR "/zoom-options.ui",
&err);
if (err)
{
g_warning ("Could not load interface file: %s", err->message);
g_error_free (err);
g_object_unref (priv->builder);
priv->builder = NULL;
return;
}
priv->settings = g_settings_new ("org.sagarmatha.desktop.a11y.magnifier");
priv->application_settings = g_settings_new ("org.sagarmatha.desktop.a11y.applications");
pango_attrs = pango_attr_list_new ();
attr = pango_attr_scale_new (FONT_SCALE);
pango_attr_list_insert (pango_attrs, attr);
/* Zoom switch */
g_settings_bind (priv->application_settings, "screen-magnifier-enabled",
WID ("seeing_zoom_switch"), "active",
G_SETTINGS_BIND_DEFAULT);
/* Magnification factor */
w = WID ("magFactorSpinButton");
g_settings_bind (priv->settings, "mag-factor",
gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w)),
"value", G_SETTINGS_BIND_DEFAULT);
/* Screen position combo */
w = WID ("screen_position_combo_box");
screen_position_notify_cb (priv->settings, "screen-position", self);
g_signal_connect (G_OBJECT (priv->settings), "changed::screen-position",
G_CALLBACK (screen_position_notify_cb), self);
g_signal_connect (G_OBJECT (w), "changed",
G_CALLBACK (screen_position_combo_changed_cb), self);
/* Screen part section */
init_screen_part_section (priv, pango_attrs);
/* Cross hairs: show/hide ... */
w = WID ("xhairsEnabledSwitch");
g_settings_bind (priv->settings, "show-cross-hairs", w, "active",
G_SETTINGS_BIND_DEFAULT);
/* ... Cross hairs: color and opacity */
w = WID ("xHairsPicker");
init_xhairs_color_opacity (GTK_COLOR_BUTTON (w), priv->settings);
g_signal_connect (G_OBJECT (priv->settings), "changed::cross-hairs-color",
G_CALLBACK (xhairs_color_notify_cb), w);
g_signal_connect (G_OBJECT (priv->settings), "changed::cross-hairs-opacity",
G_CALLBACK (xhairs_opacity_notify_cb), w);
g_signal_connect (G_OBJECT (w), "color-set",
G_CALLBACK (xhairs_color_opacity_changed),
priv);
/* ... Cross hairs: thickness ... */
w = WID ("xHairsThicknessSlider");
g_settings_bind (priv->settings, "cross-hairs-thickness",
gtk_range_get_adjustment (GTK_RANGE (w)), "value",
G_SETTINGS_BIND_DEFAULT);
/* ... Cross hairs: clip ... */
w = WID ("xHairsClipCheckbox");
scale_label (GTK_BIN(w), pango_attrs);
g_settings_bind (priv->settings, "cross-hairs-clip", w, "active",
G_SETTINGS_BIND_INVERT_BOOLEAN);
/* ... Cross hairs: length ... */
w = WID ("xHairsLengthSlider");
xhairs_length_add_marks (GTK_SCALE (w));
g_settings_bind (priv->settings, "cross-hairs-length",
gtk_range_get_adjustment (GTK_RANGE (w)), "value",
G_SETTINGS_BIND_DEFAULT);
/* ... Color effects ... */
w = WID ("inverseEnabledSwitch");
g_settings_bind (priv->settings, "invert-lightness", w, "active",
G_SETTINGS_BIND_DEFAULT);
w = WID ("brightnessSlider");
priv->brightness_slider = w;
init_effects_slider (GTK_RANGE(w), priv, brightness_keys,
G_CALLBACK (brightness_slider_notify_cb));
w = WID ("contrastSlider");
priv->contrast_slider = w;
init_effects_slider (GTK_RANGE(w), priv, contrast_keys,
G_CALLBACK (contrast_slider_notify_cb));
w = WID ("grayscale_slider");
g_settings_bind (priv->settings, "color-saturation",
gtk_range_get_adjustment (GTK_RANGE (w)), "value",
G_SETTINGS_BIND_DEFAULT);
gtk_scale_add_mark (GTK_SCALE(w), 1.0, GTK_POS_BOTTOM, NULL);
/* ... Window itself ... */
priv->dialog = WID ("magPrefsDialog");
w = WID ("closeButton");
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (zoom_option_close_dialog_cb),
priv);
g_signal_connect (G_OBJECT (priv->dialog), "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete),
NULL);
pango_attr_list_unref (pango_attrs);
}
/**
* @brief GUI thread load UI File and create the GUI
*/
static gpointer
guiThread(gpointer data)
{
GtkBuilder *builder;
GtkWidget *window;
GError *error = NULL;
/* create new GtkBuilder object */
builder = gtk_builder_new ();
/* load UI from file. If error occurs, report it and quit application. */
if (!gtk_builder_add_from_file(builder, UI_FILE, &error)) {
g_warning("error loading glade file: %s", error->message);
g_free(error);
return NULL;
}
/*Get objects from UI */
window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
scale1 = GTK_WIDGET (gtk_builder_get_object (builder, "scale1"));
scale2 = GTK_WIDGET (gtk_builder_get_object (builder, "scale2"));
scale3 = GTK_WIDGET (gtk_builder_get_object (builder, "scale3"));
scale4 = GTK_WIDGET (gtk_builder_get_object (builder, "scale4"));
scale5 = GTK_WIDGET (gtk_builder_get_object (builder, "scale5"));
scale6 = GTK_WIDGET (gtk_builder_get_object (builder, "scale6"));
adjustment1 = GTK_ADJUSTMENT (gtk_builder_get_object (builder,
"adjustment1"));
adjustment2 = GTK_ADJUSTMENT (gtk_builder_get_object (builder,
"adjustment2"));
adjustment3 = GTK_ADJUSTMENT (gtk_builder_get_object (builder,
"adjustment3"));
adjustment4 = GTK_ADJUSTMENT (gtk_builder_get_object (builder,
"adjustment4"));
adjustment5 = GTK_ADJUSTMENT (gtk_builder_get_object (builder,
"adjustment5"));
adjustment6 = GTK_ADJUSTMENT (gtk_builder_get_object (builder,
"adjustment6"));
dialog_port = GTK_DIALOG (gtk_builder_get_object (builder,
"dialog1"));
dialog_about = GTK_DIALOG (gtk_builder_get_object (builder,
"aboutdialog1"));
dialog_file = GTK_DIALOG (gtk_builder_get_object (builder,
"filechooserdialog1"));
dialog_error = GTK_DIALOG (gtk_builder_get_object (builder,
"dialog_error"));
dialog_error_port = GTK_DIALOG (gtk_builder_get_object (builder,
"dialog_error_port"));
dialog_list = GTK_DIALOG (gtk_builder_get_object (builder,
"dialog_list"));
dialog_name_exists = GTK_DIALOG (gtk_builder_get_object (builder,
"dialog_name_exists"));
combobox1 = GTK_WIDGET (gtk_builder_get_object (builder, "comboboxtext1"));
combobox2 = GTK_WIDGET (gtk_builder_get_object (builder, "comboboxtext2"));
combobox3 = GTK_WIDGET (gtk_builder_get_object (builder, "comboboxtext3"));
combobox4 = GTK_WIDGET (gtk_builder_get_object (builder, "comboboxtext4"));
combobox5 = GTK_WIDGET (gtk_builder_get_object (builder, "comboboxtext5"));
bt_con_decon = GTK_WIDGET (gtk_builder_get_object (builder,
"bt_con_decon"));
button_save = GTK_WIDGET (gtk_builder_get_object (builder,
"bt_save_position"));
button_file = GTK_WIDGET (gtk_builder_get_object (builder,
"bt_file"));
bt_file_save = GTK_WIDGET (gtk_builder_get_object (builder,
"bt_file_save"));
image_connect = GTK_IMAGE (gtk_builder_get_object (builder,
"image_connect"));
entry_name_position = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_name_position"));
bt_ok_error_port = GTK_WIDGET (gtk_builder_get_object (builder,
"bt_ok_error_port"));
switch1 = GTK_WIDGET (gtk_builder_get_object (builder,
"switch1"));
bt_edit = GTK_WIDGET (gtk_builder_get_object (builder,
"bt_edit"));
bt_open_file = GTK_WIDGET (gtk_builder_get_object (builder,
"bt_open_file"));
treeview = GTK_TREE_VIEW (gtk_builder_get_object (builder, "treeview"));
model = GTK_LIST_STORE (gtk_builder_get_object (builder, "model"));
/*************************************************/
gtk_builder_connect_signals (builder, NULL);
g_object_unref (G_OBJECT (builder));
gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (app));
gtk_window_set_title (GTK_WINDOW (window), "Servo Calibration");
gtk_window_set_default_size (GTK_WINDOW (window), 700,530);
gtk_window_set_default_icon_from_file("../glade/img8.png", NULL);
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_window_set_transient_for (GTK_WINDOW (dialog_port),
GTK_WINDOW (window));
gtk_window_set_transient_for (GTK_WINDOW (dialog_about),
GTK_WINDOW (window));
gtk_window_set_transient_for (GTK_WINDOW (dialog_file),
GTK_WINDOW (window));
gtk_window_set_transient_for (GTK_WINDOW (dialog_error),
GTK_WINDOW (window));
gtk_window_set_transient_for (GTK_WINDOW (dialog_error_port),
GTK_WINDOW (window));
gtk_window_set_transient_for (GTK_WINDOW (dialog_list),
GTK_WINDOW (window));
gtk_window_set_transient_for (GTK_WINDOW (dialog_name_exists),
GTK_WINDOW (window));
gtk_scale_add_mark (GTK_SCALE(scale1), 0, GTK_POS_LEFT ,"0°");
gtk_scale_add_mark (GTK_SCALE(scale2), 0, GTK_POS_LEFT ,"0°");
gtk_scale_add_mark (GTK_SCALE(scale3), 0, GTK_POS_LEFT ,"0°");
gtk_scale_add_mark (GTK_SCALE(scale4), 0, GTK_POS_LEFT ,"0°");
gtk_scale_add_mark (GTK_SCALE(scale5), 0, GTK_POS_LEFT ,"0°");
gtk_scale_add_mark (GTK_SCALE(scale6), 0, GTK_POS_LEFT ,"0°");
gtk_widget_set_sensitive (GTK_WIDGET(entry_name_position), FALSE);
gtk_widget_set_sensitive (GTK_WIDGET(button_save), FALSE);
gtk_widget_set_sensitive (GTK_WIDGET(switch1), FALSE);
gtk_widget_set_sensitive (GTK_WIDGET(bt_edit), FALSE);
gtk_widget_show_all(GTK_WIDGET(window));
gtk_main();
return NULL;
}
int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *box2;
GtkWidget *frame;
GtkWidget *scale;
GtkWidget *toggle;
gdouble marks[3] = { 0.0, 50.0, 100.0 };
const gchar *labels[3] = {
"<small>Left</small>",
"<small>Middle</small>",
"<small>Right</small>"
};
gdouble bath_marks[4] = { 0.0, 33.3, 66.6, 100.0 };
const gchar *bath_labels[4] = {
"<span color='blue' size='small'>Cold</span>",
"<span size='small'>Baby bath</span>",
"<span size='small'>Hot tub</span>",
"<span color='Red' size='small'>Hot</span>"
};
gdouble pos_marks[4] = { 0.0, 33.3, 66.6, 100.0 };
const gchar *pos_labels[4] = { "Left", "Right", "Top", "Bottom" };
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Ranges with marks");
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
frame = gtk_frame_new ("No marks");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Simple marks");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_BOTTOM, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_BOTTOM, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_BOTTOM, NULL);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Labeled marks");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_BOTTOM, labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_BOTTOM, labels[1]);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_BOTTOM, labels[2]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Some labels");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_BOTTOM, labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_BOTTOM, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_BOTTOM, labels[2]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Above and below");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[0], GTK_POS_TOP, bath_labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[1], GTK_POS_BOTTOM, bath_labels[1]);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[2], GTK_POS_BOTTOM, bath_labels[2]);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[3], GTK_POS_TOP, bath_labels[3]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Positions");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[0], GTK_POS_LEFT, pos_labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[1], GTK_POS_RIGHT, pos_labels[1]);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[2], GTK_POS_TOP, pos_labels[2]);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[3], GTK_POS_BOTTOM, pos_labels[3]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Show/hide trough");
box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
0, 100, 1);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
toggle = gtk_toggle_button_new_with_label ("Show slider trough");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), TRUE);
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (show_trough_toggled), scale);
gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (frame), box2);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start (GTK_BOX (box), box2, TRUE, TRUE, 0);
frame = gtk_frame_new ("No marks");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box2), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Simple marks");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_LEFT, NULL);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box2), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Labeled marks");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_LEFT, labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_LEFT, labels[1]);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_LEFT, labels[2]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box2), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Some labels");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_LEFT, labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_LEFT, labels[2]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box2), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Right and left");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[0], GTK_POS_RIGHT, bath_labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[1], GTK_POS_LEFT, bath_labels[1]);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[2], GTK_POS_LEFT, bath_labels[2]);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[3], GTK_POS_RIGHT, bath_labels[3]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box2), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Positions");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[0], GTK_POS_LEFT, pos_labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[1], GTK_POS_RIGHT, pos_labels[1]);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[2], GTK_POS_TOP, pos_labels[2]);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[3], GTK_POS_BOTTOM, pos_labels[3]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box2), frame, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
/**
* bt_volume_popup_new:
* @adj: the adjustment for the popup
*
* Create a new instance
*
* Returns: the new instance or %NULL in case of an error
*/
GtkWidget *
bt_volume_popup_new (GtkAdjustment * adj)
{
GtkWidget *box, *scale, *frame, *label;
BtVolumePopup *self = g_object_new (BT_TYPE_VOLUME_POPUP,
"can-focus", TRUE,
"type", GTK_WINDOW_POPUP,
NULL);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box),
gtk_separator_new (GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj);
self->scale = GTK_RANGE (scale);
gtk_widget_set_size_request (scale, -1, 200);
// FIXME(ensonic): workaround for https://bugzilla.gnome.org/show_bug.cgi?id=667598
//gtk_range_set_inverted(self->scale, TRUE);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
#if 0
gtk_scale_add_mark (GTK_SCALE (scale), 0.0, GTK_POS_LEFT,
"<small>0 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 25.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 50.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 75.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 100.0, GTK_POS_LEFT,
"<small>100 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 150.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 200.0, GTK_POS_LEFT,
"<small>200 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 250.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 300.0, GTK_POS_LEFT,
"<small>300 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 350.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0, GTK_POS_LEFT,
"<small>400 %</small>");
#else
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 0.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 25.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 50.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 75.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 100.0, GTK_POS_LEFT,
"<small>100 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 150.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 200.0, GTK_POS_LEFT,
"<small>200 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 250.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 300.0, GTK_POS_LEFT,
"<small>300 %</small>");
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 350.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 400.0 - 400.0, GTK_POS_LEFT,
"<small>400 %</small>");
#endif
g_signal_connect (self->scale, "value-changed", G_CALLBACK (cb_scale_changed),
label);
cb_scale_changed (self->scale, label);
gtk_box_pack_start (GTK_BOX (box), scale, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (frame), box);
gtk_container_add (GTK_CONTAINER (self), frame);
gtk_widget_show_all (frame);
g_signal_connect (self, "button-press-event", G_CALLBACK (cb_dock_press),
self);
return GTK_WIDGET (self);
}
GtkWidget *
scale_create_widget (GtkWidget *dlg)
{
GtkWidget *w;
GtkObject *adj;
gint page;
if (options.scale_data.min_value >= options.scale_data.max_value)
{
g_printerr (_("Maximum value must be greater than minimum value.\n"));
return NULL;
}
/* check for initial value */
if (options.scale_data.have_value)
{
if (options.scale_data.value < options.scale_data.min_value)
{
g_printerr (_("Initial value less than minimal.\n"));
options.scale_data.value = options.scale_data.min_value;
}
else if (options.scale_data.value > options.scale_data.max_value)
{
g_printerr (_("Initial value greater than maximum.\n"));
options.scale_data.value = options.scale_data.max_value;
}
}
else
options.scale_data.value = options.scale_data.min_value;
page = options.scale_data.page == -1 ? options.scale_data.step * 10 : options.scale_data.page;
adj = gtk_adjustment_new ((double) options.scale_data.value,
(double) options.scale_data.min_value,
(double) options.scale_data.max_value,
(double) options.scale_data.step,
(double) page, 0.0);
if (options.scale_data.vertical)
{
w = scale = gtk_vscale_new (GTK_ADJUSTMENT (adj));
gtk_widget_set_name (w, "yad-vscale-widget");
gtk_range_set_inverted (GTK_RANGE (w), !options.scale_data.invert);
}
else
{
w = scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));
gtk_widget_set_name (w, "yad-hscale-widget");
gtk_range_set_inverted (GTK_RANGE (w), options.scale_data.invert);
}
gtk_scale_set_digits (GTK_SCALE (w), 0);
if (options.scale_data.print_partial)
g_signal_connect (G_OBJECT (w), "value-changed",
G_CALLBACK (value_changed_cb), NULL);
if (options.scale_data.hide_value)
gtk_scale_set_draw_value (GTK_SCALE (w), FALSE);
/* add marks */
if (options.scale_data.marks)
{
GtkPositionType pos;
GSList *m = options.scale_data.marks;
pos = options.scale_data.vertical ? GTK_POS_LEFT : GTK_POS_BOTTOM;
for (; m; m = m->next)
{
YadScaleMark *mark = (YadScaleMark *) m->data;
gtk_scale_add_mark (GTK_SCALE (w), mark->value, pos, mark->name);
}
}
return w;
}
/****************************************************************
Create rates dialog
*****************************************************************/
static GtkWidget *create_rates_dialog(void)
{
GtkWidget *shell, *content;
GtkWidget *frame, *hgrid;
int i;
if (!can_client_issue_orders()) {
return NULL;
}
shell = gtk_dialog_new_with_buttons(_("Select tax, luxury and science rates"),
NULL,
0,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
setup_dialog(shell, toplevel);
gtk_dialog_set_default_response(GTK_DIALOG(shell), GTK_RESPONSE_OK);
gtk_window_set_position(GTK_WINDOW(shell), GTK_WIN_POS_MOUSE);
content = gtk_dialog_get_content_area(GTK_DIALOG(shell));
rates_gov_label = gtk_label_new("");
gtk_box_pack_start( GTK_BOX( content ), rates_gov_label, TRUE, TRUE, 5 );
frame = gtk_frame_new( _("Tax") );
gtk_box_pack_start( GTK_BOX( content ), frame, TRUE, TRUE, 5 );
hgrid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(hgrid), 10);
gtk_container_add(GTK_CONTAINER(frame), hgrid);
rates_tax_scale =
gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0, 10, 1);
gtk_range_set_increments(GTK_RANGE(rates_tax_scale), 1, 1);
for (i = 0; i <= 10; i++) {
gtk_scale_add_mark(GTK_SCALE(rates_tax_scale), i, GTK_POS_TOP, NULL);
}
gtk_widget_set_size_request(rates_tax_scale, 300, 40);
gtk_scale_set_digits(GTK_SCALE(rates_tax_scale), 0);
gtk_scale_set_draw_value(GTK_SCALE(rates_tax_scale), FALSE);
gtk_container_add(GTK_CONTAINER(hgrid), rates_tax_scale);
rates_tax_label = gtk_label_new(" 0%");
gtk_container_add(GTK_CONTAINER(hgrid), rates_tax_label);
gtk_widget_set_size_request(rates_tax_label, 40, -1);
rates_tax_toggle = gtk_check_button_new_with_label( _("Lock") );
gtk_container_add(GTK_CONTAINER(hgrid), rates_tax_toggle);
frame = gtk_frame_new( _("Luxury") );
gtk_box_pack_start( GTK_BOX( content ), frame, TRUE, TRUE, 5 );
hgrid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(hgrid), 10);
gtk_container_add(GTK_CONTAINER(frame), hgrid);
rates_lux_scale =
gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0, 10, 1);
gtk_range_set_increments(GTK_RANGE(rates_lux_scale), 1, 1);
for (i = 0; i <= 10; i++) {
gtk_scale_add_mark(GTK_SCALE(rates_lux_scale), i, GTK_POS_TOP, NULL);
}
gtk_widget_set_size_request(rates_lux_scale, 300, 40);
gtk_scale_set_digits(GTK_SCALE(rates_lux_scale), 0);
gtk_scale_set_draw_value(GTK_SCALE(rates_lux_scale), FALSE);
gtk_container_add(GTK_CONTAINER(hgrid), rates_lux_scale);
rates_lux_label = gtk_label_new(" 0%");
gtk_container_add(GTK_CONTAINER(hgrid), rates_lux_label);
gtk_widget_set_size_request(rates_lux_label, 40, -1);
rates_lux_toggle = gtk_check_button_new_with_label( _("Lock") );
gtk_container_add(GTK_CONTAINER(hgrid), rates_lux_toggle);
frame = gtk_frame_new( _("Science") );
gtk_box_pack_start( GTK_BOX( content ), frame, TRUE, TRUE, 5 );
hgrid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(hgrid), 10);
gtk_container_add(GTK_CONTAINER(frame), hgrid);
rates_sci_scale =
gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0, 10, 1);
gtk_range_set_increments(GTK_RANGE(rates_sci_scale), 1, 1);
for (i = 0; i <= 10; i++) {
gtk_scale_add_mark(GTK_SCALE(rates_sci_scale), i, GTK_POS_TOP, NULL);
}
gtk_widget_set_size_request(rates_sci_scale, 300, 40);
gtk_scale_set_digits(GTK_SCALE(rates_sci_scale), 0);
gtk_scale_set_draw_value(GTK_SCALE(rates_sci_scale), FALSE);
gtk_container_add(GTK_CONTAINER(hgrid), rates_sci_scale);
rates_sci_label = gtk_label_new(" 0%");
gtk_container_add(GTK_CONTAINER(hgrid), rates_sci_label);
gtk_widget_set_size_request(rates_sci_label, 40, -1);
rates_sci_toggle = gtk_check_button_new_with_label( _("Lock") );
gtk_container_add(GTK_CONTAINER(hgrid), rates_sci_toggle);
g_signal_connect(shell, "response",
G_CALLBACK(rates_command_callback), NULL);
g_signal_connect(shell, "destroy",
G_CALLBACK(gtk_widget_destroyed), &rates_dialog_shell);
gtk_widget_show_all(content);
gtk_widget_show_all(gtk_dialog_get_action_area(GTK_DIALOG(shell)));
rates_tax_value=-1;
rates_lux_value=-1;
rates_sci_value=-1;
rates_tax_sig =
g_signal_connect_after(rates_tax_scale, "value-changed",
G_CALLBACK(rates_changed_callback), NULL);
rates_lux_sig =
g_signal_connect_after(rates_lux_scale, "value-changed",
G_CALLBACK(rates_changed_callback), NULL);
rates_sci_sig =
g_signal_connect_after(rates_sci_scale, "value-changed",
G_CALLBACK(rates_changed_callback), NULL);
rates_set_values(client.conn.playing->economic.tax, 0,
client.conn.playing->economic.luxury, 0,
client.conn.playing->economic.science, 0);
return shell;
}
static void
gst_switch_ptz_init (GstSwitchPTZ * ptz)
{
GtkWidget *box_main, *box_video, *box_control;
GtkWidget *box_control_pan, *box_control_tilt, *box_control_zoom;
GtkWidget *scale_pan, *scale_tilt, *control_grid, *box_buttons_tilt;
GtkWidget *control_buttons[3][3] = { {NULL} };
GtkWidget *box_zoom, *zoom_minus, *zoom_reset, *zoom_plus;
GtkWidget *scrollwin;
GtkWidget *scale_zoom;
GtkWidget *scale_pan_speed, *scale_tilt_speed, *scale_zoom_speed;
GtkWidget *label_pan_speed, *label_tilt_speed, *label_zoom_speed;
GtkWidget *label;
const gchar *control_labels[3][3] = {
/*
{" \\ ", " ^ ", " / "},
{" < ", " * ", " > "},
{" / ", " v ", " \\ "},
*/
/*
{ " \\ ", GTK_STOCK_GO_UP, " / " },
{ GTK_STOCK_GO_BACK, GTK_STOCK_HOME, GTK_STOCK_GO_FORWARD },
{ " / ", GTK_STOCK_GO_DOWN, " \\ " },
*/
{"icons/up_left.png", "icons/up.png", "icons/up_right.png"},
{"icons/left.png", "icons/center.png", "icons/right.png"},
{"icons/down_left.png", "icons/down.png", "icons/down_right.png"},
};
int n, m;
const char *title = NULL;
ptz->controller = gst_cam_controller_new (ptz_control_protocol);
if (ptz->controller == NULL) {
return;
}
gst_cam_controller_open (ptz->controller, ptz_device_name);
title = ptz->controller->device_info;
if (title == NULL)
title = "??? - PTZ Controller";
ptz->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (ptz->window), 640, 480);
gtk_window_set_title (GTK_WINDOW (ptz->window), title);
g_signal_connect (G_OBJECT (ptz->window), "delete-event",
G_CALLBACK (gst_switch_ptz_window_closed), ptz);
box_main = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
box_video = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
box_control = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrollwin, 200, -1);
gtk_widget_set_vexpand (scrollwin, TRUE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrollwin),
box_control);
gtk_box_pack_start (GTK_BOX (box_main), box_video, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_main), scrollwin, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (ptz->window), box_main);
gtk_container_set_border_width (GTK_CONTAINER (ptz->window), 5);
ptz->video_view = gtk_drawing_area_new ();
gtk_widget_set_name (ptz->video_view, "video");
gtk_widget_set_double_buffered (ptz->video_view, FALSE);
gtk_widget_set_hexpand (ptz->video_view, TRUE);
gtk_widget_set_vexpand (ptz->video_view, TRUE);
gtk_widget_set_events (ptz->video_view, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
gtk_box_pack_start (GTK_BOX (box_video), ptz->video_view, TRUE, TRUE, 0);
scale_pan =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
ptz->controller->pan_min, ptz->controller->pan_max, 1.0);
scale_tilt =
gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
ptz->controller->tilt_min, ptz->controller->tilt_max, 1.0);
//gtk_range_set_slider_size_fixed (GTK_RANGE (scale_pan), TRUE);
gtk_widget_set_size_request (scale_pan, 300, -1);
gtk_scale_set_value_pos (GTK_SCALE (scale_pan), GTK_POS_RIGHT);
gtk_scale_set_value_pos (GTK_SCALE (scale_tilt), GTK_POS_BOTTOM);
gtk_range_set_inverted (GTK_RANGE (scale_tilt), TRUE);
ptz->adjust_pan = gtk_range_get_adjustment (GTK_RANGE (scale_pan));
ptz->adjust_tilt = gtk_range_get_adjustment (GTK_RANGE (scale_tilt));
g_signal_connect (gtk_range_get_adjustment (GTK_RANGE (scale_pan)),
"value-changed", G_CALLBACK (gst_switch_ptz_pan_changed), ptz);
g_signal_connect (gtk_range_get_adjustment (GTK_RANGE (scale_tilt)),
"value-changed", G_CALLBACK (gst_switch_ptz_tilt_changed), ptz);
control_grid = gtk_grid_new ();
gtk_grid_insert_row (GTK_GRID (control_grid), 0);
gtk_grid_insert_row (GTK_GRID (control_grid), 1);
gtk_grid_insert_row (GTK_GRID (control_grid), 2);
gtk_grid_insert_column (GTK_GRID (control_grid), 0);
gtk_grid_insert_column (GTK_GRID (control_grid), 1);
gtk_grid_insert_column (GTK_GRID (control_grid), 2);
for (n = 0; n < 3; ++n) {
for (m = 0; m < 3; ++m) {
GtkWidget *btn = control_buttons[m][n] = gtk_button_new ();
gtk_grid_attach (GTK_GRID (control_grid), btn, n, m, 1, 1);
gtk_widget_set_size_request (btn, 70, 70);
gtk_button_set_image (GTK_BUTTON (btn),
gtk_image_new_from_file (control_labels[m][n]));
}
}
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), "<b>Pan/Tilt:</b>");
box_buttons_tilt = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (box_control), label, TRUE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_control), scale_pan, FALSE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_buttons_tilt), scale_tilt, FALSE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_buttons_tilt), control_grid, FALSE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control), box_buttons_tilt, FALSE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_control), gtk_label_new (""), TRUE, TRUE,
10);
box_zoom = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
zoom_minus = gtk_button_new ();
zoom_reset = gtk_button_new ();
zoom_plus = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (zoom_minus),
gtk_image_new_from_file ("icons/zoom_out.png"));
gtk_button_set_image (GTK_BUTTON (zoom_reset),
gtk_image_new_from_file ("icons/zoom.png"));
gtk_button_set_image (GTK_BUTTON (zoom_plus),
gtk_image_new_from_file ("icons/zoom_in.png"));
gtk_widget_set_size_request (zoom_minus, 70, 70);
gtk_widget_set_size_request (zoom_reset, 70, 70);
gtk_widget_set_size_request (zoom_plus, 70, 70);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), "<b>Zoom:</b>");
gtk_box_pack_start (GTK_BOX (box_control), label, TRUE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_zoom), gtk_label_new (""), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_zoom), zoom_minus, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_zoom), zoom_reset, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_zoom), zoom_plus, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_zoom), gtk_label_new (""), TRUE, TRUE, 10);
scale_zoom =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 1.0, 0.01);
gtk_range_set_value (GTK_RANGE (scale_zoom), 0.5);
ptz->adjust_zoom = gtk_range_get_adjustment (GTK_RANGE (scale_zoom));
label = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (label), scale_zoom, TRUE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box_control), label, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (box_control), box_zoom, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (box_control), gtk_label_new (""), TRUE, TRUE,
10);
g_signal_connect (zoom_minus, "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_zoom_minus), ptz);
g_signal_connect (zoom_reset, "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_zoom_reset), ptz);
g_signal_connect (zoom_plus, "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_zoom_plus), ptz);
g_signal_connect (zoom_minus, "released",
G_CALLBACK (gst_switch_ptz_button_released_zoom_minus), ptz);
g_signal_connect (zoom_plus, "released",
G_CALLBACK (gst_switch_ptz_button_released_zoom_plus), ptz);
scale_pan_speed =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
ptz->controller->pan_speed_min, ptz->controller->pan_speed_max, 1.0);
scale_tilt_speed =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
ptz->controller->tilt_speed_min, ptz->controller->tilt_speed_max, 1.0);
scale_zoom_speed =
gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 1.0, 0.01);
gtk_range_set_value (GTK_RANGE (scale_pan_speed),
ptz->controller->pan_speed_max);
gtk_range_set_value (GTK_RANGE (scale_tilt_speed),
ptz->controller->tilt_speed_max);
gtk_range_set_value (GTK_RANGE (scale_zoom_speed), 1.0);
ptz->adjust_pan_speed =
gtk_range_get_adjustment (GTK_RANGE (scale_pan_speed));
ptz->adjust_tilt_speed =
gtk_range_get_adjustment (GTK_RANGE (scale_tilt_speed));
ptz->adjust_zoom_speed =
gtk_range_get_adjustment (GTK_RANGE (scale_zoom_speed));
label_pan_speed = gtk_label_new ("");
label_tilt_speed = gtk_label_new ("");
label_zoom_speed = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label_pan_speed), "<b>P:</b>");
gtk_label_set_markup (GTK_LABEL (label_tilt_speed), "<b>T:</b>");
gtk_label_set_markup (GTK_LABEL (label_zoom_speed), "<b>Z:</b>");
box_control_pan = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box_control_tilt = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box_control_zoom = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), "<b>Speeds:</b>");
gtk_box_pack_start (GTK_BOX (box_control), label, FALSE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_control_pan), label_pan_speed, FALSE, FALSE,
0);
gtk_box_pack_start (GTK_BOX (box_control_pan), scale_pan_speed, TRUE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control_tilt), label_tilt_speed, FALSE,
FALSE, 0);
gtk_box_pack_start (GTK_BOX (box_control_tilt), scale_tilt_speed, TRUE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control_zoom), label_zoom_speed, FALSE,
FALSE, 0);
gtk_box_pack_start (GTK_BOX (box_control_zoom), scale_zoom_speed, TRUE, TRUE,
10);
gtk_box_pack_start (GTK_BOX (box_control), box_control_pan, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_control), box_control_tilt, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_control), box_control_zoom, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box_control), gtk_label_new (""), TRUE, TRUE,
10);
{
double v, tick = 50;
gchar *s;
gchar buf[64] = { 0 };
int n;
const gchar *fmt = "<small><sub>%d</sub></small>";
const gchar *fmtb = "<small><sub><b>%d</b></sub></small>";
g_sprintf ((s = buf), fmtb, 0);
gtk_scale_add_mark (GTK_SCALE (scale_pan), 0, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->pan_min);
gtk_scale_add_mark (GTK_SCALE (scale_pan), ptz->controller->pan_min,
GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->pan_max);
gtk_scale_add_mark (GTK_SCALE (scale_pan), ptz->controller->pan_max,
GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, 0);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), 0, GTK_POS_RIGHT, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->tilt_min);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), ptz->controller->tilt_min,
GTK_POS_RIGHT, s);
g_sprintf ((s = buf), fmtb, (int) ptz->controller->tilt_max);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), ptz->controller->tilt_max,
GTK_POS_RIGHT, s);
for (v = -tick; ptz->controller->pan_min <= v; v -= tick) {
if (v - ptz->controller->pan_min < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_pan), v, GTK_POS_BOTTOM, s);
}
for (v = tick; v <= ptz->controller->pan_max; v += tick) {
if (ptz->controller->pan_max - v < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_pan), v, GTK_POS_BOTTOM, s);
}
for (v = -tick; ptz->controller->tilt_min <= v; v -= tick) {
if (v - ptz->controller->tilt_min < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), v, GTK_POS_RIGHT, s);
}
for (v = tick; v <= ptz->controller->tilt_max; v += tick) {
if (ptz->controller->tilt_max - v < 1)
continue;
n = (int) v;
s = NULL;
if (abs (n) % 50 == 0)
g_sprintf ((s = buf), fmt, n);
gtk_scale_add_mark (GTK_SCALE (scale_tilt), v, GTK_POS_RIGHT, s);
}
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->pan_speed_min + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_pan_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->pan_speed_max + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_pan_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
(ptz->controller->pan_speed_max -
ptz->controller->pan_speed_min) / 2 + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_pan_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->tilt_speed_min + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_tilt_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
ptz->controller->tilt_speed_max + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_tilt_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (int) (v =
(ptz->controller->tilt_speed_max -
ptz->controller->tilt_speed_min) / 2 + 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_tilt_speed), v, GTK_POS_BOTTOM, s);
fmtb = "<small><sub><b>%.1f</b></sub></small>";
g_sprintf ((s = buf), fmtb, (v = 0.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 1.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_zoom_speed), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 0.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 1.0));
gtk_scale_add_mark (GTK_SCALE (scale_zoom), v, GTK_POS_BOTTOM, s);
g_sprintf ((s = buf), fmtb, (v = 0.5));
gtk_scale_add_mark (GTK_SCALE (scale_zoom), v, GTK_POS_BOTTOM, s);
}
if (strcmp (ptz_control_protocol, "visca-sony") == 0) {
gtk_widget_set_sensitive (box_control_pan, FALSE);
gtk_widget_set_sensitive (box_control_tilt, FALSE);
gtk_widget_set_sensitive (box_control_zoom, FALSE);
}
/*
g_signal_connect (G_OBJECT (scale_pan_speed), "value-changed",
G_CALLBACK (gst_switch_ptz_window_closed), ptz);
*/
g_signal_connect (ptz->adjust_pan_speed, "value-changed",
G_CALLBACK (gst_switch_ptz_pan_speed_changed), ptz);
g_signal_connect (ptz->adjust_tilt_speed, "value-changed",
G_CALLBACK (gst_switch_ptz_tilt_speed_changed), ptz);
g_signal_connect (ptz->adjust_zoom_speed, "value-changed",
G_CALLBACK (gst_switch_ptz_zoom_speed_changed), ptz);
g_signal_connect (ptz->adjust_zoom, "value-changed",
G_CALLBACK (gst_switch_ptz_zoom_changed), ptz);
g_signal_connect (control_buttons[0][0], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_left_top), ptz);
g_signal_connect (control_buttons[0][1], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_top), ptz);
g_signal_connect (control_buttons[0][2], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_top_right), ptz);
g_signal_connect (control_buttons[1][0], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_left), ptz);
g_signal_connect (control_buttons[1][1], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_center), ptz);
g_signal_connect (control_buttons[1][2], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_right), ptz);
g_signal_connect (control_buttons[2][0], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_bottom_left), ptz);
g_signal_connect (control_buttons[2][1], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_bottom), ptz);
g_signal_connect (control_buttons[2][2], "pressed",
G_CALLBACK (gst_switch_ptz_button_pressed_right_bottom), ptz);
g_signal_connect (control_buttons[0][0], "released",
G_CALLBACK (gst_switch_ptz_button_released_left_top), ptz);
g_signal_connect (control_buttons[0][1], "released",
G_CALLBACK (gst_switch_ptz_button_released_top), ptz);
g_signal_connect (control_buttons[0][2], "released",
G_CALLBACK (gst_switch_ptz_button_released_top_right), ptz);
g_signal_connect (control_buttons[1][0], "released",
G_CALLBACK (gst_switch_ptz_button_released_left), ptz);
g_signal_connect (control_buttons[1][2], "released",
G_CALLBACK (gst_switch_ptz_button_released_right), ptz);
g_signal_connect (control_buttons[2][0], "released",
G_CALLBACK (gst_switch_ptz_button_released_bottom_left), ptz);
g_signal_connect (control_buttons[2][1], "released",
G_CALLBACK (gst_switch_ptz_button_released_bottom), ptz);
g_signal_connect (control_buttons[2][2], "released",
G_CALLBACK (gst_switch_ptz_button_released_right_bottom), ptz);
do_update = TRUE;
gst_switch_ptz_update_xy (ptz);
do_update = FALSE;
g_timeout_add (300, (GSourceFunc) gst_switch_ptz_update, ptz);
g_timeout_add (100, (GSourceFunc) gst_switch_ptz_update_xy, ptz);
//g_timeout_add (50, (GSourceFunc) gst_switch_ptz_update_d, ptz);
}
int main(int argc, char *argv[]){
/* global variables to be reused */
unsigned int uint = 0;
/* Declare all widgets here */
GtkWidget * window;
GtkWidget * notebook;
GtkWidget * spacer; /* this is a spacer for grid */
GtkWidget * page_volume_label;
GtkWidget * page_volume_grid;
GtkWidget * page_volume_scale;
GtkWidget * page_volume_scale_label;
GtkWidget * page_volume_mute_toggle;
GtkWidget * page_browser_label;
GtkWidget * page_browser_grid;
GtkWidget * page_browser_button;
//GtkWidget * page_browser_pid_label;
gtk_init(&argc, &argv);
/* Create a new window. This is the parent window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (window), "Control Panel");
gtk_window_set_default_size(GTK_WINDOW (window), 200, 300);
/* Create spacer */
spacer = gtk_label_new(" ");
/* Create a new notebook */
notebook = gtk_notebook_new();
gtk_container_add(GTK_CONTAINER (window), notebook);
/* Page VOLUME config */
/* label */
page_volume_label = gtk_label_new("Volume Settings");
/* volume scale */
page_volume_scale = gtk_scale_new_with_range(GTK_ORIENTATION_VERTICAL,0,100,1);
gtk_range_set_inverted(GTK_RANGE (page_volume_scale), TRUE);
gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 0, GTK_POS_RIGHT, "0");
gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 25, GTK_POS_RIGHT, "25");
gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 50, GTK_POS_RIGHT, "50");
gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 75, GTK_POS_RIGHT, "75");
gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 100, GTK_POS_RIGHT, "100");
gtk_scale_set_draw_value(GTK_SCALE (page_volume_scale), 1);
initializeVolumeScale(page_volume_scale);
/* scale label, Master */
page_volume_scale_label = gtk_label_new("Master");
/* checkbox for mute option */
page_volume_mute_toggle = gtk_toggle_button_new_with_label("Mute / Unmute");
/* page grid for layout */
page_volume_grid = gtk_grid_new();
gtk_grid_attach(GTK_GRID (page_volume_grid), spacer, 0, 0, 5, 20);
gtk_grid_attach(GTK_GRID (page_volume_grid), page_volume_scale_label, 4, 5, 10, 5);
gtk_grid_attach(GTK_GRID (page_volume_grid), page_volume_scale, 5, 20, 10, 30);
gtk_widget_set_hexpand(page_volume_scale, TRUE);
gtk_widget_set_vexpand(page_volume_scale, TRUE);
gtk_grid_attach(GTK_GRID (page_volume_grid), page_volume_mute_toggle, 7, 50, 4, 4);
/* page */
gtk_notebook_insert_page(GTK_NOTEBOOK (notebook),page_volume_grid,page_volume_label, 0);
/* signal listener */
g_signal_connect(page_volume_scale, "value-changed", G_CALLBACK (adjustVolume), page_volume_scale);
g_signal_connect(page_volume_mute_toggle, "toggled", G_CALLBACK (muteVolume), page_volume_mute_toggle);
/* Page BROWSER config */
/* page label */
page_browser_label = gtk_label_new("Web Browser");
/* page button to open browser */
page_browser_button = gtk_button_new_with_label("Start Firefox");
/* page pid label that shows pid of browsers */
//page_browser_pid_label = gtk_label_new("Test");
/*page grid */
page_browser_grid = gtk_grid_new();
spacer = gtk_label_new(" ");
gtk_grid_attach(GTK_GRID (page_browser_grid), spacer, 0, 0, 10, 10);
gtk_grid_attach(GTK_GRID (page_browser_grid), page_browser_button, 10, 10, 15, 5);
spacer = gtk_label_new(" ");
gtk_grid_attach(GTK_GRID (page_browser_grid), spacer, 10, 5, 10, 10);
//gtk_grid_attach(GTK_GRID (page_browser_grid), page_browser_pid_label, 20, 50, 10, 5);
/*page */
gtk_notebook_insert_page(GTK_NOTEBOOK (notebook), page_browser_grid, page_browser_label, 1);
/* listeners */
g_signal_connect(page_browser_button, "released", G_CALLBACK (openFirefox), spacer);//page_browser_pid_label);
/* Finally ... */
gtk_widget_show_all(window);
gtk_main ();
return 0;
}
GtkWidget *
scale_create_widget (GtkWidget * dlg)
{
GtkWidget *w;
GtkAdjustment *adj;
gint page;
if (options.scale_data.min_value >= options.scale_data.max_value)
{
g_printerr (_("Maximum value must be greater than minimum value.\n"));
return NULL;
}
/* check for initial value */
if (options.scale_data.have_value)
{
if (options.scale_data.value < options.scale_data.min_value)
{
g_printerr (_("Initial value less than minimal.\n"));
options.scale_data.value = options.scale_data.min_value;
}
else if (options.scale_data.value > options.scale_data.max_value)
{
g_printerr (_("Initial value greater than maximum.\n"));
options.scale_data.value = options.scale_data.max_value;
}
}
else
options.scale_data.value = options.scale_data.min_value;
page = options.scale_data.page == -1 ? options.scale_data.step * 10 : options.scale_data.page;
/* this type conversion needs only for gtk-2.0 */
adj = (GtkAdjustment *) gtk_adjustment_new ((double) options.scale_data.value,
(double) options.scale_data.min_value,
(double) options.scale_data.max_value,
(double) options.scale_data.step,
(double) page,
0.0);
if (options.common_data.vertical)
{
#if GTK_CHECK_VERSION(3,0,0)
scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adj));
#else
scale = gtk_vscale_new (GTK_ADJUSTMENT (adj));
#endif
gtk_range_set_inverted (GTK_RANGE (scale), !options.scale_data.invert);
}
else
{
#if GTK_CHECK_VERSION(3,0,0)
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adj));
#else
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));
#endif
gtk_range_set_inverted (GTK_RANGE (scale), options.scale_data.invert);
}
gtk_widget_set_name (scale, "yad-scale-widget");
gtk_scale_set_digits (GTK_SCALE (scale), 0);
if (options.scale_data.hide_value)
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
/* add marks */
if (options.scale_data.marks)
{
GtkPositionType pos;
GSList *m = options.scale_data.marks;
pos = options.common_data.vertical ? GTK_POS_LEFT : GTK_POS_BOTTOM;
for (; m; m = m->next)
{
YadScaleMark *mark = (YadScaleMark *) m->data;
gtk_scale_add_mark (GTK_SCALE (scale), mark->value, pos, mark->name);
}
}
/* create container */
if (options.common_data.vertical)
{
#if GTK_CHECK_VERSION(3,0,0)
w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
#else
w = gtk_vbox_new (FALSE, 1);
#endif
}
else
{
#if GTK_CHECK_VERSION(3,0,0)
w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);
#else
w = gtk_hbox_new (FALSE, 1);
#endif
}
/* create buttons */
if (options.scale_data.buttons)
{
minus_btn = gtk_button_new_with_label ("-");
gtk_button_set_relief (GTK_BUTTON (minus_btn), GTK_RELIEF_NONE);
g_signal_connect (G_OBJECT (minus_btn), "clicked", G_CALLBACK (vb_pressed), GINT_TO_POINTER (MINUS_BTN));
gtk_widget_set_sensitive (minus_btn, (options.scale_data.value > options.scale_data.min_value));
plus_btn = gtk_button_new_with_label ("+");
gtk_button_set_relief (GTK_BUTTON (plus_btn), GTK_RELIEF_NONE);
g_signal_connect (G_OBJECT (plus_btn), "clicked", G_CALLBACK (vb_pressed), GINT_TO_POINTER (PLUS_BTN));
gtk_widget_set_sensitive (plus_btn, (options.scale_data.value < options.scale_data.max_value));
}
/* create complex widget */
if (options.scale_data.buttons)
gtk_box_pack_start (GTK_BOX (w), options.common_data.vertical ? plus_btn : minus_btn, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (w), scale, TRUE, TRUE, 2);
if (options.scale_data.buttons)
gtk_box_pack_start (GTK_BOX (w), options.common_data.vertical ? minus_btn : plus_btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (scale), "value-changed", G_CALLBACK (value_changed_cb), NULL);
gtk_widget_grab_focus (scale);
return w;
}
static void fill_sample_table(DrMrUi* ui, int samples, char** names,GtkWidget** gain_sliders, GtkWidget** pan_sliders) {
int row = 0;
int col = 0;
int si;
gchar buf[64];
int rows = (samples/ui->cols);
if (samples % ui->cols != 0) rows++;
gtk_table_resize(ui->sample_table,rows,ui->cols);
switch (ui->startSamp) {
case 1: // bottom left
row = rows-1;
break;
case 2: // top right
col = ui->cols-1;
break;
case 3: // bottom right
row = rows-1;
col = ui->cols-1;
break;
}
for(si = 0;si<samples;si++) {
GtkWidget *frame,*hbox,*gain_vbox,*pan_vbox;
GtkWidget* gain_slider;
GtkWidget* pan_slider;
GtkWidget* gain_label;
GtkWidget* pan_label;
gboolean slide_expand;
snprintf(buf,64,"<b>%s</b> (%i)",names[si],si);
frame = gtk_frame_new(buf);
gtk_label_set_use_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))),true);
gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_OUT);
hbox = gtk_hbox_new(false,0);
#ifdef NO_NKNOB
gain_slider = gtk_vscale_new_with_range(GAIN_MIN,6.0,1.0);
gtk_scale_set_value_pos(GTK_SCALE(gain_slider),GTK_POS_BOTTOM);
gtk_scale_set_digits(GTK_SCALE(gain_slider),1);
gtk_scale_add_mark(GTK_SCALE(gain_slider),0.0,GTK_POS_RIGHT,"0 dB");
// Hrmm, -inf label is at top in ardour for some reason
//gtk_scale_add_mark(GTK_SCALE(gain_slider),GAIN_MIN,GTK_POS_RIGHT,"-inf");
gtk_range_set_inverted(GTK_RANGE(gain_slider),true);
slide_expand = true;
#else
gain_slider = n_knob_new_with_range(0.0,GAIN_MIN,6.0,1.0);
n_knob_set_load_prefix(N_KNOB(gain_slider),ui->bundle_path);
gtk_widget_set_has_tooltip(gain_slider,TRUE);
slide_expand = false;
#endif
g_object_set_qdata (G_OBJECT(gain_slider),ui->gain_quark,GINT_TO_POINTER(si));
if (gain_sliders) gain_sliders[si] = gain_slider;
if (si < 32)
gtk_range_set_value(GTK_RANGE(gain_slider),ui->gain_vals[si]);
else // things are gross if we have > 32 samples, what to do?
gtk_range_set_value(GTK_RANGE(gain_slider),0.0);
g_signal_connect(G_OBJECT(gain_slider),"change-value",G_CALLBACK(gain_callback),ui);
gain_label = gtk_label_new("Gain");
gain_vbox = gtk_vbox_new(false,0);
#ifdef NO_NKNOB
pan_slider = gtk_hscale_new_with_range(-1.0,1.0,0.1);
gtk_scale_add_mark(GTK_SCALE(pan_slider),0.0,GTK_POS_TOP,NULL);
#else
pan_slider = n_knob_new_with_range(0.0,-1.0,1.0,0.1);
n_knob_set_load_prefix(N_KNOB(pan_slider),ui->bundle_path);
gtk_widget_set_has_tooltip(pan_slider,TRUE);
#endif
if (pan_sliders) pan_sliders[si] = pan_slider;
if (si < 32)
gtk_range_set_value(GTK_RANGE(pan_slider),ui->pan_vals[si]);
else
gtk_range_set_value(GTK_RANGE(pan_slider),0);
g_object_set_qdata (G_OBJECT(pan_slider),ui->pan_quark,GINT_TO_POINTER(si));
g_signal_connect(G_OBJECT(pan_slider),"change-value",G_CALLBACK(pan_callback),ui);
pan_label = gtk_label_new("Pan");
pan_vbox = gtk_vbox_new(false,0);
gtk_box_pack_start(GTK_BOX(gain_vbox),gain_slider,slide_expand,slide_expand,0);
gtk_box_pack_start(GTK_BOX(gain_vbox),gain_label,false,false,0);
gtk_box_pack_start(GTK_BOX(pan_vbox),pan_slider,slide_expand,slide_expand,0);
gtk_box_pack_start(GTK_BOX(pan_vbox),pan_label,false,false,0);
gtk_box_pack_start(GTK_BOX(hbox),gain_vbox,true,true,0);
gtk_box_pack_start(GTK_BOX(hbox),pan_vbox,true,true,0);
gtk_container_add(GTK_CONTAINER(frame),hbox);
gtk_table_attach_defaults(ui->sample_table,frame,col,col+1,row,row+1);
if (ui->startSamp > 1) {
col--;
if (col < 0) {
if (ui->startSamp == 2)
row++;
else
row--;
col = ui->cols-1;
}
}
else {
col++;
if (col >= ui->cols) {
if (ui->startSamp == 0)
row++;
else
row--;
col = 0;
}
}
}
gtk_widget_queue_resize(GTK_WIDGET(ui->sample_table));
}
static void
cc_night_light_dialog_init (CcNightLightDialog *self)
{
g_autoptr(GtkCssProvider) provider = NULL;
g_autoptr(GError) error = NULL;
gtk_widget_init_template (GTK_WIDGET (self));
gtk_scale_add_mark (GTK_SCALE (self->scale_color_temperature),
3000, GTK_POS_BOTTOM,
_("More Warm"));
gtk_scale_add_mark (GTK_SCALE (self->scale_color_temperature),
4000, GTK_POS_BOTTOM,
NULL);
gtk_scale_add_mark (GTK_SCALE (self->scale_color_temperature),
5000, GTK_POS_BOTTOM,
NULL);
gtk_scale_add_mark (GTK_SCALE (self->scale_color_temperature),
6000, GTK_POS_BOTTOM,
_("Less Warm"));
self->cancellable = g_cancellable_new ();
self->settings_display = g_settings_new (DISPLAY_SCHEMA);
g_signal_connect (self->settings_display, "changed", G_CALLBACK (dialog_settings_changed_cb), self);
g_settings_bind_writable (self->settings_display, "night-light-schedule-from",
self->spinbutton_from_hours, "sensitive",
FALSE);
g_settings_bind_writable (self->settings_display, "night-light-schedule-from",
self->spinbutton_from_minutes, "sensitive",
FALSE);
g_settings_bind_writable (self->settings_display, "night-light-schedule-to",
self->spinbutton_to_minutes, "sensitive",
FALSE);
g_settings_bind_writable (self->settings_display, "night-light-schedule-to",
self->spinbutton_to_minutes, "sensitive",
FALSE);
/* use custom CSS */
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_resource (provider, "/org/gnome/control-center/display/night-light.css");
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
cc_object_storage_create_dbus_proxy (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
"org.gnome.SettingsDaemon.Color",
"/org/gnome/SettingsDaemon/Color",
"org.gnome.SettingsDaemon.Color",
self->cancellable,
dialog_got_proxy_cb,
self);
cc_object_storage_create_dbus_proxy (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
"org.gnome.SettingsDaemon.Color",
"/org/gnome/SettingsDaemon/Color",
"org.freedesktop.DBus.Properties",
self->cancellable,
dialog_got_proxy_props_cb,
self);
/* clock settings_display */
self->settings_clock = g_settings_new (CLOCK_SCHEMA);
self->clock_format = g_settings_get_enum (self->settings_clock, CLOCK_FORMAT_KEY);
dialog_update_adjustments (self);
g_signal_connect (self->settings_clock,
"changed::" CLOCK_FORMAT_KEY,
G_CALLBACK (dialog_clock_settings_changed_cb),
self);
dialog_update_state (self);
}
int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *frame;
GtkWidget *scale;
const gchar *labels[3] = {
"<small>Left</small>",
"<small>Middle</small>",
"<small>Right</small>"
};
gdouble bath_marks[4] = { 0.0, 33.3, 66.6, 100.0 };
const gchar *bath_labels[4] = {
"<span color='blue' size='small'>Cold</span>",
"<span size='small'>Baby bath</span>",
"<span size='small'>Hot tub</span>",
"<span color='Red' size='small'>Hot</span>"
};
gdouble pos_marks[4] = { 0.0, 33.3, 66.6, 100.0 };
const gchar *pos_labels[4] = { "Left", "Right", "Top", "Bottom" };
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Ranges with marks");
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
flipbox = box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_widget_set_hexpand (flipbox, TRUE);
gtk_widget_set_vexpand (flipbox, TRUE);
gtk_container_add (GTK_CONTAINER (box1), box);
gtk_container_add (GTK_CONTAINER (window), box1);
frame = gtk_frame_new ("No marks");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
scales = g_slist_prepend (scales, scale);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("With fill level");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
scales = g_slist_prepend (scales, scale);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_range_set_show_fill_level (GTK_RANGE (scale), TRUE);
gtk_range_set_fill_level (GTK_RANGE (scale), 50);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Simple marks");
extra_scale = scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
scales = g_slist_prepend (scales, scale);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_BOTTOM, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_BOTTOM, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_BOTTOM, NULL);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Simple marks up");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
scales = g_slist_prepend (scales, scale);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_TOP, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_TOP, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_TOP, NULL);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Labeled marks");
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
scales = g_slist_prepend (scales, scale);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_BOTTOM, labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_BOTTOM, labels[1]);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_BOTTOM, labels[2]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Some labels");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
scales = g_slist_prepend (scales, scale);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_TOP, labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_TOP, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_TOP, labels[2]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Above and below");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
scales = g_slist_prepend (scales, scale);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[0], GTK_POS_TOP, bath_labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[1], GTK_POS_BOTTOM, bath_labels[1]);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[2], GTK_POS_BOTTOM, bath_labels[2]);
gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[3], GTK_POS_TOP, bath_labels[3]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Positions");
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
scales = g_slist_prepend (scales, scale);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[0], GTK_POS_LEFT, pos_labels[0]);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[1], GTK_POS_RIGHT, pos_labels[1]);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[2], GTK_POS_TOP, pos_labels[2]);
gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[3], GTK_POS_BOTTOM, pos_labels[3]);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_container_add (GTK_CONTAINER (box1), box2);
button = gtk_button_new_with_label ("Flip");
g_signal_connect (button, "clicked", G_CALLBACK (flip), NULL);
gtk_container_add (GTK_CONTAINER (box2), button);
button = gtk_button_new_with_label ("Invert");
g_signal_connect (button, "clicked", G_CALLBACK (invert), NULL);
gtk_container_add (GTK_CONTAINER (box2), button);
button = gtk_toggle_button_new_with_label ("Trough");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (button, "toggled", G_CALLBACK (trough), NULL);
gtk_container_add (GTK_CONTAINER (box2), button);
gtk_widget_show_all (window);
button = gtk_toggle_button_new_with_label ("Extra");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
g_signal_connect (button, "toggled", G_CALLBACK (extra), NULL);
gtk_container_add (GTK_CONTAINER (box2), button);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
void configure_program_dialog(GtkWidget *widget, gpointer user_data) {
/** Program configuration dailog window. **/
#ifdef DEBUG
DEBUG_FUNC_MARK
#endif
GtkWidget *configure_dialog = gtk_dialog_new() ;
gtk_window_set_icon_from_file(GTK_WINDOW(configure_dialog), PATH_TO_PRG_WIN_ICON, NULL) ;
gtk_window_set_title(GTK_WINDOW(configure_dialog), "Configure program") ;
gtk_window_set_position(GTK_WINDOW(configure_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
gtk_window_set_resizable(GTK_WINDOW(configure_dialog), FALSE);
gtk_widget_set_size_request(configure_dialog,-1,-1) ;
gtk_window_set_modal(GTK_WINDOW(configure_dialog), FALSE) ;
gtk_window_set_destroy_with_parent(GTK_WINDOW(configure_dialog), TRUE) ;
gtk_window_set_decorated(GTK_WINDOW(configure_dialog), TRUE) ;
gtk_window_set_type_hint(GTK_WINDOW(configure_dialog), GDK_WINDOW_TYPE_HINT_NORMAL) ;
gtk_window_set_transient_for(GTK_WINDOW(configure_dialog), GTK_WINDOW(gui->window)) ;
gtk_container_set_border_width(GTK_CONTAINER(configure_dialog), 12) ;
#define DIALOG_DEFAULT_SPACE 12
/** ***** [START] Icon set choice [START] ***** **/
GtkWidget *icon_set_choice_frame = gtk_frame_new(" Icon set ") ;
GtkWidget *icon_set_choice_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(icon_set_choice_hbox), DIALOG_DEFAULT_SPACE) ;
gtk_box_set_spacing(GTK_BOX(icon_set_choice_hbox), DIALOG_DEFAULT_SPACE) ;
gtk_box_set_homogeneous(GTK_BOX(icon_set_choice_hbox), TRUE) ;
GtkWidget *radiobutton_icons_high_contrast = gtk_radio_button_new_with_label(NULL, " HighContrast") ;
GtkWidget *image_icons_high_contrast ;
GtkWidget *radiobutton_icons_oxygen = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_icons_high_contrast)), " Oxygen") ;
GtkWidget *image_icons_oxygen ;
gtk_widget_set_tooltip_markup(radiobutton_icons_high_contrast, "Set the <b>HighContrast</b> theme icon set.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_widget_set_tooltip_markup(radiobutton_icons_oxygen, "Set the <b>Oxygen</b> theme icon set.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(radiobutton_icons_high_contrast), FALSE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(radiobutton_icons_oxygen), FALSE) ;
if (settings.icon_set_oxygen) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_icons_oxygen), TRUE) ;
image_icons_high_contrast = gtk_image_new_from_file( PATH_TO_HIGH_CONTRAST_BUTTON_ICONS "face-angry.png") ;
image_icons_oxygen = gtk_image_new_from_file( PATH_TO_OXYGEN_BUTTON_ICONS "face-smile-big.png") ;
}
else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_icons_high_contrast), TRUE) ;
image_icons_high_contrast = gtk_image_new_from_file( PATH_TO_HIGH_CONTRAST_BUTTON_ICONS "face-smile-big.png") ;
image_icons_oxygen = gtk_image_new_from_file( PATH_TO_OXYGEN_BUTTON_ICONS "face-angry.png") ;
}
gtk_button_set_image(GTK_BUTTON(radiobutton_icons_high_contrast), image_icons_high_contrast) ;
gtk_button_set_always_show_image(GTK_BUTTON(radiobutton_icons_high_contrast), TRUE) ;
gtk_button_set_image(GTK_BUTTON(radiobutton_icons_oxygen), image_icons_oxygen) ;
gtk_button_set_always_show_image(GTK_BUTTON(radiobutton_icons_oxygen), TRUE) ;
gtk_box_pack_start(GTK_BOX(icon_set_choice_hbox), radiobutton_icons_high_contrast, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(icon_set_choice_hbox), radiobutton_icons_oxygen, TRUE, TRUE, 0) ;
gtk_container_add(GTK_CONTAINER(icon_set_choice_frame), icon_set_choice_hbox) ;
/** ***** [END] Icon set choice [END] ***** **/
/** ***** [START] Playing settings [START] ***** **/
GtkWidget *playing_settings_frame = gtk_frame_new(" Player settings ") ;
GtkWidget *playing_settings_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(playing_settings_vbox), DIALOG_DEFAULT_SPACE) ;
GtkWidget *playing_settings_repeat_all = gtk_check_button_new_with_label(" Repeat all mode. ") ;
gtk_widget_set_tooltip_markup(playing_settings_repeat_all, "Enable the <b>repeat all</b> feature.\nThis will update the player settings.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(playing_settings_repeat_all), is_repeat_all) ;
GtkWidget *playing_settings_shuffle = gtk_check_button_new_with_label(" Shuffle mode. ") ;
gtk_widget_set_tooltip_markup(playing_settings_shuffle, "Enable the <b>shuffle</b> feature.\nThis will update the player settings.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(playing_settings_shuffle), is_shuffle ) ;
GtkWidget *playing_settings_volume_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
GtkWidget *playing_settings_volume_label_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
GtkWidget *playing_settings_volume_image = gtk_image_new_from_file( (settings.path_to_button_icons + "audio-volume-medium.png").c_str() ) ;
GtkWidget *playing_settings_volume_label = gtk_label_new(" Default Volume:") ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_label_hbox), playing_settings_volume_image, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_label_hbox), playing_settings_volume_label, FALSE, FALSE, 0) ;
GtkWidget *playing_settings_volume_scale = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0.0, 100.0, 1.0) ;
gtk_widget_set_tooltip_markup(playing_settings_volume_scale, "Set the <b>default player volume</b> at start.\nThis will <b>not</b> update the player settings.\nYou must press the <b>Apply</b> button to store your configuration.") ;
gtk_range_set_value(GTK_RANGE(playing_settings_volume_scale), settings.volume) ;
gtk_scale_set_draw_value(GTK_SCALE(playing_settings_volume_scale), TRUE) ;
gtk_scale_set_has_origin(GTK_SCALE(playing_settings_volume_scale), TRUE) ;
gtk_scale_set_value_pos(GTK_SCALE(playing_settings_volume_scale), GTK_POS_TOP) ;
gtk_scale_add_mark(GTK_SCALE(playing_settings_volume_scale), 50.0, GTK_POS_TOP, NULL) ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_hbox), playing_settings_volume_label_hbox, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_hbox), playing_settings_volume_scale, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_repeat_all, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_shuffle, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_volume_hbox, FALSE, FALSE, 0) ;
gtk_container_add(GTK_CONTAINER(playing_settings_frame), playing_settings_vbox) ;
/** ***** [END] Playing settings [END] ***** **/
/** ***** [START] Interface size setting [START] ***** **/
GtkWidget *interface_size_frame = gtk_frame_new(" Interface size ") ;
GtkWidget *interface_size_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(interface_size_hbox), DIALOG_DEFAULT_SPACE) ;
GtkWidget *interface_size_radiobutton_little = gtk_radio_button_new_with_label(NULL, " Little") ;
GtkWidget *interface_size_radiobutton_middle = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(interface_size_radiobutton_little)), " Medium") ;
GtkWidget *interface_size_radiobutton_big = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(interface_size_radiobutton_little)), " Big ") ;
GtkWidget *interface_size_little_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-little.png").c_str() ) ;
GtkWidget *interface_size_middle_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-middle.png").c_str() ) ;
GtkWidget *interface_size_big_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-big.png").c_str() ) ;
gtk_widget_set_tooltip_markup(interface_size_radiobutton_little, "Set the <b>interface size</b> on <b>little</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_widget_set_tooltip_markup(interface_size_radiobutton_middle, "Set the <b>interface size</b> on <b>middle</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_widget_set_tooltip_markup(interface_size_radiobutton_big, "Set the <b>interface size</b> on <b>big</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_little), interface_size_little_image) ;
gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_middle), interface_size_middle_image) ;
gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_big), interface_size_big_image ) ;
gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_little), TRUE) ;
gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_middle), TRUE) ;
gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_big), TRUE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_little), FALSE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_middle), FALSE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_big), FALSE) ;
switch (settings.image_resized_size) {
case IMAGE_RESIZED_SIZE_LITTLE :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_little), TRUE) ;
break ;
case IMAGE_RESIZED_SIZE_MIDDLE :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_middle), TRUE) ;
break ;
case IMAGE_RESIZED_SIZE_BIG :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_big), TRUE) ;
break ;
default :
break ;
}
gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_little, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_middle, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_big, TRUE, TRUE, 0) ;
gtk_box_set_homogeneous(GTK_BOX(interface_size_hbox), TRUE) ;
gtk_box_set_spacing(GTK_BOX(interface_size_hbox), DIALOG_DEFAULT_SPACE) ;
gtk_container_add(GTK_CONTAINER(interface_size_frame), interface_size_hbox) ;
/** ***** [END] Interface size setting [END] ***** **/
/** ***** [START] Music folder setting [START] ***** **/
GtkWidget *folder_selecting_frame = gtk_frame_new(" Music folder ") ;
GtkWidget *folder_selecting_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(folder_selecting_box), DIALOG_DEFAULT_SPACE) ;
GtkWidget *folder_selecting_button = gtk_file_chooser_button_new("Set the Music folder to open per default.", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) ;
gtk_widget_set_tooltip_markup(folder_selecting_button, "Set the folder to open per default: your <b>default music folder</b>.\n<i>The default folder from the folder selector</i>.\nSet it simply to your <b>Music folder</b>.\nChanges are immediatly applied.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_file_chooser_button_set_title(GTK_FILE_CHOOSER_BUTTON(folder_selecting_button), "Set the Music folder to open per default.") ;
const char *user_music_folder = g_get_user_special_dir(G_USER_DIRECTORY_MUSIC) ;
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(folder_selecting_button), (g_file_test(settings.path_to_music_folder.c_str(), G_FILE_TEST_IS_DIR)) ? settings.path_to_music_folder.c_str() : (user_music_folder != NULL) ? user_music_folder : g_get_home_dir() ) ;
gtk_box_pack_start(GTK_BOX(folder_selecting_box), folder_selecting_button, TRUE, TRUE, 0) ;
gtk_container_add(GTK_CONTAINER(folder_selecting_frame), folder_selecting_box) ;
/** ***** [END] Music folder setting [END] ***** **/
/** ***** [START] Dialog main content box [START] ***** **/
GtkWidget *content_area = gtk_dialog_get_content_area( GTK_DIALOG(configure_dialog) ) ;
gtk_box_pack_start(GTK_BOX(content_area), icon_set_choice_frame, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(content_area), playing_settings_frame, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(content_area), interface_size_frame, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(content_area), folder_selecting_frame, FALSE, FALSE, 0) ;
gtk_box_set_spacing(GTK_BOX(content_area), DIALOG_DEFAULT_SPACE) ;
/** ***** [END] Dialog main content box [END] ***** **/
/** ***** [START] Dialog action buttons [START] ***** **/
GtkWidget *button_close = gtk_button_new_with_label("Close") ; // gtk_dialog_add_button(GTK_DIALOG(configure_dialog), "Cancel", GTK_RESPONSE_CANCEL) ;
GtkWidget *image_close = gtk_image_new_from_file((settings.path_to_button_icons + "dialog-close.png").c_str()) ;
gtk_widget_set_tooltip_markup(button_close, "<b>Close</b> the configuration window and don't store any setting.") ;
gtk_button_set_image(GTK_BUTTON(button_close), image_close) ;
gtk_button_set_always_show_image(GTK_BUTTON(button_close), TRUE) ;
GtkWidget *button_ok = gtk_button_new_with_label("Apply") ; // gtk_dialog_add_button(GTK_DIALOG(configure_dialog), "Apply", GTK_RESPONSE_APPLY) ;
GtkWidget *image_ok = gtk_image_new_from_file((settings.path_to_button_icons + "dialog-ok.png").c_str()) ;
gtk_widget_set_tooltip_markup(button_ok, "<b>Register</b> all the settings as <i>your default configuration</i> at start.") ;
gtk_button_set_image(GTK_BUTTON(button_ok), image_ok) ;
gtk_button_set_always_show_image(GTK_BUTTON(button_ok), TRUE) ;
gtk_dialog_add_action_widget(GTK_DIALOG(configure_dialog), button_close, GTK_RESPONSE_CLOSE) ;
gtk_dialog_add_action_widget(GTK_DIALOG(configure_dialog), button_ok, GTK_RESPONSE_APPLY) ;
GtkWidget *action_area = gtk_dialog_get_action_area(GTK_DIALOG(configure_dialog)) ;
gtk_container_set_border_width(GTK_CONTAINER(action_area), 0) ;
gtk_button_box_set_layout(GTK_BUTTON_BOX(action_area), GTK_BUTTONBOX_EDGE) ;
/** ***** [END] Dialog action buttons [END] ***** **/
Radio_Config high_contrast_radiobutton ;
high_contrast_radiobutton.button = radiobutton_icons_high_contrast ;
high_contrast_radiobutton.image = image_icons_high_contrast ;
high_contrast_radiobutton.volume = playing_settings_volume_image ;
high_contrast_radiobutton.cancel = image_close ;
high_contrast_radiobutton.apply = image_ok ;
high_contrast_radiobutton.little = interface_size_little_image ;
high_contrast_radiobutton.middle = interface_size_middle_image ;
high_contrast_radiobutton.big = interface_size_big_image ;
Radio_Config oxygen_radiobutton ;
oxygen_radiobutton.button = radiobutton_icons_oxygen ;
oxygen_radiobutton.image = image_icons_oxygen ;
oxygen_radiobutton.volume = playing_settings_volume_image ;
oxygen_radiobutton.cancel = image_close ;
oxygen_radiobutton.apply = image_ok ;
oxygen_radiobutton.little = interface_size_little_image ;
oxygen_radiobutton.middle = interface_size_middle_image ;
oxygen_radiobutton.big = interface_size_big_image ;
g_signal_connect(G_OBJECT(radiobutton_icons_high_contrast), "clicked", G_CALLBACK(configure_high_contrast_radiobutton), &high_contrast_radiobutton) ;
g_signal_connect(G_OBJECT(radiobutton_icons_oxygen), "clicked", G_CALLBACK(configure_oxygen_radiobutton), &oxygen_radiobutton ) ;
int little = -1 ;
int middle = 0 ;
int big = 1 ;
g_signal_connect(G_OBJECT(interface_size_radiobutton_little), "clicked", G_CALLBACK(reconfigure_interface_size), &little) ;
g_signal_connect(G_OBJECT(interface_size_radiobutton_middle), "clicked", G_CALLBACK(reconfigure_interface_size), &middle) ;
g_signal_connect(G_OBJECT(interface_size_radiobutton_big), "clicked", G_CALLBACK(reconfigure_interface_size), &big) ;
g_signal_connect(G_OBJECT(playing_settings_repeat_all), "toggled", G_CALLBACK(repeat_all_feature_set), NULL) ;
g_signal_connect(G_OBJECT(playing_settings_shuffle), "toggled", G_CALLBACK(shuffle_feature_set), NULL) ;
g_signal_connect(G_OBJECT(playing_settings_volume_scale), "value-changed", G_CALLBACK(get_volume), NULL) ;
g_signal_connect(G_OBJECT(folder_selecting_button), "file-set", G_CALLBACK(set_default_folder), NULL) ;
gtk_widget_show_all(configure_dialog) ;
int response = gtk_dialog_run(GTK_DIALOG(configure_dialog)) ;
switch (response) {
case GTK_RESPONSE_APPLY :
{
GKeyFile *conf_file = g_key_file_new() ;
GError *error = NULL ;
settings.is_repeat_all = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(playing_settings_repeat_all)) ;
settings.is_shuffle = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(playing_settings_shuffle)) ;
// Set configuration settings to configuration file buffer.
g_key_file_set_string(conf_file, "Config", "Buttons_Icons_Path", settings.path_to_button_icons.c_str()) ;
g_key_file_set_string(conf_file, "Config", "Menu_Icons_Path", settings.path_to_menu_icons.c_str()) ;
g_key_file_set_string(conf_file, "Config", "Music_Folder", settings.path_to_music_folder.c_str()) ;
g_key_file_set_boolean(conf_file, "Config", "Is_Oxygen", settings.icon_set_oxygen) ;
g_key_file_set_boolean(conf_file, "Config", "Repeat_all", settings.is_repeat_all) ;
g_key_file_set_boolean(conf_file, "Config", "Shuffle", settings.is_shuffle) ;
g_key_file_set_double(conf_file, "Config", "Volume", settings.volume) ;
g_key_file_set_uint64(conf_file, "Config", "Buttons_space", settings.space_buttons) ;
g_key_file_set_uint64(conf_file, "Config", "Display_Size", settings.display_size) ;
g_key_file_set_uint64(conf_file, "Config", "Image_Resizing", settings.image_resized_size) ;
g_key_file_set_string(conf_file, "Config", "Sized_Default_Image", settings.path_to_default_image.c_str()) ;
// Write to configuration file
g_key_file_save_to_file(conf_file, PATH_TO_CONF_FILE, &error);
// Setting global variables.
cover_image = settings.path_to_default_image ;
current_folder = settings.path_to_music_folder ;
if ( error != NULL ) {
display_message_dialog("Error store configuration !", "Cannot store the configuration.") ;
#ifdef DEBUG
fprintf(stdout,"\n%s: Error store configuratiom settings.\n", prgname.c_str() ) ; fflush(stdout) ;
#endif
}
else { // Success
#ifdef DEBUG
fprintf(stdout,"\n%s: Success store configuratiom settings.\n", prgname.c_str() ) ;
#endif
}
}
break ;
case GTK_RESPONSE_CLOSE :
// Do nothing.
break ;
}
gtk_widget_destroy(configure_dialog) ;
return ;
}
// Основная функция построения класса, в которой происходит заполнение окна виджетами.
void cMainWin::Create()
{
// Создаём объект, если ранее он был не создан или был уничтожен.
if(mbIsCreated)
return;
// Общие виджеты. Будут использованы несколько раз.
GtkWidget *awHBox; // Горизонтальный бокс.
GtkWidget *awVBox; // Вертикальный бокс.
GtkWidget *awLabel; // Заголовок.
GtkWidget *awFrame; // Фрейм для виджетов.
GtkWidget *awMenuBar; // Виджет для основного меню.
GtkWidget *awSubmenu; // Подменю.
GtkWidget *awMenuitem; // Пункт основного меню.
GtkWidget *awSubMenuitem; // Пункт подменю.
GtkWidget *awOpenFileButton; // Кнопка открытия файла.
GtkWidget *awAdditionButton; // Кнопка доп. настроек.
GtkWidget *awConvertButton; // Кнопка конвертации.
// Настраиваем виджет главного окна.
mwWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size ((GtkWindow *)mwWindow, 800, 400); // Задаём размер.
gtk_window_move((GtkWindow *)mwWindow, 50, 50); // Перемещаем окно.
gtk_window_set_title((GtkWindow *)mwWindow, msTitle.c_str()); // Задаём имя.
// Устанавливаем обработчик события уничтожения окна.
g_signal_connect(
G_OBJECT(mwWindow), "delete_event",
G_CALLBACK(gtk_main_quit), this);
// Создаём новый вертикальный бокс и забиваем его в основное окно.
mwMainBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add((GtkContainer *)mwWindow, mwMainBox);
// Создаём новый виджет основного меню.
awMenuBar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (mwMainBox), awMenuBar, FALSE, TRUE, 0); // Забиваем меню в главный бокс.
// Создаём новый пункт меню Справка и заполняем его подменю.
awMenuitem = gtk_menu_item_new_with_label ("Справка");
awSubmenu = gtk_menu_new();
// Добавляем в подменю новый пункт.
awSubMenuitem = gtk_menu_item_new_with_label ("О программе");
gtk_menu_shell_append (GTK_MENU_SHELL (awSubmenu), awSubMenuitem); // Не забываем связать этот пункт с подменю.
// Устанавливаем обработчик нажатия на пункт подменю.
g_signal_connect(awSubMenuitem, "activate",
G_CALLBACK(OnAbout), this);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (awMenuitem), awSubmenu); // Связываем подменю с главным.
gtk_menu_shell_append (GTK_MENU_SHELL (awMenuBar), awMenuitem); // И добавляем пунтк меню в главное меню.
// Добавляем в главный бокс разделитель виджетов(простая длинная линия).
gtk_box_pack_start (GTK_BOX (mwMainBox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, TRUE, 5);
// Задаём вертикальный бокс для первого пункта процесса конвертации и забиваем его в главный бокс.
awVBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(mwMainBox), awVBox, FALSE, FALSE, 1);
// Задаём горизонтальный бокс для первого пункта процесса конвертации и забиваем его в предыдущий вертикальный бокс.
awHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(awVBox), awHBox, FALSE, FALSE, 1);
// Задаём виджет для отображения текста и добавляем в горизонтальный бокс.
awLabel = gtk_label_new ("1.");
//gtk_widget_set_halign (awLabel, GTK_ALIGN_START); // Выравнивание. Не нужно, если использовать горизонтальный бокс.
gtk_box_pack_start(GTK_BOX(awHBox), awLabel, FALSE, FALSE, 5);
// Создаём кнопку Открыть файл и добавляем в горизонтальный бокс.
awOpenFileButton = gtk_button_new_with_label ("Открыть файл");
gtk_box_pack_start(GTK_BOX(awHBox), awOpenFileButton, FALSE, FALSE, 10);
// Устанавливаем обработчик нажатия на кнопку Открыть файл.
g_signal_connect(awOpenFileButton, "clicked",
G_CALLBACK(OnOpenFile), this);
// Создаём бокс для списка всех записей и добавляем в горизонтальный бокс.
mwTrackNameBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(awHBox), mwTrackNameBox, FALSE, FALSE, 5);
// Переходим ко второму пункту меню
// Задаём вертикальный бокс для второго пункта процесса конвертации и забиваем его в главный бокс.
awVBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(mwMainBox), awVBox, FALSE, FALSE, 10);
// Задаём горизонтальный бокс для второго пункта процесса конвертации и забиваем его в предыдущий вертикальный бокс.
awHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(awVBox), awHBox, FALSE, FALSE, 1);
// Задаём виджет для отображения текста и добавляем в горизонтальный бокс.
awLabel = gtk_label_new ("2. ");
gtk_box_pack_start(GTK_BOX(awHBox), awLabel, FALSE, FALSE, 5);
// Создаём комбо бокс для выбора формата конвертации.
mwFormat = gtk_combo_box_text_new ();
for(int i = eFormat_MP3; i < eFormat_Unknown; i++)
{
// Для каждого пункта из enum добавляем пункт в комбо боксе со своим текстом из asFormat.
gtk_combo_box_text_insert_text ((GtkComboBoxText *)mwFormat, -1, asFormat[i].c_str());
}
gtk_combo_box_set_active((GtkComboBox *)mwFormat, 0); // Устанавливаем активный элемент на первый в списке.
// Задаём обработчик события смены формата.
g_signal_connect (mwFormat, "changed",
G_CALLBACK (OnChangeFormat), this);
gtk_box_pack_start(GTK_BOX(awHBox), mwFormat, FALSE, FALSE, 5); // Добавляем комбо бокс в горизонтальный бокс.
// Теперь настроим виджеты, которые будут соответствовать формату конвертации из комбо бокса.
// Виджеты, соответствующие формату, будут показываться, только при выборе этого формата в комбо боксе.
// Задаём горизонтальный бокс для настроек под определённый формат и добавляем его в вертикальный бокс.
awHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(awVBox), awHBox, FALSE, FALSE, 10);
// Настроим MP3 виджеты.
// Задаём слайдер качества с определённым количеством меток.
mMP3Widgets.mwQuality = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, eMP3Quality_count-1, 1);
gtk_scale_set_draw_value ((GtkScale *)mMP3Widgets.mwQuality, FALSE); // Не будем рисовать текущее значение.
// Добавим метки на шкалу слайдера для визуализации.
for(int i = 0; i < eMP3Quality_count; i++)
{
std::string asQ = asMP3Quality[i] +"kbps"; // Значения мток берём из asMP3Quality массива.
gtk_scale_add_mark ((GtkScale *)mMP3Widgets.mwQuality, i, GTK_POS_TOP, asQ.c_str());
}
gtk_box_pack_start(GTK_BOX(awHBox), mMP3Widgets.mwQuality, TRUE, TRUE, 30); // Добавляем слайдер в горизонтальный бокс.
gtk_range_set_show_fill_level ((GtkRange *)mMP3Widgets.mwQuality, TRUE); // Заполняем слайдер другим цветом.
gtk_range_set_restrict_to_fill_level ((GtkRange *)mMP3Widgets.mwQuality, TRUE); // Устанавливаем указатель слайдера до уровня заполнения слайдера.
gtk_range_set_fill_level ((GtkRange *)mMP3Widgets.mwQuality, eMP3Quality_count-1); // Полностью заполняем слайдер цветом.
gtk_range_set_value ((GtkRange *)mMP3Widgets.mwQuality, eMP3Quality_count-1); // Ставим значение слайдера на последнее из массива значений.
// Указатель теперь связан с уровнем заполнения, но указатель всё ещё можно двигать, не меняя уровень заполнения.
// Для этого необходимо ввести 2 обработчика событий - изменение значение слайдера и изменение границ указателя, для перемещения уровня заполнения.
g_signal_connect (mMP3Widgets.mwQuality, "value-changed", G_CALLBACK (OnQualityChanged), this);
g_signal_connect (mMP3Widgets.mwQuality, "adjust-bounds", G_CALLBACK (OnAdjustBoundsQuality), this);
gtk_widget_show(mMP3Widgets.mwQuality); // Показываем виджеты страницы MP3 конвертера.
// Настраиваем OGG виджеты.
// Задаём слайдер качества с определённым количеством меток.
mOGGWidgets.mwQuality = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, eOGGQuality_count-1, 1);
gtk_scale_set_draw_value ((GtkScale *)mOGGWidgets.mwQuality, FALSE);
// Добавим метки на шкалу слайдера для визуализации.
for(int i = 0; i < eOGGQuality_count; i++)
{
std::string asQ = asOGGQuality[i] +"kbps"; // Значения мток берём из asOGGQuality массива.
gtk_scale_add_mark ((GtkScale *)mOGGWidgets.mwQuality, i, GTK_POS_TOP, asQ.c_str());
}
gtk_box_pack_start(GTK_BOX(awHBox), mOGGWidgets.mwQuality, TRUE, TRUE, 30); // Добавляем слайдер в горизонтальный бокс.
gtk_range_set_show_fill_level ((GtkRange *)mOGGWidgets.mwQuality, TRUE); // Заполняем слайдер другим цветом.
gtk_range_set_restrict_to_fill_level ((GtkRange *)mOGGWidgets.mwQuality, TRUE); // Устанавливаем указатель слайдера до уровня заполнения слайдера.
gtk_range_set_fill_level ((GtkRange *)mOGGWidgets.mwQuality, eOGGQuality_count-1); // Полностью заполняем слайдер цветом.
gtk_range_set_value ((GtkRange *)mOGGWidgets.mwQuality, eOGGQuality_count-1); // Ставим значение слайдера на последнее из массива значений.
// Снова вводим 2 обработчика событий, один на изменение значения слайдера и друго для изменения границ указателя, для перемещения уровня заполнения.
g_signal_connect (mOGGWidgets.mwQuality, "value-changed", G_CALLBACK (OnQualityChanged), this);
g_signal_connect (mOGGWidgets.mwQuality, "adjust-bounds", G_CALLBACK (OnAdjustBoundsQuality), this);
// Добавим новую кнопку Дополнительно для отображения дополнительных параметров и добавим его в горизонтальный бокс.
awAdditionButton = gtk_button_new_with_label ("Дополнительно");
gtk_box_pack_end(GTK_BOX(awHBox), awAdditionButton, FALSE, FALSE, 30);
// Введём обработчик нажатия на кнопку Дополнительно.
g_signal_connect(awAdditionButton, "clicked",
G_CALLBACK(OnShowAdditionalSettings), this);
// Переходим к третьему пункту меню.
// Задаём вертикальный бокс для третьего пункта процесса конвертации и забиваем его в главный бокс.
awVBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(mwMainBox), awVBox, FALSE, FALSE, 1);
// Задаём горизонтальный бокс для третьего пункта процесса конвертации и забиваем его в предыдущий вертикальный бокс.
awHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(awVBox), awHBox, FALSE, FALSE, 10);
// Задаём виджет для отображения текста и добавляем в горизонтальный бокс.
awLabel = gtk_label_new ("3.");
gtk_box_pack_start(GTK_BOX(awHBox), awLabel, FALSE, FALSE, 5);
// Добавим кнопку Конвертировать - для начала процесса конвертации ваших аудио файлов. Добавим кнопку в горизонтальный бокс.
awConvertButton = gtk_button_new_with_label ("Конвертировать");
gtk_box_pack_start(GTK_BOX(awHBox), awConvertButton, FALSE, FALSE, 10);
// Создадим спиннер для визуального отображения процесса конвертации.
// Это просто необходимо, т.к. программа как бы подвисает, из-за того что мы конвертируем в одном потоке с программой.
// Серъёзно нагружает процессор =(
mwSpinner = gtk_spinner_new ();
gtk_box_pack_start(GTK_BOX(awHBox), mwSpinner, FALSE, FALSE, 5);
// Обработчик события нажатие на кнопку Конвертация.
g_signal_connect(awConvertButton, "clicked",
G_CALLBACK(OnConvert), this);
gtk_widget_show_all (mwWindow); // Покажем все виджеты в окне.
gtk_widget_hide(mOGGWidgets.mwQuality); // Скроем виджеты со страницы OGG. По умолчанию отображаем конвертацию в MP3.
gtk_widget_hide(mwSpinner); // Скроем спиннер, т.к. мы хотим его показать только в момент конвертации файлов.
mbIsCreated = true; // Объект создан.
}
/* Set up the property editors in the dialog. */
static void
setup_dialog (CcMousePropertiesPrivate *d)
{
GtkRadioButton *radio;
/* Orientation radio buttons */
radio = GTK_RADIO_BUTTON (WID ("left_handed_radio"));
g_settings_bind (d->mouse_settings, "left-handed", radio, "active", G_SETTINGS_BIND_DEFAULT);
/* explicitly connect to button-release so that you can change orientation with either button */
g_signal_connect (WID ("right_handed_radio"), "button_release_event",
G_CALLBACK (orientation_radio_button_release_event), NULL);
g_signal_connect (WID ("left_handed_radio"), "button_release_event",
G_CALLBACK (orientation_radio_button_release_event), NULL);
/* Double-click time */
g_settings_bind (d->gsd_mouse_settings, "double-click",
gtk_range_get_adjustment (GTK_RANGE (WID ("double_click_scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
/* Mouse section */
gtk_widget_set_visible (WID ("mouse_vbox"), d->have_mouse);
gtk_scale_add_mark (GTK_SCALE (WID ("pointer_speed_scale")), 0,
GTK_POS_TOP, NULL);
g_settings_bind (d->mouse_settings, "speed",
gtk_range_get_adjustment (GTK_RANGE (WID ("pointer_speed_scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
/* Trackpad page */
gtk_widget_set_visible (WID ("touchpad_vbox"), d->have_touchpad);
gtk_widget_set_visible (WID ("touchpad_enabled_switch"),
show_touchpad_enabling_switch (d));
g_settings_bind_with_mapping (d->touchpad_settings, "send-events",
WID ("touchpad_enabled_switch"), "active",
G_SETTINGS_BIND_DEFAULT,
touchpad_enabled_get_mapping,
touchpad_enabled_set_mapping,
NULL, NULL);
g_settings_bind_with_mapping (d->touchpad_settings, "send-events",
WID ("touchpad_options_box"), "sensitive",
G_SETTINGS_BIND_GET,
touchpad_enabled_get_mapping,
touchpad_enabled_set_mapping,
NULL, NULL);
g_settings_bind (d->touchpad_settings, "tap-to-click",
WID ("tap_to_click_toggle"), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (d->touchpad_settings, "natural-scroll",
WID ("natural_scroll_toggle"), "active",
G_SETTINGS_BIND_DEFAULT);
gtk_scale_add_mark (GTK_SCALE (WID ("touchpad_pointer_speed_scale")), 0,
GTK_POS_TOP, NULL);
g_settings_bind (d->touchpad_settings, "speed",
gtk_range_get_adjustment (GTK_RANGE (WID ("touchpad_pointer_speed_scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
if (d->have_touchpad) {
synaptics_check_capabilities (d);
setup_scrollmethod_radios (d);
}
g_signal_connect (WID ("two_finger_scroll_toggle"), "toggled",
G_CALLBACK (scrollmethod_changed_event), d);
}
static GtkWidget *
garu_effects_init_box_equalizer (GaruEffects *self)
{
gint i;
gchar *text;
GtkWidget *vbox, *hbox, *grid, *label, *toogle, *combo_box, *scale;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
/* Label enabled */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
label = gtk_label_new (NULL);
text = garu_utils_text_bold (_("Enabled"));
gtk_label_set_markup (GTK_LABEL (label), text);
g_free (text);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
toogle = gtk_switch_new ();
g_settings_bind (self->settings, "equalizer-enabled",
toogle, "active", G_SETTINGS_BIND_DEFAULT);
gtk_box_pack_start (GTK_BOX (hbox), toogle, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* ComboBox Presets */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20);
label = gtk_label_new (_("Presets"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
combo_box = gtk_combo_box_text_new ();
for (i = 0 ; i < G_N_ELEMENTS (eq_presets); i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box),
eq_presets[i]);
gtk_box_pack_start (GTK_BOX (hbox), combo_box, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
g_settings_bind (self->settings, "equalizer-enabled",
hbox, "sensitive", G_SETTINGS_BIND_GET);
/* Grid equalizer */
grid = gtk_grid_new ();
for (i = 0; i < G_N_ELEMENTS (eq_bands); i++)
{
text = g_strdup_printf ("eq-custom-band%d", i);
scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
-12, 12, 0.1);
label = gtk_label_new (eq_bands [i]);
gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
gtk_scale_add_mark (GTK_SCALE (scale), 12.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), 0.0, GTK_POS_LEFT, NULL);
gtk_scale_add_mark (GTK_SCALE (scale), -12.0, GTK_POS_LEFT, NULL);
gtk_widget_set_size_request (scale, -1, 200);
gtk_grid_attach (GTK_GRID (grid), scale, i, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), label, i, 1, 1, 1);
g_signal_connect (scale, "value-changed",
G_CALLBACK (garu_effects_equalizer_scale_changed),
text);
self->eq_scales = g_slist_append (self->eq_scales, scale);
}
gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 0);
g_settings_bind (self->settings, "equalizer-enabled",
grid, "sensitive", G_SETTINGS_BIND_GET);
g_signal_connect (combo_box, "changed",
G_CALLBACK (garu_effects_equalizer_combo_box_changed),
self);
g_settings_bind (self->settings, "equalizer-preset",
combo_box, "active", G_SETTINGS_BIND_GET);
return vbox;
}
