phylo_tree_render.cpp

Go to the documentation of this file.

/*  $Id: phylo_tree_render.cpp 25384 2012-03-06 19:27:20Z ucko $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Authors:  Vladimir Tereshkov
 *
 * File Description:
 *
 */

#include <ncbi_pch.hpp>

#include <gui/widgets/phylo_tree/phylo_tree_render.hpp>


#include <gui/widgets/phylo_tree/phylo_tree_ds.hpp>
#include <gui/widgets/gl/mouse_zoom_handler.hpp>
#include <gui/widgets/wx/gui_event.hpp>
#include <gui/widgets/wx/glframebuffer.hpp>
#include <gui/widgets/wx/glcanvas.hpp>
#include <gui/opengl/glhelpers.hpp>
#include <gui/opengl/glexception.hpp>
#include <gui/opengl/glbitmapfont.hpp>
#include <gui/widgets/gl/attrib_menu.hpp>
#include <gui/utils/vect2.hpp>
#include <gui/widgets/gl/mouse_zoom_handler.hpp>

#include <math.h>
#include <algorithm>
#include <limits>
#include <cmath>

#define PTRENDER_EFFECTS_TIMER_ID 63200

BEGIN_NCBI_SCOPE


BEGIN_EVENT_TABLE(IPhyloTreeRenderer, wxEvtHandler)
    EVT_LEFT_DOWN(IPhyloTreeRenderer::OnLeftDown)
    EVT_LEFT_DCLICK(IPhyloTreeRenderer::OnLeftDblClick)
    EVT_LEFT_UP(IPhyloTreeRenderer::OnLeftUp)
    EVT_RIGHT_DOWN(IPhyloTreeRenderer::OnRightDown)
    EVT_MOTION(IPhyloTreeRenderer::OnMotion)
    EVT_TIMER(PTRENDER_EFFECTS_TIMER_ID, IPhyloTreeRenderer::OnTimer)
END_EVENT_TABLE()

IPhyloTreeRenderer :: IPhyloTreeRenderer()
    : m_EffectsTimer(this, PTRENDER_EFFECTS_TIMER_ID)
    , m_MinimapBuffer(NULL)
{
    m_DS            = NULL;
    m_pLabelFont    = NULL;
    m_bDistMode     = false;
    m_bAdaptiveMargins = true;
    m_bSimplification  = false;
    m_bUseSplines = false;
    m_bRegenerateTexture = false;
    m_bZoomablePrimitives = true;
    m_bHighlightCollapsed = false;
    m_LabelViewPct = 0.25f;
    m_RenderScale = true;
    m_bAutosizeLabels = false;
    m_State = eIdle;
    m_pMouseZoomHandler = NULL;
    m_ActiveTooltipNode = NULL;
    m_SwitchedLayout = false;
    m_ValidLayout = eNeedLayoutAndSize;

    // raster rect is setup to default hardcoded values
    // it can be changed by Layout()
    m_DimX      = 10000;
    m_DimY      = 10000;
    m_RasterRect.Init(0, 0, m_DimX, m_DimY);
    m_SL.Reset(new CPhyloTreeScheme()); 
    m_BufferdRenderTime = 0.0f;

#ifdef ATTRIB_MENU_SUPPORT
    CAttribMenu& m = CAttribMenuInstance::GetInstance();
    CAttribMenu* sub_menu = m.AddSubMenuUnique("Phylo Render", this);
    sub_menu->AddFloatReadOnly("Buffered Render Time", &m_BufferdRenderTime);
    sub_menu->AddFloat("Label View Pct", &m_LabelViewPct);
#endif
}

IPhyloTreeRenderer :: IPhyloTreeRenderer(double width, double height)
    : m_DimX(width), m_DimY(height)
    , m_EffectsTimer(this, PTRENDER_EFFECTS_TIMER_ID)
    , m_MinimapBuffer(NULL)
{
    m_pPane         = NULL;
    m_DS            = NULL;
    m_pLabelFont    = NULL;
    m_bDistMode     = false;
    m_bAdaptiveMargins = true;
    m_bSimplification  = false;
    m_bUseSplines = false;
    m_bRegenerateTexture = false;
    m_bZoomablePrimitives = true;
    m_bHighlightCollapsed = false;
    m_LabelViewPct = 0.25f;
    m_RenderScale = true;
    m_bAutosizeLabels = false;
    m_State = eIdle;
    m_RasterRect.Init(0, 0, m_DimX, m_DimY);
    m_SL.Reset(new CPhyloTreeScheme());
    m_ActiveTooltipNode = NULL;
    m_SwitchedLayout = false;
    m_ValidLayout = eNeedLayoutAndSize;
    m_BufferdRenderTime = 0.0f;

#ifdef ATTRIB_MENU_SUPPORT
    CAttribMenu& m = CAttribMenuInstance::GetInstance();
    CAttribMenu* sub_menu = m.AddSubMenuUnique("Phylo Render", this);
    sub_menu->AddFloatReadOnly("Buffered Render Time", &m_BufferdRenderTime);
    sub_menu->AddFloat("Label View Pct", &m_LabelViewPct);
#endif
}

IPhyloTreeRenderer::~IPhyloTreeRenderer()
{
#ifdef ATTRIB_MENU_SUPPORT
    CAttribMenuInstance::GetInstance().RemoveMenuR("Phylo Render", this);
#endif

    delete m_MinimapBuffer;
    m_MinimapBuffer = NULL;
}

void IPhyloTreeRenderer::SetHost(IPhyloTreeRendererHost* pHost)
{
    m_pHost = pHost;
}



void IPhyloTreeRenderer::SetPane(CGlPane* pane)
{
    // HACK!!!
    if (pane) {
        m_pPane = pane;
    }
}

void IPhyloTreeRenderer::x_RenderSelection(CGlPane& pane)
{
    // Draw a stippled line around the currently selected node, if any
    if (m_DS->GetCurrentNode() != NULL) {
        TVPUnit node_size = x_NodeSize(m_DS->GetCurrentNode());
        if (node_size > 0) {     
            CGlAttrGuard AttrGuard(GL_POLYGON_BIT | GL_LINE_BIT);
            pane.OpenOrtho();

            double x = (**m_DS->GetCurrentNode()).X();
            double y = (**m_DS->GetCurrentNode()).Y();

            glMatrixMode(GL_MODELVIEW);
            glPushMatrix();
            glTranslated(x, y, 0.0);
            glScaled(pane.GetScaleX(), pane.GetScaleY(), 1.0);
            
            glLineWidth(1.0f);
            glColor3f(0.0f, 0.0f, 0.0f);
            glLineStipple(3, 0xAAAA);
            glEnable(GL_LINE_STIPPLE);
            glDisable(GL_LINE_SMOOTH);

            node_size += 1;
            glBegin(GL_LINE_LOOP);
            glVertex2f(-node_size, -node_size);
            glVertex2f(node_size,  -node_size);
            glVertex2f(node_size,   node_size);
            glVertex2f(-node_size,  node_size);
            glEnd();

            glDisable(GL_LINE_STIPPLE);
            glPopMatrix();
            pane.Close();
        }
    }

    // Draw the selection rectangle, if user is currently doing a drag-selection
    if(m_State == eSelRect) {
        _ASSERT(m_pHost);

        CGlAttrGuard AttrGuard(GL_POLYGON_BIT | GL_LINE_BIT);
        pane.OpenPixels();

        glLineWidth(1.0f);
        glColor3f(0.0f, 0.0f, 0.0f);

        glLineStipple(1, 0x0F0F);
        glEnable(GL_LINE_STIPPLE);
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

        glDisable(GL_LINE_SMOOTH);

        int x1 = m_StartPoint.x;
        int y1 = m_pHost->HMGH_GetVPPosByY(m_StartPoint.y);
        int x2 = m_DragPoint.x;
        int y2 = m_pHost->HMGH_GetVPPosByY(m_DragPoint.y);
        if(x2 < x1)
            swap(x1, x2);
        if(y2 < y1)
            swap(y1, y2);

        glBegin(GL_LINES);
        glVertex2d(x1, y2);
        glVertex2d(x2, y2);

        glVertex2d(x2, y2);
        glVertex2d(x2, y1);

        glVertex2d(x1, y2);
        glVertex2d(x1, y1);

        glVertex2d(x1, y1);
        glVertex2d(x2, y1);
        glEnd();

        glDisable(GL_LINE_STIPPLE);

        pane.Close();
    }
}

void IPhyloTreeRenderer::x_RenderScaleMarker(CGlPane& pane)
{
    // Can turn off scale rendering explicitly, and if we are not in distance
    // mode it is also turned off automatically since redering scales without
    // distance makes no sense.
    if (!m_RenderScale || !m_bDistMode)
        return;

    // target length in pixels of the distance bar
    float target_len = 100.0f;        
    // actual length of distance bar, after rounding
    float final_len = target_len;

    float base_xpos;
    float base_ypos = 10.0f;
    float bar_height = 20.0f;

    // Don't try to draw if there is not enough room for
    // the error bar.  This also avoids some divide-by-0 errors
    // for when the viewport width goes to 0.
    if (pane.GetViewport().Width() <= target_len || 
        pane.GetViewport().Height() < bar_height)
        return;

    CGlAttrGuard AttrGuard(GL_POLYGON_BIT | GL_LINE_BIT);
    pane.OpenOrtho();

    if (IsDistanceBarLowerLeft()) {
        base_xpos = 10.0f;
    }
    else {
        base_xpos = (float)pane.GetViewport().Width() -
                    (1.5f*target_len + 10.0f); 
        base_xpos = std::max(0.0f, base_xpos);
    }
    
    // Compute node distance for a fixed pixel offset using
    // unproject.  m_DimX is a factor used during layout to force
    // the graph to project to a virtual window of width m_DimX (labels not
    // included) so we divide it out here.  GetNormDistance is the
    // underlying graph width that gets scaled (at layout) to m_DimX.
    double pt1 = pane.UnProjectX(base_xpos);
    double pt2 = pane.UnProjectX(base_xpos + target_len);
    double default_scale = (pt2 - pt1)*(m_DS->GetNormDistance()/m_DimX);

    pane.Close();

    // a 0 value or something very close to it won't work.  this
    // happens if a tree doesn't have distances specified for nodes.
    if (default_scale < std::numeric_limits<double>::epsilon())
        return;

    pane.OpenPixels();

    // Represent the distance bar with only 1 significant digit (first non-zero).
    // This seems a little simplistic but it seems to work OK.  Could also
    // compute significance by computing the distance bar length at 
    // different zoom levels to see how quickly number is changing...
    double rounded = default_scale;
    double multiplier;
    int precision = 0;
    if (default_scale < 1.0) { 
        multiplier = 1.0;
        while (rounded < 1.0) {
            multiplier *= 10.0;
            ++precision;
            rounded = default_scale*multiplier;
        }
        precision = std::max(precision, 1);
        rounded = (double)((int)(floor(rounded) + 0.5));
        rounded = rounded / multiplier;
    }
    else {
        precision = 1;
        multiplier = 1.0;
        while (rounded > 10.0) {
            multiplier /= 10.0f;
            rounded = default_scale*multiplier;
        }
        rounded = (double)((int)(floor(rounded) + 0.5));
        rounded = rounded / multiplier;
    }
    final_len = target_len * rounded/default_scale;    
    char buf_round[32];
    sprintf(buf_round, "%.*f", precision, rounded);
    

    // Drawing options
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glDisable(GL_LINE_SMOOTH);
    glColor4f(0.9f, 0.9f, 0.9f, 0.93f);

    // Draw a quad for the distance bar background
    glBegin(GL_QUADS);
    glVertex2f(base_xpos-5.0f, base_ypos-5.0f);       
    glVertex2f(base_xpos + final_len + 5.0f, base_ypos-5.0f);
    glVertex2f(base_xpos + final_len + 5.0f, base_ypos + bar_height + 5.0f);
    glVertex2f(base_xpos-5.0f, base_ypos + bar_height + 5.0f);
    glEnd();

    // Draw the scale (distance) bar
    glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
    glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
    glLineWidth(2.0f);

    glBegin(GL_LINES);
    glVertex2f(base_xpos, base_ypos);
    glVertex2f(base_xpos, base_ypos + bar_height);

    glVertex2f(base_xpos, base_ypos + bar_height/2.0f);
    glVertex2f(base_xpos + final_len, base_ypos + bar_height/2.0f);
    
    glVertex2f(base_xpos + final_len, base_ypos);
    glVertex2f(base_xpos + final_len, base_ypos + bar_height);
    glEnd();
    
    // draw the length represented by the distance bar
    const CGlBitmapFont* bestFont = &m_SL->GetFont();    
    float tx = base_xpos + 5.0f;
    float ty = base_ypos + bar_height/2.0f + 5.0f;
    
    bestFont->TextOut(tx, ty, buf_round);

    pane.Close();
}

void IPhyloTreeRenderer::x_RenderTooltipHints(CGlPane& pane)
{
    // Draw a stippled line around the currently selected node, if any
    if (m_DS->GetCurrentNode() != NULL) {
        TVPUnit node_size = x_NodeSize(m_DS->GetCurrentNode());
        if (node_size > 0) {     
            CGlAttrGuard AttrGuard(GL_ALL_ATTRIB_BITS);
            pane.OpenOrtho();

            double x = (**m_DS->GetCurrentNode()).X();
            double y = (**m_DS->GetCurrentNode()).Y();

            glMatrixMode(GL_MODELVIEW);
            glPushMatrix();
            glTranslated(x, y, 0.0);
            glScaled(pane.GetScaleX(), pane.GetScaleY(), 1.0);
            
            glLineWidth(1.0f);
            glColor3f(0.0f, 0.0f, 0.0f);
            glLineStipple(3, 0xAAAA);
            glEnable(GL_LINE_STIPPLE);
            glDisable(GL_LINE_SMOOTH);

            node_size += 1;
            glBegin(GL_LINE_LOOP);
            glVertex2f(-node_size, -node_size);
            glVertex2f(node_size,  -node_size);
            glVertex2f(node_size,   node_size);
            glVertex2f(-node_size,  node_size);
            glEnd();

            glDisable(GL_LINE_STIPPLE);
            glPopMatrix();
            pane.Close();
        }
    }

    // If mouse is currently over tooltip for this node...    
    if (m_ActiveTooltipNode != NULL) {
        float  s = (float)x_NodeSize(m_ActiveTooltipNode);
        int num_lines = std::max(2, GetDefaultNodeSize(m_ActiveTooltipNode))*10;

        CRgbaColor c = m_SL->SetColor(CPhyloTreeScheme::eNode,
            CPhyloTreeScheme::eTipSelColor);

        CGlAttrGuard AttrGuard(GL_ALL_ATTRIB_BITS);
        pane.OpenOrtho();

        double x = (**m_ActiveTooltipNode).X();
        double y = (**m_ActiveTooltipNode).Y();

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glTranslated(x, y, 0.0);
        glScaled(pane.GetScaleX(), pane.GetScaleY(), 1.0);

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        glColor4fv(c.GetColorArray());

        float s2 = s*3.0f;
        if (s2==0.0f)
            s2 = 3.0f*(float)GetDefaultNodeSize(m_ActiveTooltipNode);

        glBegin(GL_TRIANGLE_FAN);
        glVertex2f(0.0f, 0.0f);

        float delta = 6.28f/(float)num_lines;
        float angle = 0.0f;
        for(int i =0; i<=num_lines+1; i++){                                  
            glVertex2f(s2*cosf(angle), s2*sinf(angle));
            angle += delta;
        }
        glEnd();
        glPopMatrix();

        pane.Close();
    }

  
    // Render temporary arrows, if any currently active
    std::vector<NodePointer>::iterator niter, erase_iter = m_NodePointers.end();
    for (niter=m_NodePointers.begin(); niter!=m_NodePointers.end(); ++niter) {
        CPhyloTreeNode* node = (*niter).m_Node;
        if (node != NULL) {

            NodePointer np = *niter;
            float alpha = 0.5f;

            double x = (**node).X();
            double y = (**node).Y();

            // Check if this arrow has timed out.  Can erase 1 at a time (ok because
            // there will be very few arrows)
            if (np.m_Duration > 0.0) {
                if (np.m_Timer.Elapsed() > np.m_Duration) {
                    alpha = 0.0f;
                    erase_iter = niter;                   
                    break;
                }
                else alpha *= 1.0f - np.m_Timer.Elapsed()/np.m_Duration;
            }

            if (alpha > 0.0f) {                     
                CRgbaColor c = m_SL->SetColor(CPhyloTreeScheme::eNode,
                                              CPhyloTreeScheme::eTipSelColor);

                glEnable(GL_BLEND);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                c.SetAlpha(alpha);
                glColor4fv(c.GetColorArray());

                // Render in screen space:
                glMatrixMode(GL_MODELVIEW);
                glPushMatrix();
                glLoadIdentity();
                glMatrixMode(GL_PROJECTION);
                glPushMatrix();
                glLoadIdentity();
                glOrtho(0, m_pPane->GetViewport().Width(), 
                        0, m_pPane->GetViewport().Height(), -1.0f, 1.0f);

                // Center of the tooltip in screen (pixel) coordinates:
                CVect2<float> tip_center(np.m_TipCenter.X(), np.m_TipCenter.Y());
                CVect2<float> node_pos(x, y);
                TVPPoint tvp = m_pPane->Project(x, y);
                // Node position in screen (pixel) coordinates
                CVect2<float> node_proj_pos(tvp.X(), tvp.Y());
                CVect2<float> proj_dir(node_proj_pos - tip_center);

                float proj_len = proj_dir.Length();
                proj_dir.Normalize();
                CVect2<float> proj_dir_perp(proj_dir.Y(), -proj_dir.X());

                // Arrowhead that points at node:
                CVect2<float> arrowhead_base(node_proj_pos.X() - proj_dir.X()*16.0f,
                                             node_proj_pos.Y() - proj_dir.Y()*16.0f);

                // Draw shaft of arrow (unless tip is so close no room for shaft)
                float shaft_len = proj_len - 16.0f;
                if (shaft_len > 0.0f) {
                    CVect2<float> dir_minus_arrowhead(proj_dir*shaft_len);

                    CVect2<float>  q1 = tip_center + proj_dir_perp*3.0f;
                    CVect2<float>  q2 = q1 + dir_minus_arrowhead;
                    CVect2<float>  q3 = q2 - proj_dir_perp*6.0f;
                    CVect2<float>  q4 = q3 - dir_minus_arrowhead;
               
                    glBegin(GL_QUADS);
                        glVertex2fv(q1.GetData());
                        glVertex2fv(q2.GetData());
                        glVertex2fv(q3.GetData());
                        glVertex2fv(q4.GetData());
                    glEnd();
                }

                // Draw arrowhead
                CVect2<float>  t1(arrowhead_base + proj_dir_perp*8.0f);
                CVect2<float>  t2(node_proj_pos);             
                CVect2<float>  t3(arrowhead_base - proj_dir_perp*8.0f);
                
                glBegin(GL_TRIANGLES);
                    glVertex2fv(t1.GetData());
                    glVertex2fv(t2.GetData());
                    glVertex2fv(t3.GetData());
                glEnd();

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

                glDisable(GL_BLEND);
            }            
        }
    }

    // If a temporary arrow timed out, erase it here:
    if (erase_iter !=  m_NodePointers.end())
        m_NodePointers.erase(erase_iter);
}


////////////////////////////////////////////////////////////////////////////////
/// event handlers

void IPhyloTreeRenderer::OnLeftDown(wxMouseEvent& event)
{   
    if (m_DS == NULL) {
        event.Skip();
        return; 
    }

    m_bMoveDuringSelection = false;

    m_StartPoint  = event.GetPosition();
    m_DragPoint = m_StartPoint;

    CPhyloTreeNode * current =
                    GetHoverNode(TVPPoint(event.GetX(), event.GetY()));

    // set current or reset it
    m_DS->SetCurrentNode(current);

    // select point if we hit a node, otherwise select rect if we are in an extended selection mode
    // (!eSelectState).
    if (m_pMouseZoomHandler->GetPanMode() == CMouseZoomHandler::eLmouse) {
        if (current) {
            m_State = eSelPoint;
        }
        else if (CGUIEvent::wxGetSelectState(event) != CGUIEvent::eSelectState) {
            m_State = eSelRect;
            GetGenericHost()->GHH_CaptureMouse();
        }
        else {
            m_State = eIdle;
            event.Skip(); 
        }
    }
    else {
        if (current)
            m_State = eSelPoint;
        else 
            m_State = eSelRect;
    }

    if (m_State == eSelPoint)
        m_pHost->HMGH_OnRefresh();
}

void IPhyloTreeRenderer::OnRightDown(wxMouseEvent& event)
{   
    if (m_DS == NULL) {
        event.Skip();
        return; 
    }

    m_State = eSelPoint;

    m_StartPoint  = event.GetPosition();
    m_DragPoint = m_StartPoint;

    CPhyloTreeNode * current =
                    GetHoverNode(TVPPoint(event.GetX(), event.GetY()));

    // set current or reset it
    m_DS->SetCurrentNode(current);

    m_State = current ? eSelPoint : eIdle;

    m_pHost->HMGH_OnRefresh();
    
     // Skip so that the context menu can come up as well. (Right Down on Mac)
    event.Skip();
}


void IPhyloTreeRenderer::OnLeftDblClick(wxMouseEvent& event)
{
    if (m_DS == NULL) {
        event.Skip();
        return; 
    }

    CPhyloTreeNode * current =
                GetHoverNode(TVPPoint(event.GetX(), event.GetY()));

    // set current or reset it
    m_DS->SetCurrentNode(current);

    if (current) {
        switch ((**current).GetChildsDisplay()){
        case IPhyGraphicsNode::eHideChilds:
            if (current->CanExpandCollapse(IPhyGraphicsNode::eShowChilds)){
                // Don't try to render again until layout has been called for updated tree.
                m_ValidLayout = eNeedLayout;
                m_DS->ExpandCollapse(current, IPhyGraphicsNode::eShowChilds);
                m_pHost->FireEditEvent();
            }
            break;
        case IPhyGraphicsNode::eShowChilds:
            if (current->CanExpandCollapse(IPhyGraphicsNode::eHideChilds)){
                // Don't try to render again until layout has been called for updated tree.
                m_ValidLayout = eNeedLayout;
                m_DS->ExpandCollapse(current, IPhyGraphicsNode::eHideChilds);
                m_pHost->FireEditEvent();
            }
            break;
        }
    }
}

void IPhyloTreeRenderer::OnMotion(wxMouseEvent& event)
{
    if(event.Dragging())    {
        m_bMoveDuringSelection = true;

        if(m_State == eSelRect)   {
            wxPoint ms_pos = event.GetPosition();

            if(ms_pos != m_DragPoint)  {
                m_State = eSelRect;
                m_DragPoint = ms_pos;               
                m_pHost->HMGH_OnRefresh();
            }
        }
        else {
            event.Skip();
        }
    } 
    else {
        event.Skip();
    }

    m_LastPos = event.GetPosition();
}

void IPhyloTreeRenderer::OnTimer(wxTimerEvent& /* event */)
{
    if (m_NodePointers.size() == 0) {
        m_EffectsTimer.Stop();
        return;
    }

    m_pHost->HMGH_OnChanged();
}

void IPhyloTreeRenderer::OnLeftUp(wxMouseEvent& event)
{
    if (m_DS == NULL) {
        event.Skip();
        return; 
    }

    CPhyloTreeNode * current =
            GetHoverNode(TVPPoint(event.GetX(), event.GetY()));

    CGUIEvent::EGUIState state =
        CGUIEvent::wxGetSelectState(event);

    // not doing incremental only selection
    //bool neg = (state == CGUIEvent::eSelectExtState);
    bool inc =  (state == CGUIEvent::eSelectIncState);
    bool sel =  (state == CGUIEvent::eSelectState);

    switch(m_State) {
    case eSelPoint:
        // clear selection if you click with no modifiers on an item
        // or if you control-click on empty space (normal click on
        // empty space is pan) 
        if ((sel && current) || (inc && !current)) {
            m_DS->SetSelection(m_DS->GetTree(), false, true);
            m_SelectedIDs.clear();
        }

        if (current) {
            x_SelectByPoint(current, inc);
        }
        
        m_State = eIdle;
        m_pHost->HMGH_OnChanged();
        return;

    case eSelRect: {
        int dist = std::abs(m_StartPoint.x - m_DragPoint.x) +
                   std::abs(m_StartPoint.y - m_DragPoint.y); 

        // Don't select for tiny rectangles.  Allow de-selection on mouse up if
        // control key was down (if no key was down, we would be panning instead).
        if (dist > 4) {
            x_SelectByRect(m_DS->GetTree(), inc );
        }
        else {
            if ((m_pMouseZoomHandler->GetPanMode() == CMouseZoomHandler::eLmouse && inc) ||
                (m_pMouseZoomHandler->GetPanMode() == CMouseZoomHandler::ePkey && sel)) {
                m_DS->SetSelection(m_DS->GetTree(), false, true);
                m_SelectedIDs.clear();
            }
        }

        m_State = eIdle;

        GetGenericHost()->GHH_ReleaseMouse();

        m_pHost->HMGH_OnChanged();
        break;
    }
    default:
        // clear selection if user left clicks without moving (panning) the mouse
        if ( !m_bMoveDuringSelection && 
             m_pMouseZoomHandler->GetPanMode() == CMouseZoomHandler::eLmouse && 
             sel) {
                m_DS->SetSelection(m_DS->GetTree(), false, true);
                m_SelectedIDs.clear();
                m_pHost->HMGH_OnChanged();
            }

        event.Skip();
    }

}

void IPhyloTreeRenderer::x_OnSelectCursor(void)
{
    switch(m_State)    {
    case eIdle:
    case eSelPoint:
        m_CursorId = wxCURSOR_ARROW;
        break;
    case eSelRect:
        m_CursorId = wxCURSOR_CROSS;
        break;
    default:
        break;
    }
    GetGenericHost()->GHH_SetCursor(wxCursor(m_CursorId));
}

IGenericHandlerHost* IPhyloTreeRenderer::GetGenericHost()
{
    return dynamic_cast<IGenericHandlerHost*>(m_pHost);
}


/*************************************************************************************/


int IPhyloTreeRenderer::x_OnMouseMove(void)
{
    return (m_State == eIdle) ? 0 : 1;
}


int IPhyloTreeRenderer::x_OnKeyDown(void)
{
    return (m_State == eIdle) ? 0 : 1;
}

int IPhyloTreeRenderer::x_OnKeyUp(void)
{
    return (m_State == eIdle) ? 0 : 1;
}



void IPhyloTreeRenderer::x_RenderLine(double x1,
                                      double y1,
                                      double x2,
                                      double y2,
                                      IPhyGraphicsNode::TSelectedState state,
                                      string force_color)
{
    CRgbaColor color;
    switch (state){
    case IPhyGraphicsNode::eTraced:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eTraceColor);
        break;
    case IPhyGraphicsNode::eSelected:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eSelColor);
        break;
    case IPhyGraphicsNode::eShared:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eSharedColor);
        break;
    default:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eColor);
    }

    if (!force_color.empty() && (state!=IPhyGraphicsNode::eSelected)){
        CRgbaColor fColor(force_color);
        color = fColor;
    }

    if (state == IPhyGraphicsNode::eNotSelected && 
        m_SL->GetSelectionVisibility() == CPhyloTreeScheme::eHighlightSelection) {
            color.SetAlpha(m_SL->GetNonSelectedAlpha());
    }

    TModelUnit lineWidth =
        m_SL->SetSize(CPhyloTreeScheme::eLineWidth);

    if (DistanceBetweenNodes() < lineWidth) {
        lineWidth = 1;
    }

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glLineWidth((GLfloat)lineWidth);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_LINE_SMOOTH);

    glColor4fv(color.GetColorArray());

    glBegin(GL_LINES);
        glVertex2d(x1, y1);
        glVertex2d(x2, y2);
    glEnd();

    if (lineWidth>1){
        glLineWidth(1);
        CRgbaColor color2 = color;
        color2.Lighten(0.7f);
        glColor4fv(color2.GetColorArray());
        glBegin(GL_LINES);
            glVertex2d(x1, y1);
            glVertex2d(x2, y2);
        glEnd();
    }

    glDisable(GL_LINE_SMOOTH);
    glDisable(GL_BLEND);
}

void IPhyloTreeRenderer::x_RenderLineVbo(CGlVboNode* render_lines,
                                         double x1,
                                         double y1,
                                         double x2,
                                         double y2,
                                         IPhyGraphicsNode::TSelectedState state,
                                         string force_color)
{
    CRgbaColor color;
    switch (state){
    case IPhyGraphicsNode::eTraced:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eTraceColor);
        break;
    case IPhyGraphicsNode::eSelected:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eSelColor);
        break;
    case IPhyGraphicsNode::eShared:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eSharedColor);
        break;
    default:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eColor);
    }

    if (!force_color.empty() && (state!=IPhyGraphicsNode::eSelected)){
        CRgbaColor fColor(force_color);
        color = fColor;
    }

    if (state == IPhyGraphicsNode::eNotSelected && 
        m_SL->GetSelectionVisibility() == CPhyloTreeScheme::eHighlightSelection) {
            color.SetAlpha(m_SL->GetNonSelectedAlpha());
    }

    render_lines->GetColorBuffer().PushBack(color);
    render_lines->GetColorBuffer().PushBack(color);
    m_DS->GetModel().GetEdges().push_back(CTreeGraphicsEdge(CVect2<float>(x1,y1), CVect2<float>(x2, y2)));
}

void   IPhyloTreeRenderer::x_RenderSpline(TPoint pt1,
                                          TPoint pt2,
                                          TPoint pt3,
                                          TPoint pt4,
                                          IPhyGraphicsNode::TSelectedState state,
                                          string force_color, bool bPseudo)
{
    CRgbaColor color;

    switch (state){
    case IPhyGraphicsNode::eTraced:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eTraceColor);
        break;
    case IPhyGraphicsNode::eSelected:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eSelColor);
        break;
    case IPhyGraphicsNode::eShared:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eSharedColor);
        break;
    default:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eColor);
    }

    if (!force_color.empty() && (state==IPhyGraphicsNode::eNotSelected)){
        CRgbaColor fColor(force_color);
        color = fColor;
    }

    if (state == IPhyGraphicsNode::eNotSelected && 
        m_SL->GetSelectionVisibility() == CPhyloTreeScheme::eHighlightSelection) {
            color.SetAlpha(m_SL->GetNonSelectedAlpha());
    }

    TModelUnit lineWidth =
        m_SL->SetSize(CPhyloTreeScheme::eLineWidth);

    if (DistanceBetweenNodes() < lineWidth) {
        lineWidth = 1;
    }

    glColor4fv(color.GetColorArray());
    glLineWidth((GLfloat)lineWidth);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glShadeModel(GL_SMOOTH);

    if (!bPseudo){ // real spline
        glEnable(GL_LINE_SMOOTH);
        m_Curve.SetPoint(0, pt1);
        m_Curve.SetPoint(1, pt2);
        m_Curve.SetPoint(2, pt3);
        m_Curve.SetPoint(3, pt4);
        m_Curve.Recalc();
        m_Curve.Draw();

        if (lineWidth>1){
            glLineWidth(1);
            CRgbaColor color2 = color;
            color2.Lighten(0.7f);
            glColor4fv(color2.GetColorArray());
            m_Curve.Draw();
        }
        glDisable(GL_LINE_SMOOTH);
    }
    else {
        glDisable(GL_LINE_SMOOTH);

        // length corrections
        double dx=0, dy=0;
        if (lineWidth>2){
            dx = floor(lineWidth * 0.5) * m_pPane->GetScaleX();
            dy = floor(lineWidth * 0.5) * m_pPane->GetScaleY() * ((pt1.Y() > pt4.Y())?1:-1);
        }

        glBegin(GL_LINES);
                glVertex2d(pt1.X(), pt1.Y());
                glVertex2d(pt2.X(), pt2.Y()-dy);
                glVertex2d(pt3.X()-dx, pt3.Y());
                glVertex2d(pt4.X(), pt4.Y());
        glEnd();

        // inner line
        if (lineWidth > 2){
            glLineWidth(1);
            CRgbaColor color2 = color;
            color2.Lighten(0.7f);
            glColor4fv(color2.GetColorArray());
            glBegin(GL_LINE_STRIP);
                glVertex2d(pt1.X(), pt1.Y());
                glVertex2d(pt2.X(), pt2.Y());
                glVertex2d(pt3.X(), pt3.Y());
                glVertex2d(pt4.X(), pt4.Y());
            glEnd();
        }
    }
    glDisable(GL_BLEND);
}


void   IPhyloTreeRenderer::x_RenderSplineVbo(vector<CRgbaColor>& edge_colors,
                                             TPoint pt1,
                                             TPoint pt2,
                                             TPoint pt3,
                                             TPoint pt4,
                                             IPhyGraphicsNode::TSelectedState state,
                                             string force_color)
{    
    CRgbaColor color;

    switch (state){
    case IPhyGraphicsNode::eTraced:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eTraceColor);
        break;
    case IPhyGraphicsNode::eSelected:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eSelColor);
        break;
    case IPhyGraphicsNode::eShared:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eSharedColor);
        break;
    default:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eColor);
    }

    if (!force_color.empty() && (state==IPhyGraphicsNode::eNotSelected)){
        CRgbaColor fColor(force_color);
        color = fColor;
    }

    if (state == IPhyGraphicsNode::eNotSelected && 
        m_SL->GetSelectionVisibility() == CPhyloTreeScheme::eHighlightSelection) {
            color.SetAlpha(m_SL->GetNonSelectedAlpha());
    }


    //glEnable(GL_LINE_SMOOTH);
    m_Curve.SetPoint(0, pt1);
    m_Curve.SetPoint(1, pt2);
    m_Curve.SetPoint(2, pt3);
    m_Curve.SetPoint(3, pt4);
    m_Curve.Recalc();
    // 
    vector<CVect3<float> > buf;
    m_Curve.DrawBuffered(buf);

    size_t i;
    for (i=0; i<buf.size()-1; ++i) {
        edge_colors.push_back(color);
        edge_colors.push_back(color);
        m_DS->GetModel().GetEdges().push_back(CTreeGraphicsEdge(
            CVect2<float>(buf[i].X(), buf[i].Y()),
            CVect2<float>(buf[i+1].X(), buf[i+1].Y()) ));
    }
}

void   IPhyloTreeRenderer::x_RenderPseudoSplineVbo(CPhyloTreeNode* child_node,
                                                   CGlVboNode* render_lines,
                                                   const CVect2<float>&  pt1,
                                                   const CVect2<float>&  mid_point,                                                
                                                   const CVect2<float>&  pt2,
                                                   IPhyGraphicsNode::TSelectedState state)
{
    CRgbaColor color(0.0f, 0.0f, 0.0f, 1.0f);
    
    switch (state){
    case IPhyGraphicsNode::eNotSelected:
        {
            const string& force_color = m_SL->GetColoration()==CPhyloTreeScheme::eClusters?
                (**child_node).GetClusterFgColor():(**child_node).GetNodeEdColor();

            if (!force_color.empty()){          
                color = CRgbaColor(force_color);
            }
            else {
                color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                    CPhyloTreeScheme::eColor);
                //color.SetAlpha(0.0f);
            }

            if (m_SL->GetSelectionVisibility() == 
                CPhyloTreeScheme::eHighlightSelection) {
                    color.SetAlpha(m_SL->GetNonSelectedAlpha());
            }
        }
        break;
    case IPhyGraphicsNode::eTraced:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eTraceColor);
        break;
    case IPhyGraphicsNode::eSelected:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eSelColor);
        break;
    case IPhyGraphicsNode::eShared:
        color = m_SL->SetColor(CPhyloTreeScheme::eLine,
                                CPhyloTreeScheme::eSharedColor);
        break;
    }    

    render_lines->GetColorBuffer().PushBack(color);
    render_lines->GetColorBuffer().PushBack(color);
    render_lines->GetColorBuffer().PushBack(color);
    render_lines->GetColorBuffer().PushBack(color);
    
    m_DS->GetModel().GetEdges().push_back(CTreeGraphicsEdge(pt1, mid_point));      
    m_DS->GetModel().GetEdges().push_back(CTreeGraphicsEdge(mid_point, pt2));     
}


void IPhyloTreeRenderer::x_RenderNode(CPhyloTreeNode * node)
{
    glPushMatrix();

    double x = (**node).X();
    double y = (**node).Y();

    CRgbaColor color = GetNodeColor(node);

    // colors
    CRgbaColor col1(color);
    CRgbaColor col2(color);
    col1.Lighten(0.9f);

    TVPUnit node_size = x_NodeSize(node);
    // will give good circle - size * approx(2pi)
    int num_lines = std::max(2, GetDefaultNodeSize(node))*10;

    glTranslated(x, y, 0.0);

    if (!m_bZoomablePrimitives) {
        glScaled(m_pPane->GetScaleX(), m_pPane->GetScaleY(), 1.0);
    }
    else {
        glScaled(m_pPane->GetScaleX()/m_pPane->GetScaleY(), 1.0, 1.0);
    }

    glEnable(GL_LINE_SMOOTH);
       
    bool collapsed_node = (**node).GetChildsDisplay() == IPhyGraphicsNode::eHideChilds;
    float s = (float)node_size;

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    // rendering frame
    if (m_DS->GetCurrentNode() == node && node_size > 0) {
        CGlAttrGuard AttrGuard(GL_POLYGON_BIT | GL_LINE_BIT);

        glLineWidth(1.0f);
        glColor3f(0.0f, 0.0f, 0.0f);
        glLineStipple(1, 0x0F0F);
        glEnable(GL_LINE_STIPPLE);
        //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        glDisable(GL_LINE_SMOOTH);

        glBegin(GL_LINE_LOOP);
            glVertex2d(-node_size, -node_size);
            glVertex2d(node_size,  -node_size);
            glVertex2d(node_size,   node_size);
            glVertex2d(-node_size,  node_size);
        glEnd();

        glDisable(GL_LINE_STIPPLE);
    }

    if (collapsed_node) {
        if (m_bHighlightCollapsed) {
            float c = GetDefaultNodeSize(node)*2.5f;     
            CRgbaColor col = col2;
            col.SetAlpha(std::min(col.GetAlpha(), 0.5f));

            glBegin(GL_TRIANGLES);
                glColor4fv(col.GetColorArray()); glVertex2f(-c, 0);         
                glColor4fv(col.GetColorArray()); glVertex2f(c, -c);                
                glColor4fv(col.GetColorArray()); glVertex2f(c, c);                              
            glEnd();
        }
        else if (node_size > 0) { 
            glBegin(GL_TRIANGLE_STRIP);
                glColor4fv(col2.GetColorArray()); glVertex2f(-s, 0);         
                glColor4fv(col2.GetColorArray()); glVertex2f(s, -s);
                glColor4fv(col1.GetColorArray()); glVertex2f(0, 0);        
                glColor4fv(col2.GetColorArray()); glVertex2f(s, s);           
                glColor4fv(col2.GetColorArray()); glVertex2f(-s, 0);
            glEnd();
        }
        else {
            glBegin(GL_POINTS);
            glColor4fv(color.GetColorArray());
            glVertex2d(0, 0);
            glEnd();
        }
    }
    else {
        if (node_size > 0) {
            glBegin(GL_TRIANGLE_FAN);
                glColor4fv(col1.GetColorArray());
                glVertex2d(-s/2.0f, s/2.0f);

                float delta = 6.28f/(float)num_lines;
                float angle = 0.0f;
                for(int i =0; i<=num_lines+1; i++){                  
                    glColor4fv(col2.GetColorArray());
                    glVertex2f(s*cosf(angle), s*sinf(angle));
                    angle += delta;
                }
            glEnd();
        }
        else {
            glBegin(GL_POINTS);
            glColor4fv(color.GetColorArray());
            glVertex2d(0, 0);
            glEnd();
        }
    }
    glDisable(GL_BLEND);

    // rendering +
    /*
    if ((**node).GetChildsVisibility()==CPhyloTreeNode::eHideChilds){
        glLineWidth(1.0f);
        glColor3f(0.0f, 0.0f, 0.0f);
        glBegin(GL_LINES);
        glVertex2d(node_ize/2, 0);
        glVertex2d(-node_size/2, 0);
        glVertex2d(0, -node_size/2);
        glVertex2d(0, node_size/2);
        glEnd();
    }
    */

    float target_alpha = 1.0f;
    if (m_SL->GetSelectionVisibility()==CPhyloTreeScheme::eHighlightSelection &&
        (**node).GetSelectedState()==IPhyGraphicsNode::eNotSelected) {
            target_alpha = m_SL->GetNonSelectedAlpha();
    }

    if ((**node).GetMarkerColors().size() > 0) {
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        size_t color_count = (**node).GetMarkerColors().size();
        float color_countf = (float)color_count;
     
        float marker_size = (**node).GetMarkerSize();
        float s2 = s*marker_size;
        if (s2==0.0f)
            s2 = marker_size*(float)GetDefaultNodeSize(node);

        glBegin(GL_TRIANGLES);            
            float delta = 6.28f/(float)num_lines;
            float angle = 3.14159f/2.0f;
            for(int i =0; i<num_lines; i++){
                size_t color_idx = (size_t)((((float)i)/(float)(num_lines)) * color_countf);
                color_idx = std::min(color_idx, color_count-1);
                CRgbaColor c = (**node).GetMarkerColors()[color_idx];
                c.SetAlpha(c.GetAlpha()*target_alpha);
                glColor4fv(c.GetColorArray());
                //glColor4fv((**node).GetMarkerColors()[color_idx].GetColorArray());

                glVertex2d(0.0f, 0.0f);
                // add make angle slightly larger to avoid dropout lines.
                glVertex2f(s2*cosf(angle+delta+0.005f), s2*sinf(angle+delta+0.005f));
                glVertex2f(s2*cosf(angle), s2*sinf(angle));

                angle += delta;
            }
        glEnd();
        glDisable(GL_BLEND);
    }

    glPopMatrix();


    // rendering labels
    if (((m_SL->GetLabelVisibility()==CPhyloTreeScheme::eLabelsVisible) ||
        ((m_SL->GetLabelVisibility()==CPhyloTreeScheme::eLabelsForLeavesOnly)&&
        node->IsLeafEx())) &&
        m_Label.IsVisible(this) ){
            // label fg color
            CRgbaColor label_color    = GetNodeColor(node, true);            

            // orientation
            bool bLeft = ((**node).GetAngle() < -1.57 ||  (**node).GetAngle()>1.57);

            glEnable(GL_BLEND);
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

            // two labels styles
            // simple one supports tagging and background (and is never used)
            if (true || m_SL->GetLabelStyle()==CPhyloTreeScheme::eSimpleLabels) {
                // backround
                if ((**node).GetLabelBgColor().size() > 0) {
                    CRgbaColor c((**node).GetLabelBgColor());
                    c.SetAlpha(c.GetAlpha()*target_alpha);
                    glColorC(c);

                    CGlRect<double> rect =
                        m_Label.GetRect(*m_pPane, node, bLeft, this);

                    glBegin(GL_QUADS);
                        glVertex2d(rect.Left()-1,     rect.Bottom()-1);
                        glVertex2d(rect.Right()+1,    rect.Bottom()-1);
                        glVertex2d(rect.Right()+1,    rect.Top()+1);
                        glVertex2d(rect.Left()-1,     rect.Top()+1);
                    glEnd();
                }
                
                // drawing label
                glColorC(label_color);
                m_Label.Render(*m_pPane, node, bLeft, this);
            }
            else {

                CGlRect<double> rect =
                    m_Label.GetRect(*m_pPane, node, bLeft, this);

                double lblWidth = rect.Width() / m_pPane->GetScaleX();

                // adjusting in case of internal node
                if (!node->IsLeaf() && !collapsed_node) {
                    // finding child to get distance, nonlinear also supported this way
                    CPhyloTreeNode::TNodeList_I fst = node->SubNodeBegin();
                    double hole_x = (((***fst).X() - (**node).X()) / m_pPane->GetScaleX())-
                        node_size*2;

                    lblWidth = hole_x < lblWidth ?  hole_x : lblWidth;
                }

                if (lblWidth>0) { 
                    // drawing label
                    glColorC(label_color);
                    m_Label.Render(*m_pPane, node, bLeft, this); 
                }
            }

            glDisable(GL_BLEND);
    }

    glDisable(GL_LINE_SMOOTH);
}


void IPhyloTreeRenderer::x_RenderNodeVbo(CPhyloTreeNode* node,
                                         CGlVboNode* render_nodes)
{
    CVect2<float> node_pos( (**node).XY() );

    CRgbaColor color = GetNodeColor(node);

    // colors
    CRgbaColor col1(color);
    CRgbaColor col2(color);
    col1.Lighten(0.9f);

    // Default node size   
    TVPUnit node_size = (TVPUnit)m_SL->SetSize(CPhyloTreeScheme::eNodeSize); 

    // will give good circle - size * approx(2pi)
    int num_lines = std::max(2, GetDefaultNodeSize(node))*10;
       
    bool collapsed_node = (**node).GetChildsDisplay() == IPhyGraphicsNode::eHideChilds;
    float s = (float)node_size;
    
    TVPUnit this_node_size = GetDefaultNodeSize(node);  

    if (collapsed_node) {
        if (m_bHighlightCollapsed) {            
            //float c = GetDefaultNodeSize(node)*2.5f;
            CRgbaColor col = col2;
            col.SetAlpha(std::min(col.GetAlpha(), 0.5f));
 
            m_DS->GetModel().GetCollapsedNode()->GetColors().push_back(col);
            m_DS->GetModel().GetCollapsedNode()->GetColors().push_back(col);
            m_DS->GetModel().GetCollapsedNode()->GetColors().push_back(col);
            m_DS->GetModel().GetCollapsedNode()->GetPositions().push_back(node_pos);
            m_DS->GetModel().GetCollapsedNode()->GetSizes().push_back(GetDefaultNodeSize(node)*2.5f);   
        }
        else {
            m_DS->GetModel().GetCollapsedNode()->GetColors().push_back(col2);
            m_DS->GetModel().GetCollapsedNode()->GetColors().push_back(col2);
            m_DS->GetModel().GetCollapsedNode()->GetColors().push_back(col2);
            m_DS->GetModel().GetCollapsedNode()->GetPositions().push_back(node_pos);
            m_DS->GetModel().GetCollapsedNode()->GetSizes().push_back(s);   
        }        
    }
    else {
        float delta = (float)((M_PI*2.0)/(double)num_lines);
        float angle = 0.0f;

        //Use triangle fan for efficiency
        CTreeTriFanNode* node_fan = m_DS->GetModel().GetTriFanNode();

        if (node_fan->GetVertexBuffer2D().GetActiveBufferSize() == 0) {
            vector<CVect2<float> > tri_verts;
            vector<CRgbaColor> tri_colors;

            CRgbaColor center_color(1.0f, 1.0f, 1.0f, 1.0f);
            CRgbaColor edge_color(1.0f, 1.0f, 1.0f, 0.0f);

            CVect2<float> first_pt(cosf(angle), sinf(angle));
            CVect2<float> current_pt;            

            // Add center point
            tri_verts.push_back(CVect2<float>(-1.0f/2.0f, 1.0f/2.0f));
            tri_colors.push_back(center_color);

            // Add first point on circle
            tri_verts.push_back(first_pt);
            tri_colors.push_back(edge_color);

            for (int i=0; i<num_lines; i++) {                  
                angle += delta;

                // End exactly where we start to avoid artifacts
                if (i == num_lines-1) {
                    current_pt = first_pt;
                }
                else {
                    current_pt.X() = cosf(angle);
                    current_pt.Y() = sinf(angle);
                }

                tri_verts.push_back(current_pt);
                tri_colors.push_back(edge_color);
            }

            // If this is the first time, the buffer will be allocated, otherwise
            // it'll try to re-use.  (but this is a small buffer anyway...)
            node_fan->GetVertexBuffer2D().BufferDataResize(tri_verts.size(), 
                &tri_verts[0],
                GL_DYNAMIC_DRAW);
            node_fan->GetColorBuffer().BufferDataResize(tri_colors.size(), 
                &tri_colors[0], 
                GL_DYNAMIC_DRAW);
            node_fan->SetNodeColors(render_nodes->GetColorBuffer().GetBuffer());
            node_fan->ClearPositions(); 
            node_fan->GetState().Disable(GL_BLEND);      

            CGlVboNode* node_fan_pass2 = m_DS->GetModel().GetTriFanNodePass2();
            node_fan_pass2->GetVertexBuffer2D().SetBuffer(node_fan->GetVertexBuffer2D().GetBuffer());
            node_fan_pass2->ClearPositions();            
        }

        render_nodes->GetColorBuffer().PushBack(color);
    }


    if ((**node).GetMarkerColors().size() > 0) {
        m_DS->GetModel().GetMarkerNode()->GetNodes().push_back(node);
    }

    if ((**node).GetBoundedDisplay()) {
        m_DS->GetModel().GetBoundaryNode()->GetNodes().push_back(node);
    }

    // rendering labels
    CRgbaColor label_color    = GetNodeColor(node, true);

    // Get the label and save it with the label manager object
    CVect2<float> so(0.0, 0.0);
    CVect2<float> po(0.0, 0.0);
    CVect2<float> text_size(0.0, 0.0);

    CRgbaColor c = color;
    c.Lighten(1.0f - c.GetAlpha());

    string label_txt;
    if (((m_SL->GetLabelVisibility()==CPhyloTreeScheme::eLabelsVisible) ||
        ((m_SL->GetLabelVisibility()==CPhyloTreeScheme::eLabelsForLeavesOnly)&&
        node->IsLeafEx()))) {

        label_txt = m_Label.x_GetLabel(node);
        text_size = m_Label.GetSize(node);
        m_Label.GetNodeLabelOffset(node, this, so, po);
        CGlRect<float> r(po.X(), po.Y(), po.X() + text_size.X(), po.Y() + text_size.Y());
        
        // in boundary calcs the node position is added back in. otherwise same??
        (*node)->SetLabelCoords(so, r);
    }

    CTreeGraphicsNode* label = new CTreeGraphicsNode(
                             node,
                             c,
                             label_color,
                             label_txt,
                             (float)this_node_size,
                             &m_SL->GetFont());

    m_DS->GetModel().GetNodes().push_back(label);
}


void IPhyloTreeRenderer::x_RenderBoundary(CPhyloTreeNode * node)
{
    if ((**node).GetBoundedDisplay() == IPhyGraphicsNode::eBounded) { 
        float alpha_mod = 1.0f;

        if ((**node).GetSelectedState()!=IPhyGraphicsNode::eSelected) {
            if (m_SL->GetSelectionVisibility() == 
                CPhyloTreeScheme::eHighlightSelection) {
                    alpha_mod = m_SL->GetNonSelectedAlpha();
            }
        } 

        CVect2<float> scale(m_pPane->GetScaleX(), m_pPane->GetScaleY());
        (**node).GetSubtreeBoundary()->RenderBoundary(scale, alpha_mod); 
    }
}

void IPhyloTreeRenderer::x_ComputeNodeBoundary(CPhyloTreeNode* node,
                                               bool compute_boundary,                                           
                                               CBoundaryPoints& boundary_pts,
                                               const string& layout_type)
{
    CVect2<float>  node_pos((**node).XY());

    // Get pixel rectangle for label
    if ( (**node).GetLabel() != "") {
        CVect2<float> po, so;
        CVect2<float> pixel_size = m_Label.GetSize(node);
        m_Label.GetNodeLabelOffset(node, this, so, po);
        CGlRect<float> r(po.X(), po.Y(), 
                         po.X() + pixel_size.X(), po.Y() + pixel_size.Y());

        // Scalable offset (so) currently 0 for non-scalable node geom (which it always is...)
        (**node).SetLabelCoords(so, r);
    }

    if (compute_boundary) {        
        boundary_pts.AddBoundedPoint(node_pos);

        // Get pixel rectangle for label
        if ( !(**node).GetLabel().empty()) {
            boundary_pts.AddPixelRect((**node).GetLabelPos() + node_pos,
                                       (**node).GetLabelRect());
        }

        if ((**node).GetBoundedDisplay() == IPhyGraphicsNode::eBounded) {
            CVect2<float> scale(m_pPane->GetScaleX(), m_pPane->GetScaleY());
            (**node).GetSubtreeBoundary()->ComputeShapes(
                boundary_pts, scale, node_pos, layout_type);
        }
    }
}


void IPhyloTreeRenderer:: x_DrawBoundingAreas(CPhyloTreeNode * node)
{
    // Render boundary areas in a breadth-first approach so that bounding
    // areas defined for subtrees appear on top of the (larger) bounding areas
    // for their parents.
    x_RenderBoundary(node);

    // draw childs
    for(CPhyloTreeNode::TNodeList_I  it = node->SubNodeBeginEx();
        it != node->SubNodeEndEx();  it++ )  {
        x_DrawBoundingAreas(static_cast<CPhyloTreeNode*>(*it));
    }
}


CPhyloTreeNode * IPhyloTreeRenderer::x_TestForNode(CPhyloTreeNode * node, wxPoint pos)
{
#ifdef BUFFERED_RENDER
    wxUnusedVar(node);
    return x_TestForNodeBuffered(pos);
#else
    return x_TestForNodeRecursive(node, pos);
#endif
}

CPhyloTreeNode * IPhyloTreeRenderer::x_TestForNodeBuffered(wxPoint pos)
{
    CPhyloTreeNode* sel_node  = NULL;

    float x  = (float)m_pPane->UnProjectX(pos.x);
    float y  = (float)m_pPane->UnProjectY(m_pHost->HMGH_GetVPPosByY(pos.y));

    if (m_pPane) {
        sel_node = m_DS->GetModel().GetCollisionData().TestForNode(x, y);
    }

    return sel_node;
}

CPhyloTreeNode * IPhyloTreeRenderer::x_TestForNodeRecursive(CPhyloTreeNode * node, wxPoint pos)
{

    CPhyloTreeNode* selNode  = NULL;
    
    if (m_pPane && node != NULL) {
        TVPUnit          node_size = x_NodeSize(node);


        double hit_x = node_size * 2.0 *
                     (IsPrimitivesScalable()?1:m_pPane->GetScaleX());

        double hit_y = node_size * 2.0 *
                     (IsPrimitivesScalable()?1:m_pPane->GetScaleY());

        double x1  = m_pPane->UnProjectX(pos.x)-hit_x;
        double y1  = m_pPane->UnProjectY(m_pHost->HMGH_GetVPPosByY(pos.y))+hit_y;
        double x2  = m_pPane->UnProjectX(pos.x)+hit_x;
        double y2  = m_pPane->UnProjectY(m_pHost->HMGH_GetVPPosByY(pos.y))-hit_y;

        if (((**node).X()  >= x1 &&  (**node).X()  <=x2)&&
            ((**node).Y() >= y2 &&  (**node).Y() <=y1)){
            selNode = node;
        }

        if (!node->IsLeaf()) {
            for(CPhyloTreeNode::TNodeList_I  it = node->SubNodeBeginEx();
                it != node->SubNodeEndEx(); it++ )  {
                if (!selNode) selNode = x_TestForNode(static_cast<CPhyloTreeNode*>(*it), pos);
            }
        }
    }

    return selNode;
}


bool IPhyloTreeRenderer::x_SelectByPoint(CPhyloTreeNode * node, bool toggle)
{
    if (m_DS == NULL)
        return false;

    CPhyloTreeNode * selNode = x_TestForNode(node, m_StartPoint);
    if (selNode) {
        if (toggle)
            m_DS->SetSelection(selNode, !((**selNode).GetSelectedState()==IPhyGraphicsNode::eSelected),  true);
        else
            m_DS->SetSelection(selNode, IPhyGraphicsNode::eSelected,  true);

        vector<int>::iterator it = find(m_SelectedIDs.begin(),
                                        m_SelectedIDs.end(),
                                        (int)(**selNode).GetId());

        if ((**selNode).GetSelectedState()==IPhyGraphicsNode::eSelected) {
            if (it==m_SelectedIDs.end()){
                m_SelectedIDs.push_back((**selNode).GetId());
            }
        }
        else {
            if (it!=m_SelectedIDs.end()){
                m_SelectedIDs.erase(it);
            }
        }
    }
    return (selNode!=NULL);
}

bool IPhyloTreeRenderer::x_SelectByRect(CPhyloTreeNode * node, bool toggle)
{
#ifdef BUFFERED_RENDER
    // For now use tree-recursive select in toggle mode since selection
    // has to occur (in this case) in tree-recursive order to get the
    // correct result (because selecting/de-selecting a node will select/
    // de-select parents and children too)
    if (toggle) {
        x_SelectByRectRecursive(node, toggle);
        return true;
    }
    else {
        return x_SelectByRectBuffered(toggle);
    }
#else
    x_SelectByRectRecursive(node, toggle);
    return true;
#endif
}

void IPhyloTreeRenderer::x_SelectByRectRecursive(CPhyloTreeNode * node, bool toggle)
{
    float x1 = (float)
        m_pPane->UnProjectX(m_StartPoint.x);
    float y1 = (float)
        m_pPane->UnProjectY(m_pHost->HMGH_GetVPPosByY(m_StartPoint.y));
    float x2 = (float)
        m_pPane->UnProjectX(m_DragPoint.x);
    float y2 = (float)
        m_pPane->UnProjectY(m_pHost->HMGH_GetVPPosByY(m_DragPoint.y));
 
    bool bSel;
    if (toggle) 
        bSel = !((**node).GetSelectedState()==IPhyGraphicsNode::eSelected);
    else
        bSel = true;

    if (m_DS == NULL)
        return;

    if (x1 > x2) swap(x1, x2);
    if (y2 > y1) swap(y1, y2);

    if (((**node).X()  >= x1 &&  (**node).X()  <=x2)&&
        ((**node).Y() >= y2 &&  (**node).Y() <=y1)){
        if (toggle) 
            bSel = !((**node).GetSelectedState()==IPhyGraphicsNode::eSelected);
        else
            bSel = true;
        

       vector<int>::iterator it = find(m_SelectedIDs.begin(),
                                       m_SelectedIDs.end(),
                                       (int)(**node).GetId());
        m_DS->SetSelection(node, bSel, true);
        if (bSel) {
            if (it==m_SelectedIDs.end()){
                m_SelectedIDs.push_back((**node).GetId());
            }
        }
        else {
            if (it!=m_SelectedIDs.end()){
                m_SelectedIDs.erase(it);
            }

        }
        // do not descend to childs for selected node
        // they will be selected automatically by m_DS->SetSelection(,,true,true)

    } else if (!node->IsLeaf()) {
        for(CPhyloTreeNode::TNodeList_I  it = node->SubNodeBegin();
            it != node->SubNodeEnd(); it++ )  {
            x_SelectByRectRecursive(static_cast<CPhyloTreeNode*>(*it), toggle);
        }
    }
}

bool IPhyloTreeRenderer::x_SelectByRectBuffered(bool toggle)
{
    if (m_DS == NULL || m_pPane == NULL)
        return false;

    float x1 = (float)
        m_pPane->UnProjectX(m_StartPoint.x);
    float y1 = (float)
        m_pPane->UnProjectY(m_pHost->HMGH_GetVPPosByY(m_StartPoint.y));
    float x2 = (float)
        m_pPane->UnProjectX(m_DragPoint.x);
    float y2 = (float)
        m_pPane->UnProjectY(m_pHost->HMGH_GetVPPosByY(m_DragPoint.y));
 

    if (x1 > x2) swap(x1, x2);
    if (y1 > y2) swap(y1, y2);

    vector<CPhyloTreeNode*> selected;

    selected = m_DS->GetModel().GetCollisionData().SelectNodes(x1, y1, x2, y2);

    for (size_t i=0; i<selected.size(); ++i) {
        CPhyloTreeNode* node = selected[i];

        bool sel;
        if (toggle) 
            sel = !((**node).GetSelectedState()==IPhyGraphicsNode::eSelected);
        else
            sel = true;

        vector<int>::iterator it = find(m_SelectedIDs.begin(),
                                        m_SelectedIDs.end(),
                                        (int)(**node).GetId());
        m_DS->SetSelection(node, sel, true);
        if (sel) {
            if (it==m_SelectedIDs.end()){
                m_SelectedIDs.push_back((**node).GetId());
            }
        }
        else {
            if (it!=m_SelectedIDs.end()){
                m_SelectedIDs.erase(it);
            }
        }
    }    

    return (selected.size() > 0);
}
    

void IPhyloTreeRenderer::UpdateDataSource(CPhyloTreeDataSource& ds, CGlPane& p)
{
    m_pPane = &p;
    m_DS = &ds;
}

void IPhyloTreeRenderer::Layout(CPhyloTreeDataSource& ds, CGlPane& p)
{
    m_pPane = &p;
    m_DS = &ds;
    x_Layout(ds);

    // Mark the fact that we have a valid layout, which Render function can check.
    // Only really need this for first time, since it may not be possible to do
    // layout prior to first call to Render().
    m_ValidLayout = eValidLayout;

    // New layout establised. (flag is for swtiching between types of layout,
    // not updates to current layout like hide/show node.)
    m_SwitchedLayout = false;
}

void IPhyloTreeRenderer::x_FindBestSize(CGlPane& pane,
                                        std::vector<ProjectionElement>& xexts,
                                        std::vector<ProjectionElement>& yexts,
                                        TModelRect& limits)
{
    float goal = ((float)(limits.Left()-limits.Right()))/1e04f;
    goal = std::min(goal, ((float)(limits.Top()-limits.Bottom()))/1e04f);
    //float goal = 0.1f;
    float delta = 1e10f;

    float viewport_x, viewport_y;
    float vp_width = (float)pane.GetViewport().Width();
    float vp_height = (float)pane.GetViewport().Height();
    float left = limits.Left();
    float right = limits.Right();
    float top = limits.Top();
    float bottom = limits.Bottom();

    if (left==right) {
        left -= 1.0f;
        right += 1.0f;
    }
    if (top==bottom) {
        bottom -= 1.0f;
        top += 1.0f;
    }

    int count = 0;
 
    while (delta > goal && ++count < 500) {

        // Given current limits (which are used to create the orthographic projection),
        // find the max/min x and y viewport positions to which the labels will project.
        // This allows us to iteratively search for the optimum limits for which the 
        // tree will exactly occupy the given viewport.
        float viewport_maxx = -1e10f; 
        float viewport_minx = 1e10f;
        float viewport_maxy = -1e10f;
        float viewport_miny = 1e10f;

        // Viewport projection limits for the nodes of the tree given the 
        // the current right/left/bottom/top for the visible rect
        float node_maxx = -1e10f; 
        float node_minx = 1e10f;
        float node_maxy = -1e10f; 
        float node_miny = 1e10f;

        // We set the limits of the viewing are differently based on the zoom
        // behavior.  We want to make sure that when the user zooms  in
        // to the point labels appear, that there is room for the full label
        // within the viewing limits.  This means that if we are zooming in y
        // only, there must be space for the full labels at max. zoom level,
        // whereas for zooming in x or proportionally, we don't need the full
        // label space until we have zoomed in to the point they are visible.
        float label_zoom = 1.0f;

        if (m_SL->GetZoomBehavior() == CPhyloTreeScheme::eZoomX ||
            m_SL->GetZoomBehavior() == CPhyloTreeScheme::eZoomXY) {
                // Get the vertical distance between nodes for current projection
                // (in pixels) at maximum resolution (visible-rect==model-limits-rect)
                float scaley = (top-bottom)/(float)m_pPane->GetViewport().Height();     
                float distance_between_nodes = (float)x_DistanceBetweenNodes((TModelUnit)scaley);

                // Determine how much zoom (reduction in visible rect), if any, is 
                // required to get the distance between nodes to a value that allows
                // labels to be drawn without overlapping each other (vertically);
                if (m_Label.GetCurrFont() != NULL) {
                    float height = (float)m_Label.GetMinVerticalSeparation();
                    label_zoom = std::min(1.0f, distance_between_nodes/height);            
                }
        }
        else if (m_SL->GetZoomBehavior() == CPhyloTreeScheme::eZoomY) {
            // scale room for label width based on current zoom in horizontal
            label_zoom = 1.0f* (((float)pane.GetVisibleRect().Width())/
                                 (float)pane.GetModelLimitsRect().Width());
        }


        // Check the projection in each direction by computing the pixel
        // offset as it will computed through the orthographic 
        // projection-to-viewport mapping.  Add to this value the pixel
        // offset of the label, "offset".
        //  
        //  w = viewport width, h = viewport height, x,y = node position,
        //  l,r,t,b = limits(left, right, top, bottom)
        //   
        //  (scale model to viewport)*(tranlate model to (0,0))*(model point)
        //  --                -- --        -- -- --
        //  | w/(r-l)  0    0  | | 1  0  -l | | x |
        //  |                  | |          | |   |
        //  | 0     h/(t-b) 0  | | 0  1  -b | | y |
        //  |                  | |          | |   |
        //  | 0        0    1  | | 0  0   1 | | 1 |
        //  --                -- --        -- -- --  
        for (size_t i=0; i<xexts.size(); ++i) {
            // Get position node projects onto viewport:         
            viewport_x =
                (xexts[i].m_NodeCoord*vp_width - left*vp_width)/(right-left);

            // In this first (initial) loop over the extents, just compute the
            // region (minx..maxx) occupied by the nodes projected onto the viewport.            
            node_maxx = std::max(viewport_x, node_maxx);
            node_minx = std::min(viewport_x, node_minx);

            xexts[i].m_ProjectionCood = viewport_x;
        }

        viewport_maxx = node_maxx;
        viewport_minx = node_minx;

        // Now that we have the extent that the nodes project onto the viewport
        // (node_minx..node_maxx), determine how the viewport needs to be adjusted
        // to accomodate pixel-dimensioned (label) attachements to the nodes.
        for (size_t i=0; i<xexts.size(); ++i) {
            // Get position node projects onto viewport:         
            viewport_x = xexts[i].m_ProjectionCood;          

            // Pixl extent (which come from labels) attached to the current node
            float offsetx = xexts[i].m_PixelOffset*label_zoom;

            // If we do have a pixel attachment it may go either right (+) or left(-).
            // Figure out how many pixels of that extent (label) go beyond the right
            // or left edge of the overall tree (if the label is on a right-most or
            // left-most tree node, that value is 0, otherwise it is the length of the label
            // in pixels minus the extent that those pixels overlap with the range 
            // (node_minx, node_maxx)
            if (std::abs(offsetx) > 0.0f) {
                float overlap_x;

                // overlap_x is the extent of the label that overlaps (in x)
                // the tree (node/edges) extent.
                if (offsetx > 0.0f)
                    overlap_x = (node_maxx - viewport_x);
                else
                    overlap_x = (viewport_x - node_minx);

                // non_overlap_x is extent of pixel attachment (label) that goes
                // beyond the rightmost or leftmost node in the tree
                float non_overlap_x = std::max(std::abs(offsetx) - overlap_x, 0.0f);

                // Portion of viewport occupied by tree (node_maxx-node_minx) must be
                // > or = maximum amount of viewport alloted for labels (non_overlap_x)
                float usable_offsetx = std::min(overlap_x, std::abs(offsetx)) + 
                                       std::min(non_overlap_x, vp_width*m_LabelViewPct);//node_maxx-node_minx);
                offsetx = (offsetx >= 0.0f) ? usable_offsetx : -usable_offsetx;
            }         

            // Add the pixel offset to the overall viewport size.
            if (offsetx != 0.0f) {
                viewport_x += offsetx;
                viewport_maxx = std::max(viewport_x, viewport_maxx);
                viewport_minx = std::min(viewport_x, viewport_minx);
            }           
        }

        // In y dimension there currently are no (large) pixel attachements
        // since all labels are horizontal, but we use the same technique to
        // support future requirements.
        for (size_t i=0; i<yexts.size(); ++i) {
            // Get position node projects onto viewport:                    
            viewport_y =
                (yexts[i].m_NodeCoord*vp_height - bottom*vp_height)/(top-bottom);
            viewport_maxy = std::max(viewport_y, viewport_maxy);
            viewport_miny = std::min(viewport_y, viewport_miny);

            // In this first (initial) loop over the extents, just compute the
            // region (miny..maxy) occupied by the nodes projected onto the viewport.            
            node_maxy = std::max(viewport_y, node_maxy);
            node_miny = std::min(viewport_y, node_miny);

            yexts[i].m_ProjectionCood = viewport_y;
        }

        viewport_maxy = node_maxy;
        viewport_miny = node_miny;

        for (size_t i=0; i<yexts.size(); ++i) {
            // Get position node projects onto viewport:         
            viewport_y = yexts[i].m_ProjectionCood;          

            // Pixl extent (which come from labels) attached to the current node
            float offsety = yexts[i].m_PixelOffset*label_zoom;

            if (std::abs(offsety) > 0.0f) {
                float overlap_y;

                if (offsety > 0.0f)
                    overlap_y = (node_maxy - viewport_y);
                else
                    overlap_y = (viewport_y - node_miny);

                float non_overlap_y = std::max(std::abs(offsety) - overlap_y, 0.0f);

                // Portion of viewport occupied by tree (node_maxy-node_miny) must be
                // > or = maximum amount of viewport alloted for labels (non_overlap_y)
                float usable_offsety = std::min(overlap_y, std::abs(offsety)) + 
                                       std::min(non_overlap_y, vp_height*m_LabelViewPct); //node_maxy-node_miny);
                offsety = (offsety >= 0.0f) ? usable_offsety : -usable_offsety;
            }         

            // Add the pixel offset to the overall viewport size.
            if (offsety != 0.0f) {
                viewport_y += offsety;
                viewport_maxy = std::max(viewport_y, viewport_maxy);
                viewport_miny = std::min(viewport_y, viewport_miny);
            }           
        }

        ////////////////////////////////////////////////////////////////////////////// 
        // For the viewport directions that had projections by labels, re-estimate the
        // best size for the limits in that dimension.
        //////////////////////////////////////////////////////////////////////////////
        delta = 0.0f;
        // Pixels could go in both directions (min and max) so we
        // just double
        if (viewport_maxx != -1e10f) {
            float rd = viewport_maxx - (float)pane.GetViewport().Right();
            if (fabs(rd) > 0.0f) {
                delta = std::max(delta, (float)fabs(rd));
                float off = (rd/vp_width)*(right-left);
                right += off;
            }
        }

        if (viewport_minx != 1e10f) {
            float ld = viewport_minx - (float)pane.GetViewport().Left();
            if (fabs(ld) > 0.0f) {
                delta = std::max(delta, (float)fabs(ld));
                float off =  (ld/vp_width)*(right-left);
                left += off;
            }
        }

        if ( viewport_maxy != -1e10f) {
            float td = viewport_maxy - (float)pane.GetViewport().Top();
            if (fabs(td) > 0.0f) {
                delta = std::max(delta, (float)fabs(td));
                float off = (td/vp_height)*(top-bottom);
                top += off;
            }
        }

        if ( viewport_miny != 1e10f) {
            float bd = viewport_miny - (float)pane.GetViewport().Bottom();
            if (fabs(bd) > 0.0f) {
                delta = std::max(delta, (float)fabs(bd));
                float off = (bd/vp_height)*(top-bottom);
                bottom += off;
            }
        }        
    }

    limits.SetRight(right);
    limits.SetLeft(left);
    limits.SetBottom(bottom);
    limits.SetTop(top);
}

void IPhyloTreeRenderer::CExtentDimension::UpdateExtent(float node_coord,
                                                        float pixel_offset,
                                                        bool has_label)
{

    // If there was no label, the new coordinate can only be inserted
    // at the head of the list.  It will replace the first element in
    // the list if that element also does not have a label (pixel_offset
    // is still non-zero however, because all elements have a pixel margin
    // around themseleves) 
    if ( !has_label ) {    
        // List empty, just add
        if (m_Extents.size() == 0) {
            m_Extents.insert(m_Extents.begin(), 
                ProjectionElement(node_coord, pixel_offset));
        }
        // List not empty - decide whether or not the first elemeent will
        // be replaced
        else if (node_coord > m_Extents[0].m_NodeCoord) {
            if (m_Extents[0].m_PixelOffset <= pixel_offset) {
                m_Extents[0] = ProjectionElement(node_coord, pixel_offset);
            }
            else {
                m_Extents.insert(m_Extents.begin(), 
                    ProjectionElement(node_coord, pixel_offset));
            }
        }
    }
    // Current element has a label. Determine if it should be inserted,
    // where to insert it, whether it will overwrite an existing entry,
    // and whether elements in the list with smaller coordnates need to 
    // be erased since they no longer can effect max. projection extent
    else {
        float max_pixel_offset = -FLT_MAX;
        bool resolved = false;       
        int erase_from = -1;

        // Iterate over list until we find where to insert (list is generally
        // short (1-10 elements), so a binary search could be longer)
        for (size_t ext_idx=0; ext_idx<m_Extents.size() && !resolved; ++ext_idx) {
            max_pixel_offset = std::max(max_pixel_offset, m_Extents[ext_idx].m_PixelOffset);

            // Coord > than current element in list, so insert it
            if (node_coord > m_Extents[ext_idx].m_NodeCoord) {
                if (pixel_offset >= max_pixel_offset) {                   
                    m_Extents[ext_idx].m_PixelOffset = pixel_offset;
                    m_Extents[ext_idx].m_NodeCoord = node_coord;
                    //m_Extents[ext_idx].m_Text = label;
                    erase_from = ext_idx;   
                }
                else {
                    ProjectionElement ne(node_coord, pixel_offset);
                    //ne.m_Text = label;
                    m_Extents.insert(m_Extents.begin() + ext_idx, ne);
                }
                resolved = true;                    
            }
            // Coord == coord of current list element. Replace the current
            // element with the new IF new element has larger pixel offset
            else if (node_coord == m_Extents[ext_idx].m_NodeCoord) {                        
                if (pixel_offset > max_pixel_offset) {                  
                    //ne.m_Text = label;                  
                    m_Extents[ext_idx].m_PixelOffset = pixel_offset;
                    erase_from = ext_idx;
                }
                resolved = true;
            }
            //node_coord < m_Extents[ext_idx].m_NodeCoord
            else {
                if (pixel_offset <= max_pixel_offset) {
                    resolved = true;
                }                 
            }
        }

        // Coordinate was smaller than any element in the list,
        // but the label (pixel offset) was larger than any element
        // in the list so insert the element at the end
        if (!resolved && pixel_offset > max_pixel_offset) {
            ProjectionElement ne(node_coord, pixel_offset);
            //ne.m_Text = label;
            m_Extents.push_back(ne);
        }

        // Element was inserted into the list and its label (pixel offset) was
        // larger than all of the elements up to its insertion point.  Now erase
        // any elements after the newly inserted element that have a pixel offset
        // that is smaller than the pixel offset of the inserted element since
        // they will no longer effect the projection size (at any zoom level)
        if (erase_from >=0) {
            size_t erase_to = erase_from + 1;
            for (; erase_to < m_Extents.size(); ++erase_to)
                if (pixel_offset < m_Extents[erase_to].m_PixelOffset)
                    break;

            if (erase_to > (size_t)(erase_from + 1))
                m_Extents.erase(m_Extents.begin() +(size_t)( erase_from + 1),
                m_Extents.begin() + erase_to);               
        }            
    }
}

void IPhyloTreeRenderer::CExtentDimension::DumpExtent(const string& dim) {
    for (size_t i=0; i<m_Extents.size(); ++i) {
        _TRACE("Value: " << 
            //m_Extents[i].m_Text << 
            dim << m_Extents[i].m_NodeCoord << " ) Pix: ( " <<
            m_Extents[i].m_PixelOffset << " ) ");
    }
}


void IPhyloTreeRenderer::
CProjectionExtents::GetTextExtents(const CPhyloTreeScheme& sl,
                                   CPhyloTreeLabel& labeler,
                                   CGlPane& pane,
                                   CPhyloTreeNode * node,
                                   TModelRect& zoomable_extent)
{
    CVect2<float> pos = (**node).XY();

    GLdouble top_margin, bottom_margin, left_margin, right_margin;
    sl.GetMargins(left_margin, top_margin, right_margin, bottom_margin);

    // The zoomable_extent just holds the x/y extents without considering 
    // labels.
    zoomable_extent.SetLeft(std::min(zoomable_extent.Left(), (double)pos.X()));
    zoomable_extent.SetRight(std::max(zoomable_extent.Right(), (double)pos.X()));
    zoomable_extent.SetBottom(std::min(zoomable_extent.Bottom(), (double)pos.Y()));
    zoomable_extent.SetTop(std::max(zoomable_extent.Top(), (double)pos.Y()));

    bool label_empty = (**node).GetLabel().empty() && (*node).Expanded();
    // If no label, add to extent without considering label
    if ( label_empty ||
        sl.GetLabelVisibility() == CPhyloTreeScheme::eLabelsHidden ||
        (sl.GetLabelVisibility() == CPhyloTreeScheme::eLabelsForLeavesOnly &&
        !node->IsLeafEx()) ) {
            CVect2<float> pos = (**node).XY();       

            m_MaxX.UpdateExtent(pos.X(), right_margin, false);
            m_MaxY.UpdateExtent(pos.Y(), top_margin, false);
            m_MinX.UpdateExtent(-pos.X(), left_margin, false);
            m_MinY.UpdateExtent(-pos.Y(), bottom_margin, false);
    }
    // There is a label - add to each extent based on the labels maximum
    // projection distance (in pixels) in that direction
    else {
        CGlRect<float> label_rect = (**node).GetLabelRect();

        //string label = labeler.x_GetLabel(node);
        m_MaxX.UpdateExtent(pos.X(), label_rect.Right() + right_margin, true);
        m_MaxY.UpdateExtent(pos.Y(), label_rect.Top() + top_margin, true);
        // note that we negate minimum values for x,y so that we can use
        // the same function (UpdateExtents()) for all 4 directions
        m_MinX.UpdateExtent(-pos.X(), -label_rect.Left() + left_margin, true);
        m_MinY.UpdateExtent(-pos.Y(), -label_rect.Bottom() + bottom_margin, true);
    }

    // Recusively visit all other nodes in the tree
    if (!(**node).GetChildsDisplay() == IPhyGraphicsNode::eHideChilds) {
        for(CPhyloTreeNode::TNodeList_I  it = node->SubNodeBeginEx();
            it != node->SubNodeEndEx(); it++)  {
                CPhyloTreeNode* subnode = static_cast<CPhyloTreeNode*>(*it);                   
                GetTextExtents(sl, labeler, pane, subnode, zoomable_extent);
        }
    }
}

void IPhyloTreeRenderer::
CProjectionExtents::ConsolidateExtents(vector<ProjectionElement>& xexts,
                                       vector<ProjectionElement>& yexts)
{
    /// Combine m_MaxX and m_MinX.  All coordinates in m_MinX are
    /// flipped (negated) so we have to reverse that here.
    xexts = m_MaxX.m_Extents;
    for (size_t i=0; i<m_MinX.m_Extents.size(); ++i) {
        ProjectionElement ne(m_MinX.m_Extents[i]);
        ne.m_NodeCoord = -ne.m_NodeCoord;
        ne.m_PixelOffset = -ne.m_PixelOffset;

        xexts.push_back(ne);
    }

    /// Combine m_MaxY and m_MinY.  All coordinates in m_MinY are
    /// flipped (negated) so we have to reverse that here.
    yexts = m_MaxY.m_Extents;
    for (size_t i=0; i<m_MinY.m_Extents.size(); ++i) {
        ProjectionElement ne(m_MinY.m_Extents[i]);
        ne.m_NodeCoord = -ne.m_NodeCoord;
        ne.m_PixelOffset = -ne.m_PixelOffset;

        yexts.push_back(ne);
    }
}

void IPhyloTreeRenderer::CProjectionExtents::DumpExtents() {
    _TRACE("");
    _TRACE("Dumping + X Dimension:");
    m_MaxX.DumpExtent(" X Pos: ( ");

    _TRACE("");
    _TRACE("Dumping + Y Dimension:");
    m_MaxY.DumpExtent(" Y Pos: ( ");

    _TRACE("");
    _TRACE("Dumping - X Dimension:");
    m_MinX.DumpExtent(" -X Pos: ( ");

    _TRACE("");
    _TRACE("Dumping - Y Dimension:");
    m_MinY.DumpExtent(" -Y Pos: ( ");
}



void IPhyloTreeRenderer::ComputeViewingLimits(CGlPane& pane, 
                                              bool viewing_only)
{
    GLdouble top, bottom, left, right;
    m_SL->GetMargins(left, top, right, bottom);
  
    double scalex = m_bZoomablePrimitives?1.0:pane.GetScaleX();
    double scaley = m_bZoomablePrimitives?1.0:pane.GetScaleY();

    // This adds label size to overall viewing area, but does so incorrectly - too much space
    // is added for the label probably because the current (visible) rect already includes
    // the label from the previous call to this function? Maybe we could differentiate between 
    // nodes and edges size and that size + text size by saving the text origins with the nodes
    // and edges, and using those to compute (at each change) the size with labels...
    
    TModelRect visible = pane.GetVisibleRect();
    TModelRect limits = pane.GetModelLimitsRect();
 
    CStopWatch  t1;

    TModelRect extent_limits;   
    extent_limits.SetBottom(1e10);
    extent_limits.SetLeft(1e10f);
    extent_limits.SetRight(-1e10);
    extent_limits.SetTop(-1e10);

    t1.Start();
    // Collect all points and text that may impact the size required for the viewing area
    // (these are nodes and text and the min/max x/y positions.  There may be multiple 
    // elements in each direction since text is fixed size regardless of zoom)
    CProjectionExtents extents;
    extents.GetTextExtents(m_SL.GetNCObject(), m_Label, pane, m_DS->GetTree(), extent_limits);   

    // Consolidate the extent data into two vectors - one for min/max x values and one 
    // for min/max y values.
    vector<ProjectionElement> xexts, yexts;
    extents.ConsolidateExtents(xexts, yexts);
    t1.Stop();

    //extents.DumpExtents();

    //_TRACE("Visible Nodes: " << m_DS->GetVisibleNodes() );
    //  If there is only 1 node force a small window
    bool too_small = false;
    if (m_DS->GetVisibleNodes() == 1) {
        extent_limits.Inflate(1.0f, 1.0f);
        too_small = true;
    }

    // Get numerical problems as viewport size goes to 0 so we just use the model
    // extent in this (not-visually-usable) case:
    if (pane.GetViewport().Height() < 20 ||
        pane.GetViewport().Width() < 20) {
            pane.SetModelLimitsRect(extent_limits);
            pane.SetVisibleRect(extent_limits);
            return;
    }

    if (!viewing_only) {
        if (!too_small) {           
            t1.Start();
            x_FindBestSize(pane, xexts, yexts, extent_limits);
            // Guard against numerical issues (very small extents - maybe nodes are in a line)
            if (extent_limits.Width() < 1.0f)
                extent_limits.Inflate(1.0f, 0.0f);
            if (extent_limits.Height() < 1.0f)
                extent_limits.Inflate(0.0f, 1.0f);
            t1.Stop();

            //LOG_POST("Limits1: " << extent_limits.ToString() << " T1: " << t1.Elapsed());
        }

        scalex = 1.0f/(pane.GetViewport().Width()/(extent_limits.Right() - extent_limits.Left()));
        scaley = 1.0f/(pane.GetViewport().Height()/(extent_limits.Top() - extent_limits.Bottom()));

        TModelRect mr(extent_limits.Left()     - left * scalex,
                      extent_limits.Bottom()   - bottom * scaley,
                      extent_limits.Right()    + right * scalex, 
                      extent_limits.Top()      + top * scaley);

        pane.SetModelLimitsRect(mr);
         
        float left_pct = 0.0f;
        float right_pct = 0.0f;
        float bottom_pct = 0.0f;
        float top_pct = 0.0f;

        if (limits.Width() > 0.0 && limits.Height() > 0.0) {
            left_pct = (visible.Left() - limits.Left())/limits.Width();
            right_pct = (visible.Right() - limits.Left())/limits.Width();
            bottom_pct = (visible.Bottom() - limits.Bottom())/limits.Height();
            top_pct = (visible.Top() - limits.Bottom())/limits.Height();
        }

        visible.SetLeft(mr.Left() + mr.Width()*left_pct);
        visible.SetRight(mr.Left() + mr.Width()*right_pct);
        visible.SetBottom(mr.Bottom() + mr.Height()*bottom_pct);
        visible.SetTop(mr.Bottom() + mr.Height()*top_pct);

        // Set visible rect to fit inside model limits rect.
        pane.SetVisibleRect(visible);
    }

   BufferedRender(pane, *m_DS);
}

void IPhyloTreeRenderer::BufferedRender(CGlPane& pane, CPhyloTreeDataSource& ds)
{
    // Depending on initialization order (for a newly created view) this may 
    // get called before ComputeViewingLimits has been called for the first time.
    // Do not render in that case.
    if (m_ValidLayout != eValidLayout)
        return;

    m_pPane     = &pane;
    m_DS        = &ds;

#ifdef BUFFERED_RENDER
    CStopWatch  render_total;
    render_total.Start();

    CGlUtils::CheckGlError();
    m_DS->GetModel().ClearArrays();
    x_RenderVbo(*m_DS);
    CGlUtils::CheckGlError();   

    /// For large models, track the resolution to be relative to a 
    /// full screen of nodes with labels since that is our unit of drawing
    float collision_resolution = max(ceilf(sqrtf(m_DS->GetSize())), 
                                     ((float)m_DS->GetSize())/400.0f);
    m_DS->GetModel().GetCollisionData().
        ResizeGrid( CVect2<float>(pane.GetModelLimitsRect().Left(), pane.GetModelLimitsRect().Bottom()),
                    CVect2<float>(pane.GetModelLimitsRect().Right(), pane.GetModelLimitsRect().Top()),
                    collision_resolution );

    m_DS->GetModel().GetCollisionData().Sync(&m_DS->GetModel());
    m_DS->GetModel().SyncBuffers();            
    
    // initiate visibility computation
    CVect2<float> scale2d((float)m_pPane->GetScaleX(), (float)m_pPane->GetScaleY());
    m_DS->GetModel().GetCollisionData().UpdateScaled(scale2d);

    m_BufferdRenderTime = render_total.Elapsed();    
#endif
}


bool IPhyloTreeRenderer::Render(CGlPane& pane, CPhyloTreeDataSource& ds)
{

    m_pPane     = &pane;
    m_DS        = &ds;

#ifdef BUFFERED_RENDER
    // In this function we just draw.  In something like 'soft update' we
    // re-create the model.


    float x = m_pPane->GetScaleX();
    float y = m_pPane->GetScaleY();

    CVect3<float> scale(x, y, 0.0f);
    CVect2<float> scale2d(x, y);

    TVPUnit node_size = x_NodeSize(m_DS->GetTree());

    CGlVboNode* geom = m_DS->GetModel().FindGeomNode("HighlightedCollapsedNode");
    if (geom) {
        geom->SetScale(scale);
        geom->SetVisible(true);
    }
    geom = m_DS->GetModel().FindGeomNode("CollapsedNode");
    if (geom) {
        geom->SetScale(scale);
        geom->SetVisible(node_size > 0);
    }

    // This doesn't handle nodes that are forced to be <0 in size...
    CGlVboNode* points = m_DS->GetModel().FindGeomNode("NodePoints");
    if (points) {
        points->SetVisible(node_size <= 0);
    }

    TModelUnit line_width =
        m_SL->SetSize(CPhyloTreeScheme::eLineWidth);

    if (DistanceBetweenNodes() < line_width) {
        line_width = 1.0;
    }

    CGlVboNode* edge_node = m_DS->GetModel().FindGeomNode("TreeEdges");
    CGlVboNode* narrow_edge_node = m_DS->GetModel().FindGeomNode("NarrowTreeEdges");
    CGlVboNode* filler_points_node = m_DS->GetModel().FindGeomNode("FillerPoints");
    bool filler_points_visible = filler_points_node->IsVisible();

    if (edge_node != NULL && narrow_edge_node != NULL && filler_points_node != NULL) {
        edge_node->GetState().SetLineWidth((float)line_width);

        // Turn filler points on/off if they are in use for current rendering (and
        // reset state after rendering back to 'on')
        if (filler_points_visible) {
            filler_points_node->GetState().SetPointSize((float)line_width);
            filler_points_node->SetVisible(line_width > 1.0f);
        }

        narrow_edge_node->GetState().SetLineWidth(1.0f);
        narrow_edge_node->SetVisible(line_width > 1.0f);
    }

    CTreeTriFanNode* node_fan = m_DS->GetModel().GetTriFanNode();
    if (node_fan) {
        node_fan->SetScale(scale);
        TModelRect r = m_pPane->GetVisibleRect();
        node_fan->SetVisibilityInfo(CGlRect<float>((float)r.Left(), (float)r.Bottom(), (float)r.Right(), (float)r.Top()),
                                    (float)m_SL->SetSize(CPhyloTreeScheme::eNodeSize));
        node_fan->SetVisible(node_size > 0);    

        CGlVboNode* node_fan_pass2 = m_DS->GetModel().GetTriFanNodePass2();
        if (node_fan_pass2 != NULL) {
            node_fan_pass2->SetScale(scale);          
            node_fan_pass2->SetVisible(node_size > 0); 
        }
    
        if (( (m_SL->GetLabelVisibility()==CPhyloTreeScheme::eLabelsVisible) ||
              (m_SL->GetLabelVisibility()==CPhyloTreeScheme::eLabelsForLeavesOnly) ) &&
            m_Label.IsVisible(this) ){

            node_fan->SetLabelVisibility(true);
        }
        else {
            node_fan->SetLabelVisibility(false);
        }

        // Determines if labels and associated nodes may be visible (if they are in
        // the viewing area).  Only needed if the nodes or labels are visible.
        if (node_fan->IsVisible() || node_fan->GetLabelVisibility()) {
            CVect2<float> s = m_DS->GetModel().GetCollisionData().GetScale();
            if (s.X() != scale2d.X() || s.Y() != scale2d.Y())
                m_DS->GetModel().GetCollisionData().UpdateScaled(scale2d);
            m_DS->GetModel().GetCollisionData().UpdateVisibility(pane.GetVisibleRect());
        }
    }
        

    //m_DS->GetModel().GetLines().SetWidth(line_width);
    //m_DS->GetModel().GetNodes().SetScale(...)
    CGlUtils::CheckGlError();

    m_DS->GetModel().Render(pane);

    // Render selection box
    x_RenderSelection(pane);
    x_RenderTooltipHints(pane);
    // Render distance scale at bottom of screen
    x_RenderScaleMarker(pane);

    // Want to turn filler points on/off based on zoom, but their
    // visibility also depends on rendering style (spline/non-spline) so 
    // we want to set them visible again if they were visible before (should
    // probably capture this somewhere else...)
    if (filler_points_node != NULL)
        filler_points_node->SetVisible(filler_points_visible);

#else
    x_Render(pane, ds);
    x_RenderSelection(pane);
    x_RenderTooltipHints(pane);
    x_RenderScaleMarker(pane);
#endif

    return true;
}

void IPhyloTreeRenderer::RenderForHardcopy(CGlPane& pane, CPhyloTreeDataSource& ds)
{
    m_pPane     = &pane;
    m_DS        = &ds;

    CRgbaColor bgColor(m_SL->SetColor(CPhyloTreeScheme::eTree,
                                    CPhyloTreeScheme::eBgColor));

    glClearColor(bgColor.GetRed(), bgColor.GetGreen(),
        bgColor.GetBlue(), bgColor.GetAlpha());

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

#ifdef BUFFERED_RENDER
    Render(pane, ds); 
#else
    x_Render(pane, ds); 
#endif
}

void IPhyloTreeRenderer::Redraw(void)
{
    CRgbaColor bgColor(m_SL->SetColor(CPhyloTreeScheme::eTree,
                                    CPhyloTreeScheme::eBgColor));

    glClearColor(bgColor.GetRed(), bgColor.GetGreen(),
        bgColor.GetBlue(), bgColor.GetAlpha());

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

#ifdef BUFFERED_RENDER
    Render(*m_pPane, *m_DS);
#else
    x_Render(*m_pPane, *m_DS);
#endif
}

void IPhyloTreeRenderer::RemoveCurrentDataSource() 
{
    m_ValidLayout = eNeedLayoutAndSize;
}


void IPhyloTreeRenderer::x_GenerateTexture(void)
{
    GLint w = m_pPane->GetViewport().Width();
    GLint h = m_pPane->GetViewport().Height();

    // Get a power-of-2 size for frame buffer that is the smallest
    // power-of-2 size larger than the current viewport
    size_t size = std::max(w,h);
    size_t buf_dim = 32;
    for (int i=0; i<8 && buf_dim<size; ++i)
        buf_dim *= 2;

    // Some machines have limited framebuffer sizes available. Since we don't
    // really *need* a large buffer, make 1024 the max since any machine should
    // be able to handle that.
    if (buf_dim > 1024) 
        buf_dim = 1024;

    if (m_MinimapBuffer == NULL || 
        m_MinimapBuffer->GetFrameSize() < buf_dim) {
            delete m_MinimapBuffer;
            m_MinimapBuffer = new CGLFrameBuffer(buf_dim);
            m_MinimapBuffer->SetTextureFiltering(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
            m_MinimapBuffer->CreateFrameBuffer();
    }

    if (m_MinimapBuffer->IsValid()) {
        m_MinimapBuffer->MakeCurrent(true);

        // Set viewport and draw:
        GLint vp_width, vp_height;
        if (w > h) {
            vp_width = (int)m_MinimapBuffer->GetFrameSize();
            vp_height = (int)(((float)vp_width)*((float)h)/(float)w);
        }
        else {
            vp_height = (int)m_MinimapBuffer->GetFrameSize();
            vp_width = (int)(((float)vp_height)*((float)w)/(float)h);
        }

        // Get current viewport and visible region so we can
        // restore them later
        TVPRect saved_viewport = m_pPane->GetViewport();
        TModelRect saved_rect = m_pPane->GetVisibleRect();
        TModelRect saved_limits_rect = m_pPane->GetModelLimitsRect();        

        // Set visible rect to draw the whole tree
        m_pPane->SetVisibleRect(m_pPane->GetModelLimitsRect());
        m_pPane->GetViewport().Init(0, 0, vp_width, vp_height);

        ComputeViewingLimits(*m_pPane);
        Redraw();

        // Set viewport and model region back
        m_pPane->SetViewport(saved_viewport);
        m_pPane->SetVisibleRect(saved_rect);
        m_pPane->SetModelLimitsRect(saved_limits_rect);        

        // Set rendering target back
        m_MinimapBuffer->MakeCurrent(false);
        m_MinimapBuffer->GenerateMipMaps();

        // Update the minimap texture with the texture id from the framebuffer
        m_Texture.Reset(new CGlTexture(m_MinimapBuffer->GetTexture()));
        m_Texture->SetFilterMag(m_MinimapBuffer->GetTexMag());
        m_Texture->SetFilterMin(m_MinimapBuffer->GetTexMin());
        m_Texture->SetParams();


        CGlUtils::CheckGlError();
    }
    else {
        // If system does not support framebuffers, generate a (worse) texture the 
        // old-fashioned way.
        TModelRect saved_rect = m_pPane->GetVisibleRect();
        m_pPane->SetVisibleRect(m_pPane->GetModelLimitsRect());
        Redraw();

        try {
            CImage * image = new CImage(w, h, 4);
            glPixelStorei(GL_PACK_ALIGNMENT, 1);

            glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, image->SetData());
            m_Texture.Reset(new CGlTexture(image));
        }
        catch(COpenGLException&)
        {
            m_bRegenerateTexture = false;
        }
        catch(std::exception&)
        {
            m_bRegenerateTexture = false;
        }

        m_pPane->SetVisibleRect(saved_rect);
        Redraw();
    }
}

CGlTexture * IPhyloTreeRenderer::GetTexture(float& xcoord_limit,
                                            float& ycoord_limit)
{
    if (m_bRegenerateTexture) {
        x_GenerateTexture();
    }
    
    // The minimap is created from a square texture, but when we
    // draw to the texture the whole texture is not used.  The limits
    // represent the part of the textture that should be shown.
    GLint w = m_pPane->GetViewport().Width();
    GLint h = m_pPane->GetViewport().Height();
    if (w > h) {
        xcoord_limit = 1.0f;
        ycoord_limit = ((float)h)/(float)w;
    }
    else {
        ycoord_limit = 1.0f;
        xcoord_limit = ((float)w)/(float)h;
    }

    return m_bRegenerateTexture ? m_Texture.GetPointer() : NULL;
}

CPhyloTreeNode * IPhyloTreeRenderer::GetHoverNode(TVPPoint point)
{
    if (m_DS != NULL)
        return x_TestForNode(m_DS->GetTree(), wxPoint(point.X(), point.Y()));

    return NULL;
}

string IPhyloTreeRenderer::TTHH_NeedTooltip(const wxPoint & pt)
{
    // Since this can be checked with a timer, we may get
    // here while user is using rectangle-select and we don't 
    // want to do anything in that case.
    if (m_DS == NULL || m_State == eSelRect)
        return "";

    m_StartPoint = pt;
    CPhyloTreeNode* n = x_TestForNode(m_DS->GetTree(), m_StartPoint);
    if (n==NULL)
        return "";

    return NStr::IntToString(n->GetValue().GetId());  
}

CTooltipInfo IPhyloTreeRenderer::TTHH_GetTooltip(const wxRect & rect)
{
    CTooltipInfo  tip;

    // Should not call this while selecting, but just in case, check m_State
    if (m_DS == NULL || m_State == eSelRect)
        return tip;

    m_StartPoint.x = rect.x;  m_StartPoint.y = rect.y;
    CPhyloTreeNode * n = x_TestForNode(m_DS->GetTree(), m_StartPoint);    
    
    if (n != NULL) {
        //std::string tip_text = m_LabelExt.GetLabelForNode(n, m_SL->SetTooltipFormat());
        tip.SetTipID(NStr::IntToString(n->GetValue().GetId()));
        
        std::vector<std::string> arr;
        std::string final_text;

        // Get tip text, and then remove any lines we don't need.
        NStr::Tokenize(m_LabelExt.GetLabelForNode(n, m_SL->SetTooltipFormat()),
                       "\n", arr);
        for (unsigned int i=0; i<arr.size(); ++i) {
            if (arr[i].length() > 0) {
                // This is in the title
                if (arr[i].substr(0, 6) == "label:")
                    continue;
                // This is visually obvious
                if (arr[i].substr(0,16) == "$NODE_COLLAPSED:")
                    continue;

                // Remove blank features (no text after first ':')...
                std::string::size_type idx1 = arr[i].find_first_of(":");
                if (arr[i].length() > idx1+1) {
                    std::string::size_type idx2 = arr[i].find_first_not_of(' ', idx1+1);
                    if (idx2 != std::string::npos) {
                        final_text += arr[i];
                        final_text += '\n';
                    }
                }
            }
        }

        tip.SetTipText(final_text);
        tip.SetTitleText((*n)->GetLabel());
    }
   
    return tip;
}

void IPhyloTreeRenderer::SetActiveTooltipNode(int id) 
{ 
    m_ActiveTooltipNode = m_DS->GetNode(id);
}

void IPhyloTreeRenderer::PointToNode(int id, wxRect tip_rect, float sec)
{         
    if (m_DS == NULL)
        return;

    // Create an entry for an arrow to point from a tooltip window to node 'id'
    CPhyloTreeNode* tip_node  = m_DS->GetNode(id);
    if (tip_node){           
        NodePointer np;
        np.m_NodeID = id;
        np.m_Node = m_DS->GetNode(id);

        _ASSERT(np.m_Node != NULL);            

        np.m_TipCenter.m_X = (TModelUnit)(tip_rect.x + tip_rect.width/2);
        np.m_TipCenter.m_Y = (TModelUnit)(tip_rect.y + tip_rect.height/2);

        np.m_TipRect = tip_rect;

        np.m_Duration = sec;
        if (np.m_Duration != (TModelUnit)-1)
            np.m_Timer.Start(); 

        if (!m_EffectsTimer.IsRunning())
            m_EffectsTimer.Start(30);

        // If we are already pointing to this node, reset it
        for (unsigned int i=0; i<m_NodePointers.size(); ++i) {
            if (m_NodePointers[i].m_NodeID == (IPhyNode::TID)id) {
                m_NodePointers[i] = np;
                return;
            }
        }

        m_NodePointers.push_back(np);
    }
}

void IPhyloTreeRenderer::SetSelectedIDs(const vector<int> & vect)
{
    if (m_DS == NULL)
        return;

    m_SelectedIDs.resize(vect.size());
    copy(vect.begin(), vect.end(), m_SelectedIDs.begin());

    m_DS->SetSelection(m_DS->GetTree(), false, true);
    for (vector<int>::const_iterator it=vect.begin(); it!=vect.end(); it++){
        CPhyloTreeNode * node = m_DS->GetNode(*it);
        if (node)   m_DS->SetSelection(node, true, true);
    }
    //m_pHost->HMGH_Redraw();
    m_pHost->HMGH_OnChanged();
}

bool IPhyloTreeRenderer::x_KindOfHuge(void)
{
    if (m_DS == NULL)
        return false;

    TModelUnit modelDist        = GetDimY() / m_DS->GetSize();
    TModelUnit node_size         = m_SL->SetSize(CPhyloTreeScheme::eNodeSize) * 2;
    return modelDist < node_size;
}

TVPUnit IPhyloTreeRenderer::DistanceBetweenNodes(void)
{
    // By default, allow labels to be visible to a fairly high resolution
    return  (TVPUnit)x_DistanceBetweenNodes(m_pPane->GetScaleY());
}

TModelUnit IPhyloTreeRenderer::x_DistanceBetweenNodes(TModelUnit scaley)
{
    return  (GetDimY() / (((TModelUnit)m_DS->GetSize())* 0.25 * scaley));
}

const TModelRect & IPhyloTreeRenderer::GetRasterRect(void)
{
    return m_RasterRect;
}

CRgbaColor IPhyloTreeRenderer::GetNodeColor(CPhyloTreeNode * node, bool bLabel)
{
    if (!bLabel) { // node      
        const string & node_color = m_SL->GetColoration()==CPhyloTreeScheme::eClusters?(**node).GetClusterFgColor():(**node).GetNodeFgColor();

        if (!node_color.empty() && (**node).GetSelectedState()!=IPhyGraphicsNode::eSelected) {
            CRgbaColor c(node_color);
            if (m_SL->GetSelectionVisibility() == 
                CPhyloTreeScheme::eHighlightSelection) {
                    c.SetAlpha(m_SL->GetNonSelectedAlpha());
            }
            return c;
        }       
    }
    else { // label
        const string & label_color = (**node).GetLabelFgColor();
        if (!label_color.empty()) {
            CRgbaColor c(label_color);
            if (m_SL->GetSelectionVisibility() == 
                CPhyloTreeScheme::eHighlightSelection &&
                (**node).GetSelectedState()==IPhyGraphicsNode::eNotSelected) {
                    c.SetAlpha(m_SL->GetNonSelectedAlpha());
            }
            return c;
        }
    }

    CRgbaColor color;

    if ((**node).GetSelectedState()==IPhyGraphicsNode::eSelected) {
        color =
            m_SL->SetColor(bLabel?CPhyloTreeScheme::eLabel:CPhyloTreeScheme::eNode,
                           CPhyloTreeScheme::eSelColor);
    }
    else if ((**node).GetSelectedState()==IPhyGraphicsNode::eShared) {
        color =
            m_SL->SetColor(bLabel?CPhyloTreeScheme::eLabel:CPhyloTreeScheme::eNode,
                           CPhyloTreeScheme::eSharedColor);
    }
    else if ((**node).GetSelectedState()==IPhyGraphicsNode::eTraced) {
        color =
            m_SL->SetColor(bLabel?CPhyloTreeScheme::eLabel:CPhyloTreeScheme::eNode,
                           CPhyloTreeScheme::eTraceColor);
    }
    else {
        color = 
            m_SL->SetColor(bLabel?CPhyloTreeScheme::eLabel:CPhyloTreeScheme::eNode,
                           CPhyloTreeScheme::eColor);
        if (m_SL->GetSelectionVisibility() ==
            CPhyloTreeScheme::eHighlightSelection)
            color.SetAlpha(m_SL->GetNonSelectedAlpha());
    }

    return color;
}


string IPhyloTreeRenderer::GetEdgeColor(CPhyloTreeNode * node)
{
    const string & edge_color = m_SL->GetColoration()==CPhyloTreeScheme::eClusters?(**node).GetClusterFgColor():(**node).GetNodeEdColor();

    if (!edge_color.empty() && (**node).GetSelectedState()!=IPhyGraphicsNode::eSelected) {
        return CRgbaColor(edge_color).ToString();   
    }
    return "";
}


// by default do not allow to drag nodes
bool IPhyloTreeRenderer::CanDragNodes(void)
{
    return false;
}

void IPhyloTreeRenderer::SetRenderingOption(TRenderingOption opt, bool bVal)
{
    switch (opt) {
    case eDistancesRendering:   {m_bDistMode = bVal;            break;}
    case eAdaptiveMargins:      {m_bAdaptiveMargins = bVal;     break;}
    case eSimplification:       {m_bSimplification = bVal;      break;}
    case eSplinesRendering:     {m_bUseSplines = bVal;          break;}
    case eGenerateTextures:     {m_bRegenerateTexture = bVal;   break;}
    case eZoomablePrimitives:   {m_bZoomablePrimitives = bVal;  break;}
    case eAutofitLabels:        {m_bAutosizeLabels = bVal;      break;}
    }
}

TVPRect IPhyloTreeRenderer::GetMinDimensions(CPhyloTreeDataSource & ds,
                                             IPhyloTreeRenderer   & rr,
                                             CPhyloTreeScheme     & sc)
{
    TVPRect rec_rect(0, 0, 0, 0);

    // OpenGL limitations in pixels
    int max_width  = 2000;
    int max_height = 2000;

    // minimum visible font size
    int min_fontsize = CGlBitmapFont::eFontSize_8;

    // comfortable space between labels
    int min_space = 2;

    // retrieving margins
    GLdouble ml, mt, mr, mb;
    sc.GetMargins(ml, mt, mr, mb);

    // height calculation
    int height, width;

    if (rr.CanDragNodes()) { // unrooted tree

        height = width = int (mt + mb + ::sqrt((double)ds.GetSize()*ds.GetWidth()) *
            sc.SetSize(CPhyloTreeScheme::eNodeSize));
    }
    else {  // rooted tree
        height = int (mt + mb + (ds.GetSize() + 1) *
            (min_fontsize+min_space));
        width  = int (ml + mr + (ds.GetWidth() + 1) *
            (sc.SetSize(CPhyloTreeScheme::eNodeSize)));
    }

    // checking for limits
    if (height > max_height) height = max_height;
    if (width  > max_width)  width  = max_width;

    rec_rect.SetSize(width, height);

    return rec_rect;
}


wxEvtHandler* IPhyloTreeRenderer::GetEvtHandler()
{
    return this;
}

TVPUnit IPhyloTreeRenderer::GetDefaultNodeSize(CPhyloTreeNode * node)
{
    int         forced_size = (*node)->GetNodeSize();   
    TVPUnit     defNodeSize = 0;

    if (forced_size < 0) { // no hardcoded size         
        if (m_SL->GetBoaNodes() && node->IsLeafEx()) {
            double max_childs_size  = m_SL->SetSize(CPhyloTreeScheme::eMaxChildsNmb);
            double min_childs_size  = m_SL->SetSize(CPhyloTreeScheme::eMinChildsNmb);
            double this_childs_size = (**node).GetLeavesNmb() + 1;

            double min_node_size    = m_SL->SetSize(CPhyloTreeScheme::eMinNodeSize);
            double max_node_size    = m_SL->SetSize(CPhyloTreeScheme::eMaxNodeSize);

            defNodeSize = (TVPUnit) floor( min_node_size + (max_node_size - min_node_size) *
                (log(this_childs_size) - log(min_childs_size)) /
                (log(max_childs_size)  - log(min_childs_size)));
        }
        else {
            defNodeSize = (TVPUnit)m_SL->SetSize(CPhyloTreeScheme::eNodeSize);       
        }
    }
    else {
        defNodeSize = (TVPUnit)forced_size;
    }


    return defNodeSize;
}

TVPUnit IPhyloTreeRenderer::x_NodeSize(CPhyloTreeNode * node)
{
    TVPUnit nodeSize = 0;

    if (m_pPane) {
        TVPUnit defNodeSize = GetDefaultNodeSize(node);

        // boanodes (whatever that stands for)
        // seems to be always false, so this is never executed...
        if ((m_SL->GetBoaNodes() && node->IsLeafEx() && !node->IsLeaf()) || 
            DistanceBetweenNodes()> defNodeSize*2) {
            nodeSize = defNodeSize;
        }
    }
    
    return nodeSize;
}

void IPhyloTreeRenderer::x_DrawNodes(CPhyloTreeNode * node)
{
    for(CPhyloTreeNode::TNodeList_I  it = node->SubNodeBeginEx();
        it != node->SubNodeEnd(); it++ )  x_DrawNodes(static_cast<CPhyloTreeNode*>(*it));

    x_RenderNode(node);
}

void IPhyloTreeRenderer::x_DrawNodesVbo(CPhyloTreeNode* node, CGlVboNode* render_nodes)
{
    for(CPhyloTreeNode::TNodeList_I  it = node->SubNodeBeginEx();
        it != node->SubNodeEnd(); it++ )  x_DrawNodesVbo(static_cast<CPhyloTreeNode*>(*it), render_nodes);

    x_RenderNodeVbo(node, render_nodes);
}



END_NCBI_SCOPE