ocbox.cpp

Go to the documentation of this file.

#include <../../nrnconf.h>
 
#if HAVE_IV
#include <OS/string.h>
#include <InterViews/polyglyph.h>
#include <InterViews/layout.h>
#include <InterViews/place.h>
#include <InterViews/patch.h>
#include <InterViews/background.h>
#include <InterViews/box.h>
#include <IV-look/kit.h>
#include <InterViews/input.h>
#include <ivstream.h>
#include <stdio.h>
#include "ocbox.h"
#include "apwindow.h"
#include "objcmd.h"
#include "ivoc.h"
#endif /* HAVE_IV */
 
#include <InterViews/resource.h>
#include "oc2iv.h"
#include "classreg.h"
 
#include "gui-redirect.h"
 
extern int hoc_return_type_code;
 
extern Object** (*nrnpy_gui_helper_)(const char* name, Object* obj);
extern double (*nrnpy_object_to_double_)(Object*);
 
#if HAVE_IV
 
class NrnFixedLayout: public Layout {
  public:
    NrnFixedLayout(const DimensionName, Coord span);
    virtual ~NrnFixedLayout();
 
    virtual void request(GlyphIndex count, const Requisition*, Requisition& result);
    virtual void allocate(const Allocation& given,
                          GlyphIndex count,
                          const Requisition*,
                          Allocation* result);
    virtual void span(Coord);
    virtual Coord span() {
        return span_;
    }
    virtual bool vertical() {
        return dimension_ == Dimension_Y;
    }
 
  private:
    DimensionName dimension_;
    Coord span_;
};
 
/*static*/ class OcBoxImpl {
  public:
    PolyGlyph* ocglyph_list_;
    PolyGlyph* box_;
    Object* oc_ref_;  // reference to oc "this"
    CopyString* save_action_;
    Object* save_pyact_;
    int type_;
    ostream* o_;
    Object* keep_ref_;
    CopyString* dis_act_;
    Object* dis_pyact_;
    bool dismissing_;
    Coord next_map_adjust_;
    PolyGlyph* ba_list_;
    bool full_request_;
};
 
/*static*/ class BoxAdjust: public InputHandler {
  public:
    BoxAdjust(OcBox*, OcBoxImpl*, Glyph*, Coord natural);
    virtual ~BoxAdjust();
    virtual void press(const Event&);
    virtual void drag(const Event&);
    virtual void release(const Event&);
    NrnFixedLayout* fixlay_;
    OcBox* b_;
    OcBoxImpl* bi_;
    Glyph* ga_;  // not part of this glyph.
    Coord pstart_, fstart_;
};
 
/*static*/ class BoxDismiss: public WinDismiss {
  public:
    BoxDismiss(DismissableWindow*, String*, OcBox*, Object* pyact = NULL);
    virtual ~BoxDismiss();
    virtual void execute();
 
  private:
    HocCommand* hc_;
    OcBox* b_;
};
 
BoxDismiss::BoxDismiss(DismissableWindow* w, String* s, OcBox* b, Object* pyact)
    : WinDismiss(w) {
    if (pyact) {
        hc_ = new HocCommand(pyact);
    } else {
        hc_ = new HocCommand(s->string());
    }
    b_ = b;
}
BoxDismiss::~BoxDismiss() {
    delete hc_;
}
void BoxDismiss::execute() {
    if (b_->dismissing() == true) {
        WinDismiss::execute();
    } else {
        hc_->execute();
    }
}
#endif /* HAVE_IV */
static void* vcons(Object*) {
    TRY_GUI_REDIRECT_OBJ("VBox", NULL);
#if HAVE_IV
    OcBox* b = NULL;
    int frame = OcBox::INSET;
    bool scroll = false;
    if (ifarg(1))
        frame = int(chkarg(1, 0, 3));
    if (ifarg(2) && int(chkarg(2, 0, 1)) == 1) {
        scroll = true;
    }
    b = new OcBox(OcBox::V, frame, scroll);
    b->ref();
    return (void*) b;
#else
    return nullptr;
#endif /* HAVE_IV  */
}
 
static void* hcons(Object*) {
    TRY_GUI_REDIRECT_OBJ("HBox", NULL);
#if HAVE_IV
    OcBox* b = NULL;
    int frame = OcBox::INSET;
    if (ifarg(1))
        frame = int(chkarg(1, 0, 3));
    b = new OcBox(OcBox::H, frame);
    b->ref();
    return (void*) b;
#else
    return nullptr;
#endif /* HAVE_IV  */
}
 
static void destruct(void* v) {
    // TODO: this doesn't seem to get called; why?
    TRY_GUI_REDIRECT_NO_RETURN("~Box", v);
#if HAVE_IV
    OcBox* b = (OcBox*) v;
    IFGUI
    if (b->has_window()) {
        b->window()->dismiss();
    }
    ENDGUI
    b->unref();
#endif /* HAVE_IV */
}
 
static double intercept(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.intercept", v);
#if HAVE_IV
    bool b = int(chkarg(1, 0., 1.));
    IFGUI((OcBox*) v)->intercept(b);
    ENDGUI
    return double(b);
#else
    return 0.;
#endif /* HAVE_IV  */
}
 
static double ses_pri(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.priority", v);
#if HAVE_IV
    int p = int(chkarg(1, -1000, 10000));
    IFGUI((OcBox*) v)->session_priority(p);
    ENDGUI
    return double(p);
#else
    return 0.;
#endif /* HAVE_IV  */
}
 
static double map(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.map", v);
#if HAVE_IV
    IFGUI
    OcBox* b = (OcBox*) v;
    PrintableWindow* w;
    b->premap();
    if (ifarg(3)) {
        w = b->make_window(float(*getarg(2)),
                           float(*getarg(3)),
                           float(*getarg(4)),
                           float(*getarg(5)));
    } else {
        w = b->make_window();
    }
    if (ifarg(1)) {
        char* name = gargstr(1);
        w->name(name);
    }
    b->dismissing(false);
    w->map();
    if (b->full_request() && b->has_window()) {
        b->window()->request_on_resize(true);
    }
    b->dismiss_action(NULL);
    ENDGUI
    return 1.;
#else
    return 0.;
#endif /* HAVE_IV  */
}
 
static double dialog(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.dialog", v);
#if HAVE_IV
    bool r = false;
    IFGUI
    OcBox* b = (OcBox*) v;
    const char* a = "Accept";
    const char* c = "Cancel";
    if (ifarg(2)) {
        a = gargstr(2);
    }
    if (ifarg(3)) {
        c = gargstr(3);
    }
    Oc oc;
    oc.notify();
    r = b->dialog(gargstr(1), a, c);
    ENDGUI
    return double(r);
#else
    return 0.;
#endif /* HAVE_IV  */
}
 
static double unmap(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.unmap", v);
#if HAVE_IV
    IFGUI
    OcBox* b = (OcBox*) v;
    bool accept = true;
    if (ifarg(1)) {
        accept = (bool) chkarg(1, 0, 1);
    }
    if (b->dialog_dismiss(accept)) {
        return 0.;
    }
    if (b->has_window()) {
        b->ref();
        b->dismissing(true);
        b->window()->dismiss();
        b->window(NULL);  // so we don't come back here again before
                          // printable window destructor called
        b->unref();
    }
    ENDGUI
    return 0.;
#else
    return 0.;
#endif /* HAVE_IV  */
}
 
static double ismapped(void* v) {
    hoc_return_type_code = 2;
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.ismapped", v);
#if HAVE_IV
    bool b = false;
    IFGUI
    b = ((OcBox*) v)->has_window();
    ENDGUI
    return double(b);
#else
    return 0.;
#endif /* HAVE_IV  */
}
 
static double adjuster(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.adjuster", v);
#if HAVE_IV
    IFGUI((OcBox*) v)->adjuster(chkarg(1, -1., 1e5));
    ENDGUI
#endif /* HAVE_IV  */
    return 0.;
}
 
static double adjust(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.adjust", v);
#if HAVE_IV
    IFGUI
    int index = 0;
    if (ifarg(2)) {
        index = (int) chkarg(2, 0, 1000);
    }
    ((OcBox*) v)->adjust(chkarg(1, -1., 1e5), index);
    ENDGUI
#endif /* HAVE_IV  */
    return 0.;
}
 
static double full_request(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.full_request", v);
#if HAVE_IV
    IFGUI
    OcBox* b = (OcBox*) v;
    if (ifarg(1)) {
        bool x = ((int) chkarg(1, 0, 1) != 0) ? true : false;
        b->full_request(x);
    }
    return (b->full_request() ? 1. : 0.);
    ENDGUI
#endif /* HAVE_IV  */
    return 0.;
}
 
static double b_size(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.size", v);
#if HAVE_IV
    IFGUI
    double* p = hoc_pgetarg(1);  // array for at least 4 numbers
    OcBox* b = (OcBox*) v;
    if (b->has_window()) {
        p[0] = b->window()->save_left();
        p[1] = b->window()->save_bottom();
        p[2] = b->window()->width();
        p[3] = b->window()->height();
    }
    ENDGUI
#endif
    return 0.;
}
 
const char* pwm_session_filename();
 
static double save(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.save", v);
#if HAVE_IV
    IFGUI
    OcBox* b = (OcBox*) v;
    char buf[256];
    if (hoc_is_object_arg(1)) {
        b->save_action(0, *hoc_objgetarg(1));
        return 1.;
    } else if (ifarg(2)) {
        if (hoc_is_double_arg(2)) {  // return save session file name
            hoc_assign_str(hoc_pgargstr(1), pwm_session_filename());
            return 1.;
        } else {
            sprintf(buf, "execute(\"%s\", %s)", gargstr(1), gargstr(2));
        }
    } else {
        // sprintf(buf, "%s", gargstr(1));
        b->save_action(gargstr(1), 0);
        return 1.0;
    }
    b->save_action(buf, 0);
    ENDGUI
    return 1.;
#else
    return 0.;
#endif /* HAVE_IV  */
}
 
/* help ref
.ref(objectvar)
    solves the problem of keeping an anonymous hoc object which should
    be destroyed when the window it manages is dismissed.
    The box keeps a pointer to the hoc object and the object is
    referenced when the box has a window and unreferenced when the window
    is dismissed.
*/
static double ref(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.ref", v);
#if HAVE_IV
    OcBox* b = (OcBox*) v;
    b->keep_ref(*hoc_objgetarg(1));
    return 0.;
#else
    Object* ob = *hoc_objgetarg(1);
    hoc_obj_ref(ob);
    return 0.;
#endif /* HAVE_IV  */
}
 
/* help dismiss_action
.dismiss_action("action")
    execute the action when the vbox is dismissed from the screen.
*/
static double dismiss_action(void* v) {
    TRY_GUI_REDIRECT_ACTUAL_DOUBLE("Box.dismiss_action", v);
#if HAVE_IV
    IFGUI
    OcBox* b = (OcBox*) v;
    if (hoc_is_object_arg(1)) {
        b->dismiss_action(0, *hoc_objgetarg(1));
    } else {
        b->dismiss_action(gargstr(1));
    }
    ENDGUI
    return 0.;
#else
    return 0.;
#endif /* HAVE_IV  */
}
 
static Member_func members[] = {"intercept",
                                intercept,  // #if HAVE_IV ok
                                "adjuster",
                                adjuster,  // #if HAVE_IV ok
                                "adjust",
                                adjust,  // #if HAVE_IV ok
                                "full_request",
                                full_request,  // #if HAVE_IV ok
                                "save",
                                save,  // #if HAVE_IV ok
                                "map",
                                map,  // #if HAVE_IV ok
                                "unmap",
                                unmap,  // #if HAVE_IV ok
                                "ismapped",
                                ismapped,  // #if HAVE_IV ok
                                "ref",
                                ref,  // #if HAVE_IV ok
                                "dismiss_action",
                                dismiss_action,  // #if HAVE_IV ok
                                "dialog",
                                dialog,  // #if HAVE_IV ok
                                "priority",
                                ses_pri,
                                "size",
                                b_size,
                                0,
                                0};
 
void HBox_reg() {
    class2oc("HBox", hcons, destruct, members, NULL, NULL, NULL);
}
 
void VBox_reg() {
    class2oc("VBox", vcons, destruct, members, NULL, NULL, NULL);
}
#if HAVE_IV
OcGlyphContainer::OcGlyphContainer()
    : OcGlyph(NULL) {
    parent_ = NULL;
    recurse_ = false;
}
 
void OcGlyphContainer::request(Requisition& r) const {
    if (!recurse_) {
        OcGlyphContainer* t = (OcGlyphContainer*) this;
        t->recurse_ = true;
        OcGlyph::request(r);
        Coord w, h;
        w = h = -1.;
        def_size(w, h);
        if (w != -1.) {
            r.x_requirement().natural(w);
            r.y_requirement().natural(h);
        }
        t->recurse_ = false;
    } else {
        hoc_execerror("Box or Deck is recursive. The GUI may no longer work correctly.\n",
                      "Exit program and eliminate the recursion");
    }
}
OcBox::OcBox(int type, int frame, bool scroll)
    : OcGlyphContainer() {
    ScrollBox* sb;
    PolyGlyph* box;
    bi_ = new OcBoxImpl;
    bi_->full_request_ = false;
    bi_->dismissing_ = false;
    bi_->next_map_adjust_ = -1.;
    bi_->ocglyph_list_ = new PolyGlyph();
    bi_->ba_list_ = NULL;
    Resource::ref(bi_->ocglyph_list_);
    bi_->box_ = NULL;
    IFGUI
    WidgetKit& wk = *WidgetKit::instance();
    LayoutKit& lk = *LayoutKit::instance();
    if (type == H) {
        box = bi_->box_ = lk.hbox(3);
    } else {
        if (scroll) {
            bi_->box_ = sb = lk.vscrollbox(10);
            box = lk.hbox(sb, lk.hspace(4), wk.vscroll_bar(sb));
        } else {
            box = bi_->box_ = lk.vbox(3);
            //((Box*)box)->debug_ = new char[50];
            // sprintf(((Box*)box)->debug_, "box%p:", this);
            // printf("%s\n", ((Box*)box)->debug_);
        }
    }
    Resource::ref(bi_->box_);
 
    switch (frame) {
    case INSET:
        body(new Background(wk.inset_frame(lk.variable_span(box)), wk.background()));
        break;
    case OUTSET:
        body(new Background(wk.outset_frame(lk.variable_span(box)), wk.background()));
        break;
    case BRIGHT_INSET:
        body(new Background(wk.bright_inset_frame(lk.variable_span(box)), wk.background()));
        break;
    case FLAT:
        body(new Background(lk.variable_span(box), wk.background()));
        break;
    }
    ENDGUI
    bi_->type_ = type;
    bi_->oc_ref_ = NULL;
    bi_->save_action_ = NULL;
    bi_->save_pyact_ = NULL;
    bi_->o_ = NULL;
    bi_->keep_ref_ = NULL;
    bi_->dis_act_ = NULL;
    bi_->dis_pyact_ = NULL;
}
 
OcBox::~OcBox() {
    // printf("~OcBox\n");
    GlyphIndex i, cnt = bi_->ocglyph_list_->count();
    for (i = 0; i < cnt; ++i) {
        ((OcGlyph*) (bi_->ocglyph_list_->component(i)))->parents(false);
    }
    Resource::unref(bi_->ocglyph_list_);
    Resource::unref(bi_->box_);
    Resource::unref(bi_->ba_list_);
    hoc_obj_unref(bi_->oc_ref_);
    if (bi_->save_action_) {
        delete bi_->save_action_;
    }
    if (bi_->save_pyact_) {
        hoc_obj_unref(bi_->save_pyact_);
    }
    if (bi_->dis_act_) {
        delete bi_->dis_act_;
    }
    if (bi_->dis_pyact_) {
        hoc_obj_unref(bi_->dis_pyact_);
    }
    assert(!bi_->keep_ref_);
    delete bi_;
}
 
bool OcBox::full_request() {
    return bi_->full_request_;
}
void OcBox::full_request(bool b) {
    bi_->full_request_ = b;
}
bool OcBox::dismissing() {
    return bi_->dismissing_;
}
void OcBox::dismissing(bool d) {
    bi_->dismissing_ = d;
}
 
void OcGlyphContainer::intercept(bool b) {
    if (b) {
        parent_ = PrintableWindow::intercept(this);
    } else {
        PrintableWindow::intercept(parent_);
        parent_ = NULL;
    }
}
 
void OcBox::box_append(OcGlyph* g) {
    WidgetKit& wk = *WidgetKit::instance();
    LayoutKit& lk = *LayoutKit::instance();
    bi_->ocglyph_list_->append(g);
    g->parents(true);
    if (bi_->next_map_adjust_ > 0.) {
        BoxAdjust* ba = new BoxAdjust(this, bi_, g, bi_->next_map_adjust_);
        if (!bi_->ba_list_) {
            bi_->ba_list_ = new PolyGlyph(1);
            bi_->ba_list_->ref();
        }
        bi_->ba_list_->append(ba);
        bi_->box_->append(ba->ga_);
        bi_->box_->append(ba);
        bi_->next_map_adjust_ = -1.;
    } else {
        if (bi_->type_ == V) {
            bi_->box_->append(lk.hflexible(lk.vcenter(g, 1.)));
        } else {
            bi_->box_->append(lk.vflexible(lk.vcenter(g, 1.)));
        }
    }
}
 
void OcBox::premap() {
    if (bi_->ba_list_) {
        body(new Patch(body()));
    }
}
 
void OcBox::adjuster(Coord natural) {
    bi_->next_map_adjust_ = natural;
}
 
void OcBox::adjust(Coord natural, int index) {
    // printf("OcBox::adjust %g %d\n", natural, index);
    if (bi_->ba_list_ && index < bi_->ba_list_->count()) {
        BoxAdjust* ba = (BoxAdjust*) bi_->ba_list_->component(index);
        adjust(natural, ba);
    }
}
void OcBox::adjust(Coord natural, BoxAdjust* ba) {
    ba->fixlay_->span(natural);
    Box::full_request(true);
    bi_->box_->modified(0);
    //  ((Patch*)body())->reallocate();
    ((Patch*) body())->redraw();
    Box::full_request(false);
}
 
NrnFixedLayout::NrnFixedLayout(const DimensionName d, Coord span) {
    dimension_ = d;
    span_ = span;
}
 
NrnFixedLayout::~NrnFixedLayout() {}
 
void NrnFixedLayout::request(GlyphIndex, const Requisition*, Requisition& result) {
    Requirement& r = result.requirement(dimension_);
    r.natural(span_);
    r.stretch(0.0);
    r.shrink(0.0);
}
 
void NrnFixedLayout::allocate(const Allocation&,
                              GlyphIndex,
                              const Requisition*,
                              Allocation* result) {
    Allotment& a = result[0].allotment(dimension_);
    a.span(span_);
}
 
void NrnFixedLayout::span(Coord s) {
    span_ = s;
}
 
BoxAdjust::BoxAdjust(OcBox* b, OcBoxImpl* bi, Glyph* g, Coord natural)
    : InputHandler(NULL, WidgetKit::instance()->style()) {
    b_ = b;
    bi_ = bi;
    LayoutKit& lk = *LayoutKit::instance();
    fixlay_ = new NrnFixedLayout(bi->type_ == OcBox::V ? Dimension_Y : Dimension_X, natural);
    ga_ = lk.vcenter(g, 1.);
    if (bi->type_ == OcBox::V) {
        ga_ = lk.hflexible(ga_);
        body(lk.vspace(10));
    } else {
        ga_ = lk.vflexible(ga_);
        body(lk.hspace(10));
    }
    ga_ = new Placement(ga_, fixlay_);
}
 
BoxAdjust::~BoxAdjust() {}
 
void BoxAdjust::press(const Event& e) {
    if (fixlay_->vertical()) {
        pstart_ = e.pointer_y();
    } else {
        pstart_ = e.pointer_x();
    }
    fstart_ = fixlay_->span();
}
 
void BoxAdjust::drag(const Event& e) {
    Coord d;
    if (fixlay_->vertical()) {
        d = e.pointer_y() - pstart_;
        d = fstart_ - d;
    } else {
        d = e.pointer_x() - pstart_;
        d = fstart_ + d;
    }
    if (d < 10.) {
        d = 10.;
    }
    b_->adjust(d, this);
}
 
void BoxAdjust::release(const Event& e) {
    drag(e);
}
 
void OcBox::save_action(const char* creat, Object* pyact) {
    if (bi_->o_) {
        // old endl cause great slowness on remote filesystem
        // with gcc version 3.3 20030226 (prerelease) (SuSE Linux)
        //*bi_->o_ << creat << endl;
        *bi_->o_ << creat << "\n";
    } else {
        if (pyact) {
            bi_->save_pyact_ = pyact;
            hoc_obj_ref(pyact);
        } else {
            bi_->save_action_ = new CopyString(creat);
        }
    }
}
 
void OcBox::dismiss_action(const char* act, Object* pyact) {
    if (pyact) {
        hoc_obj_ref(pyact);
        bi_->dis_pyact_ = pyact;
        if (bi_->dis_act_) {
            delete bi_->dis_act_;
            bi_->dis_act_ = NULL;
        }
    } else if (act) {
        if (bi_->dis_pyact_) {
            hoc_obj_unref(bi_->dis_pyact_);
            bi_->dis_pyact_ = NULL;
        }
        if (bi_->dis_act_) {
            *bi_->dis_act_ = act;
        } else {
            bi_->dis_act_ = new CopyString(act);
        }
    }
    if ((bi_->dis_act_ || bi_->dis_pyact_) && has_window()) {
        window()->replace_dismiss_action(
            new BoxDismiss(window(), bi_->dis_act_, this, bi_->dis_pyact_));
    }
}
 
void OcBox::save(ostream& o) {
    char buf[256];
    if (bi_->save_action_ || bi_->save_pyact_) {
        if (bi_->save_action_ && strcmp(bi_->save_action_->string(), "") == 0) {
            return;
        }
        if (has_window()) {
            sprintf(buf, "\n//Begin %s", window()->name());
            o << buf << endl;
        }
        o << "{" << endl;
        bi_->o_ = &o;
        if (bi_->save_pyact_) {
            HocCommand hc(bi_->save_pyact_);
            hc.execute();
        } else {
            HocCommand hc(bi_->save_action_->string(), bi_->keep_ref_);
            hc.execute();
        }
        bi_->o_ = NULL;
    } else {
        if (bi_->type_ == H) {
            o << "{\nocbox_ = new HBox()" << endl;
        } else {
            o << "{\nocbox_ = new VBox()" << endl;
        }
        o << "ocbox_list_.prepend(ocbox_)" << endl;
        o << "ocbox_.intercept(1)\n}" << endl;
        long i, cnt = bi_->ocglyph_list_->count();
        for (i = 0; i < cnt; ++i) {
            ((OcGlyph*) bi_->ocglyph_list_->component(i))->save(o);
        }
        o << "{\nocbox_ = ocbox_list_.object(0)" << endl;
        o << "ocbox_.intercept(0)" << endl;
    }
    if (has_window()) {
#if defined(WIN32)
        const char* cp1;
        if (strchr(window()->name(), '"')) {
            cp1 = "Neuron";
        } else {
            cp1 = window()->name();
        }
        sprintf(buf,
                "ocbox_.map(\"%s\", %g, %g, %g, %g)\n}",
                cp1,
#else
        sprintf(buf,
                "ocbox_.map(\"%s\", %g, %g, %g, %g)\n}",
                window()->name(),
#endif
                window()->save_left(),
                window()->save_bottom(),
#if MAC
                window()->canvas()->width(),
                window()->canvas()->height());
#else
                window()->width(),
                window()->height());
#endif
        o << buf << endl;
    } else {
        o << "ocbox_.map()\n}" << endl;
    }
    if (bi_->oc_ref_) {
        sprintf(buf, "%s = ocbox_", hoc_object_pathname(bi_->oc_ref_));
        o << buf << endl;
        o << "ocbox_list_.remove(0)" << endl;
    }
    o << "objref ocbox_" << endl;
    if (bi_->save_action_ && has_window()) {
        sprintf(buf, "//End %s\n", window()->name());
        o << buf << endl;
    }
}
 
 
void OcBox::no_parents() {
    // printf("OcBox::no_parents()\n");
    if (bi_->keep_ref_) {
        // printf("OcBox::no_parents unreffing %s\n", hoc_object_name(bi_->keep_ref_));
        hoc_obj_unref(bi_->keep_ref_);
        bi_->keep_ref_ = NULL;
    }
}
 
void OcBox::keep_ref(Object* ob) {
    hoc_obj_ref(ob);
    if (bi_->keep_ref_) {
        hoc_obj_unref(bi_->keep_ref_);
    }
    bi_->keep_ref_ = ob;
}
 
Object* OcBox::keep_ref() {
    return bi_->keep_ref_;
}
 
#endif /* HAVE_IV */