grmanip.cpp

Go to the documentation of this file.

#include <../../nrnconf.h>
#if HAVE_IV  // to end of file
 
#include <InterViews/canvas.h>
#include <InterViews/transformer.h>
#include <InterViews/label.h>
#include <InterViews/hit.h>
#include <InterViews/cursor.h>
#include <IV-look/kit.h>
 
#include <stdio.h>
#include <string.h>
 
#include "ivoc.h"
#include "mymath.h"
#include "rubband.h"
#include "graph.h"
#include "hocmark.h"
#include "utility.h"
 
#define LineRubberMarker_event_   "Crosshair Graph"
#define DeleteLabelHandler_event_ "Delete Graph"
#define ChangeLabelHandler_event_ "ChangeText"
#define DeleteLineHandler_event_  "Delete Graph"
#define LinePicker_event_         "Pick Graph"
#define MoveLabelBand_press_      "MoveText Graph"
 
extern double hoc_cross_x_, hoc_cross_y_;
 
class LineRubberMarker: public Rubberband {
  public:
    LineRubberMarker(GPolyLine*, RubberAction*, Canvas* c = NULL);
    LineRubberMarker(Coord, Coord, RubberAction*, Canvas* c = NULL);
    virtual ~LineRubberMarker();
    virtual bool event(Event&);
    virtual void undraw(Coord, Coord);
    virtual void draw(Coord, Coord);
    int index() {
        return index_;
    }
 
  private:
    GPolyLine* gl_;
    Label* label_;
    Coord x_, y_;
    int index_;
#if defined(WIN32) || MAC
    CopyString def_str_;
#endif
};
 
class MoveLabelBand: public Rubberband {
  public:
    MoveLabelBand(GLabel*, RubberAction*, Canvas* = NULL);
    virtual ~MoveLabelBand();
    virtual void draw(Coord, Coord);
    virtual void press(Event&);
    virtual void release(Event&);
 
  private:
    GLabel* gl_;
    GLabel* label_;
    GlyphIndex index_;
    Allocation a_;
    Cursor* cursor_;
    Coord x0_, y0_;
};
 
/*static*/ class DeleteLabelHandler: public Handler {
  public:
    DeleteLabelHandler(GLabel*);
    ~DeleteLabelHandler();
    virtual bool event(Event&);
 
  private:
    GLabel* gl_;
};
 
/*static*/ class ChangeLabelHandler: public Handler {
  public:
    ChangeLabelHandler(GLabel*);
    ~ChangeLabelHandler();
    virtual bool event(Event&);
 
  private:
    GLabel* gl_;
};
 
/*static*/ class DeleteLineHandler: public Handler {
  public:
    DeleteLineHandler(GPolyLine*);
    ~DeleteLineHandler();
    virtual bool event(Event&);
 
  private:
    GPolyLine* gpl_;
};
 
/*static*/ class LinePicker: public Rubberband {
  public:
    LinePicker(GPolyLine*);
    ~LinePicker();
    virtual void press(Event&);
    virtual void release(Event&);
 
  private:
    void common();
 
  private:
    GPolyLine* gpl_;
    const Color* c_;
};
 
void GraphLine::pick(Canvas* c, const Allocation& a, int depth, Hit& h) {
    GPolyLine::pick(c, a, depth, h);
}
 
void GPolyLine::pick(Canvas* c, const Allocation&, int depth, Hit& h) {
    if (h.count() && h.target(depth, 0)) {
        return;
    }
    if (h.event() && h.event()->type() == Event::down &&
        h.event()->pointer_button() == Event::left) {
        Coord x = h.left(), y = h.bottom();
        switch (XYView::current_pick_view()->scene()->tool()) {
        case Graph::CROSSHAIR:
            if (near(x, y, 10, c->transformer())) {
                h.target(depth, this, 0, new LineRubberMarker(this, NULL, c));
            }
            break;
        case Scene::DELETE:
            if (near(x, y, 10, c->transformer())) {
                h.target(depth, this, 0, new DeleteLineHandler(this));
            }
            break;
        case Graph::CHANGECOLOR:
            if (near(x, y, 10, c->transformer())) {
                XYView::current_pick_view()->scene()->change_line_color(this);
            }
            break;
        case Graph::PICK:
            if (near(x, y, 5, c->transformer())) {
                h.target(depth, this, 0, new LinePicker(this));
            }
            break;
        }
    }
}
void HocMark::pick(Canvas* c, const Allocation& a, int depth, Hit& h) {
    if (h.count() && h.target(depth, 0)) {
        return;
    }
    if (h.event() && h.event()->type() == Event::down &&
        h.event()->pointer_button() == Event::left) {
        Coord x = h.left(), y = h.bottom();
        switch (XYView::current_pick_view()->scene()->tool()) {
        case Graph::CROSSHAIR:
            h.target(depth, this, 0, new LineRubberMarker(a.x(), a.y(), NULL, c));
            break;
        }
    }
}
 
bool GPolyLine::near(Coord xcm, Coord ycm, float epsilon, const Transformer& t) const {
    if (x_->count() <= 0) {
        return false;
    }
    int index = nearest(xcm, ycm, t);
    Coord xc, yc, x1, x2, y1, y2;
    x1 = x(index);
    y1 = y(index);
    if (index < x_->count() - 1) {
        x2 = x(index + 1);
        y2 = y(index + 1);
    } else {
        x2 = x1;
        y2 = y1;
    }
    // printf("nearest model %g %g to mouse %g %g\n", x1, y1, xcm, ycm);
    t.transform(xcm, ycm, xc, yc);
    t.transform(x1, y1);
    t.transform(x2, y2);
    // printf("nearest mouse %g %g box %g %g %g %g\n", xc, yc, x1, y1, x2, y2);
    return MyMath::near_line(xc, yc, x1, y1, x2, y2, epsilon);
}
 
int GPolyLine::nearest(Coord x1, Coord y1, const Transformer& t, int index_begin) const {
    int index, i;
    int count = x_->count();
    Coord x, y, xt, yt;
    t.transform(x1, y1, x, y);
 
#define Norm2(lval, arg)                                     \
    t.transform(x_->get_val(arg), y_->get_val(arg), xt, yt); \
    lval = MyMath::norm2(x - xt, y - yt);
 
    float dxmin, dx;
    if (index_begin < 0) {
        index = 0;
        Norm2(dxmin, 0);
        for (i = 1; i < count; ++i) {
            Norm2(dx, i);
            if (dx < dxmin) {
                dxmin = dx;
                index = i;
            }
        }
    } else {
        float dxleft, dxright;
        i = index = index_begin;
        Norm2(dxmin, i);
        dxleft = dxright = dxmin;
        if (i - 1 >= 0) {
            Norm2(dxleft, i - 1);
        }
        if (i + 1 > count) {
            Norm2(dxright, i + 1);
        }
        if (dxright < dxleft) {
            while (++i < count) {
                Norm2(dx, i);
                if (dx < dxmin) {
                    dxmin = dx;
                    index = i;
                } else {
                    break;
                }
            }
        } else {
            while (--i >= 0) {
                Norm2(dx, i);
                if (dx < dxmin) {
                    dxmin = dx;
                    index = i;
                } else {
                    break;
                }
            }
        }
    }
    return index;
}
 
LineRubberMarker::LineRubberMarker(GPolyLine* gl, RubberAction* ra, Canvas* c)
    : Rubberband(ra, c) {
    // printf("LineRubberMarker\n");
    gl_ = gl;
    Resource::ref(gl);
    label_ = NULL;
    index_ = -1;
}
LineRubberMarker::LineRubberMarker(Coord x, Coord y, RubberAction* ra, Canvas* c)
    : Rubberband(ra, c) {
    // printf("LineRubberMarker\n");
    gl_ = NULL;
    label_ = NULL;
    index_ = -1;
    x_ = x;
    y_ = y;
}
LineRubberMarker::~LineRubberMarker() {
    // printf("~LineRubberMarker\n");
    Resource::unref(gl_);
    Resource::unref(label_);
}
bool LineRubberMarker::event(Event& e) {
    if (Oc::helpmode()) {
        if (e.type() == Event::down) {
            Oc::help(LineRubberMarker_event_);
        }
        return true;
    }
    if (e.type() == Event::key) {
        char buf[2];
        if (e.mapkey(buf, 1) > 0) {
            if (gl_) {
                ((Graph*) XYView::current_pick_view()->scene())->cross_action(buf[0], gl_, index_);
            } else {
                ((Graph*) XYView::current_pick_view()->scene())->cross_action(buf[0], x_, y_);
            }
        }
        return true;
    } else {
#if defined(WIN32) || MAC
        if (e.type() == Event::down) {
            def_str_ = ((DismissableWindow*) canvas()->window())->name();
        } else if (e.type() == Event::up) {
            ((DismissableWindow*) canvas()->window())->name(def_str_.string());
        }
#endif
        return Rubberband::event(e);
    }
}
void LineRubberMarker::undraw(Coord, Coord) {
    Coord x, y;
    transformer().transform(x_, y_, x, y);
    Canvas* c = canvas();
    Transformer identity;
    c->push_transform();
    c->transformer(identity);
#if !defined(WIN32) && !MAC
    Allocation a;
    a.allot_x(Allotment(x + 20, 0, 0));
    a.allot_y(Allotment(y, 0, 0));
    label_->draw(c, a);
#endif
    c->line(x - 10, y, x + 10, y, Rubberband::color(), Rubberband::brush());
    c->line(x, y - 10, x, y + 10, Rubberband::color(), Rubberband::brush());
    c->pop_transform();
}
void LineRubberMarker::draw(Coord x, Coord y) {
    // printf("draw %g %g", x, y);
    Coord x1, y1;
    transformer().inverse_transform(x, y, x1, y1);
    // printf(" model %g %g", x1, y1);
    if (gl_) {
        index_ = gl_->nearest(x1, y1, transformer(), index_);
        x_ = gl_->x(index_);
        y_ = gl_->y(index_);
        // printf("  on line %g %g\n", x_, y_);
    }
    char s[50];
 
#if defined(WIN32) || MAC
    sprintf(s, "crosshair x=%g y=%g", x_, y_);
    ((DismissableWindow*) canvas()->window())->name(s);
#else
    sprintf(s, "(%g,%g)", x_, y_);
    Resource::unref(label_);
    label_ = new Label(s, WidgetKit::instance()->font(), Rubberband::color());
#endif
    hoc_cross_x_ = x_;
    hoc_cross_y_ = y_;
    undraw(0, 0);
}
 
void GLabel::pick(Canvas* c, const Allocation&, int depth, Hit& h) {
    if (h.count() && h.target(depth, 0)) {
        return;
    }
    if (h.event() && h.event()->type() == Event::down &&
        h.event()->pointer_button() == Event::left) {
        // printf("GLabel picked %s\n", text_.string());
        switch (XYView::current_pick_view()->scene()->tool()) {
        case Scene::MOVE:
            h.target(depth, this, 0, new MoveLabelBand(this, NULL, c));
            break;
        case Scene::DELETE:
            h.target(depth, this, 0, new DeleteLabelHandler(this));
            break;
        case Scene::CHANGECOLOR:
            XYView::current_pick_view()->scene()->change_label_color(this);
            break;
        case Graph::CHANGELABEL:
            h.target(depth, this, 0, new ChangeLabelHandler(this));
        }
    }
}
 
DeleteLabelHandler::DeleteLabelHandler(GLabel* gl) {
    //  printf("DeleteLabelHandler\n");
    gl_ = gl;
}
 
DeleteLabelHandler::~DeleteLabelHandler() {
    //  printf("~DeleteLabelHandler\n");
}
bool DeleteLabelHandler::event(Event& e) {
    if (Oc::helpmode()) {
        if (e.type() == Event::down) {
            Oc::help(DeleteLabelHandler_event_);
        }
        return true;
    }
    XYView::current_pick_view()->scene()->delete_label(gl_);
    return true;
}
 
ChangeLabelHandler::ChangeLabelHandler(GLabel* gl) {
    //  printf("ChangeLabelHandler\n");
    gl_ = gl;
}
 
ChangeLabelHandler::~ChangeLabelHandler() {
    //  printf("~ChangeLabelHandler\n");
}
bool ChangeLabelHandler::event(Event& e) {
    if (Oc::helpmode()) {
        if (e.type() == Event::down) {
            Oc::help(ChangeLabelHandler_event_);
        }
        return true;
    }
    char buf[200];
    strcpy(buf, gl_->text());
    GLabel* gl = (GLabel*) gl_->clone();
    gl->ref();
    if (Graph::label_chooser("Modify Label", buf, gl, e.pointer_root_x(), e.pointer_root_y())) {
        ((Graph*) (XYView::current_pick_view()->scene()))->change_label(gl_, buf, gl);
    }
    gl->unref();
    return true;
}
 
void Scene::change_label_color(GLabel* gl) {
    printf("No method for changeing label color %s\n", gl->text());
}
 
void Scene::change_line_color(GPolyLine*) {
    printf("No method for changeing line color \n");
}
 
void Scene::delete_label(GLabel* gl) {
    printf("No method for deleting label %s\n", gl->text());
}
 
DeleteLineHandler::DeleteLineHandler(GPolyLine* gpl) {
    //  printf("DeleteLineHandler\n");
    gpl_ = gpl;
}
 
DeleteLineHandler::~DeleteLineHandler() {
    //  printf("~DeleteLineHandler\n");
}
bool DeleteLineHandler::event(Event& e) {
    if (Oc::helpmode()) {
        if (e.type() == Event::down) {
            Oc::help(DeleteLineHandler_event_);
        }
        return true;
    }
    Scene* s = XYView::current_pick_view()->scene();
    GlyphIndex i = s->glyph_index(gpl_);
    s->modified(i);
    s->damage(i);
    gpl_->erase_line(s, i);
    return true;
}
 
LinePicker::LinePicker(GPolyLine* gpl)
    : Rubberband() {
    //  printf("LinePicker\n");
    gpl_ = gpl;
}
 
LinePicker::~LinePicker() {
    //  printf("~LinePicker\n");
}
void LinePicker::press(Event&) {
    const Color* c;
    if (Oc::helpmode()) {
        Oc::help(LinePicker_event_);
        return;
    }
    c_ = gpl_->color();
    c = colors->color(2);
    if (c == c_) {
        c = colors->color(3);
    }
    gpl_->color(c);
    gpl_->pick_vector();
    common();
}
void LinePicker::release(Event&) {
    gpl_->color(c_);
    common();
}
 
void LinePicker::common() {
    Scene* s = XYView::current_pick_view()->scene();
    GlyphIndex i = s->glyph_index(gpl_);
    s->modified(i);
    s->damage(i);
    if (gpl_->label() && (i = s->glyph_index(gpl_->label())) >= 0) {
        s->modified(i);
        s->damage(i);
    }
}
 
MoveLabelBand::MoveLabelBand(GLabel* gl, RubberAction* ra, Canvas* c)
    : Rubberband(ra, c) {
    //  printf("MoveLabelBand\n");
    gl_ = gl;
    gl_->ref();
    label_ = (GLabel*) gl_->clone();
    label_->ref();
    label_->color(Rubberband::color());
    Graph* gr = (Graph*) XYView::current_pick_view()->scene();
    index_ = gr->glyph_index(gl);
    gr->location(index_, x0_, y0_);
    if (gl_->fixed()) {
        transformer().transform(x0_, y0_);
    } else {
        XYView::current_pick_view()->view_ratio(x0_, y0_, x0_, y0_);
    }
    //  printf("MoveLabelBand label index %d (%g, %g)\n", index_, x0_, y0_);
    Allotment ax, ay;
    gr->allotment(index_, Dimension_X, ax);
    gr->allotment(index_, Dimension_Y, ay);
    a_.allot_x(ax);
    a_.allot_y(ay);
}
 
MoveLabelBand::~MoveLabelBand() {
    //  printf("~MoveLabelBand\n");
    Resource::unref(label_);
    Resource::unref(gl_);
}
 
void MoveLabelBand::press(Event&) {
    if (Oc::helpmode()) {
        Oc::help(MoveLabelBand_press_);
        return;
    }
    x0_ -= x_begin();
    y0_ -= y_begin();
#if 0 && !defined(WIN32)
    cursor_ = canvas()->window()->cursor();
    canvas()->window()->cursor(noCursor);
#endif
#if !defined(WIN32) && !MAC
    undraw(x(), y());  // so initial draw does not make it disappear
#endif
}
 
void MoveLabelBand::release(Event&) {
    if (Oc::helpmode()) {
        return;
    }
    Graph* gr = (Graph*) XYView::current_pick_view()->scene();
    Coord x1, y1, x2, y2;
    if (gl_->fixed()) {
        transformer().inverse_transform(x(), y(), x2, y2);
        transformer().inverse_transform(x_begin(), y_begin(), x1, y1);
    } else {
        x2 = x();
        y2 = y();
        x1 = x_begin();
        y1 = y_begin();
    }
    gr->location(index_, x0_, y0_);
    if (gl_->fixed()) {
        x1 = x0_ + x2 - x1;
        y1 = y0_ + y2 - y1;
    } else {
        XYView::current_pick_view()->view_ratio(x0_, y0_, x0_, y0_);
        XYView::current_pick_view()->ratio_view(x0_ + x2 - x1, y0_ + y2 - y1, x1, y1);
    }
    // printf("move to %g %g\n", x1, y1);
    gr->move(index_, x1, y1);
#if 0 && !defined(WIN32)
    canvas()->window()->cursor(cursor_);
#endif
}
 
void MoveLabelBand::draw(Coord x, Coord y) {
    if (Oc::helpmode()) {
        return;
    }
    Canvas* c = canvas();
    // printf("MoveLabelBand::draw(%g, %g)\n", x, y);
    a_.x_allotment().origin(x + x0_);
    a_.y_allotment().origin(y + y0_);
#if defined(WIN32) || MAC
    c->rect(a_.x_allotment().begin(),
            a_.y_allotment().begin(),
            a_.x_allotment().end(),
            a_.y_allotment().end(),
            Rubberband::color(),
            Rubberband::brush());
#else
    label_->draw(c, a_);
#endif
}
#endif