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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1185 - (show annotations) (download)
Sun May 13 14:09:20 2007 UTC (12 years, 10 months ago) by schoenebeck
File size: 24278 byte(s)
* allow to resize dimension zones even when the respective dimension has
  no custom dimension splits yet

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++) {
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 double maxwidth = 0;
85 for (int i = 0 ; i < region->Dimensions ; i++) {
86
87 int nbZones = region->pDimensionDefinitions[i].zones;
88 if (nbZones) {
89 char* dstr;
90 char dstrbuf[10];
91 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 case gig::dimension_smartmidi: dstr="smartmidi"; break;
102 case gig::dimension_roundrobinkeyboard: dstr="roundrobinkeyboard"; break;
103 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 default:
127 sprintf(dstrbuf, "%d",
128 region->pDimensionDefinitions[i].dimension);
129 dstr = dstrbuf;
130 break;
131 }
132 layout->set_text(dstr);
133
134 Pango::Rectangle rectangle = layout->get_logical_extents();
135 double text_w = double(rectangle.get_width()) / Pango::SCALE;
136 if (text_w > maxwidth) maxwidth = text_w;
137 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 }
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 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 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 window->draw_rectangle(get_style()->get_white_gc(), true,
161 label_width + 1, y + 1, (w - label_width - 2), h - 2);
162
163 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 window->draw_line(black, label_width, y + 1, label_width, y + h - 2);
176 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 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 }
184 } else {
185 for (int j = 0 ; j <= nbZones ; j++) {
186 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 }
189 }
190
191 if (dimregno >= 0) {
192 gc->set_foreground(red);
193 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 int x2 = int((w - label_width - 1) * v / 128.0 + 0.5);
202 if (j == dr && x1 < x2) {
203 window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,
204 (x2 - x1) - 1, h - 2);
205 break;
206 }
207 x1 = x2;
208 }
209 } else {
210 if (dr < nbZones) {
211 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 window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,
214 (x2 - x1) - 1, h - 2);
215 }
216 }
217 }
218
219 y += h;
220 }
221 bitpos += region->pDimensionDefinitions[i].bits;
222 }
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 requisition->height = region ? nbDimensions * 20 : 0;
232 requisition->width = 800;
233 }
234
235 void DimRegionChooser::set_region(gig::Region* region)
236 {
237 this->region = region;
238 dimregno = 0;
239 nbDimensions = 0;
240 if (region) {
241 int bitcount = 0;
242 for (int dim = 0 ; dim < region->Dimensions ; dim++) {
243 if (region->pDimensionDefinitions[dim].bits == 0) continue;
244 nbDimensions++;
245
246 int from = dimvalue_from[region->pDimensionDefinitions[dim].dimension];
247 int to = dimvalue_to[region->pDimensionDefinitions[dim].dimension];
248 int z;
249 switch (region->pDimensionDefinitions[dim].split_type) {
250 case gig::split_type_normal:
251 z = int((to + from) / 2.0 / region->pDimensionDefinitions[dim].zone_size);
252 break;
253 case gig::split_type_bit:
254 z = std::min(from, region->pDimensionDefinitions[dim].zones - 1);
255 break;
256 }
257 int mask =
258 ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) <<
259 bitcount);
260 dimregno &= mask;
261 dimregno |= (z << bitcount);
262 bitcount += region->pDimensionDefinitions[dim].bits;
263 }
264 dimreg = region->pDimensionRegions[dimregno];
265 } else {
266 dimreg = 0;
267 }
268 sel_changed_signal.emit();
269 queue_resize();
270 }
271
272 bool DimRegionChooser::on_button_release_event(GdkEventButton* event)
273 {
274 if (resize.active) {
275 get_window()->pointer_ungrab(event->time);
276 resize.active = false;
277
278 if (region->pDimensionDefinitions[resize.dimension].dimension == gig::dimension_velocity) {
279
280 int bitpos = 0;
281 for (int j = 0 ; j < resize.dimension ; j++) {
282 bitpos += region->pDimensionDefinitions[j].bits;
283 }
284 int mask =
285 ~(((1 << region->pDimensionDefinitions[resize.dimension].bits) - 1) << bitpos);
286 int c = dimregno & mask; // mask away this dimension
287
288 gig::DimensionRegion *d = region->pDimensionRegions[c + resize.offset];
289 if (d->DimensionUpperLimits[resize.dimension]) {
290 d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
291 } else {
292 d->VelocityUpperLimit = resize.pos - 1;
293 }
294
295 } else {
296 for (int i = 0 ; i < region->DimensionRegions ; ) {
297
298 gig::DimensionRegion *d = region->pDimensionRegions[i + resize.offset];
299 d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
300
301 int bitpos = 0;
302 int j;
303 for (j = 0 ; j < region->Dimensions ; j++) {
304 if (j != resize.dimension) {
305 int maxzones = 1 << region->pDimensionDefinitions[j].bits;
306 int dimj = (i >> bitpos) & (maxzones - 1);
307 if (dimj + 1 < region->pDimensionDefinitions[j].zones) break;
308 }
309 bitpos += region->pDimensionDefinitions[j].bits;
310 }
311 if (j == region->Dimensions) break;
312 i = (i & ~((1 << bitpos) - 1)) + (1 << bitpos);
313 }
314 }
315
316 if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {
317 get_window()->set_cursor();
318 cursor_is_resize = false;
319 }
320 }
321 return true;
322 }
323
324 bool DimRegionChooser::on_button_press_event(GdkEventButton* event)
325 {
326 if (region && event->y < nbDimensions * h &&
327 event->x >= label_width && event->x < w) {
328
329 if (is_in_resize_zone(event->x, event->y)) {
330 Gdk::Cursor double_arrow(Gdk::SB_H_DOUBLE_ARROW);
331 get_window()->pointer_grab(false,
332 Gdk::BUTTON_RELEASE_MASK |
333 Gdk::POINTER_MOTION_MASK |
334 Gdk::POINTER_MOTION_HINT_MASK,
335 double_arrow, event->time);
336 resize.active = true;
337 } else {
338 int ydim = int(event->y / h);
339 int dim;
340 for (dim = 0 ; dim < region->Dimensions ; dim++) {
341 if (region->pDimensionDefinitions[dim].bits == 0) continue;
342 if (ydim == 0) break;
343 ydim--;
344 }
345 int nbZones = region->pDimensionDefinitions[dim].zones;
346
347 int z = -1;
348 int bitpos = 0;
349 for (int i = 0 ; i < dim ; i++) {
350 bitpos += region->pDimensionDefinitions[i].bits;
351 }
352
353 int i = dim;
354 if (dimregno < 0) dimregno = 0;
355 int mask = ~(((1 << region->pDimensionDefinitions[i].bits) - 1) << bitpos);
356 int c = dimregno & mask; // mask away this dimension
357
358 bool customsplits =
359 ((region->pDimensionDefinitions[i].split_type == gig::split_type_normal &&
360 region->pDimensionRegions[c]->DimensionUpperLimits[i]) ||
361 (region->pDimensionDefinitions[i].dimension == gig::dimension_velocity &&
362 region->pDimensionRegions[c]->VelocityUpperLimit));
363 if (customsplits) {
364 int val = int((event->x - label_width) * 128 / (w - label_width - 1));
365
366 if (region->pDimensionRegions[c]->DimensionUpperLimits[i]) {
367 for (z = 0 ; z < nbZones ; z++) {
368 gig::DimensionRegion *d = region->pDimensionRegions[c + (z << bitpos)];
369 if (val <= d->DimensionUpperLimits[i]) break;
370 }
371 } else {
372 for (z = 0 ; z < nbZones ; z++) {
373 gig::DimensionRegion *d = region->pDimensionRegions[c + (z << bitpos)];
374 if (val <= d->VelocityUpperLimit) break;
375 }
376 }
377 } else {
378 z = int((event->x - label_width) * nbZones / (w - label_width - 1));
379 }
380
381 printf("dim=%d z=%d dimensionsource=%d split_type=%d zones=%d zone_size=%f\n", dim, z,
382 region->pDimensionDefinitions[dim].dimension,
383 region->pDimensionDefinitions[dim].split_type,
384 region->pDimensionDefinitions[dim].zones,
385 region->pDimensionDefinitions[dim].zone_size);
386 #if 0
387 switch (region->pDimensionDefinitions[dim].split_type) {
388 case gig::split_type_normal:
389 dimvalue_from[region->pDimensionDefinitions[dim].dimension] =
390 int(z * region->pDimensionDefinitions[dim].zone_size);
391 dimvalue_to[region->pDimensionDefinitions[dim].dimension] =
392 int((z + 1) * region->pDimensionDefinitions[dim].zone_size) - 1;
393 break;
394 case gig::split_type_bit:
395 dimvalue_from[region->pDimensionDefinitions[dim].dimension] = z;
396 dimvalue_to[region->pDimensionDefinitions[dim].dimension] = z + 1;
397 break;
398 }
399 #endif
400
401 dimregno = c | (z << bitpos);
402
403 focus_line = dim;
404 if (has_focus()) queue_draw();
405 else grab_focus();
406 dimreg = region->pDimensionRegions[dimregno];
407 sel_changed_signal.emit();
408 }
409 }
410 return true;
411 }
412
413 bool DimRegionChooser::on_motion_notify_event(GdkEventMotion* event)
414 {
415 Glib::RefPtr<Gdk::Window> window = get_window();
416 int x, y;
417 Gdk::ModifierType state = Gdk::ModifierType(0);
418 window->get_pointer(x, y, state);
419
420 if (resize.active) {
421 int k = int((x - label_width) * 128.0 / (w - label_width - 1) + 0.5);
422
423 if (k < resize.min) k = resize.min;
424 else if (k > resize.max) k = resize.max;
425
426 if (k < 2) k = 2; // k is upper limit + 1, upper limit 0 is forbidden
427
428 if (k != resize.pos) {
429 Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
430 Glib::RefPtr<const Gdk::GC> white = get_style()->get_white_gc();
431
432 int prevx = int((w - label_width - 1) * resize.pos / 128.0 + 0.5) + label_width;
433 int x = int((w - label_width - 1) * k / 128.0 + 0.5) + label_width;
434 int y = resize.dimension * h;
435
436 if (resize.selected == resize.none) {
437 if (resize.pos != resize.min && resize.pos != resize.max) {
438 window->draw_line(white, prevx, y + 1, prevx, y + h - 2);
439 }
440 } else {
441 gc->set_foreground(red);
442
443 Glib::RefPtr<const Gdk::GC> left;
444 Glib::RefPtr<const Gdk::GC> right;
445 if (resize.selected == resize.left) {
446 left = gc;
447 right = white;
448 } else {
449 left = white;
450 right = gc;
451 }
452
453 if (k > resize.pos) {
454 int xx = resize.pos == resize.min ? 1 : 0;
455 window->draw_rectangle(left, true,
456 prevx + xx, y + 1, x - prevx - xx, h - 2);
457 } else {
458 int xx = resize.pos == resize.max ? 0 : 1;
459 window->draw_rectangle(right, true,
460 x, y + 1, prevx - x + xx, h - 2);
461 }
462 }
463 window->draw_line(black, x, y + 1, x, y + h - 2);
464 resize.pos = k;
465 }
466 } else {
467 if (is_in_resize_zone(x, y)) {
468 if (!cursor_is_resize) {
469 Gdk::Cursor double_arrow(Gdk::SB_H_DOUBLE_ARROW);
470 window->set_cursor(double_arrow);
471 cursor_is_resize = true;
472 }
473 } else if (cursor_is_resize) {
474 window->set_cursor();
475 cursor_is_resize = false;
476 }
477 }
478 return true;
479 }
480
481 bool DimRegionChooser::is_in_resize_zone(double x, double y)
482 {
483 if (region && y < nbDimensions * h && x >= label_width && x < w) {
484 int ydim = int(y / h);
485 int dim;
486 int bitpos = 0;
487 for (dim = 0 ; dim < region->Dimensions ; dim++) {
488 if (region->pDimensionDefinitions[dim].bits == 0) continue;
489 if (ydim == 0) break;
490 ydim--;
491 bitpos += region->pDimensionDefinitions[dim].bits;
492 }
493 int nbZones = region->pDimensionDefinitions[dim].zones;
494
495 int c = 0;
496 if (dimregno >= 0) {
497 int mask = ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) << bitpos);
498 c = dimregno & mask; // mask away this dimension
499 }
500 const bool customsplits =
501 ((region->pDimensionDefinitions[dim].split_type == gig::split_type_normal &&
502 region->pDimensionRegions[c]->DimensionUpperLimits[dim]) ||
503 (region->pDimensionDefinitions[dim].dimension == gig::dimension_velocity &&
504 region->pDimensionRegions[c]->VelocityUpperLimit));
505
506 // dimensions of split_type_bit cannot be resized
507 if (region->pDimensionDefinitions[dim].split_type != gig::split_type_bit) {
508 int prev_limit = 0;
509 for (int iZone = 0 ; iZone < nbZones - 1 ; iZone++) {
510 gig::DimensionRegion *d = region->pDimensionRegions[c + (iZone << bitpos)];
511 const int upperLimit =
512 (customsplits) ?
513 (d->DimensionUpperLimits[dim]) ?
514 d->DimensionUpperLimits[dim] : d->VelocityUpperLimit
515 : (iZone+1) * (int)region->pDimensionDefinitions[dim].zone_size;
516 int limit = upperLimit + 1;
517 int limitx = int((w - label_width - 1) * limit / 128.0 + 0.5) + label_width;
518 if (x <= limitx - 2) break;
519 if (x <= limitx + 2) {
520 resize.dimension = dim;
521 resize.offset = iZone << bitpos;
522 resize.pos = limit;
523 resize.min = prev_limit;
524
525 int dr = (dimregno >> bitpos) &
526 ((1 << region->pDimensionDefinitions[dim].bits) - 1);
527 resize.selected = dr == iZone ? resize.left :
528 dr == iZone + 1 ? resize.right : resize.none;
529
530 iZone++;
531 gig::DimensionRegion *d = region->pDimensionRegions[c + (iZone << bitpos)];
532
533 const int upperLimit =
534 (customsplits) ?
535 (d->DimensionUpperLimits[dim]) ?
536 d->DimensionUpperLimits[dim] : d->VelocityUpperLimit
537 : (iZone+1) * (int)region->pDimensionDefinitions[dim].zone_size;
538
539 int limit = upperLimit + 1;
540 resize.max = limit;
541 return true;
542 }
543 prev_limit = limit;
544 }
545 }
546 }
547 return false;
548 }
549
550 sigc::signal<void> DimRegionChooser::signal_sel_changed()
551 {
552 return sel_changed_signal;
553 }
554
555 bool DimRegionChooser::on_focus(Gtk::DirectionType direction)
556 {
557 // TODO: kolla att region finns osv, dvs att det g�r att s�tta
558 // fokus.
559 if (direction == Gtk::DIR_TAB_FORWARD ||
560 direction == Gtk::DIR_DOWN) {
561 if (!has_focus()) {
562 focus_line = 0;
563 grab_focus();
564 return true;
565 } else {
566 if (focus_line + 1 < region->Dimensions) {
567 focus_line++;
568 queue_draw();
569 return true;
570 } else {
571 return false;
572 }
573 }
574 } else if (direction == Gtk::DIR_TAB_BACKWARD ||
575 direction == Gtk::DIR_UP) {
576 if (!has_focus()) {
577 focus_line = region->Dimensions - 1;
578 grab_focus();
579 return true;
580 } else {
581 if (focus_line > 0) {
582 focus_line--;
583 queue_draw();
584 return true;
585 } else {
586 return false;
587 }
588 }
589 } else if (!has_focus()) {
590 // TODO: kolla att focus_line finns!
591 grab_focus();
592 return true;
593 } else {
594 // TODO: �ka eller minska v�rde!
595 }
596 }

  ViewVC Help
Powered by ViewVC