shapeplt.cpp

Go to the documentation of this file.

#include <../../nrnconf.h>
#include "classreg.h"
#include "gui-redirect.h"
 
#if HAVE_IV
 
#include <InterViews/handler.h>
#include <InterViews/action.h>
#include <InterViews/style.h>
#include <InterViews/color.h>
#include <InterViews/polyglyph.h>
#include <IV-look/kit.h>
#include <InterViews/layout.h>
#include <InterViews/background.h>
#include <OS/math.h>
 
#include <ivstream.h>
#include <stdio.h>
#include "scenepic.h"
#endif
#include "shapeplt.h"
#if HAVE_IV
#include "graph.h"
#include "ivoc.h"
#include "nrnoc2iv.h"
#include "rubband.h"
#include "symchoos.h"
#include "symdir.h"
#include "parse.hpp"
#include "utility.h"
#include "objcmd.h"
#include "idraw.h"
 
#define SelectVariable_ "PlotWhat PlotShape"
#define VariableScale_  "VariableScale PlotShape"
#define TimePlot_       "TimePlot PlotShape"
#define SpacePlot_      "SpacePlot PlotShape"
#define ShapePlot_      "ShapePlot PlotShape"
#define MoveText_       "MoveText PlotShape"
 
extern Symlist* hoc_built_in_symlist;
#endif  // HAVE_IV
 
extern Object** (*nrnpy_gui_helper_)(const char* name, Object* obj);
extern double (*nrnpy_object_to_double_)(Object*);
void* (*nrnpy_get_pyobj)(Object* obj) = 0;
void (*nrnpy_decref)(void* pyobj) = 0;
 
// PlotShape class registration for oc
static double sh_flush(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.flush", v);
#if HAVE_IV
    IFGUI((ShapePlot*) v)->flush();
    ENDGUI
#endif
    return 1.;
}
 
static double fast_flush(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.fast_flush", v);
#if HAVE_IV
    IFGUI((ShapePlot*) v)->fast_flush();
    ENDGUI
#endif
    return 1.;
}
 
static double sh_begin(void* v) {  // a noop. Exists only because graphs and
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.begin", v);
    return 1.;  // shapes are often in same list
}
 
static double sh_scale(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.scale", v);
#if HAVE_IV
    IFGUI((ShapePlot*) v)->scale(float(*getarg(1)), float(*getarg(2)));
}
else {
    ((ShapePlotData*) v)->scale(float(*getarg(1)), float(*getarg(2)));
    ENDGUI
#else
    ((ShapePlotData*) v)->scale(float(*getarg(1)), float(*getarg(2)));
#endif
    return 1.;
}
 
#if HAVE_IV
void ShapePlot::has_iv_view(bool value) {
    has_iv_view_ = value;
}
#endif
 
static double sh_view(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.view", v);
#if HAVE_IV
    IFGUI
    ShapePlot* sh = (ShapePlot*) v;
    sh->has_iv_view(true);
    if (sh->varobj()) {
        hoc_execerror("InterViews only supports string variables.", NULL);
    }
    if (ifarg(8)) {
        Coord x[8];
        int i;
        for (i = 0; i < 8; ++i) {
            x[i] = *getarg(i + 1);
        }
        sh->view(x);
    }
    ENDGUI
#endif
    return 1.;
}
 
static double sh_variable(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.variable", v);
    ShapePlotData* spd = (ShapePlotData*) v;
#if HAVE_IV
    // NOTE: only sh OR spd is valid, but both may be safely set
    ShapePlot* sh = (ShapePlot*) v;
#endif
    if (hoc_is_object_arg(1) && nrnpy_get_pyobj) {
        // note that we only get inside here when Python is available
        void* py_var_ = nrnpy_get_pyobj(*hoc_objgetarg(1));
        if (!py_var_) {
            hoc_execerror("variable must be either a string or Python object", NULL);
        }
#if HAVE_IV
        IFGUI
        if (sh->has_iv_view()) {
            nrnpy_decref(py_var_);
            hoc_execerror("InterViews only supports string variables.", NULL);
        }
        nrnpy_decref(sh->varobj());
        sh->varobj(py_var_);
        return 1;
        ENDGUI
#endif
        nrnpy_decref(spd->varobj());
        spd->varobj(py_var_);
        return 1;
    }
    Symbol* s;
    s = hoc_table_lookup(gargstr(1), hoc_built_in_symlist);
    if (s) {
#if HAVE_IV
        IFGUI
        if (nrnpy_decref) {
            nrnpy_decref(sh->varobj());
        }
 
        sh->varobj(NULL);
        sh->variable(s);
    } else {
        if (nrnpy_decref) {
            nrnpy_decref(spd->varobj());
        }
        spd->varobj(NULL);
        spd->variable(s);
        ENDGUI
#else
        if (nrnpy_decref) {
            nrnpy_decref(spd->varobj());
        }
        spd->varobj(NULL);
        spd->variable(s);
#endif
    }
    return 1.;
}
 
static double sh_view_count(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.view_count", v);
    int n = 0;
#if HAVE_IV
    IFGUI
    n = ((ShapeScene*) v)->view_count();
    ENDGUI
#endif
    return double(n);
}
 
static double sh_save_name(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.save_name", v);
#if HAVE_IV
    IFGUI((ShapeScene*) v)->name(gargstr(1));
    ENDGUI
#endif
    return 1.;
}
 
static double sh_unmap(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.unmap", v);
#if HAVE_IV
    IFGUI
    ShapeScene* s = (ShapeScene*) v;
    s->dismiss();
    ENDGUI
#endif
    return 0.;
}
 
static double sh_printfile(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.printfile", v);
#if HAVE_IV
    IFGUI
    ShapeScene* s = (ShapeScene*) v;
    s->printfile(gargstr(1));
    ENDGUI
#endif
    return 1.;
}
 
static double sh_show(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.show", v);
#if HAVE_IV
    IFGUI
    ShapeScene* s = (ShapeScene*) v;
    s->shape_type(int(chkarg(1, 0., 2.)));
    ENDGUI
#endif
    return 1.;
}
 
extern double ivoc_gr_menu_action(void* v);
 
static double s_colormap(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.colormap", v);
#if HAVE_IV
    IFGUI
    ShapePlot* s = (ShapePlot*) v;
    if (ifarg(4)) {
        s->color_value()->colormap(int(chkarg(1, 0, 255)),
                                   int(chkarg(2, 0, 255)),
                                   int(chkarg(3, 0, 255)),
                                   int(chkarg(4, 0, 255)));
    } else {
        bool b = false;
        if (ifarg(2)) {
            b = (bool) chkarg(2, 0, 1);
        }
        s->color_value()->colormap(int(chkarg(1, 0, 1000)), b);
    }
    ENDGUI
#endif
    return 1.;
}
 
static double sh_hinton(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.hinton", v);
#if HAVE_IV
    IFGUI
    ShapeScene* ss = (ShapeScene*) v;
    double* pd = hoc_pgetarg(1);
    double xsize = chkarg(4, 1e-9, 1e9);
    double ysize = xsize;
    if (ifarg(5)) {
        ysize = chkarg(5, 1e-9, 1e9);
    }
    Hinton* h = new Hinton(pd, xsize, ysize, ss);
    ss->append(new FastGraphItem(h));
    ss->move(ss->count() - 1, *getarg(2), *getarg(3));
    ENDGUI
#endif
    return 1.;
}
 
static double exec_menu(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("PlotShape.exec_menu", v);
#if HAVE_IV
    IFGUI((Scene*) v)->picker()->exec_item(gargstr(1));
    ENDGUI
#endif
    return 0.;
}
 
extern double ivoc_gr_menu_tool(void*);
extern double ivoc_gr_mark(void*);
extern double ivoc_gr_size(void*);
extern double ivoc_gr_label(void*);
extern double ivoc_gr_line(void*);
extern double ivoc_gr_begin_line(void*);
extern double ivoc_gr_erase(void*);
extern double ivoc_gr_gif(void*);
extern double ivoc_erase_all(void*);
extern double nrniv_sh_observe(void*);
extern double nrniv_sh_rotate(void*);
extern double nrniv_sh_nearest(void*);
extern double nrniv_sh_push(void*);
extern double nrniv_sh_color(void*);
extern double nrniv_sh_color_all(void*);
extern double nrniv_sh_color_list(void*);
extern double nrniv_len_scale(void*);
extern Object** nrniv_sh_nearest_seg(void*);
extern Object** nrniv_sh_selected_seg(void*);
 
static Member_func sh_members[] = {"hinton",
                                   sh_hinton,
                                   "nearest",
                                   nrniv_sh_nearest,
                                   "push_selected",
                                   nrniv_sh_push,
                                   "scale",
                                   sh_scale,
                                   "view",
                                   sh_view,
                                   "size",
                                   ivoc_gr_size,
                                   "view_count",
                                   sh_view_count,
                                   "flush",
                                   sh_flush,
                                   "fastflush",
                                   fast_flush,
                                   "begin",
                                   sh_begin,
                                   "variable",
                                   sh_variable,
                                   "save_name",
                                   sh_save_name,
                                   "unmap",
                                   sh_unmap,
                                   "color",
                                   nrniv_sh_color,
                                   "color_all",
                                   nrniv_sh_color_all,
                                   "color_list",
                                   nrniv_sh_color_list,
                                   "printfile",
                                   sh_printfile,
                                   "show",
                                   sh_show,
                                   "menu_action",
                                   ivoc_gr_menu_action,
                                   "menu_tool",
                                   ivoc_gr_menu_tool,
                                   "colormap",
                                   s_colormap,
                                   "exec_menu",
                                   exec_menu,
                                   "observe",
                                   nrniv_sh_observe,
                                   "rotate",
                                   nrniv_sh_rotate,
                                   "beginline",
                                   ivoc_gr_begin_line,
                                   "line",
                                   ivoc_gr_line,
                                   "label",
                                   ivoc_gr_label,
                                   "mark",
                                   ivoc_gr_mark,
                                   "erase",
                                   ivoc_gr_erase,
                                   "erase_all",
                                   ivoc_erase_all,
                                   "len_scale",
                                   nrniv_len_scale,
                                   "gif",
                                   ivoc_gr_gif,
                                   0,
                                   0};
 
static Member_ret_obj_func retobj_members[] =
    {"nearest_seg", nrniv_sh_nearest_seg, "selected_seg", nrniv_sh_selected_seg, NULL, NULL};
 
static void* sh_cons(Object* ho) {
    TRY_GUI_REDIRECT_OBJ("PlotShape", NULL);
    int i = 1;
    int iarg = 1;
    SectionList* sl = NULL;
    Object* ob = NULL;
    // first arg may be an object.
    if (ifarg(iarg)) {
        if (hoc_is_object_arg(iarg)) {
            ob = *hoc_objgetarg(iarg);
            check_obj_type(ob, "SectionList");
#if HAVE_IV
            IFGUI
            sl = new SectionList(ob);
            sl->ref();
            ENDGUI
#endif
            ++iarg;
        }
    }
    if (ifarg(iarg)) {
        i = int(chkarg(iarg, 0, 1));
    }
#if HAVE_IV
    IFGUI
    ShapePlot* sh = NULL;
    sh = new ShapePlot(NULL, sl);
    sh->has_iv_view(i ? true : false);
    sh->varobj(NULL);
    Resource::unref(sl);
    sh->ref();
    sh->hoc_obj_ptr(ho);
    if (i) {
        sh->view(200);
    }
    return (void*) sh;
}
else {
    ShapePlotData* spd = new ShapePlotData(NULL, ob);
    return (void*) spd;
    ENDGUI
#else
    ShapePlotData* sh = new ShapePlotData(NULL, ob);
    return (void*) sh;
#endif
}
 
static void sh_destruct(void* v) {
    TRY_GUI_REDIRECT_NO_RETURN("~PlotShape", v);
#if HAVE_IV
    IFGUI
    if (nrnpy_decref) {
        ShapePlot* sp = (ShapePlot*) v;
        nrnpy_decref(sp->varobj());
    }
 
    ((ShapeScene*) v)->dismiss();
}
else {
    if (nrnpy_decref) {
        ShapePlotData* sp = (ShapePlotData*) v;
        nrnpy_decref(sp->varobj());
    }
    ENDGUI
    Resource::unref((ShapeScene*) v);
#else
    if (nrnpy_decref) {
        ShapePlotData* sp = (ShapePlotData*) v;
        nrnpy_decref(sp->varobj());
    }
 
#endif
}
void PlotShape_reg() {
    //  printf("PlotShape_reg\n");
    class2oc("PlotShape", sh_cons, sh_destruct, sh_members, NULL, retobj_members, NULL);
}
 
void* ShapePlotData::varobj() const {
    return py_var_;
}
 
void ShapePlotData::varobj(void* obj) {
    py_var_ = obj;
}
 
#if HAVE_IV
 
/* static */ class ShapePlotImpl: public Observer {
  public:
    ShapePlotImpl(ShapePlot*, Symbol*);
    ~ShapePlotImpl();
    virtual void time();
    virtual void space();
    virtual void shape();
    virtual void show_shape_val(bool);
    virtual void select_variable();
    virtual void scale();
    virtual void colorbar();
    virtual void update(Observable*);
 
  public:
    ShapePlot* sp_;
    Symbol* sym_;
    GLabel* variable_;
    double graphid_;
    int colorid_;
    SectionHandler* time_sh_;
    bool showing_;
    Glyph* colorbar_;
    bool fast_;
};
 
/* static */ class MakeTimePlot: public SectionHandler {
  public:
    MakeTimePlot(ShapePlotImpl*);
    virtual ~MakeTimePlot();
    virtual bool event(Event&);
 
  private:
    ShapePlotImpl* spi_;
};
 
/* static */ class MakeSpacePlot: public RubberAction {
  public:
    MakeSpacePlot(ShapePlotImpl*);
    virtual ~MakeSpacePlot();
    virtual void execute(Rubberband*);
 
  private:
    ShapePlotImpl* spi_;
};
 
declareActionCallback(ShapePlotImpl);
implementActionCallback(ShapePlotImpl);
 
ShapePlot::ShapePlot(Symbol* sym, SectionList* sl)
    : ShapeScene(sl) {
    py_var_ = NULL;
    if (sl) {
        sl_ = sl->nrn_object();
    } else {
        sl_ = NULL;
    }
    if (sl_)
        ++sl_->refcount;
    spi_ = new ShapePlotImpl(this, sym);
    variable(spi_->sym_);
    picker()->add_menu("Plot What?",
                       new ActionCallback(ShapePlotImpl)(spi_, &ShapePlotImpl::select_variable));
    picker()->add_menu("Variable scale",
                       new ActionCallback(ShapePlotImpl)(spi_, &ShapePlotImpl::scale));
    picker()->add_radio_menu("Time Plot",
                             new ActionCallback(ShapePlotImpl)(spi_, &ShapePlotImpl::time));
    picker()->add_radio_menu("Space Plot",
                             new ActionCallback(ShapePlotImpl)(spi_, &ShapePlotImpl::space));
    picker()->add_radio_menu("Shape Plot",
                             new ActionCallback(ShapePlotImpl)(spi_, &ShapePlotImpl::shape));
    color_value()->attach(spi_);
    spi_->colorbar();
}
ShapePlot::~ShapePlot() {
    if (sl_)
        hoc_dec_refcount(&sl_);
    color_value()->detach(spi_);
    delete spi_;
}
 
 
float ShapePlot::low() {
    return color_value()->low();
}
float ShapePlot::high() {
    return color_value()->high();
}
 
Object* ShapePlot::neuron_section_list() {
    return sl_;
}
 
void ShapePlot::observe(SectionList* sl) {
    //  printf("ShapePlot::observe\n");
    if (sl_)
        hoc_dec_refcount(&sl_);
    sl_ = sl ? sl->nrn_object() : NULL;
    if (sl_)
        ++sl_->refcount;
    ShapeScene::observe(sl);
    if (spi_->showing_) {
        PolyGlyph* pg = shape_section_list();
        GlyphIndex i, cnt = pg->count();
        for (i = 0; i < cnt; ++i) {
            ShapeSection* ss = (ShapeSection*) pg->component(i);
            ss->set_range_variable(spi_->sym_);
        }
        damage_all();
    }
}
 
void ShapePlot::update_ptrs() {
    PolyGlyph* pg = shape_section_list();
    GlyphIndex i, cnt = pg->count();
    for (i = 0; i < cnt; ++i) {
        ShapeSection* ss = (ShapeSection*) pg->component(i);
        ss->update_ptrs();
    }
}
 
void ShapePlot::erase_all() {
    Resource::unref(spi_->colorbar_);
    spi_->colorbar_ = NULL;
    ShapeScene::erase_all();
}
void ShapePlotImpl::update(Observable*) {
    colorbar();
    sp_->damage_all();
}
 
void ShapePlot::variable(Symbol* sym) {
    GlyphIndex i;
    spi_->sym_ = sym;
    i = glyph_index(spi_->variable_);
    GLabel* g = new GLabel(spi_->sym_->name, colors->color(1), 1, 1, .5, .5);
    if (i >= 0) {
        damage(i);
        replace(i, new GraphItem(g, 0));
        damage(i);
    } else {
        append_fixed(new GraphItem(g, 0));
    }
    Resource::unref(spi_->variable_);
    Resource::ref(g);
    spi_->variable_ = g;
    if (spi_->showing_) {
        spi_->showing_ = false;
        spi_->show_shape_val(true);
    }
    scale(-80, 40);
}
const char* ShapePlot::varname() const {
    return spi_->sym_->name;
}
 
void* ShapePlot::varobj() const {
    return py_var_;
}
 
void ShapePlot::varobj(void* obj) {
    py_var_ = obj;
}
 
 
void ShapePlot::scale(float min, float max) {
    color_value()->set_scale(min, max);
}
 
 
void ShapePlot::save_phase1(ostream& o) {
    o << "{" << endl;
    save_class(o, "PlotShape");
    char buf[256];
    sprintf(buf, "save_window_.variable(\"%s\")", spi_->sym_->name);
    o << buf << endl;
}
 
void ShapePlot::shape_plot() {}
void ShapePlot::make_time_plot(Section*, float) {}
void ShapePlot::make_space_plot(Section*, float, Section*, float) {}
void ShapePlot::flush() {
    spi_->fast_ = false;
    if (tool() == SHAPE) {
        damage_all();
    }
}
void ShapePlot::fast_flush() {
    if (tool() == SHAPE) {
        int i, cnt = view_count();
        spi_->fast_ = true;
        // fast for only one view
        for (i = 0; i < cnt; ++i) {
            XYView* v = sceneview(i);
            Coord x = v->left(), y = v->bottom();
#if defined(WIN32)
            // if x,y is not on the screen then use right, top. Otherwise InvalidateRect
            // will not take effect.
            Window* w = v->canvas() ? v->canvas()->window() : NULL;
            if (w) {
                if (w->left() < 0) {
                    x = v->right();
                }
                if (w->bottom() < 0) {
                    y = v->top();
                }
            }
#endif
            v->damage(x, y, x, y);
        }
    }
}
#if defined(WIN32)
extern void* mswin_setclip(Canvas*, int, int, int, int);
extern void mswin_delete_object(void*);
#endif
 
void ShapePlot::draw(Canvas* c, const Allocation& a) const {
    if (spi_->fast_) {
#if defined(WIN32) || MAC
        // win32 clipping is much more strict than X11 clipping even though the
        // implementations seem to agree that clipping is the intersection of
        // all clip requests on the clip stack in canvas. Clipping is originally
        // set to the damage area and thus nothing actually gets drawn to
        // the buffer. Furthermore, when copying from buffer to screen, only
        // the original damage area is copied. For some reason in X11 neither
        // seems to prevent the correct appearance although I wonder if it
        // will work on all x11 implementations. However, for WIN32, both cause
        // problems and thus the implementation of Canvas16::clip was changed to
        // not do an intersection and the "damage_all" below along with a change
        // to the window.cpp paint function in which the damage area is reread before
        // the bit block transfer solves the problem.
        // At any rate this is fast only for the first view since the fast_draw's
        // only work once.
 
        XYView* v = XYView::current_draw_view();
        c->push_clipping(true);
#if MAC
        c->clip_rect(v->left(), v->bottom(), v->right(), v->top());
#endif
#if defined(WIN32)
        // Consider the commit message:
        // -------
        // 28)  Branch: MAIN Date: 2004-05-21 06:30 Commit by: hines
        // canvas16.cpp
        // MSWin PolyGlyphs inside a ScrollBox occasionally do not repair all the damage
        // This is apparently a long standing problem dating from 1999 which just
        // now became very noticable with the MultipleRunFitter Parameter panel
        // when there are many parameters (so that it is a scrollbox). This has
        // been traced to a #if 0 fragment in the clipping mechanism which turned
        // off the intersection calculation when a new clipping region was requested
        // We have turned this section back on. There was no reason mentioned in
        // the 1999 log message when the #if 0 was introduced. The major reason for
        // the larger change in that file was drawing dashed brush lines. If a
        // problem with clipping exists then it will have to be fixed in another way.
        // -------
        // Well, here is the reason for the #if 0. Without it, the fast_flush movie
        // is not drawn for shapeplots. (Strangely, the neurondemo movie works for
        // the stylized neuron but not the pyramidal cell.
        // So as not to ruin the MAIN 28 commit of canvas16.cpp
        // we force the clipping to the entire canvas for the fast_flush.
        // Feeble attempts to do everything here, foundered on my inability to
        // include <windows.h> in this file. So the implementation is placed in
        // ivocwin.cpp. Note that the clip region must be deleted after use.
        //
        void* new_clip = mswin_setclip(c, 0, 0, c->pwidth(), c->pheight());
#endif
#endif
        GlyphIndex i, cnt = count();
        for (i = 0; i < cnt; ++i) {
            GraphItem* gi = (GraphItem*) component(i);
            if (gi->is_fast()) {
                Coord x, y;
                location(i, x, y);
                ((FastShape*) (gi->body()))->fast_draw(c, x, y, false);
            }
        }
#if defined(WIN32) || MAC
        c->pop_clipping();
#if defined(WIN32)
        mswin_delete_object(new_clip);
#endif
        v->damage_all();
        ;
#endif
        spi_->fast_ = false;
    } else {
        ShapeScene::draw(c, a);
    }
}
 
ShapePlotImpl::ShapePlotImpl(ShapePlot* sp, Symbol* sym) {
    sp_ = sp;
    colorid_ = 0;
    graphid_ = 0;
    showing_ = false;
    fast_ = false;
    colorbar_ = NULL;
    if (sym) {
        sym_ = sym;
    } else {
        sym_ = hoc_table_lookup("v", hoc_built_in_symlist);
    }
    variable_ = NULL;
    time_sh_ = new MakeTimePlot(this);
    time_sh_->ref();
}
 
ShapePlotImpl::~ShapePlotImpl() {
    Resource::unref(variable_);
    time_sh_->unref();
    Resource::unref(colorbar_);
}
 
void ShapePlotImpl::colorbar() {
    bool showing;
    if (colorbar_) {
        int i = sp_->glyph_index(colorbar_);
        Resource::unref(colorbar_);
        showing = sp_->showing(i);
        sp_->remove(i);
    } else {
        showing = false;
    }
    colorbar_ = sp_->color_value()->make_glyph();
    colorbar_->ref();
    sp_->append_fixed(new GraphItem(colorbar_, 0));
    sp_->show(sp_->count() - 1, showing);
    if (showing) {
        XYView* v = XYView::current_pick_view();
        sp_->move(sp_->count() - 1, v->left(), v->top());
    }
}
 
void ShapePlotImpl::select_variable() {
    if (Oc::helpmode()) {
        Oc::help(SelectVariable_);
    }
    SymChooser* sc;
    Oc oc;
    Style* style = new Style(Session::instance()->style());
    style->attribute("caption", "Variable in the shape domain");
    sc = new SymChooser(new SymDirectory(RANGEVAR), WidgetKit::instance(), style, NULL, 1);
    sc->ref();
    while (sc->post_for(XYView::current_pick_view()->canvas()->window())) {
        Symbol* s;
        s = hoc_table_lookup(sc->selected()->string(), hoc_built_in_symlist);
        if (s) {
            sp_->variable(s);
            break;
        }
    }
    sc->unref();
}
 
void ShapePlotImpl::scale() {
    if (Oc::helpmode()) {
        Oc::help(VariableScale_);
    }
    Coord x, y;
    x = sp_->color_value()->low();
    y = sp_->color_value()->high();
    if (var_pair_chooser(
            "Variable range scale", x, y, XYView::current_pick_view()->canvas()->window())) {
        sp_->scale(x, y);
    }
}
 
void ShapePlotImpl::time() {
    if (Oc::helpmode()) {
        Oc::help(TimePlot_);
        return;
    }
    sp_->tool(ShapePlot::TIME);
    graphid_ = 0;
    colorid_ = 2;
    sp_->color(colors->color(1));
    sp_->section_handler(time_sh_);
    show_shape_val(false);
    sp_->picker()->bind_select((OcHandler*) NULL);
}
 
void ShapePlotImpl::space() {
    if (Oc::helpmode()) {
        Oc::help(SpacePlot_);
        return;
    }
    sp_->tool(ShapePlot::SPACE);
    graphid_ = 0;
    colorid_ = 1;
    sp_->color(colors->color(1));
    sp_->section_handler((SectionHandler*) NULL);
    show_shape_val(false);
    sp_->picker()->bind_select(new RubberLine(new MakeSpacePlot(this)));
}
 
void ShapePlotImpl::shape() {
    if (Oc::helpmode()) {
        Oc::help(ShapePlot_);
        return;
    }
    sp_->tool(ShapePlot::SHAPE);
    // printf("shape\n");
    sp_->section_handler((SectionHandler*) NULL);
    sp_->picker()->bind_select((OcHandler*) NULL);
    show_shape_val(true);
}
 
void ShapePlotImpl::show_shape_val(bool show) {
    if (show != showing_) {
        PolyGlyph* pg = sp_->shape_section_list();
        GlyphIndex i, cnt = pg->count();
        if (show) {
            for (i = 0; i < cnt; ++i) {
                ShapeSection* ss = (ShapeSection*) pg->component(i);
                ss->set_range_variable(sym_);
            }
        } else {
            for (i = 0; i < cnt; ++i) {
                ShapeSection* ss = (ShapeSection*) pg->component(i);
                ss->clear_variable();
            }
        }
        if (colorbar_) {
            int i = sp_->glyph_index(colorbar_);
            sp_->show(i, show);
            if (show) {
                XYView* v = XYView::current_pick_view();
                sp_->move(i, v->left(), v->top());
            }
        }
        sp_->damage_all();
        showing_ = show;
    }
}
 
MakeTimePlot::MakeTimePlot(ShapePlotImpl* spi) {
    spi_ = spi;
}
MakeTimePlot::~MakeTimePlot() {}
 
bool MakeTimePlot::event(Event&) {
    Oc oc;
    ShapeSection* ss = shape_section();
    Section* sec = ss->section();
    if (spi_->sp_->tool() != ShapePlot::TIME) {
        return false;
    }
    if (spi_->graphid_ == 0) {
        oc.run("newPlotV()\n");
        oc.run("hoc_ac_ = object_id(graphItem)\n");
        spi_->graphid_ = hoc_ac_;
    }
    oc.run("hoc_ac_ = object_id(graphItem)\n");
    // printf("graphid_=%g hoc_ac_=%g\n", graphid_, hoc_ac_);
    float x = spi_->sp_->arc_selected();
    x = nrn_arc_position(sec, node_exact(sec, x));
    x = (nrn_section_orientation(sec) == 0.) ? x : 1. - x;
    if (spi_->graphid_ == hoc_ac_) {
        char buf[200];
        sprintf(buf, "{graphItem.color(%d)}\n", spi_->colorid_);
        oc.run(buf);
        sprintf(buf,
                "{graphItem.addvar(\"%s.%s(%g)\")}\n",
                hoc_section_pathname(sec),
                spi_->sp_->varname(),
                x);
        oc.run(buf);
        ss->setColor(colors->color(spi_->colorid_), ShapeScene::current_pick_scene());
        ++spi_->colorid_;
    } else {
        spi_->graphid_ = 0;
    }
    return true;
}
 
MakeSpacePlot::MakeSpacePlot(ShapePlotImpl* spi) {
    spi_ = spi;
}
MakeSpacePlot::~MakeSpacePlot() {}
 
void MakeSpacePlot::execute(Rubberband* rb) {
    ShapePlot* sp = spi_->sp_;
    RubberLine* rl = (RubberLine*) rb;
    Coord x1, y1, x2, y2;
    float a1, a2;
    rl->get_line(x1, y1, x2, y2);
    // printf("MakeSpacePlot %g %g %g %g\n", x1, y1, x2, y2);
    char buf[256];
    Oc oc;
    oc.run("objectvar rvp_\n");
    Section *sec1, *sec2;
    sp->nearest(x1, y1);
    sec1 = sp->selected()->section();
    a1 = sp->arc_selected();
    a1 = (a1 < .5) ? 0. : 1.;
    sp->nearest(x2, y2);
    sec2 = sp->selected()->section();
    a2 = sp->arc_selected();
    a2 = (a2 < .5) ? 0. : 1.;
    if (sec1 == sec2 && a1 == a2) {
        printf("Null path for space plot: ignored\n");
        return;
    }
    oc.run("hoc_ac_ = object_id(graphItem)\n");
    // printf("graphid_=%g hoc_ac_=%g\n", graphid_, hoc_ac_);
    if (spi_->graphid_ == 0. || spi_->graphid_ != hoc_ac_) {
        oc.run("graphItem = new Graph()\n");
        oc.run("hoc_ac_ = object_id(graphItem)\n");
        spi_->graphid_ = hoc_ac_;
        oc.run("{graphItem.save_name(\"flush_list.\")}\n");
        oc.run("{flush_list.append(graphItem)}\n");
        spi_->colorid_ = 1;
    }
    ++spi_->colorid_;
    ColorValue* cv = sp->color_value();
    sprintf(buf, "rvp_ = new RangeVarPlot(\"%s\")\n", sp->varname());
    oc.run(buf);
    sprintf(buf, "%s rvp_.begin(%g)\n", hoc_section_pathname(sec1), a1);
    oc.run(buf);
    sprintf(buf, "%s rvp_.end(%g)\n", hoc_section_pathname(sec2), a2);
    oc.run(buf);
    oc.run("{rvp_.origin(rvp_.d2root)}\n");
    sprintf(buf, "{graphItem.size(rvp_.left(), rvp_.right(), %g, %g)}\n", cv->low(), cv->high());
    oc.run(buf);
    sprintf(buf, "{graphItem.addobject(rvp_, %d, 1) graphItem.yaxis()}\n", spi_->colorid_);
    oc.run(buf);
    sp->color(sec1, sec2, colors->color(spi_->colorid_));
}
 
 
static const Color* gray;
static int csize;
static const Color** crange;
 
static int spec[] = {95,  0,   95, 111, 0,   111, 127, 0,   143, 143, 0,   127, 159, 0,   111,
                     175, 0,   95, 191, 0,   79,  207, 0,   63,  207, 31,  47,  223, 47,  47,
                     239, 63,  31, 255, 79,  15,  255, 95,  7,   255, 111, 0,   255, 127, 0,
                     255, 143, 0,  255, 159, 0,   255, 175, 0,   255, 191, 0,   255, 207, 0,
                     255, 223, 0,  255, 239, 0,   255, 247, 0,   255, 255, 0,   -1};
 
 
ColorValue::ColorValue() {
    if (!gray) {
        Style* s = Session::instance()->style();
        CopyString name;
        csize = 0;
        if (s->find_attribute("shape_scale_file", name)) {
            name = expand_env_var(name.string());
            // printf("ColorValue %s\n", name.string());
            FILE* f;
            if ((f = fopen(name.string(), "r")) == 0) {
#ifdef WIN32
#else
                printf("Cannot open %s: Using built-in colormap for shapeplot\n", name.string());
#endif
            } else {
                int r, g, b;
                while (fscanf(f, "%d %d %d", &r, &g, &b) == 3) {
                    ++csize;
                }
                if (csize) {
                    crange = new const Color*[csize];
                    rewind(f);
                    csize = 0;
                    while (fscanf(f, "%d %d %d", &r, &g, &b) == 3) {
                        crange[csize] = new Color(ColorIntensity(r / 256.),
                                                  ColorIntensity(g / 256.),
                                                  ColorIntensity(b / 256.));
                        Resource::ref(crange[csize]);
                        ++csize;
                    }
                }
                fclose(f);
            }
        }
        if (csize == 0) {
            for (csize = 0; spec[csize * 3] != -1; csize++) {
            }
            crange = new const Color*[csize];
            for (csize = 0; spec[csize * 3] != -1; csize++) {
                crange[csize] = new Color(ColorIntensity(spec[csize * 3] / 256.),
                                          ColorIntensity(spec[csize * 3 + 1] / 256.),
                                          ColorIntensity(spec[csize * 3 + 2] / 256.));
                Resource::ref(crange[csize]);
            }
        }
        gray = Color::lookup(Session::instance()->default_display(), "gray");
        Resource::ref(gray);
    }
    csize_ = 0;
    crange_ = NULL;
    set_scale(0, 1);
}
 
ColorValue::~ColorValue() {
    int i;
    if (csize_) {  // delete the local
        for (i = 0; i < csize_; ++i) {
            crange_[i]->unref();
        }
        delete[] crange_;
    }
}
 
void ColorValue::set_scale(float low, float high) {
    if (low < high) {
        low_ = low;
        high_ = high;
    }
    notify();
}
 
const Color* ColorValue::get_color(float val) const {
    float x = (val - low_) / (high_ - low_);
    if (csize_) {
        if (x > .99)
            return crange_[csize_ - 1];
        else if (x < 0)
            return crange_[0];
        else
            return crange_[int(csize_ * x)];
    } else {
        if (x > .99)
            return crange[csize - 1];
        else if (x < 0)
            return crange[0];
        else
            return crange[int(csize * x)];
    }
}
 
const Color* ColorValue::no_value() const {
    return gray;
}
 
class ColorValueGlyphItem: public MonoGlyph {
  public:
    ColorValueGlyphItem(const char*, const Color*);
    virtual ~ColorValueGlyphItem();
    virtual void draw(Canvas*, const Allocation&) const;
 
  private:
    CopyString label_;
    const Color* color_;
};
 
ColorValueGlyphItem::ColorValueGlyphItem(const char* buf, const Color* c) {
    body(new Background(WidgetKit::instance()->label(buf), c));
    label_ = buf;
    color_ = c;
}
 
ColorValueGlyphItem::~ColorValueGlyphItem() {}
 
void ColorValueGlyphItem::draw(Canvas* c, const Allocation& a) const {
    body()->draw(c, a);
    if (OcIdraw::idraw_stream) {
        OcIdraw::pict();
        OcIdraw::rect(c, a.left(), a.bottom(), a.right(), a.top(), color_, NULL, true);
        Transformer t;
        t.translate(a.left(), a.bottom());
        OcIdraw::text(c, label_.string(), t);
        OcIdraw::end();
    }
}
 
Glyph* ColorValue::make_glyph() {
    LayoutKit& lk = *LayoutKit::instance();
    WidgetKit& wk = *WidgetKit::instance();
    PolyGlyph* box = lk.vbox(csize + 2);
    int c = csize_ ? csize_ : csize;
    for (int i = c - 1; i >= 0; --i) {
        char buf[50];
        float x = low_ + i * (high_ - low_) / (c - 1);
        sprintf(buf, "%5g", x);
        box->append(new ColorValueGlyphItem(buf, get_color(x)));
        //      box->append(new Background(wk.label(buf), get_color(x)));
    }
    return box;
}
 
void ColorValue::colormap(int size, bool global) {
    int i;
    if (csize_) {
        for (i = 0; i < csize_; ++i) {
            crange_[i]->unref();
        }
        delete[] crange_;
        crange_ = NULL;
        csize_ = 0;
    }
    if (global) {
        if (csize) {
            for (i = 0; i < csize; ++i) {
                crange[i]->unref();
            }
            delete[] crange;
        }
        csize = (size > 1) ? size : 2;
        crange = new const Color*[csize];
        for (i = 0; i < csize; ++i) {
            crange[i] = gray;
            crange[i]->ref();
        }
    } else {
        csize_ = (size > 1) ? size : 2;
        crange_ = new const Color*[csize_];
        for (i = 0; i < csize_; ++i) {
            crange_[i] = gray;
            crange_[i]->ref();
        }
    }
}
void ColorValue::colormap(int i, int r, int g, int b) {
    if (crange_) {
        if (i >= 0 && i < csize_ && r < 256 && g < 256 && b < 256) {
            crange_[i]->unref();
            crange_[i] = new Color(ColorIntensity(r / 256.),
                                   ColorIntensity(g / 256.),
                                   ColorIntensity(b / 256.));
            Resource::ref(crange_[i]);
        }
    } else {
        if (i >= 0 && i < csize && r < 256 && g < 256 && b < 256) {
            crange[i]->unref();
            crange[i] = new Color(ColorIntensity(r / 256.),
                                  ColorIntensity(g / 256.),
                                  ColorIntensity(b / 256.));
            Resource::ref(crange[i]);
        }
    }
}
 
FastGraphItem::FastGraphItem(FastShape* g, bool s, bool p)
    : GraphItem(g, s, p) {}
 
FastShape::FastShape() {}
FastShape::~FastShape() {}
 
Hinton::Hinton(double* pd, Coord xsize, Coord ysize, ShapeScene* ss) {
    pd_ = pd;
    old_ = NULL;  // not referenced
    xsize_ = xsize / 2;
    ysize_ = ysize / 2;
    ss_ = ss;
    Oc oc;
    oc.notify_when_freed(pd_, this);
}
Hinton::~Hinton() {
    Oc oc;
    oc.notify_pointer_disconnect(this);
}
void Hinton::update(Observable*) {
    pd_ = NULL;
    ss_->remove(ss_->glyph_index(this));
}
void Hinton::request(Requisition& req) const {
    assert(this);
    Requirement rx(2. * xsize_, 0, 0, .5);
    Requirement ry(2. * ysize_, 0, 0, .5);
    req.require_x(rx);
    req.require_y(ry);
}
 
void Hinton::allocate(Canvas* c, const Allocation& a, Extension& ext) {
    ext.set(c, a);
}
 
void Hinton::draw(Canvas* c, const Allocation& a) const {
    if (pd_) {
        Coord x = a.x();
        Coord y = a.y();
        const Color* color = ss_->color_value()->get_color(*pd_);
        c->fill_rect(x - xsize_, y - ysize_, x + xsize_, y + ysize_, color);
        ((Hinton*) this)->old_ = color;
        IfIdraw(rect(c, x - xsize_, y - ysize_, x + xsize_, y + ysize_, color, NULL, true));
    }
}
void Hinton::fast_draw(Canvas* c, Coord x, Coord y, bool) const {
    if (pd_) {
        const Color* color = ss_->color_value()->get_color(*pd_);
        if (color != old_) {
            c->fill_rect(x - xsize_, y - ysize_, x + xsize_, y + ysize_, color);
            ((Hinton*) this)->old_ = color;
        }
    }
}
 
bool ShapePlot::has_iv_view() {
    return has_iv_view_;
}
 
#endif  // HAVE_IV
 
ShapePlotData::ShapePlotData(Symbol* sym, Object* sl) {
    sym_ = sym;
    sl_ = sl;
    if (sl_) {
        ++sl_->refcount;
    }
    varobj(NULL);
}
 
ShapePlotData::~ShapePlotData() {
    if (sl_) {
        hoc_dec_refcount(&sl_);
    }
}
 
bool ShapePlotData::has_iv_view() {
    return false;
}
 
float ShapePlotData::low() {
    return lo;
}
 
float ShapePlotData::high() {
    return hi;
}
 
void ShapePlotData::scale(float min, float max) {
    lo = min;
    hi = max;
}
 
void ShapePlotData::variable(Symbol* sym) {
    sym_ = sym;
    scale(-80, 40);
}
 
const char* ShapePlotData::varname() const {
    if (sym_ == NULL) {
        return "v";
    }
    return sym_->name;
}
 
Object* ShapePlotData::neuron_section_list() {
    return sl_;
}