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; }