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 gtk_dial_set_property(GObject *object,
static void gtk_dial_set_property(
GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_dial_get_property(GObject *object,
GParamSpec *pspec
);
static void gtk_dial_get_property(
GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
GParamSpec *pspec
);
static void gtk_dial_move_slider(GtkDial *dial,
GtkScrollType scroll);
static void
gtk_dial_drag_gesture_begin (GtkGestureDrag *gesture,
static void gtk_dial_move_slider(GtkDial *dial, GtkScrollType scroll);
static void gtk_dial_drag_gesture_begin(
GtkGestureDrag *gesture,
double offset_x,
double offset_y,
GtkDial *dial);
GtkDial *dial
);
static void
gtk_dial_drag_gesture_update (GtkGestureDrag *gesture,
static void gtk_dial_drag_gesture_update(
GtkGestureDrag *gesture,
double offset_x,
double offset_y,
GtkDial *dial);
GtkDial *dial
);
static void
gtk_dial_drag_gesture_end (GtkGestureDrag *gesture,
static void gtk_dial_drag_gesture_end(
GtkGestureDrag *gesture,
double offset_x,
double offset_y,
GtkDial *dial);
GtkDial *dial
);
static void
gtk_dial_click_gesture_pressed (GtkGestureClick *gesture,
static void gtk_dial_click_gesture_pressed(
GtkGestureClick *gesture,
int n_press,
double x,
double y,
GtkDial *dial);
GtkDial *dial
);
static gboolean
gtk_dial_scroll_controller_scroll (GtkEventControllerScroll *scroll,
static gboolean gtk_dial_scroll_controller_scroll(
GtkEventControllerScroll *scroll,
double dx,
double dy,
GtkDial *dial);
GtkDial *dial
);
static void gtk_dial_dispose(GObject *o);
@@ -112,13 +122,15 @@ struct _GtkDial {
G_DEFINE_TYPE(GtkDial, gtk_dial, GTK_TYPE_WIDGET)
static void dial_snapshot(GtkWidget *widget, GtkSnapshot *snapshot);
static void dial_measure(GtkWidget *widget,
static void dial_measure(
GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline);
int *natural_baseline
);
#define add_slider_binding(w_class, binding_set, keyval, mask, scroll) \
gtk_widget_class_add_binding_signal(w_class, \
@@ -135,13 +147,11 @@ static void dial_measure(GtkWidget *widget,
#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);
}
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)
return 0.0;
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;
}
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;
}
struct dial_properties
{
struct dial_properties {
double w;
double h;
double radius;
@@ -177,9 +185,10 @@ struct dial_properties
double slider_cy;
};
static void get_dial_properties(GtkDial *dial,
struct dial_properties *props)
{
static void get_dial_properties(
GtkDial *dial,
struct dial_properties *props
) {
props->w = gtk_widget_get_width(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;
}
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 dy = y2 - y1;
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;
}
// 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);
GObjectClass *g_class = G_OBJECT_CLASS(klass);
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.
*/
properties[PROP_ADJUSTMENT] =
g_param_spec_object ("adjustment",
properties[PROP_ADJUSTMENT] = g_param_spec_object(
"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,
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)
*
* Limits the number of decimal points this GtkDial will store (default 0: integers).
*/
properties[PROP_ROUND_DIGITS] =
g_param_spec_int("round_digits",
properties[PROP_ROUND_DIGITS] = g_param_spec_int(
"round_digits",
"RoundDigits",
"Limits the number of decimal points this GtkDial will store",
-1, 1000,
-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)
*
* Limits the number of decimal points this GtkDial will store (default 0: integers).
*/
properties[PROP_ZERO_DB] =
g_param_spec_double("zero_db",
properties[PROP_ZERO_DB] = g_param_spec_double(
"zero_db",
"ZerodB",
"The zero-dB value of the dial",
-G_MAXDOUBLE, G_MAXDOUBLE,
0.0,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT);
G_PARAM_READWRITE | G_PARAM_CONSTRUCT
);
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.
*/
signals[VALUE_CHANGED] =
g_signal_new ("value-changed",
signals[VALUE_CHANGED] = g_signal_new(
"value-changed",
G_TYPE_FROM_CLASS(g_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GtkDialClass, value_changed),
NULL, NULL,
NULL,
G_TYPE_NONE, 0);
G_TYPE_NONE, 0
);
/**
* GtkDial::move-slider:
@@ -298,32 +315,25 @@ static void gtk_dial_class_init(GtkDialClass *klass)
*
* Used for keybindings.
*/
signals[MOVE_SLIDER] =
g_signal_new ("move-slider",
signals[MOVE_SLIDER] = g_signal_new(
"move-slider",
G_TYPE_FROM_CLASS(g_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET(GtkDialClass, move_slider),
NULL, NULL,
NULL,
G_TYPE_NONE, 1,
GTK_TYPE_SCROLL_TYPE);
GTK_TYPE_SCROLL_TYPE
);
add_slider_binding (w_class, binding_set, GDK_KEY_Left, 0,
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_Right, 0,
GTK_SCROLL_STEP_RIGHT);
add_slider_binding (w_class, binding_set, GDK_KEY_Up, 0,
GTK_SCROLL_STEP_RIGHT);
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);
add_slider_binding(w_class, binding_set, GDK_KEY_Left, 0, 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_Right, 0, GTK_SCROLL_STEP_RIGHT);
add_slider_binding(w_class, binding_set, GDK_KEY_Up, 0, GTK_SCROLL_STEP_RIGHT);
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(
@@ -332,69 +342,87 @@ static void gtk_dial_focus_change_cb(
gtk_widget_queue_draw(GTK_WIDGET(dial));
}
static void gtk_dial_init(GtkDial *dial)
{
// gtk_dial_set_style(dial, "#cdc7c2", "white", "#3584e4");
static void gtk_dial_init(GtkDial *dial) {
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_parent(dial->slider_container, GTK_WIDGET(dial) );
dial->adj = NULL;
dial->grab = GRAB_NONE;
dial->drag_gesture = gtk_gesture_drag_new();
gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(dial->drag_gesture), 0);
g_signal_connect (dial->drag_gesture, "drag-begin",
G_CALLBACK (gtk_dial_drag_gesture_begin), dial);
g_signal_connect (dial->drag_gesture, "drag-update",
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) );
g_signal_connect(
dial->drag_gesture, "drag-begin",
G_CALLBACK(gtk_dial_drag_gesture_begin), dial
);
g_signal_connect(
dial->drag_gesture, "drag-update",
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();
//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);
g_signal_connect (dial->click_gesture, "pressed",
G_CALLBACK (gtk_dial_click_gesture_pressed), dial);
gtk_widget_add_controller (GTK_WIDGET (dial), GTK_EVENT_CONTROLLER (dial->click_gesture) );
g_signal_connect(
dial->click_gesture, "pressed",
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);
dial->scroll_controller = gtk_event_controller_scroll_new (GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES);
g_signal_connect (dial->scroll_controller, "scroll",
G_CALLBACK (gtk_dial_scroll_controller_scroll), dial);
dial->scroll_controller = gtk_event_controller_scroll_new(
GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES
);
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);
GtkEventController *controller = gtk_event_controller_focus_new();
g_signal_connect (controller, "enter", G_CALLBACK (gtk_dial_focus_change_cb), dial);
g_signal_connect (controller, "leave", G_CALLBACK (gtk_dial_focus_change_cb), dial);
g_signal_connect(
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);
}
static void dial_measure(GtkWidget *widget,
static void dial_measure(
GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
int *natural_baseline
) {
*minimum = 50;
*natural = 50;
*minimum_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);
struct dial_properties p;
get_dial_properties(dial, &p);
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
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);
// 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);
gdk_cairo_set_source_rgba(cr, &dial->colors.trough_bg);
cairo_stroke(cr);
// 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);
gdk_cairo_set_source_rgba(cr, &dial->colors.trough_fill);
cairo_stroke(cr);
@@ -424,35 +462,22 @@ static void dial_snapshot(GtkWidget *widget, GtkSnapshot *snapshot)
cairo_stroke(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)
{
g_return_val_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment),
NULL);
GtkWidget *gtk_dial_new(GtkAdjustment *adjustment) {
g_return_val_if_fail(
adjustment == NULL || GTK_IS_ADJUSTMENT(adjustment),
NULL
);
return g_object_new (GTK_TYPE_DIAL,
return g_object_new(
GTK_TYPE_DIAL,
"adjustment", adjustment,
NULL);
NULL
);
}
GtkWidget *
gtk_dial_new_with_range ( double min,
double max,
double step)
{
GtkWidget *gtk_dial_new_with_range(double min, double max, double step) {
GtkAdjustment *adj;
int digits;
@@ -461,31 +486,31 @@ gtk_dial_new_with_range ( double min,
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;
}
else
{
} else {
digits = abs((int)floor(log10(fabs(step))));
if (digits > 5)
digits = 5;
}
return g_object_new (GTK_TYPE_DIAL,
return g_object_new(
GTK_TYPE_DIAL,
"adjustment", adj,
"round_digits", 0,
NULL);
NULL
);
}
static void gtk_dial_set_property (GObject *object,
static void gtk_dial_set_property(
GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GParamSpec *pspec
) {
GtkDial *dial = GTK_DIAL(object);
switch(prop_id)
{
switch (prop_id) {
case PROP_ADJUSTMENT:
gtk_dial_set_adjustment(dial, g_value_get_object(value));
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,
GValue *value,
GParamSpec *pspec)
{
GParamSpec *pspec
) {
GtkDial *dial = GTK_DIAL(object);
switch(prop_id)
{
switch (prop_id) {
case PROP_ADJUSTMENT:
g_value_set_object(value, dial->adj);
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);
}
void gtk_dial_set_value (GtkDial *dial,
double value)
{
void gtk_dial_set_value(GtkDial *dial, double value) {
set_value(dial, value);
gtk_widget_queue_draw(GTK_WIDGET(dial));
}
void gtk_dial_set_round_digits (GtkDial *dial,
int round_digits)
{
void gtk_dial_set_round_digits(GtkDial *dial, int round_digits) {
dial->round_digits = round_digits;
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;
}
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;
}
double gtk_dial_get_zero_db(GtkDial *dial)
{
double gtk_dial_get_zero_db(GtkDial *dial) {
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_bg,
const char *trough_fill,
const char *pointer)
{
const char *pointer
) {
gboolean out = TRUE;
if (trough_border)
out = out && gdk_rgba_parse(&dial->colors.trough_border, trough_border);
if (trough_bg)
@@ -578,9 +597,7 @@ gboolean gtk_dial_set_style(GtkDial *dial,
return out;
}
void gtk_dial_set_adjustment (GtkDial *dial,
GtkAdjustment *adj)
{
void gtk_dial_set_adjustment(GtkDial *dial, GtkAdjustment *adj) {
if (!(adj == NULL || GTK_IS_ADJUSTMENT(adj)))
return;
if (dial->adj)
@@ -591,16 +608,12 @@ void gtk_dial_set_adjustment (GtkDial *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;
}
static void
set_value (GtkDial *dial, double newval)
{
if (dial->round_digits >= 0)
{
static void set_value(GtkDial *dial, double newval) {
if (dial->round_digits >= 0) {
double power;
int i;
@@ -611,68 +624,56 @@ set_value (GtkDial *dial, double newval)
newval = floor((newval * power) + 0.5) / power;
}
gtk_adjustment_set_value(dial->adj, newval);
g_signal_emit(dial, signals[VALUE_CHANGED], 0);
}
static void
step_back (GtkDial *dial)
{
static void step_back(GtkDial *dial) {
double newval;
newval = gtk_adjustment_get_value(dial->adj) - gtk_adjustment_get_step_increment(dial->adj);
set_value(dial, newval);
}
static void
step_forward (GtkDial *dial)
{
static void step_forward(GtkDial *dial) {
double newval;
newval = gtk_adjustment_get_value(dial->adj) + gtk_adjustment_get_step_increment(dial->adj);
set_value(dial, newval);
}
static void
page_back (GtkDial *dial)
{
static void page_back(GtkDial *dial) {
double newval;
newval = gtk_adjustment_get_value(dial->adj) - gtk_adjustment_get_page_increment(dial->adj);
set_value(dial, newval);
}
static void
page_forward (GtkDial *dial)
{
static void page_forward(GtkDial *dial) {
double newval;
newval = gtk_adjustment_get_value(dial->adj) + gtk_adjustment_get_page_increment(dial->adj);
set_value(dial, newval);
}
static void
scroll_begin (GtkDial *dial)
{
static void scroll_begin(GtkDial *dial) {
double newval = gtk_adjustment_get_lower(dial->adj);
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);
set_value(dial, newval);
}
static gboolean should_invert_move(GtkDial *dial, GtkOrientation o)
{
static gboolean should_invert_move(GtkDial *dial, GtkOrientation o) {
return FALSE;
}
static void gtk_dial_move_slider(GtkDial *dial,
GtkScrollType scroll)
{
static void gtk_dial_move_slider(GtkDial *dial, GtkScrollType scroll) {
switch (scroll) {
case GTK_SCROLL_STEP_LEFT:
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));
}
static void
gtk_dial_drag_gesture_begin (GtkGestureDrag *gesture,
static void gtk_dial_drag_gesture_begin(
GtkGestureDrag *gesture,
double offset_x,
double offset_y,
GtkDial *dial)
{
dial->dvalp = calc_valp(gtk_dial_get_value(dial), gtk_adjustment_get_lower(dial->adj), gtk_adjustment_get_upper(dial->adj) );
GtkDial *dial
) {
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);
}
static void
gtk_dial_drag_gesture_update (GtkGestureDrag *gesture,
static void gtk_dial_drag_gesture_update(
GtkGestureDrag *gesture,
double offset_x,
double offset_y,
GtkDial *dial)
{
GtkDial *dial
) {
double 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);
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);
gtk_widget_queue_draw(GTK_WIDGET(dial));
}
static void
gtk_dial_drag_gesture_end (GtkGestureDrag *gesture,
static void gtk_dial_drag_gesture_end(
GtkGestureDrag *gesture,
double offset_x,
double offset_y,
GtkDial *dial)
{
GtkDial *dial
) {
dial->grab = GRAB_NONE;
gtk_widget_queue_draw(GTK_WIDGET(dial));
}
static void
gtk_dial_click_gesture_pressed (GtkGestureClick *gesture,
static void gtk_dial_click_gesture_pressed(
GtkGestureClick *gesture,
int n_press,
double x,
double y,
GtkDial *dial)
{
GtkDial *dial
) {
// on double (or more) click, toggle between lower and zero_db value
if (n_press >= 2) {
double lower = gtk_adjustment_get_lower(dial->adj);
if (gtk_dial_get_value(dial) != lower)
set_value(dial, lower);
else
set_value(dial, dial->zero_db);
return;
}
@@ -827,24 +839,29 @@ gtk_dial_click_gesture_pressed (GtkGestureClick *gesture,
gtk_widget_grab_focus(GTK_WIDGET(dial));
struct dial_properties p;
get_dial_properties(dial, &p);
if (circle_contains_point(p.slider_cx, p.slider_cy, p.slider_radius, x, y))
dial->grab = GRAB_SLIDER;
else
dial->grab = GRAB_NONE;
gtk_widget_queue_draw(GTK_WIDGET(dial));
gtk_gesture_set_state(GTK_GESTURE(gesture), GTK_EVENT_SEQUENCE_CLAIMED);
}
static gboolean
gtk_dial_scroll_controller_scroll (GtkEventControllerScroll *scroll,
static gboolean gtk_dial_scroll_controller_scroll(
GtkEventControllerScroll *scroll,
double dx,
double dy,
GtkDial *dial)
{
double delta = dx ? dx : dy, absolute_delta = fabs(delta);
GtkDial *dial
) {
double delta = dx ? dx : dy;
double absolute_delta = fabs(delta);
if (absolute_delta > 1)
delta *= absolute_delta;
double step = -gtk_adjustment_get_step_increment(dial->adj) * delta;
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;
}
void gtk_dial_dispose(GObject *o)
{
void gtk_dial_dispose(GObject *o) {
GtkDial *dial = GTK_DIAL(o);
g_object_unref(dial->adj);
dial->adj = NULL;

37
src/gtkdial.h
View File

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