robert/alsa-scarlett-gui
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reformat gtkdial.c to match rest of code

Browse Source
This commit is contained in:
Geoffrey D. Bennett
2024-01-14 12:15:15 +10:30
parent b646bc92cc
commit 28604f08a3
2 changed files with 621 additions and 608 deletions
Download Patch File Download Diff File Expand all files Collapse all files

446
src/gtkdial.c
View File

@@ -20,47 +20,57 @@
static void set_value(GtkDial *dial, double newval); static void set_value(GtkDial *dial, double newval);
static void gtk_dial_set_property(GObject *object, static void gtk_dial_set_property(
GObject *object,
guint prop_id, guint prop_id,
const GValue *value, const GValue *value,
GParamSpec *pspec); GParamSpec *pspec
static void gtk_dial_get_property(GObject *object, );
static void gtk_dial_get_property(
GObject *object,
guint prop_id, guint prop_id,
GValue *value, GValue *value,
GParamSpec *pspec); GParamSpec *pspec
);
static void gtk_dial_move_slider(GtkDial *dial, static void gtk_dial_move_slider(GtkDial *dial, GtkScrollType scroll);
GtkScrollType scroll);
static void static void gtk_dial_drag_gesture_begin(
gtk_dial_drag_gesture_begin (GtkGestureDrag *gesture, GtkGestureDrag *gesture,
double offset_x, double offset_x,
double offset_y, double offset_y,
GtkDial *dial); GtkDial *dial
);
static void static void gtk_dial_drag_gesture_update(
gtk_dial_drag_gesture_update (GtkGestureDrag *gesture, GtkGestureDrag *gesture,
double offset_x, double offset_x,
double offset_y, double offset_y,
GtkDial *dial); GtkDial *dial
);
static void static void gtk_dial_drag_gesture_end(
gtk_dial_drag_gesture_end (GtkGestureDrag *gesture, GtkGestureDrag *gesture,
double offset_x, double offset_x,
double offset_y, double offset_y,
GtkDial *dial); GtkDial *dial
);
static void static void gtk_dial_click_gesture_pressed(
gtk_dial_click_gesture_pressed (GtkGestureClick *gesture, GtkGestureClick *gesture,
int n_press, int n_press,
double x, double x,
double y, double y,
GtkDial *dial); GtkDial *dial
);
static gboolean static gboolean gtk_dial_scroll_controller_scroll(
gtk_dial_scroll_controller_scroll (GtkEventControllerScroll *scroll, GtkEventControllerScroll *scroll,
double dx, double dx,
double dy, double dy,
GtkDial *dial); GtkDial *dial
);
static void gtk_dial_dispose(GObject *o); static void gtk_dial_dispose(GObject *o);
@@ -112,13 +122,15 @@ struct _GtkDial {
G_DEFINE_TYPE(GtkDial, gtk_dial, GTK_TYPE_WIDGET) G_DEFINE_TYPE(GtkDial, gtk_dial, GTK_TYPE_WIDGET)
static void dial_snapshot(GtkWidget *widget, GtkSnapshot *snapshot); static void dial_snapshot(GtkWidget *widget, GtkSnapshot *snapshot);
static void dial_measure(GtkWidget *widget, static void dial_measure(
GtkWidget *widget,
GtkOrientation orientation, GtkOrientation orientation,
int for_size, int for_size,
int *minimum, int *minimum,
int *natural, int *natural,
int *minimum_baseline, int *minimum_baseline,
int *natural_baseline); int *natural_baseline
);
#define add_slider_binding(w_class, binding_set, keyval, mask, scroll) \ #define add_slider_binding(w_class, binding_set, keyval, mask, scroll) \
gtk_widget_class_add_binding_signal(w_class, \ gtk_widget_class_add_binding_signal(w_class, \
@@ -135,13 +147,11 @@ static void dial_measure(GtkWidget *widget,
#define DRAG_FACTOR 0.5 #define DRAG_FACTOR 0.5
static inline double calc_valp(double val, double mn, double mx) static inline double calc_valp(double val, double mn, double mx) {
{
return (val - mn) / (mx - mn); return (val - mn) / (mx - mn);
} }
static inline double calc_valp_log(double val, double mn, double mx) static inline double calc_valp_log(double val, double mn, double mx) {
{
if (val <= mn) if (val <= mn)
return 0.0; return 0.0;
if (val >= mx) if (val >= mx)
@@ -157,13 +167,11 @@ static inline double calc_valp_log(double val, double mn, double mx)
return (val - 0.1) / 0.9; return (val - 0.1) / 0.9;
} }
static inline double calc_val(double valp, double mn, double mx) static inline double calc_val(double valp, double mn, double mx) {
{
return (mx - mn) * valp + mn; return (mx - mn) * valp + mn;
} }
struct dial_properties struct dial_properties {
{
double w; double w;
double h; double h;
double radius; double radius;
@@ -177,9 +185,10 @@ struct dial_properties
double slider_cy; double slider_cy;
}; };
static void get_dial_properties(GtkDial *dial, static void get_dial_properties(
struct dial_properties *props) GtkDial *dial,
{ struct dial_properties *props
) {
props->w = gtk_widget_get_width(GTK_WIDGET(dial)); props->w = gtk_widget_get_width(GTK_WIDGET(dial));
props->h = gtk_widget_get_height(GTK_WIDGET(dial)); props->h = gtk_widget_get_height(GTK_WIDGET(dial));
@@ -201,22 +210,26 @@ static void get_dial_properties(GtkDial *dial,
props->slider_cy = sin(props->angle) * radius + props->cy; props->slider_cy = sin(props->angle) * radius + props->cy;
} }
static inline double pdist2(double x1, double y1, double x2, double y2) static inline double pdist2(double x1, double y1, double x2, double y2) {
{
double dx = x2 - x1; double dx = x2 - x1;
double dy = y2 - y1; double dy = y2 - y1;
return dx * dx + dy * dy; return dx * dx + dy * dy;
} }
static inline gboolean circle_contains_point(double cx, double cy, double r, double px, double py) static inline gboolean circle_contains_point(
{ double cx,
double cy,
double r,
double px,
double py
) {
return pdist2(cx, cy, px, py) <= r * r; return pdist2(cx, cy, px, py) <= r * r;
} }
// END SECTION HELPERS // END SECTION HELPERS
static void gtk_dial_class_init(GtkDialClass *klass) static void gtk_dial_class_init(GtkDialClass *klass) {
{
GtkWidgetClass *w_class = GTK_WIDGET_CLASS(klass); GtkWidgetClass *w_class = GTK_WIDGET_CLASS(klass);
GObjectClass *g_class = G_OBJECT_CLASS(klass); GObjectClass *g_class = G_OBJECT_CLASS(klass);
GtkWidgetClass *p_class = GTK_WIDGET_CLASS(gtk_dial_parent_class); GtkWidgetClass *p_class = GTK_WIDGET_CLASS(gtk_dial_parent_class);
@@ -239,38 +252,41 @@ static void gtk_dial_class_init(GtkDialClass *klass)
* *
* The GtkAdjustment that contains the current value of this range object. * The GtkAdjustment that contains the current value of this range object.
*/ */
properties[PROP_ADJUSTMENT] = properties[PROP_ADJUSTMENT] = g_param_spec_object(
g_param_spec_object ("adjustment", "adjustment",
"Adjustment", "Adjustment",
"The GtkAdjustment that contains the current value of this range object", "The GtkAdjustment that contains the current value of this dial object",
GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT); G_PARAM_READWRITE | G_PARAM_CONSTRUCT
);
/** /**
* GtkDial:round_digits: (attributes org.gtk.Method.get=gtk_dial_get_round_digits org.gtk.Method.set=gtk_dial_set_round_digits) * GtkDial:round_digits: (attributes org.gtk.Method.get=gtk_dial_get_round_digits org.gtk.Method.set=gtk_dial_set_round_digits)
* *
* Limits the number of decimal points this GtkDial will store (default 0: integers). * Limits the number of decimal points this GtkDial will store (default 0: integers).
*/ */
properties[PROP_ROUND_DIGITS] = properties[PROP_ROUND_DIGITS] = g_param_spec_int(
g_param_spec_int("round_digits", "round_digits",
"RoundDigits", "RoundDigits",
"Limits the number of decimal points this GtkDial will store", "Limits the number of decimal points this GtkDial will store",
-1, 1000, -1, 1000,
-1, -1,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT); G_PARAM_READWRITE | G_PARAM_CONSTRUCT
);
/** /**
* GtkDial:zero_db: (attributes org.gtk.Method.get=gtk_dial_get_zero_db org.gtk.Method.set=gtk_dial_set_zero_db) * GtkDial:zero_db: (attributes org.gtk.Method.get=gtk_dial_get_zero_db org.gtk.Method.set=gtk_dial_set_zero_db)
* *
* Limits the number of decimal points this GtkDial will store (default 0: integers). * Limits the number of decimal points this GtkDial will store (default 0: integers).
*/ */
properties[PROP_ZERO_DB] = properties[PROP_ZERO_DB] = g_param_spec_double(
g_param_spec_double("zero_db", "zero_db",
"ZerodB", "ZerodB",
"The zero-dB value of the dial", "The zero-dB value of the dial",
-G_MAXDOUBLE, G_MAXDOUBLE, -G_MAXDOUBLE, G_MAXDOUBLE,
0.0, 0.0,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT); G_PARAM_READWRITE | G_PARAM_CONSTRUCT
);
g_object_class_install_properties(g_class, LAST_PROP, properties); g_object_class_install_properties(g_class, LAST_PROP, properties);
@@ -280,14 +296,15 @@ static void gtk_dial_class_init(GtkDialClass *klass)
* *
* Emitted when the range value changes. * Emitted when the range value changes.
*/ */
signals[VALUE_CHANGED] = signals[VALUE_CHANGED] = g_signal_new(
g_signal_new ("value-changed", "value-changed",
G_TYPE_FROM_CLASS(g_class), G_TYPE_FROM_CLASS(g_class),
G_SIGNAL_RUN_LAST, G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GtkDialClass, value_changed), G_STRUCT_OFFSET(GtkDialClass, value_changed),
NULL, NULL, NULL, NULL,
NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0
);
/** /**
* GtkDial::move-slider: * GtkDial::move-slider:
@@ -298,32 +315,25 @@ static void gtk_dial_class_init(GtkDialClass *klass)
* *
* Used for keybindings. * Used for keybindings.
*/ */
signals[MOVE_SLIDER] = signals[MOVE_SLIDER] = g_signal_new(
g_signal_new ("move-slider", "move-slider",
G_TYPE_FROM_CLASS(g_class), G_TYPE_FROM_CLASS(g_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET(GtkDialClass, move_slider), G_STRUCT_OFFSET(GtkDialClass, move_slider),
NULL, NULL, NULL, NULL,
NULL, NULL,
G_TYPE_NONE, 1, G_TYPE_NONE, 1,
GTK_TYPE_SCROLL_TYPE); GTK_TYPE_SCROLL_TYPE
);
add_slider_binding (w_class, binding_set, GDK_KEY_Left, 0, add_slider_binding(w_class, binding_set, GDK_KEY_Left, 0, GTK_SCROLL_STEP_LEFT);
GTK_SCROLL_STEP_LEFT); add_slider_binding(w_class, binding_set, GDK_KEY_Down, 0, GTK_SCROLL_STEP_LEFT);
add_slider_binding (w_class, binding_set, GDK_KEY_Down, 0, add_slider_binding(w_class, binding_set, GDK_KEY_Right, 0, GTK_SCROLL_STEP_RIGHT);
GTK_SCROLL_STEP_LEFT); add_slider_binding(w_class, binding_set, GDK_KEY_Up, 0, GTK_SCROLL_STEP_RIGHT);
add_slider_binding (w_class, binding_set, GDK_KEY_Right, 0, add_slider_binding(w_class, binding_set, GDK_KEY_Page_Up, 0, GTK_SCROLL_PAGE_RIGHT);
GTK_SCROLL_STEP_RIGHT); add_slider_binding(w_class, binding_set, GDK_KEY_Page_Down, 0, GTK_SCROLL_PAGE_LEFT);
add_slider_binding (w_class, binding_set, GDK_KEY_Up, 0, add_slider_binding(w_class, binding_set, GDK_KEY_Home, 0, GTK_SCROLL_START);
GTK_SCROLL_STEP_RIGHT); add_slider_binding(w_class, binding_set, GDK_KEY_End, 0, GTK_SCROLL_END);
add_slider_binding (w_class, binding_set, GDK_KEY_Page_Up, 0,
GTK_SCROLL_PAGE_RIGHT);
add_slider_binding (w_class, binding_set, GDK_KEY_Page_Down, 0,
GTK_SCROLL_PAGE_LEFT);
add_slider_binding (w_class, binding_set, GDK_KEY_Home, 0,
GTK_SCROLL_START);
add_slider_binding (w_class, binding_set, GDK_KEY_End, 0,
GTK_SCROLL_END);
} }
static void gtk_dial_focus_change_cb( static void gtk_dial_focus_change_cb(
@@ -332,69 +342,87 @@ static void gtk_dial_focus_change_cb(
gtk_widget_queue_draw(GTK_WIDGET(dial)); gtk_widget_queue_draw(GTK_WIDGET(dial));
} }
static void gtk_dial_init(GtkDial *dial) static void gtk_dial_init(GtkDial *dial) {
{
// gtk_dial_set_style(dial, "#cdc7c2", "white", "#3584e4");
gtk_dial_set_style(dial, "#cdc7c2", "#f0f0f0", "#3584e4", "#808080"); gtk_dial_set_style(dial, "#cdc7c2", "#f0f0f0", "#3584e4", "#808080");
//gdk_rgba_parse(&dial->colors.trough_border, "#cdc7c2");
gtk_widget_set_focusable(GTK_WIDGET(dial), TRUE); gtk_widget_set_focusable(GTK_WIDGET(dial), TRUE);
//gtk_widget_set_parent(dial->slider_container, GTK_WIDGET(dial) );
dial->adj = NULL; dial->adj = NULL;
dial->grab = GRAB_NONE; dial->grab = GRAB_NONE;
dial->drag_gesture = gtk_gesture_drag_new(); dial->drag_gesture = gtk_gesture_drag_new();
gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(dial->drag_gesture), 0); gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(dial->drag_gesture), 0);
g_signal_connect (dial->drag_gesture, "drag-begin", g_signal_connect(
G_CALLBACK (gtk_dial_drag_gesture_begin), dial); dial->drag_gesture, "drag-begin",
g_signal_connect (dial->drag_gesture, "drag-update", G_CALLBACK(gtk_dial_drag_gesture_begin), dial
G_CALLBACK (gtk_dial_drag_gesture_update), dial); );
g_signal_connect (dial->drag_gesture, "drag-end", g_signal_connect(
G_CALLBACK (gtk_dial_drag_gesture_end), dial); dial->drag_gesture, "drag-update",
gtk_widget_add_controller (GTK_WIDGET (dial), GTK_EVENT_CONTROLLER (dial->drag_gesture) ); G_CALLBACK(gtk_dial_drag_gesture_update), dial
);
g_signal_connect(
dial->drag_gesture, "drag-end",
G_CALLBACK(gtk_dial_drag_gesture_end), dial
);
gtk_widget_add_controller(
GTK_WIDGET(dial), GTK_EVENT_CONTROLLER(dial->drag_gesture)
);
dial->click_gesture = gtk_gesture_click_new(); dial->click_gesture = gtk_gesture_click_new();
//gtk_gesture_long_press_set_delay_factor (GTK_GESTURE_LONG_PRESS (dial->click_gesture), 0.1);
gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(dial->click_gesture), 0); gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(dial->click_gesture), 0);
g_signal_connect (dial->click_gesture, "pressed", g_signal_connect(
G_CALLBACK (gtk_dial_click_gesture_pressed), dial); dial->click_gesture, "pressed",
gtk_widget_add_controller (GTK_WIDGET (dial), GTK_EVENT_CONTROLLER (dial->click_gesture) ); G_CALLBACK(gtk_dial_click_gesture_pressed), dial
);
gtk_widget_add_controller(
GTK_WIDGET(dial), GTK_EVENT_CONTROLLER(dial->click_gesture)
);
gtk_gesture_group(dial->click_gesture, dial->drag_gesture); gtk_gesture_group(dial->click_gesture, dial->drag_gesture);
dial->scroll_controller = gtk_event_controller_scroll_new (GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES); dial->scroll_controller = gtk_event_controller_scroll_new(
g_signal_connect (dial->scroll_controller, "scroll", GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES
G_CALLBACK (gtk_dial_scroll_controller_scroll), dial); );
g_signal_connect(
dial->scroll_controller, "scroll",
G_CALLBACK(gtk_dial_scroll_controller_scroll), dial
);
gtk_widget_add_controller(GTK_WIDGET(dial), dial->scroll_controller); gtk_widget_add_controller(GTK_WIDGET(dial), dial->scroll_controller);
GtkEventController *controller = gtk_event_controller_focus_new(); GtkEventController *controller = gtk_event_controller_focus_new();
g_signal_connect (controller, "enter", G_CALLBACK (gtk_dial_focus_change_cb), dial); g_signal_connect(
g_signal_connect (controller, "leave", G_CALLBACK (gtk_dial_focus_change_cb), dial); controller, "enter", G_CALLBACK(gtk_dial_focus_change_cb), dial
);
g_signal_connect(
controller, "leave", G_CALLBACK(gtk_dial_focus_change_cb), dial
);
gtk_widget_add_controller(GTK_WIDGET(dial), controller); gtk_widget_add_controller(GTK_WIDGET(dial), controller);
} }
static void dial_measure(GtkWidget *widget, static void dial_measure(
GtkWidget *widget,
GtkOrientation orientation, GtkOrientation orientation,
int for_size, int for_size,
int *minimum, int *minimum,
int *natural, int *natural,
int *minimum_baseline, int *minimum_baseline,
int *natural_baseline) int *natural_baseline
{ ) {
*minimum = 50; *minimum = 50;
*natural = 50; *natural = 50;
*minimum_baseline = for_size; *minimum_baseline = for_size;
*natural_baseline = for_size; *natural_baseline = for_size;
} }
static void dial_snapshot(GtkWidget *widget, GtkSnapshot *snapshot) static void dial_snapshot(GtkWidget *widget, GtkSnapshot *snapshot) {
{
GtkDial *dial = GTK_DIAL(widget); GtkDial *dial = GTK_DIAL(widget);
struct dial_properties p; struct dial_properties p;
get_dial_properties(dial, &p); get_dial_properties(dial, &p);
p.valp = CLAMP(p.valp, 0.0001, 1.0); p.valp = CLAMP(p.valp, 0.0001, 1.0);
cairo_t *cr = gtk_snapshot_append_cairo(snapshot, &GRAPHENE_RECT_INIT(0, 0, p.w, p.h) ); cairo_t *cr = gtk_snapshot_append_cairo(
snapshot,
&GRAPHENE_RECT_INIT(0, 0, p.w, p.h)
);
// draw border // draw border
cairo_set_line_width(cr, gtk_widget_has_focus(widget) ? 5 : 2); cairo_set_line_width(cr, gtk_widget_has_focus(widget) ? 5 : 2);
@@ -405,13 +433,23 @@ static void dial_snapshot(GtkWidget *widget, GtkSnapshot *snapshot)
cairo_stroke(cr); cairo_stroke(cr);
// bg trough // bg trough
cairo_arc(cr, p.cx, p.cy, (2*p.radius-p.thickness)/2.0, ANGLE_START, ANGLE_END); cairo_arc(
cr,
p.cx, p.cy,
(2 * p.radius - p.thickness) / 2.0,
ANGLE_START, ANGLE_END
);
cairo_set_line_width(cr, p.thickness); cairo_set_line_width(cr, p.thickness);
gdk_cairo_set_source_rgba(cr, &dial->colors.trough_bg); gdk_cairo_set_source_rgba(cr, &dial->colors.trough_bg);
cairo_stroke(cr); cairo_stroke(cr);
// fill trough // fill trough
cairo_arc(cr, p.cx, p.cy, (2*p.radius-p.thickness)/2.0, ANGLE_START, p.angle); cairo_arc(
cr,
p.cx, p.cy,
(2 * p.radius - p.thickness) / 2.0,
ANGLE_START, p.angle
);
cairo_set_line_width(cr, p.thickness); cairo_set_line_width(cr, p.thickness);
gdk_cairo_set_source_rgba(cr, &dial->colors.trough_fill); gdk_cairo_set_source_rgba(cr, &dial->colors.trough_fill);
cairo_stroke(cr); cairo_stroke(cr);
@@ -424,35 +462,22 @@ static void dial_snapshot(GtkWidget *widget, GtkSnapshot *snapshot)
cairo_stroke(cr); cairo_stroke(cr);
cairo_destroy(cr); cairo_destroy(cr);
// //FILL SLIDER
// cairo_arc(cr, p.slider_cx, p.slider_cy, p.slider_radius, 0, 2*M_PI);
// gdk_cairo_set_source_rgba(cr, &dial->colors.trough_bg);
// cairo_fill(cr);
//
// //STROKE SLIDER
// GdkRGBA *scolor = dial->grab != GRAB_SLIDER ? &dial->colors.trough_border : &dial->colors.trough_fill;
// cairo_arc(cr, p.slider_cx, p.slider_cy, p.slider_radius, 0, 2*M_PI);
// cairo_set_line_width(cr, 1);
// gdk_cairo_set_source_rgba(cr, scolor);
// cairo_stroke(cr);
} }
GtkWidget* gtk_dial_new(GtkAdjustment *adjustment) GtkWidget *gtk_dial_new(GtkAdjustment *adjustment) {
{ g_return_val_if_fail(
g_return_val_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment), adjustment == NULL || GTK_IS_ADJUSTMENT(adjustment),
NULL); NULL
);
return g_object_new (GTK_TYPE_DIAL, return g_object_new(
GTK_TYPE_DIAL,
"adjustment", adjustment, "adjustment", adjustment,
NULL); NULL
);
} }
GtkWidget * GtkWidget *gtk_dial_new_with_range(double min, double max, double step) {
gtk_dial_new_with_range ( double min,
double max,
double step)
{
GtkAdjustment *adj; GtkAdjustment *adj;
int digits; int digits;
@@ -461,31 +486,31 @@ gtk_dial_new_with_range ( double min,
adj = gtk_adjustment_new(min, min, max, step, 10 * step, 0); adj = gtk_adjustment_new(min, min, max, step, 10 * step, 0);
if (fabs(step) >= 1.0 || step == 0.0) if (fabs(step) >= 1.0 || step == 0.0) {
{
digits = 0; digits = 0;
} } else {
else
{
digits = abs((int)floor(log10(fabs(step)))); digits = abs((int)floor(log10(fabs(step))));
if (digits > 5) if (digits > 5)
digits = 5; digits = 5;
} }
return g_object_new (GTK_TYPE_DIAL,
return g_object_new(
GTK_TYPE_DIAL,
"adjustment", adj, "adjustment", adj,
"round_digits", 0, "round_digits", 0,
NULL); NULL
);
} }
static void gtk_dial_set_property (GObject *object, static void gtk_dial_set_property(
GObject *object,
guint prop_id, guint prop_id,
const GValue *value, const GValue *value,
GParamSpec *pspec) GParamSpec *pspec
{ ) {
GtkDial *dial = GTK_DIAL(object); GtkDial *dial = GTK_DIAL(object);
switch(prop_id) switch (prop_id) {
{
case PROP_ADJUSTMENT: case PROP_ADJUSTMENT:
gtk_dial_set_adjustment(dial, g_value_get_object(value)); gtk_dial_set_adjustment(dial, g_value_get_object(value));
break; break;
@@ -501,15 +526,15 @@ static void gtk_dial_set_property (GObject *object,
} }
} }
static void gtk_dial_get_property (GObject *object, static void gtk_dial_get_property(
GObject *object,
guint prop_id, guint prop_id,
GValue *value, GValue *value,
GParamSpec *pspec) GParamSpec *pspec
{ ) {
GtkDial *dial = GTK_DIAL(object); GtkDial *dial = GTK_DIAL(object);
switch(prop_id) switch (prop_id) {
{
case PROP_ADJUSTMENT: case PROP_ADJUSTMENT:
g_value_set_object(value, dial->adj); g_value_set_object(value, dial->adj);
break; break;
@@ -525,47 +550,41 @@ static void gtk_dial_get_property (GObject *object,
} }
} }
double gtk_dial_get_value (GtkDial *dial) double gtk_dial_get_value(GtkDial *dial) {
{
return gtk_adjustment_get_value(dial->adj); return gtk_adjustment_get_value(dial->adj);
} }
void gtk_dial_set_value (GtkDial *dial, void gtk_dial_set_value(GtkDial *dial, double value) {
double value)
{
set_value(dial, value); set_value(dial, value);
gtk_widget_queue_draw(GTK_WIDGET(dial)); gtk_widget_queue_draw(GTK_WIDGET(dial));
} }
void gtk_dial_set_round_digits (GtkDial *dial, void gtk_dial_set_round_digits(GtkDial *dial, int round_digits) {
int round_digits)
{
dial->round_digits = round_digits; dial->round_digits = round_digits;
gtk_dial_set_value(dial, gtk_dial_get_value(dial)); gtk_dial_set_value(dial, gtk_dial_get_value(dial));
} }
int gtk_dial_get_round_digits (GtkDial *dial) int gtk_dial_get_round_digits(GtkDial *dial) {
{
return dial->round_digits; return dial->round_digits;
} }
void gtk_dial_set_zero_db(GtkDial *dial, double zero_db) void gtk_dial_set_zero_db(GtkDial *dial, double zero_db) {
{
dial->zero_db = zero_db; dial->zero_db = zero_db;
} }
double gtk_dial_get_zero_db(GtkDial *dial) double gtk_dial_get_zero_db(GtkDial *dial) {
{
return dial->zero_db; return dial->zero_db;
} }
gboolean gtk_dial_set_style(GtkDial *dial, gboolean gtk_dial_set_style(
GtkDial *dial,
const char *trough_border, const char *trough_border,
const char *trough_bg, const char *trough_bg,
const char *trough_fill, const char *trough_fill,
const char *pointer) const char *pointer
{ ) {
gboolean out = TRUE; gboolean out = TRUE;
if (trough_border) if (trough_border)
out = out && gdk_rgba_parse(&dial->colors.trough_border, trough_border); out = out && gdk_rgba_parse(&dial->colors.trough_border, trough_border);
if (trough_bg) if (trough_bg)
@@ -578,9 +597,7 @@ gboolean gtk_dial_set_style(GtkDial *dial,
return out; return out;
} }
void gtk_dial_set_adjustment (GtkDial *dial, void gtk_dial_set_adjustment(GtkDial *dial, GtkAdjustment *adj) {
GtkAdjustment *adj)
{
if (!(adj == NULL || GTK_IS_ADJUSTMENT(adj))) if (!(adj == NULL || GTK_IS_ADJUSTMENT(adj)))
return; return;
if (dial->adj) if (dial->adj)
@@ -591,16 +608,12 @@ void gtk_dial_set_adjustment (GtkDial *dial,
gtk_widget_queue_draw(GTK_WIDGET(dial)); gtk_widget_queue_draw(GTK_WIDGET(dial));
} }
GtkAdjustment* gtk_dial_get_adjustment (GtkDial *dial) GtkAdjustment *gtk_dial_get_adjustment(GtkDial *dial) {
{
return dial->adj; return dial->adj;
} }
static void static void set_value(GtkDial *dial, double newval) {
set_value (GtkDial *dial, double newval) if (dial->round_digits >= 0) {
{
if (dial->round_digits >= 0)
{
double power; double power;
int i; int i;
@@ -611,68 +624,56 @@ set_value (GtkDial *dial, double newval)
newval = floor((newval * power) + 0.5) / power; newval = floor((newval * power) + 0.5) / power;
} }
gtk_adjustment_set_value(dial->adj, newval); gtk_adjustment_set_value(dial->adj, newval);
g_signal_emit(dial, signals[VALUE_CHANGED], 0); g_signal_emit(dial, signals[VALUE_CHANGED], 0);
} }
static void static void step_back(GtkDial *dial) {
step_back (GtkDial *dial)
{
double newval; double newval;
newval = gtk_adjustment_get_value(dial->adj) - gtk_adjustment_get_step_increment(dial->adj); newval = gtk_adjustment_get_value(dial->adj) - gtk_adjustment_get_step_increment(dial->adj);
set_value(dial, newval); set_value(dial, newval);
} }
static void static void step_forward(GtkDial *dial) {
step_forward (GtkDial *dial)
{
double newval; double newval;
newval = gtk_adjustment_get_value(dial->adj) + gtk_adjustment_get_step_increment(dial->adj); newval = gtk_adjustment_get_value(dial->adj) + gtk_adjustment_get_step_increment(dial->adj);
set_value(dial, newval); set_value(dial, newval);
} }
static void static void page_back(GtkDial *dial) {
page_back (GtkDial *dial)
{
double newval; double newval;
newval = gtk_adjustment_get_value(dial->adj) - gtk_adjustment_get_page_increment(dial->adj); newval = gtk_adjustment_get_value(dial->adj) - gtk_adjustment_get_page_increment(dial->adj);
set_value(dial, newval); set_value(dial, newval);
} }
static void static void page_forward(GtkDial *dial) {
page_forward (GtkDial *dial)
{
double newval; double newval;
newval = gtk_adjustment_get_value(dial->adj) + gtk_adjustment_get_page_increment(dial->adj); newval = gtk_adjustment_get_value(dial->adj) + gtk_adjustment_get_page_increment(dial->adj);
set_value(dial, newval); set_value(dial, newval);
} }
static void static void scroll_begin(GtkDial *dial) {
scroll_begin (GtkDial *dial)
{
double newval = gtk_adjustment_get_lower(dial->adj); double newval = gtk_adjustment_get_lower(dial->adj);
set_value(dial, newval); set_value(dial, newval);
} }
static void scroll_end(GtkDial *dial) static void scroll_end(GtkDial *dial) {
{
double newval = gtk_adjustment_get_upper(dial->adj) - gtk_adjustment_get_page_size(dial->adj); double newval = gtk_adjustment_get_upper(dial->adj) - gtk_adjustment_get_page_size(dial->adj);
set_value(dial, newval); set_value(dial, newval);
} }
static gboolean should_invert_move(GtkDial *dial, GtkOrientation o) static gboolean should_invert_move(GtkDial *dial, GtkOrientation o) {
{
return FALSE; return FALSE;
} }
static void gtk_dial_move_slider(GtkDial *dial, static void gtk_dial_move_slider(GtkDial *dial, GtkScrollType scroll) {
GtkScrollType scroll)
{
switch (scroll) { switch (scroll) {
case GTK_SCROLL_STEP_LEFT: case GTK_SCROLL_STEP_LEFT:
if (should_invert_move(dial, GTK_ORIENTATION_HORIZONTAL)) if (should_invert_move(dial, GTK_ORIENTATION_HORIZONTAL))
@@ -763,22 +764,26 @@ static void gtk_dial_move_slider(GtkDial *dial,
gtk_widget_queue_draw(GTK_WIDGET(dial)); gtk_widget_queue_draw(GTK_WIDGET(dial));
} }
static void static void gtk_dial_drag_gesture_begin(
gtk_dial_drag_gesture_begin (GtkGestureDrag *gesture, GtkGestureDrag *gesture,
double offset_x, double offset_x,
double offset_y, double offset_y,
GtkDial *dial) GtkDial *dial
{ ) {
dial->dvalp = calc_valp(gtk_dial_get_value(dial), gtk_adjustment_get_lower(dial->adj), gtk_adjustment_get_upper(dial->adj) ); dial->dvalp = calc_valp(
gtk_dial_get_value(dial),
gtk_adjustment_get_lower(dial->adj),
gtk_adjustment_get_upper(dial->adj)
);
gtk_gesture_set_state(dial->drag_gesture, GTK_EVENT_SEQUENCE_CLAIMED); gtk_gesture_set_state(dial->drag_gesture, GTK_EVENT_SEQUENCE_CLAIMED);
} }
static void static void gtk_dial_drag_gesture_update(
gtk_dial_drag_gesture_update (GtkGestureDrag *gesture, GtkGestureDrag *gesture,
double offset_x, double offset_x,
double offset_y, double offset_y,
GtkDial *dial) GtkDial *dial
{ ) {
double start_x, start_y; double start_x, start_y;
gtk_gesture_drag_get_start_point(gesture, &start_x, &start_y); gtk_gesture_drag_get_start_point(gesture, &start_x, &start_y);
@@ -789,36 +794,43 @@ gtk_dial_drag_gesture_update (GtkGestureDrag *gesture,
double valp = dial->dvalp - DRAG_FACTOR * (offset_y / p.h); double valp = dial->dvalp - DRAG_FACTOR * (offset_y / p.h);
valp = CLAMP(valp, 0.0, 1.0); valp = CLAMP(valp, 0.0, 1.0);
double val = calc_val(valp, gtk_adjustment_get_lower(dial->adj), gtk_adjustment_get_upper(dial->adj) ); double val = calc_val(
valp,
gtk_adjustment_get_lower(dial->adj),
gtk_adjustment_get_upper(dial->adj)
);
set_value(dial, val); set_value(dial, val);
gtk_widget_queue_draw(GTK_WIDGET(dial)); gtk_widget_queue_draw(GTK_WIDGET(dial));
} }
static void static void gtk_dial_drag_gesture_end(
gtk_dial_drag_gesture_end (GtkGestureDrag *gesture, GtkGestureDrag *gesture,
double offset_x, double offset_x,
double offset_y, double offset_y,
GtkDial *dial) GtkDial *dial
{ ) {
dial->grab = GRAB_NONE; dial->grab = GRAB_NONE;
gtk_widget_queue_draw(GTK_WIDGET(dial)); gtk_widget_queue_draw(GTK_WIDGET(dial));
} }
static void static void gtk_dial_click_gesture_pressed(
gtk_dial_click_gesture_pressed (GtkGestureClick *gesture, GtkGestureClick *gesture,
int n_press, int n_press,
double x, double x,
double y, double y,
GtkDial *dial) GtkDial *dial
{ ) {
// on double (or more) click, toggle between lower and zero_db value // on double (or more) click, toggle between lower and zero_db value
if (n_press >= 2) { if (n_press >= 2) {
double lower = gtk_adjustment_get_lower(dial->adj); double lower = gtk_adjustment_get_lower(dial->adj);
if (gtk_dial_get_value(dial) != lower) if (gtk_dial_get_value(dial) != lower)
set_value(dial, lower); set_value(dial, lower);
else else
set_value(dial, dial->zero_db); set_value(dial, dial->zero_db);
return; return;
} }
@@ -827,24 +839,29 @@ gtk_dial_click_gesture_pressed (GtkGestureClick *gesture,
gtk_widget_grab_focus(GTK_WIDGET(dial)); gtk_widget_grab_focus(GTK_WIDGET(dial));
struct dial_properties p; struct dial_properties p;
get_dial_properties(dial, &p); get_dial_properties(dial, &p);
if (circle_contains_point(p.slider_cx, p.slider_cy, p.slider_radius, x, y)) if (circle_contains_point(p.slider_cx, p.slider_cy, p.slider_radius, x, y))
dial->grab = GRAB_SLIDER; dial->grab = GRAB_SLIDER;
else else
dial->grab = GRAB_NONE; dial->grab = GRAB_NONE;
gtk_widget_queue_draw(GTK_WIDGET(dial)); gtk_widget_queue_draw(GTK_WIDGET(dial));
gtk_gesture_set_state(GTK_GESTURE(gesture), GTK_EVENT_SEQUENCE_CLAIMED); gtk_gesture_set_state(GTK_GESTURE(gesture), GTK_EVENT_SEQUENCE_CLAIMED);
} }
static gboolean static gboolean gtk_dial_scroll_controller_scroll(
gtk_dial_scroll_controller_scroll (GtkEventControllerScroll *scroll, GtkEventControllerScroll *scroll,
double dx, double dx,
double dy, double dy,
GtkDial *dial) GtkDial *dial
{ ) {
double delta = dx ? dx : dy, absolute_delta = fabs(delta); double delta = dx ? dx : dy;
double absolute_delta = fabs(delta);
if (absolute_delta > 1) if (absolute_delta > 1)
delta *= absolute_delta; delta *= absolute_delta;
double step = -gtk_adjustment_get_step_increment(dial->adj) * delta; double step = -gtk_adjustment_get_step_increment(dial->adj) * delta;
set_value(dial, gtk_adjustment_get_value(dial->adj) + step); set_value(dial, gtk_adjustment_get_value(dial->adj) + step);
@@ -853,8 +870,7 @@ gtk_dial_scroll_controller_scroll (GtkEventControllerScroll *scroll,
return GDK_EVENT_STOP; return GDK_EVENT_STOP;
} }
void gtk_dial_dispose(GObject *o) void gtk_dial_dispose(GObject *o) {
{
GtkDial *dial = GTK_DIAL(o); GtkDial *dial = GTK_DIAL(o);
g_object_unref(dial->adj); g_object_unref(dial->adj);
dial->adj = NULL; dial->adj = NULL;

37
src/gtkdial.h
View File

@@ -24,44 +24,40 @@ G_BEGIN_DECLS
typedef struct _GtkDial GtkDial; typedef struct _GtkDial GtkDial;
typedef struct _GtkDialClass GtkDialClass; typedef struct _GtkDialClass GtkDialClass;
struct _GtkDialClass struct _GtkDialClass {
{
GtkWidgetClass parent_class; GtkWidgetClass parent_class;
void (*value_changed)(GtkDial *dial); void (*value_changed)(GtkDial *dial);
/* action signals for keybindings */ /* action signals for keybindings */
void (* move_slider) (GtkDial *dial, void (*move_slider)(GtkDial *dial, GtkScrollType scroll);
GtkScrollType scroll);
gboolean (*change_value) (GtkDial *dial, gboolean (*change_value)(
GtkDial *dial,
GtkScrollType scroll, GtkScrollType scroll,
double new_value); double new_value
);
}; };
GType gtk_dial_get_type(void) G_GNUC_CONST; GType gtk_dial_get_type(void) G_GNUC_CONST;
GtkWidget *gtk_dial_new(GtkAdjustment *adjustment); GtkWidget *gtk_dial_new(GtkAdjustment *adjustment);
GtkWidget * gtk_dial_new_with_range (double min,
double max, GtkWidget *gtk_dial_new_with_range(double min, double max, double step);
double step);
void gtk_dial_set_has_origin (GtkDial *dial, void gtk_dial_set_has_origin(GtkDial *dial, gboolean has_origin);
gboolean has_origin);
gboolean gtk_dial_get_has_origin(GtkDial *dial); gboolean gtk_dial_get_has_origin(GtkDial *dial);
void gtk_dial_set_adjustment (GtkDial *dial, void gtk_dial_set_adjustment(GtkDial *dial, GtkAdjustment *adj);
GtkAdjustment *adj);
GtkAdjustment *gtk_dial_get_adjustment(GtkDial *dial); GtkAdjustment *gtk_dial_get_adjustment(GtkDial *dial);
double gtk_dial_get_value(GtkDial *dial); double gtk_dial_get_value(GtkDial *dial);
void gtk_dial_set_value(GtkDial *dial, double value);
void gtk_dial_set_value (GtkDial *dial, void gtk_dial_set_round_digits(GtkDial *dial, int round_digits);
double value);
void gtk_dial_set_round_digits (GtkDial *dial,
int round_digits);
int gtk_dial_get_round_digits(GtkDial *range); int gtk_dial_get_round_digits(GtkDial *range);
void gtk_dial_set_zero_db (GtkDial *dial,
double zero_db); void gtk_dial_set_zero_db(GtkDial *dial, double zero_db);
double gtk_dial_get_zero_db(GtkDial *range); double gtk_dial_get_zero_db(GtkDial *range);
/** /**
@@ -83,6 +79,7 @@ gboolean gtk_dial_set_style(GtkDial *dial,
const char *trough_bg, const char *trough_bg,
const char *trough_fill, const char *trough_fill,
const char *pointer); const char *pointer);
G_END_DECLS G_END_DECLS
#endif #endif