trunk/src/dimregionchooser.cpp

/*
 * Copyright (C) 2006, 2007 Andreas Persson
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with program; see the file COPYING. If not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 */

#include "dimregionchooser.h"
#include <gdkmm/cursor.h>

DimRegionChooser::DimRegionChooser()
{
    // get_window() would return 0 because the Gdk::Window has not yet been realized
    // So we can only allocate the colors here - the rest will happen in on_realize().
    Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();

    black = Gdk::Color("black");
    white = Gdk::Color("white");
    red = Gdk::Color("#8070ff");
    blue = Gdk::Color("blue");
    green = Gdk::Color("green");

    colormap->alloc_color(black);
    colormap->alloc_color(white);
    colormap->alloc_color(red);
    colormap->alloc_color(blue);
    colormap->alloc_color(green);
    instrument = 0;
    region = 0;
    dimregno = -1;
    focus_line = 0;
    resize.active = false;
    cursor_is_resize = false;
    h = 20;
    w = 800;
    set_flags(Gtk::CAN_FOCUS);
    add_events(Gdk::BUTTON_PRESS_MASK | Gdk::POINTER_MOTION_MASK |
               Gdk::POINTER_MOTION_HINT_MASK);

    for (int i = 0 ; i < 256 ; i++) {
        dimvalue_from[i] = 0;
        dimvalue_to[i] = 1;
    }
}

DimRegionChooser::~DimRegionChooser()
{
}

void DimRegionChooser::on_realize()
{
    // We need to call the base on_realize()
    Gtk::DrawingArea::on_realize();

    // Now we can allocate any additional resources we need
    Glib::RefPtr<Gdk::Window> window = get_window();
    gc = Gdk::GC::create(window);
}

bool DimRegionChooser::on_expose_event(GdkEventExpose* event)
{
    if (!region) return true;

    // This is where we draw on the window
    Glib::RefPtr<Gdk::Window> window = get_window();
    Glib::RefPtr<Pango::Context> context = get_pango_context();

    Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);

    window->clear();
    int y = 0;
    double maxwidth = 0;
    for (int i = 0 ; i < region->Dimensions ; i++) {

        int nbZones = region->pDimensionDefinitions[i].zones;
        if (nbZones) {
            char* dstr;
            char dstrbuf[10];
            switch (region->pDimensionDefinitions[i].dimension) {
            case gig::dimension_none: dstr="none"; break;
            case gig::dimension_samplechannel: dstr="samplechannel"; break;
            case gig::dimension_layer: dstr="layer"; break;
            case gig::dimension_velocity: dstr="velocity"; break;
            case gig::dimension_channelaftertouch: dstr="channelaftertouch"; break;
            case gig::dimension_releasetrigger: dstr="releasetrigger"; break;
            case gig::dimension_keyboard: dstr="keyboard"; break;
            case gig::dimension_roundrobin: dstr="roundrobin"; break;
            case gig::dimension_random: dstr="random"; break;
            case gig::dimension_smartmidi: dstr="smartmidi"; break;
            case gig::dimension_roundrobinkeyboard: dstr="roundrobinkeyboard"; break;
            case gig::dimension_modwheel: dstr="modwheel"; break;
            case gig::dimension_breath: dstr="breath"; break;
            case gig::dimension_foot: dstr="foot"; break;
            case gig::dimension_portamentotime: dstr="portamentotime"; break;
            case gig::dimension_effect1: dstr="effect1"; break;
            case gig::dimension_effect2: dstr="effect2"; break;
            case gig::dimension_genpurpose1: dstr="genpurpose1"; break;
            case gig::dimension_genpurpose2: dstr="genpurpose2"; break;
            case gig::dimension_genpurpose3: dstr="genpurpose3"; break;
            case gig::dimension_genpurpose4: dstr="genpurpose4"; break;
            case gig::dimension_sustainpedal: dstr="sustainpedal"; break;
            case gig::dimension_portamento: dstr="portamento"; break;
            case gig::dimension_sostenutopedal: dstr="sostenutopedal"; break;
            case gig::dimension_softpedal: dstr="softpedal"; break;
            case gig::dimension_genpurpose5: dstr="genpurpose5"; break;
            case gig::dimension_genpurpose6: dstr="genpurpose6"; break;
            case gig::dimension_genpurpose7: dstr="genpurpose7"; break;
            case gig::dimension_genpurpose8: dstr="genpurpose8"; break;
            case gig::dimension_effect1depth: dstr="effect1depth"; break;
            case gig::dimension_effect2depth: dstr="effect2depth"; break;
            case gig::dimension_effect3depth: dstr="effect3depth"; break;
            case gig::dimension_effect4depth: dstr="effect4depth"; break;
            case gig::dimension_effect5depth: dstr="effect5depth"; break;
            default:
                sprintf(dstrbuf, "%d",
                        region->pDimensionDefinitions[i].dimension);
                dstr = dstrbuf;
                break;
            }
            layout->set_text(dstr);

            Pango::Rectangle rectangle = layout->get_logical_extents();
            double text_w = double(rectangle.get_width()) / Pango::SCALE;
            if (text_w > maxwidth) maxwidth = text_w;
            double text_h = double(rectangle.get_height()) / Pango::SCALE;
            Glib::RefPtr<const Gdk::GC> fg = get_style()->get_fg_gc(get_state());
            window->draw_layout(fg, 4, int(y + (h - text_h) / 2 + 0.5), layout);

        }
        y += h;
    }
    y = 0;
    int bitpos = 0;
    label_width = int(maxwidth + 10);
    for (int i = 0 ; i < region->Dimensions ; i++) {
        int nbZones = region->pDimensionDefinitions[i].zones;
        if (nbZones) {

            if (has_focus() && focus_line == i) {
                Gdk::Rectangle farea(0, y, 150, 20);
                get_style()->paint_focus(window, get_state(), farea, *this, "",
                                         0, y, label_width, 20);
            }

            Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
            window->draw_line(black, label_width, y, w - 1, y);
            window->draw_line(black, w - 1, y + h - 1, label_width, y + h - 1);
            window->draw_rectangle(get_style()->get_white_gc(), true,
                                   label_width + 1, y + 1, (w - label_width - 2), h - 2);

            int c = 0;
            if (dimregno >= 0) {
                int mask = ~(((1 << region->pDimensionDefinitions[i].bits) - 1) << bitpos);
                c = dimregno & mask; // mask away this dimension
            }
            bool customsplits =
                ((region->pDimensionDefinitions[i].split_type == gig::split_type_normal &&
                 region->pDimensionRegions[c]->DimensionUpperLimits[i]) ||
                (region->pDimensionDefinitions[i].dimension == gig::dimension_velocity &&
                 region->pDimensionRegions[c]->VelocityUpperLimit));

            if (customsplits) {
                window->draw_line(black, label_width, y + 1, label_width, y + h - 2);
                for (int j = 0 ; j < nbZones ; j++) {
                    gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
                    int upperLimit = d->DimensionUpperLimits[i];
                    if (!upperLimit) upperLimit = d->VelocityUpperLimit;
                    int v = upperLimit + 1;
                    int x = int((w - label_width - 1) * v / 128.0 + 0.5);
                    window->draw_line(black, label_width + x, y + 1, label_width + x, y + h - 2);
                }
            } else {
                for (int j = 0 ; j <= nbZones ; j++) {
                    int x = int((w - label_width - 1) * j / double(nbZones) + 0.5);
                    window->draw_line(black, label_width + x, y + 1, label_width + x, y + h - 2);
                }
            }

            if (dimregno >= 0) {
                gc->set_foreground(red);
                int dr = (dimregno >> bitpos) & ((1 << region->pDimensionDefinitions[i].bits) - 1);
                if (customsplits) {
                    int x1 = 0;
                    for (int j = 0 ; j < nbZones ; j++) {
                        gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
                        int upperLimit = d->DimensionUpperLimits[i];
                        if (!upperLimit) upperLimit = d->VelocityUpperLimit;
                        int v = upperLimit + 1;
                        int x2 = int((w - label_width - 1) * v / 128.0 + 0.5);
                        if (j == dr && x1 < x2) {
                            window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,
                                                   (x2 - x1) - 1, h - 2);
                            break;
                        }
                        x1 = x2;
                    }
                } else {
                    if (dr < nbZones) {
                        int x1 = int((w - label_width - 1) * dr / double(nbZones) + 0.5);
                        int x2 = int((w - label_width - 1) * (dr + 1) / double(nbZones) + 0.5);
                        window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,
                                               (x2 - x1) - 1, h - 2);
                    }
                }
            }

            y += h;
        }
        bitpos += region->pDimensionDefinitions[i].bits;
    }

    return true;
}

void DimRegionChooser::on_size_request(GtkRequisition* requisition)
{
    printf("DimRegionChooser::on_size_request\n");
    *requisition = GtkRequisition();
    requisition->height = region ? nbDimensions * 20 : 0;
    requisition->width = 800;
}

void DimRegionChooser::set_instrument(gig::Instrument* instrument)
{
    this->instrument = instrument;
    this->region = 0;
    this->dimregno = -1;
    queue_draw();
}

void DimRegionChooser::set_region(gig::Region* region)
{
    this->region = region;
    dimregno = 0;
    int bitcount = 0;
    nbDimensions = 0;
    if (region) {
        for (int dim = 0 ; dim < region->Dimensions ; dim++) {
            if (region->pDimensionDefinitions[dim].bits == 0) continue;
            nbDimensions++;

            int from = dimvalue_from[region->pDimensionDefinitions[dim].dimension];
            int to = dimvalue_to[region->pDimensionDefinitions[dim].dimension];
            int z;
            switch (region->pDimensionDefinitions[dim].split_type) {
            case gig::split_type_normal:
                z = int((to + from) / 2.0 / region->pDimensionDefinitions[dim].zone_size);
                break;
            case gig::split_type_bit:
                z = std::min(from, region->pDimensionDefinitions[dim].zones - 1);
                break;
            }
            int mask =
                ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) <<
                  bitcount);
            dimregno &= mask;
            dimregno |= (z << bitcount);
            bitcount += region->pDimensionDefinitions[dim].bits;
        }
        dimreg = region->pDimensionRegions[dimregno];
    }
    sel_changed_signal.emit();
    queue_resize();
}

/*
  void DimRegionChooser::set_dimregno(int x) {
  this->dimregno = x;
  queue_draw();
  }
*/

bool DimRegionChooser::on_button_release_event(GdkEventButton* event)
{
    if (resize.active) {
        get_window()->pointer_ungrab(event->time);
        resize.active = false;

        if (region->pDimensionDefinitions[resize.dimension].dimension == gig::dimension_velocity) {

            int bitpos = 0;
            for (int j = 0 ; j < resize.dimension ; j++) {
                bitpos += region->pDimensionDefinitions[j].bits;
            }
            int mask =
                     ~(((1 << region->pDimensionDefinitions[resize.dimension].bits) - 1) << bitpos);
            int c = dimregno & mask; // mask away this dimension

            gig::DimensionRegion *d = region->pDimensionRegions[c + resize.offset];
            if (d->DimensionUpperLimits[resize.dimension]) {
                d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
            } else {
                d->VelocityUpperLimit = resize.pos - 1;
            }

        } else {
            for (int i = 0 ; i < region->DimensionRegions ; ) {

                gig::DimensionRegion *d = region->pDimensionRegions[i + resize.offset];
                d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;

                int bitpos = 0;
                int j;
                for (j = 0 ; j < region->Dimensions ; j++) {
                    if (j != resize.dimension) {
                        int maxzones = 1 << region->pDimensionDefinitions[j].bits;
                        int dimj = (i >> bitpos) & (maxzones - 1);
                        if (dimj + 1 < region->pDimensionDefinitions[j].zones) break;
                    }
                    bitpos += region->pDimensionDefinitions[j].bits;
                }
                if (j == region->Dimensions) break;
                i = (i & ~((1 << bitpos) - 1)) + (1 << bitpos);
            }
        }

        if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {
            get_window()->set_cursor();
            cursor_is_resize = false;
        }
    }
    return true;
}

bool DimRegionChooser::on_button_press_event(GdkEventButton* event)
{
    if (region && event->y < nbDimensions * h &&
        event->x >= label_width && event->x < w) {

        if (is_in_resize_zone(event->x, event->y)) {
            Gdk::Cursor double_arrow(Gdk::SB_H_DOUBLE_ARROW);
            get_window()->pointer_grab(false,
                                       Gdk::BUTTON_RELEASE_MASK |
                                       Gdk::POINTER_MOTION_MASK |
                                       Gdk::POINTER_MOTION_HINT_MASK,
                                       double_arrow, event->time);
            resize.active = true;
        } else {
            int ydim = int(event->y / h);
            int dim;
            for (dim = 0 ; dim < region->Dimensions ; dim++) {
                if (region->pDimensionDefinitions[dim].bits == 0) continue;
                if (ydim == 0) break;
                ydim--;
            }
            int nbZones = region->pDimensionDefinitions[dim].zones;

            int z = -1;
            int bitpos = 0;
            for (int i = 0 ; i < dim ; i++) {
                bitpos += region->pDimensionDefinitions[i].bits;
            }

            int i = dim;
            if (dimregno < 0) dimregno = 0;
            int mask = ~(((1 << region->pDimensionDefinitions[i].bits) - 1) << bitpos);
            int c = dimregno & mask; // mask away this dimension

            bool customsplits =
                ((region->pDimensionDefinitions[i].split_type == gig::split_type_normal &&
                  region->pDimensionRegions[c]->DimensionUpperLimits[i]) ||
                 (region->pDimensionDefinitions[i].dimension == gig::dimension_velocity &&
                  region->pDimensionRegions[c]->VelocityUpperLimit));
            if (customsplits) {
                int val = int((event->x - label_width) * 128 / (w - label_width - 1));

                if (region->pDimensionRegions[c]->DimensionUpperLimits[i]) {
                    for (z = 0 ; z < nbZones ; z++) {
                        gig::DimensionRegion *d = region->pDimensionRegions[c + (z << bitpos)];
                        if (val <= d->DimensionUpperLimits[i]) break;
                    }
                } else {
                    for (z = 0 ; z < nbZones ; z++) {
                        gig::DimensionRegion *d = region->pDimensionRegions[c + (z << bitpos)];
                        if (val <= d->VelocityUpperLimit) break;
                    }
                }
            } else {
                z = int((event->x - label_width) * nbZones / (w - label_width - 1));
            }

            printf("dim=%d z=%d dimensionsource=%d split_type=%d zones=%d zone_size=%f\n", dim, z,
                   region->pDimensionDefinitions[dim].dimension,
                   region->pDimensionDefinitions[dim].split_type,
                   region->pDimensionDefinitions[dim].zones,
                   region->pDimensionDefinitions[dim].zone_size);
#if 0
            switch (region->pDimensionDefinitions[dim].split_type) {
            case gig::split_type_normal:
                dimvalue_from[region->pDimensionDefinitions[dim].dimension] =
                    int(z * region->pDimensionDefinitions[dim].zone_size);
                dimvalue_to[region->pDimensionDefinitions[dim].dimension] =
                    int((z + 1) * region->pDimensionDefinitions[dim].zone_size) - 1;
                break;
            case gig::split_type_bit:
                dimvalue_from[region->pDimensionDefinitions[dim].dimension] = z;
                dimvalue_to[region->pDimensionDefinitions[dim].dimension] = z + 1;
                break;
            }
#endif

            dimregno = c | (z << bitpos);

            focus_line = dim;
            if (has_focus()) queue_draw();
            else grab_focus();
            dimreg = region->pDimensionRegions[dimregno];
            sel_changed_signal.emit();
        }
    }
    return true;
}

bool DimRegionChooser::on_motion_notify_event(GdkEventMotion* event)
{
    Glib::RefPtr<Gdk::Window> window = get_window();
    int x, y;
    Gdk::ModifierType state = Gdk::ModifierType(0);
    window->get_pointer(x, y, state);

    if (resize.active) {
        int k = int((x - label_width) * 128.0 / (w - label_width - 1) + 0.5);

        if (k < resize.min) k = resize.min;
        else if (k > resize.max) k = resize.max;

        if (k < 2) k = 2; // k is upper limit + 1, upper limit 0 is forbidden

        if (k != resize.pos) {
            Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
            Glib::RefPtr<const Gdk::GC> white = get_style()->get_white_gc();

            int prevx = int((w - label_width - 1) * resize.pos / 128.0 + 0.5) + label_width;
            int x = int((w - label_width - 1) * k / 128.0 + 0.5) + label_width;
            int y = resize.dimension * h;

            if (resize.selected == resize.none) {
                if (resize.pos != resize.min && resize.pos != resize.max) {
                    window->draw_line(white, prevx, y + 1, prevx, y + h - 2);
                }
            } else {
                gc->set_foreground(red);

                Glib::RefPtr<const Gdk::GC> left;
                Glib::RefPtr<const Gdk::GC> right;
                if (resize.selected == resize.left) {
                    left = gc;
                    right = white;
                } else {
                    left = white;
                    right = gc;
                }

                if (k > resize.pos) {
                    int xx = resize.pos == resize.min ? 1 : 0;
                    window->draw_rectangle(left, true,
                                           prevx + xx, y + 1, x - prevx - xx, h - 2);
                } else {
                    int xx = resize.pos == resize.max ? 0 : 1;
                    window->draw_rectangle(right, true,
                                           x, y + 1, prevx - x + xx, h - 2);
                }
            }
            window->draw_line(black, x, y + 1, x, y + h - 2);
            resize.pos = k;
        }
    } else {
        if (is_in_resize_zone(x, y)) {
            if (!cursor_is_resize) {
                Gdk::Cursor double_arrow(Gdk::SB_H_DOUBLE_ARROW);
                window->set_cursor(double_arrow);
                cursor_is_resize = true;
            }
        } else if (cursor_is_resize) {
            window->set_cursor();
            cursor_is_resize = false;
        }
    }
    return true;
}

bool DimRegionChooser::is_in_resize_zone(double x, double y)
{
    if (region && y < nbDimensions * h && x >= label_width && x < w) {
        int ydim = int(y / h);
        int dim;
        int bitpos = 0;
        for (dim = 0 ; dim < region->Dimensions ; dim++) {
            if (region->pDimensionDefinitions[dim].bits == 0) continue;
            if (ydim == 0) break;
            ydim--;
            bitpos += region->pDimensionDefinitions[dim].bits;
        }
        int nbZones = region->pDimensionDefinitions[dim].zones;

        int c = 0;
        if (dimregno >= 0) {
            int mask = ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) << bitpos);
            c = dimregno & mask; // mask away this dimension
        }
        bool customsplits =
            ((region->pDimensionDefinitions[dim].split_type == gig::split_type_normal &&
              region->pDimensionRegions[c]->DimensionUpperLimits[dim]) ||
             (region->pDimensionDefinitions[dim].dimension == gig::dimension_velocity &&
              region->pDimensionRegions[c]->VelocityUpperLimit));

        if (customsplits) {
            int prev_limit = 0;
            for (int j = 0 ; j < nbZones - 1 ; j++) {
                gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
                int upperLimit = d->DimensionUpperLimits[dim];
                if (!upperLimit) upperLimit = d->VelocityUpperLimit;
                int limit = upperLimit + 1;
                int limitx = int((w - label_width - 1) * limit / 128.0 + 0.5) + label_width;

                if (x <= limitx - 2) break;
                if (x <= limitx + 2) {
                    resize.dimension = dim;
                    resize.offset = j << bitpos;
                    resize.pos = limit;
                    resize.min = prev_limit;

                    int dr = (dimregno >> bitpos) &
                        ((1 << region->pDimensionDefinitions[dim].bits) - 1);
                    resize.selected = dr == j ? resize.left :
                        dr == j + 1 ? resize.right : resize.none;

                    j++;
                    gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
                    int upperLimit = d->DimensionUpperLimits[dim];
                    if (!upperLimit) upperLimit = d->VelocityUpperLimit;
                    int limit = upperLimit + 1;
                    resize.max = limit;
                    return true;
                }
                prev_limit = limit;
            }
        }
    }
    return false;
}

sigc::signal<void> DimRegionChooser::signal_sel_changed()
{
    return sel_changed_signal;
}

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