Mercurial > pidgin
comparison finch/libgnt/gntslider.c @ 18352:f1dbe3151051
Add a slider widget.
author | Sadrul Habib Chowdhury <imadil@gmail.com> |
---|---|
date | Fri, 29 Jun 2007 04:56:19 +0000 |
parents | |
children | d5d1c12a5ad4 |
comparison
equal
deleted
inserted
replaced
18351:4f66226418e3 | 18352:f1dbe3151051 |
---|---|
1 /** | |
2 * GNT - The GLib Ncurses Toolkit | |
3 * | |
4 * GNT is the legal property of its developers, whose names are too numerous | |
5 * to list here. Please refer to the COPYRIGHT file distributed with this | |
6 * source distribution. | |
7 * | |
8 * This library is free software; you can redistribute it and/or modify | |
9 * it under the terms of the GNU General Public License as published by | |
10 * the Free Software Foundation; either version 2 of the License, or | |
11 * (at your option) any later version. | |
12 * | |
13 * This program is distributed in the hope that it will be useful, | |
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 * GNU General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU General Public License | |
19 * along with this program; if not, write to the Free Software | |
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
21 */ | |
22 | |
23 #include "gntcolors.h" | |
24 #include "gntkeys.h" | |
25 #include "gntslider.h" | |
26 #include "gntstyle.h" | |
27 | |
28 enum | |
29 { | |
30 SIG_VALUE_CHANGED, | |
31 SIGS, | |
32 }; | |
33 | |
34 static guint signals[SIGS] = { 0 }; | |
35 | |
36 static GntWidgetClass *parent_class = NULL; | |
37 | |
38 /* returns TRUE if the value was changed */ | |
39 static gboolean | |
40 sanitize_value(GntSlider *slider) | |
41 { | |
42 if (slider->current < slider->min) | |
43 slider->current = slider->min; | |
44 else if (slider->current > slider->max) | |
45 slider->current = slider->max; | |
46 else | |
47 return FALSE; | |
48 return TRUE; | |
49 } | |
50 | |
51 static void | |
52 redraw_slider(GntSlider *slider) | |
53 { | |
54 GntWidget *widget = GNT_WIDGET(slider); | |
55 if (GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_MAPPED)) | |
56 gnt_widget_draw(widget); | |
57 } | |
58 | |
59 static void | |
60 slider_value_changed(GntSlider *slider) | |
61 { | |
62 g_signal_emit(slider, signals[SIG_VALUE_CHANGED], 0, slider->current); | |
63 } | |
64 | |
65 static void | |
66 gnt_slider_draw(GntWidget *widget) | |
67 { | |
68 GntSlider *slider = GNT_SLIDER(widget); | |
69 int attr = 0; | |
70 int position, size = 0; | |
71 | |
72 if (slider->vertical) | |
73 mvwvline(widget->window, 0, 0, ACS_VLINE | COLOR_PAIR(GNT_COLOR_NORMAL), | |
74 (size = widget->priv.height)); | |
75 else | |
76 mvwhline(widget->window, 0, 0, ACS_HLINE | COLOR_PAIR(GNT_COLOR_NORMAL), | |
77 (size = widget->priv.width)); | |
78 | |
79 if (gnt_widget_has_focus(widget)) | |
80 attr |= GNT_COLOR_HIGHLIGHT; | |
81 else | |
82 attr |= GNT_COLOR_HIGHLIGHT_D; | |
83 | |
84 if (slider->max != slider->min) | |
85 position = ((size - 1) * (slider->current - slider->min)) / (slider->max - slider->min); | |
86 else | |
87 position = 0; | |
88 mvwaddch(widget->window, | |
89 slider->vertical ? (size - position - 1) : 0, | |
90 slider->vertical ? 0 : position, | |
91 ACS_BLOCK | COLOR_PAIR(attr)); | |
92 } | |
93 | |
94 static void | |
95 gnt_slider_size_request(GntWidget *widget) | |
96 { | |
97 if (GNT_SLIDER(widget)->vertical) { | |
98 widget->priv.width = 1; | |
99 widget->priv.height = 5; | |
100 } else { | |
101 widget->priv.width = 5; | |
102 widget->priv.height = 1; | |
103 } | |
104 } | |
105 | |
106 static void | |
107 gnt_slider_map(GntWidget *widget) | |
108 { | |
109 if (widget->priv.width == 0 || widget->priv.height == 0) | |
110 gnt_widget_size_request(widget); | |
111 GNTDEBUG; | |
112 } | |
113 | |
114 static gboolean | |
115 step_back(GntBindable *bindable, GList *null) | |
116 { | |
117 GntSlider *slider = GNT_SLIDER(bindable); | |
118 if (slider->current <= slider->min) | |
119 return FALSE; | |
120 slider->current -= slider->step; | |
121 sanitize_value(slider); | |
122 redraw_slider(slider); | |
123 slider_value_changed(slider); | |
124 return TRUE; | |
125 } | |
126 | |
127 static gboolean | |
128 step_forward(GntBindable *bindable, GList *list) | |
129 { | |
130 GntSlider *slider = GNT_SLIDER(bindable); | |
131 if (slider->current >= slider->max) | |
132 return FALSE; | |
133 slider->current += slider->step; | |
134 sanitize_value(slider); | |
135 redraw_slider(slider); | |
136 slider_value_changed(slider); | |
137 return TRUE; | |
138 } | |
139 | |
140 static void | |
141 gnt_slider_class_init(GntSliderClass *klass) | |
142 { | |
143 GntBindableClass *bindable = GNT_BINDABLE_CLASS(klass); | |
144 parent_class = GNT_WIDGET_CLASS(klass); | |
145 parent_class->draw = gnt_slider_draw; | |
146 parent_class->map = gnt_slider_map; | |
147 parent_class->size_request = gnt_slider_size_request; | |
148 | |
149 klass->changed = NULL; | |
150 | |
151 signals[SIG_VALUE_CHANGED] = | |
152 g_signal_new("changed", | |
153 G_TYPE_FROM_CLASS(klass), | |
154 G_SIGNAL_RUN_LAST, | |
155 G_STRUCT_OFFSET(GntSliderClass, changed), | |
156 NULL, NULL, | |
157 g_cclosure_marshal_VOID__INT, | |
158 G_TYPE_NONE, 1, G_TYPE_INT); | |
159 | |
160 gnt_bindable_class_register_action(bindable, "step-backward", step_back, GNT_KEY_LEFT, NULL); | |
161 gnt_bindable_register_binding(bindable, "step-backward", GNT_KEY_DOWN, NULL); | |
162 gnt_bindable_class_register_action(bindable, "step-forward", step_forward, GNT_KEY_RIGHT, NULL); | |
163 gnt_bindable_register_binding(bindable, "step-forward", GNT_KEY_UP, NULL); | |
164 | |
165 /* XXX: how would home/end work? */ | |
166 | |
167 gnt_style_read_actions(G_OBJECT_CLASS_TYPE(klass), GNT_BINDABLE_CLASS(klass)); | |
168 } | |
169 | |
170 static void | |
171 gnt_slider_init(GTypeInstance *instance, gpointer class) | |
172 { | |
173 GntWidget *widget = GNT_WIDGET(instance); | |
174 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_NO_SHADOW | GNT_WIDGET_NO_BORDER | GNT_WIDGET_CAN_TAKE_FOCUS); | |
175 widget->priv.minw = 1; | |
176 widget->priv.minh = 1; | |
177 GNTDEBUG; | |
178 } | |
179 | |
180 /****************************************************************************** | |
181 * GntSlider API | |
182 *****************************************************************************/ | |
183 GType | |
184 gnt_slider_get_gtype(void) | |
185 { | |
186 static GType type = 0; | |
187 | |
188 if(type == 0) | |
189 { | |
190 static const GTypeInfo info = { | |
191 sizeof(GntSliderClass), | |
192 NULL, /* base_init */ | |
193 NULL, /* base_finalize */ | |
194 (GClassInitFunc)gnt_slider_class_init, | |
195 NULL, /* class_finalize */ | |
196 NULL, /* class_data */ | |
197 sizeof(GntSlider), | |
198 0, /* n_preallocs */ | |
199 gnt_slider_init, /* instance_init */ | |
200 NULL /* value_table */ | |
201 }; | |
202 | |
203 type = g_type_register_static(GNT_TYPE_WIDGET, | |
204 "GntSlider", | |
205 &info, 0); | |
206 } | |
207 | |
208 return type; | |
209 } | |
210 | |
211 GntWidget *gnt_slider_new(gboolean vertical, int max, int min) | |
212 { | |
213 GntWidget *widget = g_object_new(GNT_TYPE_SLIDER, NULL); | |
214 GntSlider *slider = GNT_SLIDER(widget); | |
215 | |
216 slider->vertical = vertical; | |
217 | |
218 if (vertical) { | |
219 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_GROW_Y); | |
220 } else { | |
221 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_GROW_X); | |
222 } | |
223 | |
224 gnt_slider_set_range(slider, max, min); | |
225 slider->step = 1; | |
226 | |
227 return widget; | |
228 } | |
229 | |
230 void gnt_slider_set_value(GntSlider *slider, int value) | |
231 { | |
232 if (slider->current == value) | |
233 return; | |
234 slider->current = value; | |
235 sanitize_value(slider); | |
236 redraw_slider(slider); | |
237 slider_value_changed(slider); | |
238 } | |
239 | |
240 int gnt_slider_advance_step(GntSlider *slider, int steps) | |
241 { | |
242 slider->current += steps * slider->step; | |
243 sanitize_value(slider); | |
244 redraw_slider(slider); | |
245 slider_value_changed(slider); | |
246 return slider->current; | |
247 } | |
248 | |
249 void gnt_slider_set_step(GntSlider *slider, int step) | |
250 { | |
251 slider->step = step; | |
252 } | |
253 | |
254 void gnt_slider_set_range(GntSlider *slider, int max, int min) | |
255 { | |
256 slider->max = MAX(max, min); | |
257 slider->min = MIN(max, min); | |
258 sanitize_value(slider); | |
259 } | |
260 | |
261 static void | |
262 update_label(GntSlider *slider, int current_value, GntLabel *label) | |
263 { | |
264 char value[256]; | |
265 g_snprintf(value, sizeof(value), "%d/%d", current_value, slider->max); | |
266 gnt_label_set_text(label, value); | |
267 } | |
268 | |
269 void gnt_slider_reflect_label(GntSlider *slider, GntLabel *label) | |
270 { | |
271 g_signal_connect(G_OBJECT(slider), "changed", G_CALLBACK(update_label), label); | |
272 } | |
273 |