KraView  Check-in [9356d6cdbc]

    const Net* net;
    bool initialized;
};


Netpane::Netpane() :
    data(*new Data)
{
    data.x = 0;
    data.y = 0;
    data.width = 0;
    data.height = 0;
    data.scale = MAX_SCALE;
    data.xscale = MAX_SCALE;
    data.yscale = MAX_SCALE;
    data.itemlist = 0;
    data.hitlist = 0;
    data.scalelist = 0;
    data.net = nullptr;
    data.initialized = false;
}

Netpane::~Netpane()
{
    delete &data;
}

static void draw_disc(int name, double x, double y, double r)
{
    static GLUquadric* quadric = nullptr;
    if (quadric == nullptr) quadric = gluNewQuadric();

        draw_arc(net, i, with_names);
    }
}


void Netpane::redraw_net()
{
    if (!data.net || !data.initialized) return;

    glNewList(data.itemlist, GL_COMPILE);
    draw_graph(*data.net, false);
    glEndList();

    glNewList(data.hitlist, GL_COMPILE);
    draw_graph(*data.net, true);
    glEndList();
}


void Netpane::rescale()
{
    if (!data.initialized) return;

    if (log10(data.scale) < MIN_SCALE)
        data.scale = pow(10.0, MIN_SCALE);
    else if (log10(data.scale) > MAX_SCALE)
        data.scale = pow(10.0, MAX_SCALE);

    glNewList(data.scalelist, GL_COMPILE);
    glScalef(data.scale, data.scale, 1);
    glEndList();

    if (data.width < data.height) {
        data.xscale = data.scale;
        data.yscale = data.scale * data.height / data.width;
    } else {
        data.xscale = data.scale * data.width / data.height;
        data.yscale = data.scale;
    }

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-data.xscale / 2, data.xscale / 2, -data.yscale / 2, data.yscale / 2);
    glMatrixMode(GL_MODELVIEW);
}


void Netpane::init()
{
    glShadeModel(GL_FLAT);
    glClearColor(1.0, 1.0, 1.0, 1.0);
    glClearDepth(1.0);

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LINE_SMOOTH);

    glDepthFunc(GL_LEQUAL);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    GLuint n = glGenLists(3);
    data.itemlist = (int)n++;
    data.hitlist = (int)n++;
    data.scalelist = (int)n++;

    data.initialized = true;
    data.scale = 1.0;
    data.height = 1;
    data.width = 1;
    rescale();
    redraw_net();
}


void Netpane::resize(double width, double height)
{
    data.width = width;
    data.height = height;
    glViewport(0, 0, width, height);
    rescale();
}


void Netpane::fit()
{
    if (!data.net) return;

    double min_x = std::numeric_limits<double>::infinity();
    double max_x = -std::numeric_limits<double>::infinity();
    double min_y = std::numeric_limits<double>::infinity();
    double max_y = -std::numeric_limits<double>::infinity();

    for (size_type i = 0, n = data.net->num_nodes(); i < n; i++) {
        auto& node = data.net->node(i);
        min_x = std::min(node.x, min_x);
        max_x = std::max(node.x, max_x);
        min_y = std::min(node.y, min_y);
        max_y = std::max(node.y, max_y);
    }

    double dx, dy;
    if (data.width > data.height) {
        dx = (max_x - min_x) * data.height / data.width;
        dy = max_y - min_y;
    } else {
        dx = max_x - min_x;
        dy = (max_y - min_y) * data.width / data.height;
    }
    data.scale = 1.1 * (dx > dy ? dx : dy);
    data.x = -(min_x + max_x) / 2;
    data.y = (min_y + max_y) / 2;
    rescale();
}


void Netpane::paint()
{
    glMatrixMode(GL_MODELVIEW);
    glLineWidth(1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glTranslatef(data.x, data.y, 0);
    glScalef(1, -1, 1);
    glCallList(data.itemlist);

    if (!data.hl_nodes.empty()) {
        glLineWidth(3.0);
        for (auto nodeid : data.hl_nodes)
            draw_node(*data.net, nodeid, false, NODE_RADIUS * 1.3);
    }

    if (!data.hl_arcs.empty()) {
        glLineWidth(5.0);
        for (auto arcid : data.hl_arcs)
            draw_arc(*data.net, arcid, false);
    }
}


double Netpane::zoom() const
{
    return data.scale;
}


void Netpane::set_zoom(double newscale)
{
    data.scale = newscale;
    rescale();
}


void Netpane::start_scale(int d)
{
    data.startscale = d;
    data.scalebase = data.scale;
}


void Netpane::do_scale(int d)
{
    double h = data.height < data.width ? data.width : data.height;
    data.scale = data.scalebase * exp(10 * (d - data.startscale) / h);
    rescale();
}


void Netpane::start_move(int x, int y)
{
    data.startmovex = x;
    data.startmovey = y;
    data.movebasex = data.x;
    data.movebasey = data.y;
}


void Netpane::do_move(int x, int y)
{
    data.x = data.movebasex
             + (x - data.startmovex) / data.width * data.xscale;
    data.y = data.movebasey
             + (y - data.startmovey) / data.height * data.yscale;
}

void Netpane::get_items(int x, int y,
                        std::vector<size_type>& nodes,
                        std::vector<size_type>& arcs) const
{
    nodes.clear();
    arcs.clear();

    if (!data.net) return;

    GLint vp[4];
    glGetIntegerv(GL_VIEWPORT, vp);

    GLuint select_buf[512];
    glSelectBuffer(512, select_buf);

    glRenderMode(GL_SELECT);

    glInitNames();
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    gluPickMatrix(x, vp[3] - y, 5, 5, vp);
    gluOrtho2D(-data.xscale / 2, +data.xscale / 2, -data.yscale / 2, +data.yscale / 2);

    glMatrixMode(GL_MODELVIEW);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glTranslatef(data.x , data.y, 0);
    glScalef(1, -1, 1);
    glCallList(data.hitlist);
    glFlush();

    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);

    GLint nhits = glRenderMode(GL_RENDER);
    GLint idx = 0;
    size_type n = data.net->num_nodes();
    for (GLint i = 0; i < nhits; i++) {
        GLuint nnames = select_buf[idx];
        idx += 3;
        for (size_type j = 0; j < nnames; j++) {
            if (select_buf[idx] < n)
                nodes.push_back(select_buf[idx]);
            else
                arcs.push_back(select_buf[idx] - n);
            idx += 1;
        }
    }
}

void Netpane::highlight_node(size_type nodeid, bool highlight)
{
    if (highlight)
        data.hl_nodes.insert(nodeid);
    else
        data.hl_nodes.erase(nodeid);
}

void Netpane::highlight_arc(size_type arcid, bool highlight)
{
    if (highlight)
        data.hl_arcs.insert(arcid);
    else
        data.hl_arcs.erase(arcid);
}

void Netpane::unhighlight_all()
{
    data.hl_nodes.clear();
    data.hl_arcs.clear();
}

void Netpane::set_net(const Net& net)
{
    data.net = &net;
    unhighlight_all();
    redraw_net();
}

void Netpane::clear_net()
{
    data.net = nullptr;
    unhighlight_all();
    redraw_net();
}

const Net* Netpane::net() const
{
    return data.net;
}

 * You should have received a copy of the GNU General Public License
 * along with KraView.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __GRAV_NETPANE_HXX__
#define __GRAV_NETPANE_HXX__

#include <cstddef>
#include <vector>

namespace fifr {
namespace graph {
namespace grav {

class Net;

     * do_scale. If d' - d = 0 then the zoom is unchanged, otherwise
     * it is increased or decreased.
     *
     * The typical use of these functions is by calling start_scale
     * with some mouse-coordinate on a click and do_scale with the new
     * mouse coordinate on subsequent drags.
     *
     * @param d start value for interactive zoom
     */
    void start_scale(int d);

    /**
     * Updates an interactive zoom.
     *
     * @param d update value for interactive zoom
     *
     * @see start_scale.
     */
    void do_scale(int d);

    /**
     * Starts an interactive move.
     *
     * This function should be called with the x and y coordinates of
     * a mouse click. Subsequent mouse drags should call do_move with
     * the new coordinates.

    void redraw_net();

    /// Updates the viewpane w.r.t. the current scale.
    void rescale();

private:
    struct Data;
    Data& data;
};

#endif