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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1092 - (hide annotations) (download)
Sun Mar 11 15:21:58 2007 UTC (17 years ago) by persson
File size: 23872 byte(s)
* implemented editing of dimension region upper limits

1 persson 1052 /*
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 persson 1092 #include <gdkmm/cursor.h>
22 persson 1052
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 persson 1092 resize.active = false;
45     cursor_is_resize = false;
46     h = 20;
47     w = 800;
48 persson 1052 set_flags(Gtk::CAN_FOCUS);
49 persson 1092 add_events(Gdk::BUTTON_PRESS_MASK | Gdk::POINTER_MOTION_MASK |
50     Gdk::POINTER_MOTION_HINT_MASK);
51 persson 1052
52     for (int i = 0 ; i < 256 ; i++) {
53     dimvalue_from[i] = 0;
54     dimvalue_to[i] = 1;
55     }
56     }
57    
58     DimRegionChooser::~DimRegionChooser()
59     {
60     }
61    
62     void DimRegionChooser::on_realize()
63     {
64     // We need to call the base on_realize()
65     Gtk::DrawingArea::on_realize();
66    
67     // Now we can allocate any additional resources we need
68     Glib::RefPtr<Gdk::Window> window = get_window();
69     gc = Gdk::GC::create(window);
70     }
71    
72     bool DimRegionChooser::on_expose_event(GdkEventExpose* event)
73     {
74     if (!region) return true;
75    
76     // This is where we draw on the window
77     Glib::RefPtr<Gdk::Window> window = get_window();
78     Glib::RefPtr<Pango::Context> context = get_pango_context();
79    
80     Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);
81    
82     window->clear();
83     int y = 0;
84 persson 1078 double maxwidth = 0;
85 persson 1052 for (int i = 0 ; i < region->Dimensions ; i++) {
86 persson 1071
87     int nbZones = region->pDimensionDefinitions[i].zones;
88     if (nbZones) {
89 persson 1052 char* dstr;
90 persson 1071 char dstrbuf[10];
91 persson 1052 switch (region->pDimensionDefinitions[i].dimension) {
92     case gig::dimension_none: dstr="none"; break;
93     case gig::dimension_samplechannel: dstr="samplechannel"; break;
94     case gig::dimension_layer: dstr="layer"; break;
95     case gig::dimension_velocity: dstr="velocity"; break;
96     case gig::dimension_channelaftertouch: dstr="channelaftertouch"; break;
97     case gig::dimension_releasetrigger: dstr="releasetrigger"; break;
98     case gig::dimension_keyboard: dstr="keyboard"; break;
99     case gig::dimension_roundrobin: dstr="roundrobin"; break;
100     case gig::dimension_random: dstr="random"; break;
101 persson 1077 case gig::dimension_smartmidi: dstr="smartmidi"; break;
102     case gig::dimension_roundrobinkeyboard: dstr="roundrobinkeyboard"; break;
103 persson 1052 case gig::dimension_modwheel: dstr="modwheel"; break;
104     case gig::dimension_breath: dstr="breath"; break;
105     case gig::dimension_foot: dstr="foot"; break;
106     case gig::dimension_portamentotime: dstr="portamentotime"; break;
107     case gig::dimension_effect1: dstr="effect1"; break;
108     case gig::dimension_effect2: dstr="effect2"; break;
109     case gig::dimension_genpurpose1: dstr="genpurpose1"; break;
110     case gig::dimension_genpurpose2: dstr="genpurpose2"; break;
111     case gig::dimension_genpurpose3: dstr="genpurpose3"; break;
112     case gig::dimension_genpurpose4: dstr="genpurpose4"; break;
113     case gig::dimension_sustainpedal: dstr="sustainpedal"; break;
114     case gig::dimension_portamento: dstr="portamento"; break;
115     case gig::dimension_sostenutopedal: dstr="sostenutopedal"; break;
116     case gig::dimension_softpedal: dstr="softpedal"; break;
117     case gig::dimension_genpurpose5: dstr="genpurpose5"; break;
118     case gig::dimension_genpurpose6: dstr="genpurpose6"; break;
119     case gig::dimension_genpurpose7: dstr="genpurpose7"; break;
120     case gig::dimension_genpurpose8: dstr="genpurpose8"; break;
121     case gig::dimension_effect1depth: dstr="effect1depth"; break;
122     case gig::dimension_effect2depth: dstr="effect2depth"; break;
123     case gig::dimension_effect3depth: dstr="effect3depth"; break;
124     case gig::dimension_effect4depth: dstr="effect4depth"; break;
125     case gig::dimension_effect5depth: dstr="effect5depth"; break;
126 persson 1071 default:
127     sprintf(dstrbuf, "%d",
128     region->pDimensionDefinitions[i].dimension);
129     dstr = dstrbuf;
130     break;
131 persson 1052 }
132     layout->set_text(dstr);
133    
134     Pango::Rectangle rectangle = layout->get_logical_extents();
135 persson 1078 double text_w = double(rectangle.get_width()) / Pango::SCALE;
136     if (text_w > maxwidth) maxwidth = text_w;
137 persson 1052 double text_h = double(rectangle.get_height()) / Pango::SCALE;
138     Glib::RefPtr<const Gdk::GC> fg = get_style()->get_fg_gc(get_state());
139     window->draw_layout(fg, 4, int(y + (h - text_h) / 2 + 0.5), layout);
140    
141 persson 1078 }
142     y += h;
143     }
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    
151 persson 1052 if (has_focus() && focus_line == i) {
152 persson 1078 Gdk::Rectangle farea(0, y, 150, 20);
153 persson 1092 get_style()->paint_focus(window, get_state(), farea, *this, "",
154     0, y, label_width, 20);
155 persson 1052 }
156    
157     Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
158 persson 1078 window->draw_line(black, label_width, y, w - 1, y);
159     window->draw_line(black, w - 1, y + h - 1, label_width, y + h - 1);
160 persson 1092 window->draw_rectangle(get_style()->get_white_gc(), true,
161     label_width + 1, y + 1, (w - label_width - 2), h - 2);
162 persson 1052
163 persson 1071 int c = 0;
164     if (dimregno >= 0) {
165     int mask = ~(((1 << region->pDimensionDefinitions[i].bits) - 1) << bitpos);
166     c = dimregno & mask; // mask away this dimension
167     }
168     bool customsplits =
169     ((region->pDimensionDefinitions[i].split_type == gig::split_type_normal &&
170     region->pDimensionRegions[c]->DimensionUpperLimits[i]) ||
171     (region->pDimensionDefinitions[i].dimension == gig::dimension_velocity &&
172     region->pDimensionRegions[c]->VelocityUpperLimit));
173    
174     if (customsplits) {
175 persson 1078 window->draw_line(black, label_width, y + 1, label_width, y + h - 2);
176 persson 1071 for (int j = 0 ; j < nbZones ; j++) {
177     gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
178     int upperLimit = d->DimensionUpperLimits[i];
179     if (!upperLimit) upperLimit = d->VelocityUpperLimit;
180     int v = upperLimit + 1;
181 persson 1078 int x = int((w - label_width - 1) * v / 128.0 + 0.5);
182     window->draw_line(black, label_width + x, y + 1, label_width + x, y + h - 2);
183 persson 1052 }
184     } else {
185 persson 1071 for (int j = 0 ; j <= nbZones ; j++) {
186 persson 1078 int x = int((w - label_width - 1) * j / double(nbZones) + 0.5);
187     window->draw_line(black, label_width + x, y + 1, label_width + x, y + h - 2);
188 persson 1052 }
189     }
190    
191     if (dimregno >= 0) {
192     gc->set_foreground(red);
193 persson 1071 int dr = (dimregno >> bitpos) & ((1 << region->pDimensionDefinitions[i].bits) - 1);
194     if (customsplits) {
195     int x1 = 0;
196     for (int j = 0 ; j < nbZones ; j++) {
197     gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
198     int upperLimit = d->DimensionUpperLimits[i];
199     if (!upperLimit) upperLimit = d->VelocityUpperLimit;
200     int v = upperLimit + 1;
201 persson 1078 int x2 = int((w - label_width - 1) * v / 128.0 + 0.5);
202 persson 1071 if (j == dr && x1 < x2) {
203 persson 1092 window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,
204     (x2 - x1) - 1, h - 2);
205 persson 1052 break;
206     }
207     x1 = x2;
208     }
209     } else {
210 persson 1071 if (dr < nbZones) {
211 persson 1078 int x1 = int((w - label_width - 1) * dr / double(nbZones) + 0.5);
212     int x2 = int((w - label_width - 1) * (dr + 1) / double(nbZones) + 0.5);
213 persson 1092 window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,
214     (x2 - x1) - 1, h - 2);
215 persson 1052 }
216     }
217     }
218    
219     y += h;
220     }
221 persson 1071 bitpos += region->pDimensionDefinitions[i].bits;
222 persson 1052 }
223    
224     return true;
225     }
226    
227     void DimRegionChooser::on_size_request(GtkRequisition* requisition)
228     {
229     printf("DimRegionChooser::on_size_request\n");
230     *requisition = GtkRequisition();
231 persson 1089 requisition->height = region ? nbDimensions * 20 : 0;
232 persson 1052 requisition->width = 800;
233     }
234    
235     void DimRegionChooser::set_instrument(gig::Instrument* instrument)
236     {
237     this->instrument = instrument;
238     this->region = 0;
239     this->dimregno = -1;
240     queue_draw();
241     }
242    
243     void DimRegionChooser::set_region(gig::Region* region)
244     {
245     this->region = region;
246     dimregno = 0;
247     int bitcount = 0;
248 persson 1089 nbDimensions = 0;
249 persson 1052 for (int dim = 0 ; dim < region->Dimensions ; dim++) {
250 persson 1089 if (region->pDimensionDefinitions[dim].bits == 0) continue;
251     nbDimensions++;
252    
253 persson 1052 int from = dimvalue_from[region->pDimensionDefinitions[dim].dimension];
254     int to = dimvalue_to[region->pDimensionDefinitions[dim].dimension];
255     int z;
256     switch (region->pDimensionDefinitions[dim].split_type) {
257     case gig::split_type_normal:
258     z = int((to + from) / 2.0 / region->pDimensionDefinitions[dim].zone_size);
259     break;
260     case gig::split_type_bit:
261     z = std::min(from, region->pDimensionDefinitions[dim].zones - 1);
262     break;
263     }
264     int mask =
265     ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) <<
266     bitcount);
267     dimregno &= mask;
268     dimregno |= (z << bitcount);
269     bitcount += region->pDimensionDefinitions[dim].bits;
270     }
271     dimreg = region->pDimensionRegions[dimregno];
272     sel_changed_signal.emit();
273     queue_resize();
274     }
275    
276     /*
277     void DimRegionChooser::set_dimregno(int x) {
278     this->dimregno = x;
279     queue_draw();
280     }
281     */
282    
283 persson 1092 bool DimRegionChooser::on_button_release_event(GdkEventButton* event)
284     {
285     if (resize.active) {
286     get_window()->pointer_ungrab(event->time);
287     resize.active = false;
288    
289     if (region->pDimensionDefinitions[resize.dimension].dimension == gig::dimension_velocity) {
290    
291     int bitpos = 0;
292     for (int j = 0 ; j < resize.dimension ; j++) {
293     bitpos += region->pDimensionDefinitions[j].bits;
294     }
295     int mask =
296     ~(((1 << region->pDimensionDefinitions[resize.dimension].bits) - 1) << bitpos);
297     int c = dimregno & mask; // mask away this dimension
298    
299     gig::DimensionRegion *d = region->pDimensionRegions[c + resize.offset];
300     if (d->DimensionUpperLimits[resize.dimension]) {
301     d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
302     } else {
303     d->VelocityUpperLimit = resize.pos - 1;
304     }
305    
306     } else {
307     for (int i = 0 ; i < region->DimensionRegions ; ) {
308    
309     gig::DimensionRegion *d = region->pDimensionRegions[i + resize.offset];
310     d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
311    
312     int bitpos = 0;
313     int j;
314     for (j = 0 ; j < region->Dimensions ; j++) {
315     if (j != resize.dimension) {
316     int maxzones = 1 << region->pDimensionDefinitions[j].bits;
317     int dimj = (i >> bitpos) & (maxzones - 1);
318     if (dimj + 1 < region->pDimensionDefinitions[j].zones) break;
319     }
320     bitpos += region->pDimensionDefinitions[j].bits;
321     }
322     if (j == region->Dimensions) break;
323     i = (i & ~((1 << bitpos) - 1)) + (1 << bitpos);
324     }
325     }
326    
327     if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {
328     get_window()->set_cursor();
329     cursor_is_resize = false;
330     }
331     }
332     return true;
333     }
334    
335 persson 1052 bool DimRegionChooser::on_button_press_event(GdkEventButton* event)
336     {
337 persson 1092 if (region && event->y < nbDimensions * h &&
338     event->x >= label_width && event->x < w) {
339 persson 1052
340 persson 1092 if (is_in_resize_zone(event->x, event->y)) {
341     Gdk::Cursor double_arrow(Gdk::SB_H_DOUBLE_ARROW);
342     get_window()->pointer_grab(false,
343     Gdk::BUTTON_RELEASE_MASK |
344     Gdk::POINTER_MOTION_MASK |
345     Gdk::POINTER_MOTION_HINT_MASK,
346     double_arrow, event->time);
347     resize.active = true;
348     } else {
349 persson 1089 int ydim = int(event->y / h);
350     int dim;
351     for (dim = 0 ; dim < region->Dimensions ; dim++) {
352     if (region->pDimensionDefinitions[dim].bits == 0) continue;
353     if (ydim == 0) break;
354     ydim--;
355     }
356 persson 1071 int nbZones = region->pDimensionDefinitions[dim].zones;
357 persson 1052
358     int z = -1;
359 persson 1071 int bitpos = 0;
360     for (int i = 0 ; i < dim ; i++) {
361     bitpos += region->pDimensionDefinitions[i].bits;
362     }
363 persson 1052
364 persson 1071 int i = dim;
365     if (dimregno < 0) dimregno = 0;
366     int mask = ~(((1 << region->pDimensionDefinitions[i].bits) - 1) << bitpos);
367     int c = dimregno & mask; // mask away this dimension
368 persson 1052
369 persson 1071 bool customsplits =
370     ((region->pDimensionDefinitions[i].split_type == gig::split_type_normal &&
371     region->pDimensionRegions[c]->DimensionUpperLimits[i]) ||
372     (region->pDimensionDefinitions[i].dimension == gig::dimension_velocity &&
373     region->pDimensionRegions[c]->VelocityUpperLimit));
374     if (customsplits) {
375 persson 1078 int val = int((event->x - label_width) * 128 / (w - label_width - 1));
376 persson 1071
377     if (region->pDimensionRegions[c]->DimensionUpperLimits[i]) {
378     for (z = 0 ; z < nbZones ; z++) {
379     gig::DimensionRegion *d = region->pDimensionRegions[c + (z << bitpos)];
380     if (val <= d->DimensionUpperLimits[i]) break;
381 persson 1052 }
382 persson 1071 } else {
383     for (z = 0 ; z < nbZones ; z++) {
384     gig::DimensionRegion *d = region->pDimensionRegions[c + (z << bitpos)];
385     if (val <= d->VelocityUpperLimit) break;
386     }
387 persson 1052 }
388 persson 1071 } else {
389 persson 1078 z = int((event->x - label_width) * nbZones / (w - label_width - 1));
390 persson 1052 }
391    
392     printf("dim=%d z=%d dimensionsource=%d split_type=%d zones=%d zone_size=%f\n", dim, z,
393     region->pDimensionDefinitions[dim].dimension,
394     region->pDimensionDefinitions[dim].split_type,
395     region->pDimensionDefinitions[dim].zones,
396     region->pDimensionDefinitions[dim].zone_size);
397 persson 1071 #if 0
398 persson 1052 switch (region->pDimensionDefinitions[dim].split_type) {
399     case gig::split_type_normal:
400     dimvalue_from[region->pDimensionDefinitions[dim].dimension] =
401     int(z * region->pDimensionDefinitions[dim].zone_size);
402     dimvalue_to[region->pDimensionDefinitions[dim].dimension] =
403     int((z + 1) * region->pDimensionDefinitions[dim].zone_size) - 1;
404     break;
405     case gig::split_type_bit:
406     dimvalue_from[region->pDimensionDefinitions[dim].dimension] = z;
407     dimvalue_to[region->pDimensionDefinitions[dim].dimension] = z + 1;
408     break;
409     }
410 persson 1071 #endif
411 persson 1052
412 persson 1071 dimregno = c | (z << bitpos);
413 persson 1052
414     focus_line = dim;
415     if (has_focus()) queue_draw();
416     else grab_focus();
417     dimreg = region->pDimensionRegions[dimregno];
418     sel_changed_signal.emit();
419     }
420     }
421     return true;
422     }
423    
424 persson 1092 bool DimRegionChooser::on_motion_notify_event(GdkEventMotion* event)
425     {
426     Glib::RefPtr<Gdk::Window> window = get_window();
427     int x, y;
428     Gdk::ModifierType state = Gdk::ModifierType(0);
429     window->get_pointer(x, y, state);
430    
431     if (resize.active) {
432     int k = int((x - label_width) * 128.0 / (w - label_width - 1) + 0.5);
433    
434     if (k < resize.min) k = resize.min;
435     else if (k > resize.max) k = resize.max;
436    
437     if (k < 2) k = 2; // k is upper limit + 1, upper limit 0 is forbidden
438    
439     if (k != resize.pos) {
440     Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
441     Glib::RefPtr<const Gdk::GC> white = get_style()->get_white_gc();
442    
443     int prevx = int((w - label_width - 1) * resize.pos / 128.0 + 0.5) + label_width;
444     int x = int((w - label_width - 1) * k / 128.0 + 0.5) + label_width;
445     int y = resize.dimension * h;
446    
447     if (resize.selected == resize.none) {
448     if (resize.pos != resize.min && resize.pos != resize.max) {
449     window->draw_line(white, prevx, y + 1, prevx, y + h - 2);
450     }
451     } else {
452     gc->set_foreground(red);
453    
454     Glib::RefPtr<const Gdk::GC> left;
455     Glib::RefPtr<const Gdk::GC> right;
456     if (resize.selected == resize.left) {
457     left = gc;
458     right = white;
459     } else {
460     left = white;
461     right = gc;
462     }
463    
464     if (k > resize.pos) {
465     int xx = resize.pos == resize.min ? 1 : 0;
466     window->draw_rectangle(left, true,
467     prevx + xx, y + 1, x - prevx - xx, h - 2);
468     } else {
469     int xx = resize.pos == resize.max ? 0 : 1;
470     window->draw_rectangle(right, true,
471     x, y + 1, prevx - x + xx, h - 2);
472     }
473     }
474     window->draw_line(black, x, y + 1, x, y + h - 2);
475     resize.pos = k;
476     }
477     } else {
478     if (is_in_resize_zone(x, y)) {
479     if (!cursor_is_resize) {
480     Gdk::Cursor double_arrow(Gdk::SB_H_DOUBLE_ARROW);
481     window->set_cursor(double_arrow);
482     cursor_is_resize = true;
483     }
484     } else if (cursor_is_resize) {
485     window->set_cursor();
486     cursor_is_resize = false;
487     }
488     }
489     return true;
490     }
491    
492     bool DimRegionChooser::is_in_resize_zone(double x, double y)
493     {
494     if (region && y < nbDimensions * h && x >= label_width && x < w) {
495     int ydim = int(y / h);
496     int dim;
497     int bitpos = 0;
498     for (dim = 0 ; dim < region->Dimensions ; dim++) {
499     if (region->pDimensionDefinitions[dim].bits == 0) continue;
500     if (ydim == 0) break;
501     ydim--;
502     bitpos += region->pDimensionDefinitions[dim].bits;
503     }
504     int nbZones = region->pDimensionDefinitions[dim].zones;
505    
506     int c = 0;
507     if (dimregno >= 0) {
508     int mask = ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) << bitpos);
509     c = dimregno & mask; // mask away this dimension
510     }
511     bool customsplits =
512     ((region->pDimensionDefinitions[dim].split_type == gig::split_type_normal &&
513     region->pDimensionRegions[c]->DimensionUpperLimits[dim]) ||
514     (region->pDimensionDefinitions[dim].dimension == gig::dimension_velocity &&
515     region->pDimensionRegions[c]->VelocityUpperLimit));
516    
517     if (customsplits) {
518     int prev_limit = 0;
519     for (int j = 0 ; j < nbZones - 1 ; j++) {
520     gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
521     int upperLimit = d->DimensionUpperLimits[dim];
522     if (!upperLimit) upperLimit = d->VelocityUpperLimit;
523     int limit = upperLimit + 1;
524     int limitx = int((w - label_width - 1) * limit / 128.0 + 0.5) + label_width;
525    
526     if (x <= limitx - 2) break;
527     if (x <= limitx + 2) {
528     resize.dimension = dim;
529     resize.offset = j << bitpos;
530     resize.pos = limit;
531     resize.min = prev_limit;
532    
533     int dr = (dimregno >> bitpos) &
534     ((1 << region->pDimensionDefinitions[dim].bits) - 1);
535     resize.selected = dr == j ? resize.left :
536     dr == j + 1 ? resize.right : resize.none;
537    
538     j++;
539     gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
540     int upperLimit = d->DimensionUpperLimits[dim];
541     if (!upperLimit) upperLimit = d->VelocityUpperLimit;
542     int limit = upperLimit + 1;
543     resize.max = limit;
544     return true;
545     }
546     prev_limit = limit;
547     }
548     }
549     }
550     return false;
551     }
552    
553 persson 1052 sigc::signal<void> DimRegionChooser::signal_sel_changed()
554     {
555     return sel_changed_signal;
556     }
557    
558     bool DimRegionChooser::on_focus(Gtk::DirectionType direction)
559     {
560     // TODO: kolla att region finns osv, dvs att det g�r att s�tta
561     // fokus.
562     if (direction == Gtk::DIR_TAB_FORWARD ||
563     direction == Gtk::DIR_DOWN) {
564     if (!has_focus()) {
565     focus_line = 0;
566     grab_focus();
567     return true;
568     } else {
569     if (focus_line + 1 < region->Dimensions) {
570     focus_line++;
571     queue_draw();
572     return true;
573     } else {
574     return false;
575     }
576     }
577     } else if (direction == Gtk::DIR_TAB_BACKWARD ||
578     direction == Gtk::DIR_UP) {
579     if (!has_focus()) {
580     focus_line = region->Dimensions - 1;
581     grab_focus();
582     return true;
583     } else {
584     if (focus_line > 0) {
585     focus_line--;
586     queue_draw();
587     return true;
588     } else {
589     return false;
590     }
591     }
592     } else if (!has_focus()) {
593     // TODO: kolla att focus_line finns!
594     grab_focus();
595     return true;
596     } else {
597     // TODO: �ka eller minska v�rde!
598     }
599     }

  ViewVC Help
Powered by ViewVC