/[svn]/gigedit/trunk/src/gigedit/dimregionchooser.cpp
ViewVC logotype

Contents of /gigedit/trunk/src/gigedit/dimregionchooser.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1339 - (show annotations) (download)
Mon Sep 10 19:56:26 2007 UTC (16 years, 6 months ago) by schoenebeck
File size: 25724 byte(s)
* bugfix: signals triggered before and after sensible modifications didn't
  ever make it to the outer world (i.e. to LinuxSampler)

1 /*
2 * Copyright (C) 2006, 2007 Andreas Persson
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2, or (at
7 * your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with program; see the file COPYING. If not, write to the Free
16 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
17 * 02110-1301 USA.
18 */
19
20 #include "dimregionchooser.h"
21 #include <gdkmm/cursor.h>
22
23 DimRegionChooser::DimRegionChooser()
24 {
25 // get_window() would return 0 because the Gdk::Window has not yet been realized
26 // So we can only allocate the colors here - the rest will happen in on_realize().
27 Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();
28
29 black = Gdk::Color("black");
30 white = Gdk::Color("white");
31 red = Gdk::Color("#8070ff");
32 blue = Gdk::Color("blue");
33 green = Gdk::Color("green");
34
35 colormap->alloc_color(black);
36 colormap->alloc_color(white);
37 colormap->alloc_color(red);
38 colormap->alloc_color(blue);
39 colormap->alloc_color(green);
40 instrument = 0;
41 region = 0;
42 dimregno = -1;
43 focus_line = 0;
44 resize.active = false;
45 cursor_is_resize = false;
46 h = 20;
47 w = 800;
48 set_flags(Gtk::CAN_FOCUS);
49 add_events(Gdk::BUTTON_PRESS_MASK | Gdk::POINTER_MOTION_MASK |
50 Gdk::POINTER_MOTION_HINT_MASK);
51
52 for (int i = 0 ; i < 256 ; i++) dimvalue[i] = 0;
53 }
54
55 DimRegionChooser::~DimRegionChooser()
56 {
57 }
58
59 void DimRegionChooser::on_realize()
60 {
61 // We need to call the base on_realize()
62 Gtk::DrawingArea::on_realize();
63
64 // Now we can allocate any additional resources we need
65 Glib::RefPtr<Gdk::Window> window = get_window();
66 gc = Gdk::GC::create(window);
67 }
68
69 bool DimRegionChooser::on_expose_event(GdkEventExpose* event)
70 {
71 if (!region) return true;
72
73 // This is where we draw on the window
74 Glib::RefPtr<Gdk::Window> window = get_window();
75 Glib::RefPtr<Pango::Context> context = get_pango_context();
76
77 Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);
78
79 window->clear();
80
81 // draw labels on the left (reflecting the dimension type)
82 int y = 0;
83 double maxwidth = 0;
84 for (int i = 0 ; i < region->Dimensions ; i++) {
85 int nbZones = region->pDimensionDefinitions[i].zones;
86 if (nbZones) {
87 const char* dstr;
88 char dstrbuf[10];
89 switch (region->pDimensionDefinitions[i].dimension) {
90 case gig::dimension_none: dstr="none"; break;
91 case gig::dimension_samplechannel: dstr="samplechannel"; break;
92 case gig::dimension_layer: dstr="layer"; break;
93 case gig::dimension_velocity: dstr="velocity"; break;
94 case gig::dimension_channelaftertouch: dstr="channelaftertouch"; break;
95 case gig::dimension_releasetrigger: dstr="releasetrigger"; break;
96 case gig::dimension_keyboard: dstr="keyboard"; break;
97 case gig::dimension_roundrobin: dstr="roundrobin"; break;
98 case gig::dimension_random: dstr="random"; break;
99 case gig::dimension_smartmidi: dstr="smartmidi"; break;
100 case gig::dimension_roundrobinkeyboard: dstr="roundrobinkeyboard"; break;
101 case gig::dimension_modwheel: dstr="modwheel"; break;
102 case gig::dimension_breath: dstr="breath"; break;
103 case gig::dimension_foot: dstr="foot"; break;
104 case gig::dimension_portamentotime: dstr="portamentotime"; break;
105 case gig::dimension_effect1: dstr="effect1"; break;
106 case gig::dimension_effect2: dstr="effect2"; break;
107 case gig::dimension_genpurpose1: dstr="genpurpose1"; break;
108 case gig::dimension_genpurpose2: dstr="genpurpose2"; break;
109 case gig::dimension_genpurpose3: dstr="genpurpose3"; break;
110 case gig::dimension_genpurpose4: dstr="genpurpose4"; break;
111 case gig::dimension_sustainpedal: dstr="sustainpedal"; break;
112 case gig::dimension_portamento: dstr="portamento"; break;
113 case gig::dimension_sostenutopedal: dstr="sostenutopedal"; break;
114 case gig::dimension_softpedal: dstr="softpedal"; break;
115 case gig::dimension_genpurpose5: dstr="genpurpose5"; break;
116 case gig::dimension_genpurpose6: dstr="genpurpose6"; break;
117 case gig::dimension_genpurpose7: dstr="genpurpose7"; break;
118 case gig::dimension_genpurpose8: dstr="genpurpose8"; break;
119 case gig::dimension_effect1depth: dstr="effect1depth"; break;
120 case gig::dimension_effect2depth: dstr="effect2depth"; break;
121 case gig::dimension_effect3depth: dstr="effect3depth"; break;
122 case gig::dimension_effect4depth: dstr="effect4depth"; break;
123 case gig::dimension_effect5depth: dstr="effect5depth"; break;
124 default:
125 sprintf(dstrbuf, "%d",
126 region->pDimensionDefinitions[i].dimension);
127 dstr = dstrbuf;
128 break;
129 }
130 layout->set_text(dstr);
131
132 Pango::Rectangle rectangle = layout->get_logical_extents();
133 double text_w = double(rectangle.get_width()) / Pango::SCALE;
134 if (text_w > maxwidth) maxwidth = text_w;
135 double text_h = double(rectangle.get_height()) / Pango::SCALE;
136 Glib::RefPtr<const Gdk::GC> fg = get_style()->get_fg_gc(get_state());
137 window->draw_layout(fg, 4, int(y + (h - text_h) / 2 + 0.5), layout);
138
139 }
140 y += h;
141 }
142
143 // draw dimensions' zones areas
144 y = 0;
145 int bitpos = 0;
146 label_width = int(maxwidth + 10);
147 for (int i = 0 ; i < region->Dimensions ; i++) {
148 int nbZones = region->pDimensionDefinitions[i].zones;
149 if (nbZones) {
150 // draw focus rectangle around dimension's label and zones
151 if (has_focus() && focus_line == i) {
152 Gdk::Rectangle farea(0, y, 150, 20);
153 get_style()->paint_focus(window, get_state(), farea, *this, "",
154 0, y, label_width, 20);
155 }
156
157 Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
158 // draw top and bottom lines of dimension's zones
159 window->draw_line(black, label_width, y, w - 1, y);
160 window->draw_line(black, w - 1, y + h - 1, label_width, y + h - 1);
161 // erase whole dimension's zones area
162 window->draw_rectangle(get_style()->get_white_gc(), true,
163 label_width + 1, y + 1, (w - label_width - 2), h - 2);
164
165 int c = 0;
166 if (dimregno >= 0) {
167 int mask = ~(((1 << region->pDimensionDefinitions[i].bits) - 1) << bitpos);
168 c = dimregno & mask; // mask away this dimension
169 }
170 bool customsplits =
171 ((region->pDimensionDefinitions[i].split_type == gig::split_type_normal &&
172 region->pDimensionRegions[c]->DimensionUpperLimits[i]) ||
173 (region->pDimensionDefinitions[i].dimension == gig::dimension_velocity &&
174 region->pDimensionRegions[c]->VelocityUpperLimit));
175
176 // draw dimension's zone borders
177 if (customsplits) {
178 window->draw_line(black, label_width, y + 1, label_width, y + h - 2);
179 for (int j = 0 ; j < nbZones ; j++) {
180 gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
181 int upperLimit = d->DimensionUpperLimits[i];
182 if (!upperLimit) upperLimit = d->VelocityUpperLimit;
183 int v = upperLimit + 1;
184 int x = int((w - label_width - 1) * v / 128.0 + 0.5);
185 window->draw_line(black, label_width + x, y + 1, label_width + x, y + h - 2);
186 }
187 } else {
188 for (int j = 0 ; j <= nbZones ; j++) {
189 int x = int((w - label_width - 1) * j / double(nbZones) + 0.5);
190 window->draw_line(black, label_width + x, y + 1, label_width + x, y + h - 2);
191 }
192 }
193
194 // draw fill for currently selected zone
195 if (dimregno >= 0) {
196 gc->set_foreground(red);
197 int dr = (dimregno >> bitpos) & ((1 << region->pDimensionDefinitions[i].bits) - 1);
198 if (customsplits) {
199 int x1 = 0;
200 for (int j = 0 ; j < nbZones ; j++) {
201 gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
202 int upperLimit = d->DimensionUpperLimits[i];
203 if (!upperLimit) upperLimit = d->VelocityUpperLimit;
204 int v = upperLimit + 1;
205 int x2 = int((w - label_width - 1) * v / 128.0 + 0.5);
206 if (j == dr && x1 < x2) {
207 window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,
208 (x2 - x1) - 1, h - 2);
209 break;
210 }
211 x1 = x2;
212 }
213 } else {
214 if (dr < nbZones) {
215 int x1 = int((w - label_width - 1) * dr / double(nbZones) + 0.5);
216 int x2 = int((w - label_width - 1) * (dr + 1) / double(nbZones) + 0.5);
217 window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,
218 (x2 - x1) - 1, h - 2);
219 }
220 }
221 }
222
223 y += h;
224 }
225 bitpos += region->pDimensionDefinitions[i].bits;
226 }
227
228 return true;
229 }
230
231 void DimRegionChooser::on_size_request(GtkRequisition* requisition)
232 {
233 printf("DimRegionChooser::on_size_request\n");
234 *requisition = GtkRequisition();
235 requisition->height = region ? nbDimensions * 20 : 0;
236 requisition->width = 800;
237 }
238
239 void DimRegionChooser::set_region(gig::Region* region)
240 {
241 this->region = region;
242 dimregno = 0;
243 nbDimensions = 0;
244 if (region) {
245 int bitcount = 0;
246 for (int dim = 0 ; dim < region->Dimensions ; dim++) {
247 if (region->pDimensionDefinitions[dim].bits == 0) continue;
248 nbDimensions++;
249
250 int z = std::min(dimvalue[region->pDimensionDefinitions[dim].dimension],
251 region->pDimensionDefinitions[dim].zones - 1);
252 int mask =
253 ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) <<
254 bitcount);
255 dimregno &= mask;
256 dimregno |= (z << bitcount);
257 bitcount += region->pDimensionDefinitions[dim].bits;
258 }
259 dimreg = region->pDimensionRegions[dimregno];
260 } else {
261 dimreg = 0;
262 }
263 dimregion_selected();
264 queue_resize();
265 }
266
267 bool DimRegionChooser::on_button_release_event(GdkEventButton* event)
268 {
269 if (resize.active) {
270 get_window()->pointer_ungrab(event->time);
271 resize.active = false;
272
273 if (region->pDimensionDefinitions[resize.dimension].dimension == gig::dimension_velocity) {
274
275 int bitpos = 0;
276 for (int j = 0 ; j < resize.dimension ; j++) {
277 bitpos += region->pDimensionDefinitions[j].bits;
278 }
279 int mask =
280 ~(((1 << region->pDimensionDefinitions[resize.dimension].bits) - 1) << bitpos);
281 int c = dimregno & mask; // mask away this dimension
282
283 if (region->pDimensionRegions[c]->DimensionUpperLimits[resize.dimension] == 0) {
284 // the velocity dimension didn't previously have
285 // custom v3 splits, so we initialize all splits with
286 // default values
287 int nbZones = region->pDimensionDefinitions[resize.dimension].zones;
288 for (int j = 0 ; j < nbZones ; j++) {
289 gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
290 d->DimensionUpperLimits[resize.dimension] = int(128.0 * (j + 1) / nbZones - 1);
291 }
292 }
293 if (region->pDimensionRegions[c]->VelocityUpperLimit == 0) {
294 // the velocity dimension didn't previously have
295 // custom v2 splits, so we initialize all splits with
296 // default values
297 int nbZones = region->pDimensionDefinitions[resize.dimension].zones;
298 for (int j = 0 ; j < nbZones ; j++) {
299 gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
300 d->VelocityUpperLimit = int(128.0 * (j + 1) / nbZones - 1);
301 }
302 }
303
304 gig::DimensionRegion *d = region->pDimensionRegions[c + resize.offset];
305 // update both v2 and v3 values
306 d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
307 d->VelocityUpperLimit = resize.pos - 1;
308
309 } else {
310 for (int i = 0 ; i < region->DimensionRegions ; ) {
311
312 if (region->pDimensionRegions[i]->DimensionUpperLimits[resize.dimension] == 0) {
313 // the dimension didn't previously have custom
314 // limits, so we have to set default limits for
315 // all the dimension regions
316 int bitpos = 0;
317 for (int j = 0 ; j < resize.dimension ; j++) {
318 bitpos += region->pDimensionDefinitions[j].bits;
319 }
320 int nbZones = region->pDimensionDefinitions[resize.dimension].zones;
321
322 for (int j = 0 ; j < nbZones ; j++) {
323 gig::DimensionRegion *d = region->pDimensionRegions[i + (j << bitpos)];
324 d->DimensionUpperLimits[resize.dimension] = int(128.0 * (j + 1) / nbZones - 1);
325 }
326 }
327 gig::DimensionRegion *d = region->pDimensionRegions[i + resize.offset];
328 d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
329
330 int bitpos = 0;
331 int j;
332 for (j = 0 ; j < region->Dimensions ; j++) {
333 if (j != resize.dimension) {
334 int maxzones = 1 << region->pDimensionDefinitions[j].bits;
335 int dimj = (i >> bitpos) & (maxzones - 1);
336 if (dimj + 1 < region->pDimensionDefinitions[j].zones) break;
337 }
338 bitpos += region->pDimensionDefinitions[j].bits;
339 }
340 if (j == region->Dimensions) break;
341 i = (i & ~((1 << bitpos) - 1)) + (1 << bitpos);
342 }
343 }
344 region_changed();
345
346 if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {
347 get_window()->set_cursor();
348 cursor_is_resize = false;
349 }
350 }
351 return true;
352 }
353
354 bool DimRegionChooser::on_button_press_event(GdkEventButton* event)
355 {
356 if (region && event->y < nbDimensions * h &&
357 event->x >= label_width && event->x < w) {
358
359 if (is_in_resize_zone(event->x, event->y)) {
360 Gdk::Cursor double_arrow(Gdk::SB_H_DOUBLE_ARROW);
361 get_window()->pointer_grab(false,
362 Gdk::BUTTON_RELEASE_MASK |
363 Gdk::POINTER_MOTION_MASK |
364 Gdk::POINTER_MOTION_HINT_MASK,
365 double_arrow, event->time);
366 resize.active = true;
367 } else {
368 int ydim = int(event->y / h);
369 int dim;
370 for (dim = 0 ; dim < region->Dimensions ; dim++) {
371 if (region->pDimensionDefinitions[dim].bits == 0) continue;
372 if (ydim == 0) break;
373 ydim--;
374 }
375 int nbZones = region->pDimensionDefinitions[dim].zones;
376
377 int z = -1;
378 int bitpos = 0;
379 for (int i = 0 ; i < dim ; i++) {
380 bitpos += region->pDimensionDefinitions[i].bits;
381 }
382
383 int i = dim;
384 if (dimregno < 0) dimregno = 0;
385 int mask = ~(((1 << region->pDimensionDefinitions[i].bits) - 1) << bitpos);
386 int c = dimregno & mask; // mask away this dimension
387
388 bool customsplits =
389 ((region->pDimensionDefinitions[i].split_type == gig::split_type_normal &&
390 region->pDimensionRegions[c]->DimensionUpperLimits[i]) ||
391 (region->pDimensionDefinitions[i].dimension == gig::dimension_velocity &&
392 region->pDimensionRegions[c]->VelocityUpperLimit));
393 if (customsplits) {
394 int val = int((event->x - label_width) * 128 / (w - label_width - 1));
395
396 if (region->pDimensionRegions[c]->DimensionUpperLimits[i]) {
397 for (z = 0 ; z < nbZones ; z++) {
398 gig::DimensionRegion *d = region->pDimensionRegions[c + (z << bitpos)];
399 if (val <= d->DimensionUpperLimits[i]) break;
400 }
401 } else {
402 for (z = 0 ; z < nbZones ; z++) {
403 gig::DimensionRegion *d = region->pDimensionRegions[c + (z << bitpos)];
404 if (val <= d->VelocityUpperLimit) break;
405 }
406 }
407 } else {
408 z = int((event->x - label_width) * nbZones / (w - label_width - 1));
409 }
410
411 printf("dim=%d z=%d dimensionsource=%d split_type=%d zones=%d zone_size=%f\n", dim, z,
412 region->pDimensionDefinitions[dim].dimension,
413 region->pDimensionDefinitions[dim].split_type,
414 region->pDimensionDefinitions[dim].zones,
415 region->pDimensionDefinitions[dim].zone_size);
416 dimvalue[region->pDimensionDefinitions[dim].dimension] = z;
417
418 dimregno = c | (z << bitpos);
419
420 focus_line = dim;
421 if (has_focus()) queue_draw();
422 else grab_focus();
423 dimreg = region->pDimensionRegions[dimregno];
424 dimregion_selected();
425 }
426 }
427 return true;
428 }
429
430 bool DimRegionChooser::on_motion_notify_event(GdkEventMotion* event)
431 {
432 Glib::RefPtr<Gdk::Window> window = get_window();
433 int x, y;
434 Gdk::ModifierType state = Gdk::ModifierType(0);
435 window->get_pointer(x, y, state);
436
437 if (resize.active) {
438 int k = int((x - label_width) * 128.0 / (w - label_width - 1) + 0.5);
439
440 if (k < resize.min) k = resize.min;
441 else if (k > resize.max) k = resize.max;
442
443 if (k < 2) k = 2; // k is upper limit + 1, upper limit 0 is forbidden
444
445 if (k != resize.pos) {
446 Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
447 Glib::RefPtr<const Gdk::GC> white = get_style()->get_white_gc();
448
449 int prevx = int((w - label_width - 1) * resize.pos / 128.0 + 0.5) + label_width;
450 int x = int((w - label_width - 1) * k / 128.0 + 0.5) + label_width;
451 int y = resize.dimension * h;
452
453 if (resize.selected == resize.none) {
454 if (resize.pos != resize.min && resize.pos != resize.max) {
455 window->draw_line(white, prevx, y + 1, prevx, y + h - 2);
456 }
457 } else {
458 gc->set_foreground(red);
459
460 Glib::RefPtr<const Gdk::GC> left;
461 Glib::RefPtr<const Gdk::GC> right;
462 if (resize.selected == resize.left) {
463 left = gc;
464 right = white;
465 } else {
466 left = white;
467 right = gc;
468 }
469
470 if (k > resize.pos) {
471 int xx = resize.pos == resize.min ? 1 : 0;
472 window->draw_rectangle(left, true,
473 prevx + xx, y + 1, x - prevx - xx, h - 2);
474 } else {
475 int xx = resize.pos == resize.max ? 0 : 1;
476 window->draw_rectangle(right, true,
477 x, y + 1, prevx - x + xx, h - 2);
478 }
479 }
480 window->draw_line(black, x, y + 1, x, y + h - 2);
481 resize.pos = k;
482 }
483 } else {
484 if (is_in_resize_zone(x, y)) {
485 if (!cursor_is_resize) {
486 Gdk::Cursor double_arrow(Gdk::SB_H_DOUBLE_ARROW);
487 window->set_cursor(double_arrow);
488 cursor_is_resize = true;
489 }
490 } else if (cursor_is_resize) {
491 window->set_cursor();
492 cursor_is_resize = false;
493 }
494 }
495 return true;
496 }
497
498 bool DimRegionChooser::is_in_resize_zone(double x, double y)
499 {
500 if (region && y < nbDimensions * h && x >= label_width && x < w) {
501 int ydim = int(y / h);
502 int dim;
503 int bitpos = 0;
504 for (dim = 0 ; dim < region->Dimensions ; dim++) {
505 if (region->pDimensionDefinitions[dim].bits == 0) continue;
506 if (ydim == 0) break;
507 ydim--;
508 bitpos += region->pDimensionDefinitions[dim].bits;
509 }
510 int nbZones = region->pDimensionDefinitions[dim].zones;
511
512 int c = 0;
513 if (dimregno >= 0) {
514 int mask = ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) << bitpos);
515 c = dimregno & mask; // mask away this dimension
516 }
517 const bool customsplits =
518 ((region->pDimensionDefinitions[dim].split_type == gig::split_type_normal &&
519 region->pDimensionRegions[c]->DimensionUpperLimits[dim]) ||
520 (region->pDimensionDefinitions[dim].dimension == gig::dimension_velocity &&
521 region->pDimensionRegions[c]->VelocityUpperLimit));
522
523 // dimensions of split_type_bit cannot be resized
524 if (region->pDimensionDefinitions[dim].split_type != gig::split_type_bit) {
525 int prev_limit = 0;
526 for (int iZone = 0 ; iZone < nbZones - 1 ; iZone++) {
527 gig::DimensionRegion *d = region->pDimensionRegions[c + (iZone << bitpos)];
528 const int upperLimit =
529 (customsplits) ?
530 (d->DimensionUpperLimits[dim]) ?
531 d->DimensionUpperLimits[dim] : d->VelocityUpperLimit
532 : (iZone+1) * (int)region->pDimensionDefinitions[dim].zone_size - 1;
533 int limit = upperLimit + 1;
534 int limitx = int((w - label_width - 1) * limit / 128.0 + 0.5) + label_width;
535 if (x <= limitx - 2) break;
536 if (x <= limitx + 2) {
537 resize.dimension = dim;
538 resize.offset = iZone << bitpos;
539 resize.pos = limit;
540 resize.min = prev_limit;
541
542 int dr = (dimregno >> bitpos) &
543 ((1 << region->pDimensionDefinitions[dim].bits) - 1);
544 resize.selected = dr == iZone ? resize.left :
545 dr == iZone + 1 ? resize.right : resize.none;
546
547 iZone++;
548 gig::DimensionRegion *d = region->pDimensionRegions[c + (iZone << bitpos)];
549
550 const int upperLimit =
551 (customsplits) ?
552 (d->DimensionUpperLimits[dim]) ?
553 d->DimensionUpperLimits[dim] : d->VelocityUpperLimit
554 : (iZone+1) * (int)region->pDimensionDefinitions[dim].zone_size - 1;
555
556 int limit = upperLimit + 1;
557 resize.max = limit;
558 return true;
559 }
560 prev_limit = limit;
561 }
562 }
563 }
564 return false;
565 }
566
567 sigc::signal<void>& DimRegionChooser::signal_dimregion_selected()
568 {
569 return dimregion_selected;
570 }
571
572 sigc::signal<void>& DimRegionChooser::signal_region_changed()
573 {
574 return region_changed;
575 }
576
577 bool DimRegionChooser::on_focus(Gtk::DirectionType direction)
578 {
579 // TODO: kolla att region finns osv, dvs att det g�r att s�tta
580 // fokus.
581 if (direction == Gtk::DIR_TAB_FORWARD ||
582 direction == Gtk::DIR_DOWN) {
583 if (!has_focus()) {
584 focus_line = 0;
585 grab_focus();
586 return true;
587 } else {
588 if (focus_line + 1 < region->Dimensions) {
589 focus_line++;
590 queue_draw();
591 return true;
592 } else {
593 return false;
594 }
595 }
596 } else if (direction == Gtk::DIR_TAB_BACKWARD ||
597 direction == Gtk::DIR_UP) {
598 if (!has_focus()) {
599 focus_line = region->Dimensions - 1;
600 grab_focus();
601 return true;
602 } else {
603 if (focus_line > 0) {
604 focus_line--;
605 queue_draw();
606 return true;
607 } else {
608 return false;
609 }
610 }
611 } else if (!has_focus()) {
612 // TODO: kolla att focus_line finns!
613 grab_focus();
614 return true;
615 } else {
616 // TODO: �ka eller minska v�rde!
617 }
618 }

  ViewVC Help
Powered by ViewVC