phylo_tree_pane.cpp

Go to the documentation of this file.

/*  $Id: phylo_tree_pane.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 <corelib/ncbitime.hpp>

#include <gui/widgets/phylo_tree/phylo_tree_pane.hpp>
#include <gui/widgets/phylo_tree/phylo_tree_widget.hpp>
#include <gui/widgets/phylo_tree/phylo_tree_pane.hpp>

#include <gui/widgets/gl/attrib_menu.hpp>   
#include <gui/objutils/registry.hpp>
#include <gui/opengl/glutils.hpp>
#include <corelib/ncbitime.hpp>

#include <wx/wxchar.h>
#include <wx/dcclient.h>

BEGIN_NCBI_SCOPE

#define AXIS_AREA_W 50
#define AXIS_AREA_H 30


BEGIN_EVENT_TABLE(CPhyloTreePane, CGlWidgetPane)
    EVT_SIZE(CPhyloTreePane::OnSize)
    EVT_LEFT_DOWN(CPhyloTreePane::OnLeftDown)
    EVT_PAINT(CPhyloTreePane::OnPaint)
END_EVENT_TABLE()

CPhyloTreePane::CPhyloTreePane(CPhyloTreeWidget * parent)
:   CGlWidgetPane(parent->GetTopLevelPanel(), wxID_ANY, wxDefaultPosition, wxDefaultSize, 0),
    m_CurrRenderer(-1),
    m_pParent(parent),
    m_BackColor(0.95f, 1.0f, 0.95f),
    m_pTextFont(NULL),
    m_pLblFont(NULL),
    m_VertSelHandler(eVert),
    m_BottomRuler(true),
    m_TopRuler(true),
    m_LeftRuler(false),
    m_RightRuler(false),
    m_MouseLeftDownEvent(true)
{
    m_Renderers.clear();
    m_Gen.SetIntegerMode(true, true);
    m_Gen.EnableOneBased(true, true);
    m_Grid.EnableIntegerCentering(true);

    m_pTextFont = new CGlBitmapFont(CGlBitmapFont::eHelvetica12);
    m_pLblFont = new CGlBitmapFont(CGlBitmapFont::eHelvetica10);

    m_TooltipManager.SetHost(static_cast<IStickyTooltipHandlerHost*>(this));
    x_RegisterHandler(dynamic_cast<IGlEventHandler*>(&m_TooltipManager),
        fMatrixArea, &m_MatrixPane);

    m_MouseZoomHandler.SetHost(static_cast<IMouseZoomHandlerHost*>(this));
    x_RegisterHandler(dynamic_cast<IGlEventHandler*>(&m_MouseZoomHandler),
        fMatrixArea, &m_MatrixPane);

    m_MinimapHandler.SetHost(static_cast<IMinimapHandlerHost*>(this));
    x_RegisterHandler(dynamic_cast<IGlEventHandler*>(&m_MinimapHandler),
        fMatrixArea, &m_MatrixPane);

    x_Layout();
    x_SetupAxes();

    CGuiRegistry& gui_reg = CGuiRegistry::GetInstance();

    CGuiRegistry::TReadView view =
            gui_reg.GetReadView("GBENCH.Mouse.ModePhylo");

    std::string pan_mode = view.GetString("Pan");
    if (pan_mode == "lmouse") {
        m_MouseZoomHandler.SetPanMode(CMouseZoomHandler::eLmouse);
    }
    else {
        m_MouseZoomHandler.SetPanMode(CMouseZoomHandler::ePkey);
    }
}

CPhyloTreePane::~CPhyloTreePane()
{
    // delete all installed renderers
    ITERATE(TRenderers, rr, m_Renderers) {
        delete *rr;
    }
    m_Renderers.clear(); 
}


void    CPhyloTreePane::x_SetupAxes()
{
    m_TopRuler.SetHorizontal(true, CRuler::eTop);
    m_RightRuler.SetHorizontal(false, CRuler::eRight);
}


TVPPoint CPhyloTreePane::GetPortSize(void)
{
    return TVPPoint(m_rcMatrix.Width(), m_rcMatrix.Height());
}

void CPhyloTreePane::UpdatePane(const TModelRect& r)
{
    m_MatrixPane.SetModelLimitsRect(r);
    m_MatrixPane.SetVisibleRect(r);
    m_MatrixPane.AdjustToLimits();
}

void CPhyloTreePane::RemoveCurrentDataSource()
{
    // This is for the purpose of cancelling any background jobs
    // dependent on the data source.  We do not re-display base don this.
    if (m_CurrRenderer>=0) {
        GetCurrRenderer()->RemoveCurrentDataSource();
    }
}

void CPhyloTreePane::UpdateDataSource()
{
    if (m_CurrRenderer>=0) {
        GetCurrRenderer()->UpdateDataSource(*x_GetParent()->GetDS(), m_MatrixPane);
    }
}

void    CPhyloTreePane::OnSize(wxSizeEvent& event)
{
    x_Layout();

    event.Skip();
}


void    CPhyloTreePane::x_Render(void)
{    
    if (m_MatrixPane.GetProjMode()!=CGlPane::eNone) {
        // recursive call - something wrong or renderer crashed
        //m_MatrixPane.Close();
        return;
    }
    x_RenderContent();
}


void    CPhyloTreePane::x_OnShowPopup()
{
    x_GetParent()->OnShowPopup();
}


void    CPhyloTreePane::Update()
{
    _ASSERT(x_GetParent());

    if (m_CurrRenderer>=0 && x_GetParent() && x_GetParent()->GetDS()) {
        x_SetupGLContext();
        GetCurrRenderer()->Layout(*x_GetParent()->GetDS(), m_MatrixPane);
        m_NavHistory.Reset(m_MatrixPane);

      
        x_GetParent()->SetPortLimits(m_MatrixPane.GetModelLimitsRect(), true);
    }
}


void    CPhyloTreePane::SoftUpdate()
{
    _ASSERT(x_GetParent());

    if (m_CurrRenderer>=0 && x_GetParent() && x_GetParent()->GetDS()) {
        GetCurrRenderer()->Layout(*x_GetParent()->GetDS(), m_MatrixPane);
        m_NavHistory.Reset(m_MatrixPane);
        x_GetParent()->SetPortLimits(m_MatrixPane.GetModelLimitsRect(), false);
    }
}

const CPhyloTreePane::TRangeColl & CPhyloTreePane::GetSubjectSelection() const
{
    return m_HorzSelHandler.GetSelection();
}


const CPhyloTreePane::TRangeColl & CPhyloTreePane::GetQuerySelection() const
{
    return m_VertSelHandler.GetSelection();
}


CGlPane CPhyloTreePane::TreeNavHistory::Current() const
{ 
    return Empty() ? CGlPane() : m_History[m_BackForwardPos]; 
}

bool CPhyloTreePane::TreeNavHistory::EqualPanes(const CGlPane& lhs, const CGlPane& rhs) const
{
    // compute roughly the pct scrolling that has taken place in order
    // to ignore very (imperceptibly) small changes
    TModelRect l = lhs.GetVisibleRect();
    TModelRect r = rhs.GetVisibleRect();

    float delta = fabs(l.Left() - r.Left()) +
                  fabs(l.Right() - r.Right()) +
                  fabs(l.Top() - r.Top()) +
                  fabs(l.Bottom() - r.Bottom());

    float m = l.Width() + l.Height() + r.Width() + r.Height();

    float delta_pct = delta/m;

    return delta_pct < 0.0001f;        
}

void CPhyloTreePane::TreeNavHistory::Reset(const CGlPane& p) 
{
    m_History.clear(); 
    m_History.push_back(p); 
    m_BackForwardPos = 0;
}

void CPhyloTreePane::TreeNavHistory::Add(const CGlPane& p) 
{
    if (m_BackForwardPos < m_History.size()) {
        m_History.erase(m_History.begin() + m_BackForwardPos +1,
                        m_History.end());
    }
  
    m_History.push_back(p);
    m_BackForwardPos = m_History.size() - 1;
}

void CPhyloTreePane::SaveCurrentView()
{
    if (m_NavHistory.Empty() || 
        !m_NavHistory.EqualPanes(x_GetParent()->GetPort(), m_NavHistory.Current())) {
            m_NavHistory.Add(x_GetParent()->GetPort());
    }
}

bool CPhyloTreePane::CanGoBack() const
{
    return m_NavHistory.CanGoBack();
}


bool CPhyloTreePane::CanGoForward() const
{
    return m_NavHistory.CanGoForward();
}


void CPhyloTreePane::GoBack(void)
{
    if (CanGoBack()) {
        CGlPane p = m_NavHistory.Back();
        //m_MatrixPane = p;
        m_MatrixPane.SetVisibleRect(p.GetVisibleRect());
        m_MatrixPane.SetModelLimitsRect(p.GetModelLimitsRect());
        x_GetParent()->GetPort().SetModelLimitsRect(m_MatrixPane.GetModelLimitsRect());
        x_GetParent()->GetPort().SetVisibleRect(m_MatrixPane.GetVisibleRect());
        x_GetParent()->UpdateViewingArea();
        x_GetParent()->Refresh();
    }
}


void CPhyloTreePane::GoForward(void)
{
    if (CanGoForward()) {
        CGlPane p = m_NavHistory.Forward();
        //m_MatrixPane = p;
        m_MatrixPane.SetVisibleRect(p.GetVisibleRect());
        m_MatrixPane.SetModelLimitsRect(p.GetModelLimitsRect());
        x_GetParent()->GetPort().SetVisibleRect(m_MatrixPane.GetVisibleRect());
        x_GetParent()->UpdateViewingArea();
        x_GetParent()->Refresh();
    }
}


void CPhyloTreePane::x_Layout(void)
{
    TModelRect vis = m_MatrixPane.GetVisibleRect();
    m_rcMatrix.Init(0, 0, GetClientSize().GetWidth(), GetClientSize().GetHeight());    
    m_MatrixPane.SetViewport(m_rcMatrix);

    if (m_CurrRenderer >= 0 && x_GetParent()->GetDS() != NULL) {
        m_MatrixPane.SetVisibleRect(vis);
        GetCurrRenderer()->ComputeViewingLimits(m_MatrixPane);
        x_GetParent()->SetPortLimits(m_MatrixPane.GetModelLimitsRect(), false);
    }

    m_NavHistory.Reset(m_MatrixPane);
}

void    CPhyloTreePane::SetupHardcopyRender()
{
    if (m_CurrRenderer >= 0  &&
        m_CurrRenderer < (int)m_Renderers.size() &&
        x_GetParent()->GetDS()){
        m_Renderers[m_CurrRenderer]->ComputeViewingLimits(
            m_MatrixPane, false);
    }
}

void CPhyloTreePane::RenderCurrent(void)
{
    if (m_CurrRenderer >= 0  &&
        m_CurrRenderer < (int)m_Renderers.size() &&
        x_GetParent()->GetDS()){
        m_Renderers[m_CurrRenderer]->RenderForHardcopy(
            m_MatrixPane, *x_GetParent()->GetDS());
    }
}

void CPhyloTreePane::BufferedRender(void)
{
    if (m_CurrRenderer >= 0  &&
        m_CurrRenderer < (int)m_Renderers.size() &&
        x_GetParent()->GetDS()){
        m_Renderers[m_CurrRenderer]->BufferedRender(
            m_MatrixPane, *x_GetParent()->GetDS());
    }
}

// We override the base class version only because we want to be
// able to Not call SwapBuffers() since x_Render() will sometimes
// not draw because synchronization is in progress in
// the particle system thread.  And if you don't draw, you can't 
// call SwapBuffers().
void CPhyloTreePane::OnPaint( wxPaintEvent& WXUNUSED(event) )
{
    //LOG_POST("CGLCanvas::OnPaint()");

    // This is a dummy, to avoid an endless succession of paint messages.
    // OnPaint handlers must always create a wxPaintDC.
    wxPaintDC dc(this);

    // The hack is used for tooltip window
    // SwapBuffers ovewrites child windows on some systems
    // Ubuntu with Intel videocard (netbook).
    if (m_DoNotUpdate) {
        m_DoNotUpdate = false;
        return;
    }

    x_SetupGLContext();
    x_Render();

    // Move swapbuffers() to x_Render() and only call
    // it if the rendering is actually completed.
}

void    CPhyloTreePane::x_RenderContent(void)
{
    if(x_GetParent()) {
        CStopWatch sw;
        sw.Start();

        CRgbaColor bg(1.0f, 1.0f, 1.0f, 1.0f);
        if (x_GetParent()->HasScheme())
            bg = x_GetParent()->GetScheme().SetColor(
                CPhyloTreeScheme::eTree, CPhyloTreeScheme::eBgColor);
        glClearColor(bg.GetRed(), bg.GetGreen(), bg.GetBlue(), bg.GetAlpha());    
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

        // Make sure layout has been called (special case for first-time render
        // of newly created view)
        if (m_CurrRenderer >= 0  &&
            m_CurrRenderer < (int)m_Renderers.size() &&
            x_GetParent()->GetDS()){
                if ( m_Renderers[m_CurrRenderer]->ValidLayout() == 
                     IPhyloTreeRenderer::eNeedLayout ) 
                    SoftUpdate();
                else if ( m_Renderers[m_CurrRenderer]->ValidLayout() == 
                          IPhyloTreeRenderer::eNeedLayoutAndSize ) 
                    Update();
        }

        const CGlPane& VP = x_GetParent()->GetPort();

        // prepare CGlPanes

        // The limits rect is set in Layout() and OnSize().  But
        // we need updates to the visible rect since it captures
        // zoom.  Not sure why the design called for a CGlPane in
        // both this (CPhyloTreePane) and CPhyloTreeWidget, forcing
        // us to keep them in sync.....
        TModelRect rc_V = VP.GetVisibleRect();
        m_MatrixPane.SetVisibleRect(rc_V);
        m_MatrixPane.SetModelLimitsRect( VP.GetModelLimitsRect() );

        // now rendering

        if (m_CurrRenderer >= 0  &&
            m_CurrRenderer < (int)m_Renderers.size() &&
            x_GetParent()->GetDS()){

                /// Stop rendering if Render() returns false (can return false
                /// in force layout due to active data synchronization)
                if (!m_Renderers[m_CurrRenderer]->Render(
                    m_MatrixPane, *x_GetParent()->GetDS())) {
                        return;
                }           
        }

        x_RenderMouseZoomHandler(m_MatrixPane);
#ifdef ATTRIB_MENU_SUPPORT
        CAttribMenuInstance::GetInstance().DrawMenu();
#endif


    }

    if (m_MouseLeftDownEvent) {
         m_MouseLeftDownEvent= false;
         m_TooltipManager.ParentShow(false);
         m_TooltipManager.ParentShow(true);
    }

    // Move swapbuffers code from glcanvas basecalss to here because
    // Render() may return false from the force layout in which case
    // it returns before reaching here.
#if defined __WXMSW__
    ShowCursor(false);
#endif

    SwapBuffers();

#if defined __WXMSW__
    ShowCursor(true);
#endif
}


void    CPhyloTreePane::x_AdjsutToMasterPane(CGlPane& pane,
                                             bool b_model_x,
                                             bool b_model_y)
{
    const CGlPane& VP = x_GetParent()->GetPort();

    TModelRect rc_vis = VP.GetVisibleRect();
    TModelRect rc_lim = VP.GetModelLimitsRect();

    // assuming that Viewport in the pane has been set properly
    if(! b_model_x) { // adjust horz range to represent pixels
        int max_x = pane.GetViewport().Width() - 1;
        rc_lim.SetHorz(0, max_x);
        rc_vis.SetHorz(0, max_x);
    }

    if(! b_model_y) { // adjust vert range to represent pixels
        int max_y = pane.GetViewport().Height() - 1;
        rc_lim.SetVert(0, max_y);
        rc_vis.SetVert(0, max_y);
    }
    pane.SetModelLimitsRect(rc_lim);
    pane.SetVisibleRect(rc_vis);
}

int     CPhyloTreePane::x_GetAreaByVPPos(TVPUnit vp_x, TVPUnit vp_y)
{
    if(m_rcMatrix.PtInRect(vp_x, vp_y)) {
        return fMatrixArea;
    } else if(m_rcBottomSeq.PtInRect(vp_x, vp_y)) {
        return fSubjectArea;
    } else if(m_rcLeftSeq.PtInRect(vp_x, vp_y)) {
        return fQueryArea;
    }
    return fOther;
}

void    CPhyloTreePane::x_RenderMouseZoomHandler(CGlPane& pane)
{
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    m_MouseZoomHandler.Render(pane);
    m_MinimapHandler.Render(pane);


    glDisable(GL_BLEND);
}

void    CPhyloTreePane::x_RenderSelHandler(bool b_horz,
                                           CGlPane& pane,
                                           CLinearSelHandler::ERenderingOption option)
{
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    CLinearSelHandler& handler = b_horz ? m_HorzSelHandler : m_VertSelHandler;
    handler.Render(pane, option);

    glDisable(GL_BLEND);

}

bool CPhyloTreePane::x_GrabFocus()
{
    // Grab the focus unless user is in a text control.  This is primarly here
    // for the case where the user is typing in the search control, and may use
    // the mouse to move the cursor around.  We do not want to lose focus for
    // the text control in this case.
    if ( CGlWidgetPane::x_GrabFocus() )
        return true;

    return false;

    // Maybe not - I think you only want to take focus from certain controls, 
    // such as maybe those (other than the text edit control) in the search bar.
    /*
    wxWindow* w = wxWindow::FindFocus();

    if (w != NULL) {
        //_TRACE("Focus Parent: " << w->GetClassInfo()->GetClassName()    << " " << w->GetName());
    
        if (wxString(w->GetClassInfo()->GetClassName()) == wxT("wxTextCtrl") ||
            wxString(w->GetClassInfo()->GetClassName()) == wxT("wxRichTextCtrl") ||
            wxString(w->GetClassInfo()->GetClassName()) == wxT("wxComboBox"))
            return false;
    }    

    return true;    
    */
}
////////////////////////////////////////////////////////////////////////////////
/// IAlnMarkHandlerHost implementation

TModelUnit  CPhyloTreePane::MZHH_GetScale(EScaleType type)
{
    const CGlPane& VP = x_GetParent()->GetPort();

    switch(type)    {
    case IMouseZoomHandlerHost::eCurrent:   {
        return x_GetParent()->GetScheme().GetZoomBehavior()==CPhyloTreeScheme::eZoomY ?
            VP.GetScaleY() : VP.GetScaleX();
    }
    case IMouseZoomHandlerHost::eMin: {
        return x_GetParent()->GetScheme().GetZoomBehavior()==CPhyloTreeScheme::eZoomY?
            VP.GetMinScaleY() : VP.GetMinScaleX();
    }
    case IMouseZoomHandlerHost::eMax:  {
        return x_GetParent()->GetScheme().GetZoomBehavior()==CPhyloTreeScheme::eZoomY?
            VP.GetZoomAllScaleY() : VP.GetZoomAllScaleX();
    }
    default: _ASSERT(false); return -1;
    }
}

void    CPhyloTreePane::MZHH_SetScale(TModelUnit scale,
                                      const TModelPoint& point)
{
    x_GetParent()->OnSetScaleXY(scale, point);
}

void     CPhyloTreePane::MZHH_ZoomRect(const TModelRect& rc)
{
    x_GetParent()->ZoomRect(rc);
}


void     CPhyloTreePane::MZHH_ZoomPoint(const TModelPoint& point,
                                        TModelUnit factor)
{
    x_GetParent()->ZoomPoint(point, factor);
}


void     CPhyloTreePane::MZHH_EndOp()
{
    SaveCurrentView();
}


void     CPhyloTreePane::MZHH_Scroll(TModelUnit d_x, TModelUnit d_y)
{
    x_GetParent()->Scroll(d_x, d_y);
}


TVPUnit  CPhyloTreePane::MZHH_GetVPPosByY(int y) const
{
    return GetClientSize().GetHeight() - 1  - y;
}





TVPUnit  CPhyloTreePane::HMGH_GetVPPosByY(int y) const
{
    return GetClientSize().GetHeight() - 1  - y;
}



void    CPhyloTreePane::HMGH_UpdateLimits(bool force_redraw)
{
    _ASSERT(x_GetParent());

    if (m_CurrRenderer>=0 && x_GetParent() && x_GetParent()->GetDS()) {       
        x_GetParent()->GetPort().SetModelLimitsRect(m_MatrixPane.GetModelLimitsRect());
        x_GetParent()->GetPort().SetVisibleRect(m_MatrixPane.GetVisibleRect());
        x_GetParent()->UpdateViewingArea();            

        if ( force_redraw) {
            x_GetParent()->Refresh();
        }

        m_NavHistory.Reset(m_MatrixPane);
    }
}



////////////////////////////////////////////////////////////////////////////////
/// ISelHandlerHost implementation


void CPhyloTreePane::SHH_OnChanged()
{
    CEvent evt(CEvent::eEvent_Message, CViewEvent::eWidgetSelectionChanged);
    Send(&evt, ePool_Parent);
    
    Refresh();
}

void CPhyloTreePane::SHH_SetCursor(const wxCursor& cursor)
{
    SetCursor(cursor);
}


TModelUnit  CPhyloTreePane::SHH_GetModelByWindow(int z, EOrientation orient)
{
    switch(orient)  {
    case eHorz: return m_MatrixPane.UnProjectX(z);
    case eVert: return m_MatrixPane.UnProjectY(GetClientSize().GetHeight() - z);
    default:    _ASSERT(false); return -1;
    }
}


TVPUnit     CPhyloTreePane::SHH_GetWindowByModel(TModelUnit z, EOrientation orient)
{
    switch(orient)  {
    case eHorz: return m_MatrixPane.ProjectX(z);
    case eVert: return GetClientSize().GetHeight() - m_MatrixPane.ProjectY(z);
    default:    _ASSERT(false); return -1;
    }
}


void CPhyloTreePane::AddRenderer(IPhyloTreeRenderer * renderer)
{
    renderer->SetZoomHandler(&m_MouseZoomHandler);
    renderer->SetFont(m_pLblFont);
    renderer->SetSimplification(false);
    renderer->SetAdaptiveMargins(true);
    //renderer->SetSplinesRendering(true);
    renderer->SetRegenerateTexture(true);
    renderer->SetZoomablePrimitives(false);
    renderer->SetRenderingOption(IPhyloTreeRenderer::eAutofitLabels, true);

    m_Renderers.push_back(renderer);

    renderer->SetHost(static_cast<IPhyloTreeRendererHost*>(this));

    if (m_CurrRenderer<0) SetCurrRendererIdx(0);
}


void CPhyloTreePane::SetCurrRendererIdx(Int4 idx)
{
    if (m_CurrRenderer != idx) {
        if (m_CurrRenderer>=0) {
            x_UnregisterHandler(dynamic_cast<IGlEventHandler*>(GetCurrRenderer()));
        }

        if (m_CurrRenderer >= 0)
            m_Renderers[m_CurrRenderer]->StartRendering(false);
        m_CurrRenderer = idx;
        m_Renderers[m_CurrRenderer]->StartRendering(true);

        if (m_MouseZoomHandler.GetPanMode() == CMouseZoomHandler::eLmouse) {
            x_RegisterHandler(dynamic_cast<IGlEventHandler*>(GetCurrRenderer()),
                fMatrixArea, &m_MatrixPane, 1);
        }
        else {
            x_RegisterHandler(dynamic_cast<IGlEventHandler*>(GetCurrRenderer()),
                fMatrixArea, &m_MatrixPane);
        }
    }
}

void CPhyloTreePane::x_SendCommand(TCmdID cmd)
{
    CEventHandler* target = dynamic_cast<CEventHandler*>(x_GetParent());
    if(target)  {
        target->OnCommand(cmd);
    }
}

string  CPhyloTreePane::TTHH_NeedTooltip(const wxPoint & pt)
{
    return GetCurrRenderer()->TTHH_NeedTooltip(pt);
}

CTooltipInfo  CPhyloTreePane::TTHH_GetTooltip(const wxRect & rect)
{
    return GetCurrRenderer()->TTHH_GetTooltip(rect);
}

void  CPhyloTreePane::FireCBEvent(void)
{
    m_pParent->SendSelChangedEvent();
}

void  CPhyloTreePane::FireEditEvent(void)
{
    m_pParent->SendEditEvent();
}

TModelUnit  CPhyloTreePane::MMHH_GetScale(EMMScaleType type)
{
    const CGlPane& VP = x_GetParent()->GetPort();

    switch(type)    {
    case IMinimapHandlerHost::eCurrent:   return VP.GetScaleX();
    case IMinimapHandlerHost::eMin: return VP.GetMinScaleX();
    case IMinimapHandlerHost::eMax: return VP.GetZoomAllScaleX();
    default: _ASSERT(false); return -1;
    }
}

void     CPhyloTreePane::MMHH_EndOp()
{
    SaveCurrentView();
}


void     CPhyloTreePane::MMHH_Scroll(TModelUnit d_x, TModelUnit d_y)
{
    x_GetParent()->Scroll(d_x, d_y);
}


TVPUnit  CPhyloTreePane::MMHH_GetVPPosByY(int y) const
{
    return GetClientSize().GetHeight() - 1  - y;
}


CGlTexture* CPhyloTreePane::MMHH_GetTexture(float& xcoord_limit,
                                            float& ycoord_limit)
{
    return GetCurrRenderer()->GetTexture(xcoord_limit, ycoord_limit);
}


void CPhyloTreePane::HMGH_OnChanged(void)
{
    Refresh();
    x_GetParent()->SendSelChangedEvent();
}

void CPhyloTreePane::HMGH_OnRefresh(void)
{
    Refresh();
}

void CPhyloTreePane::OnLeftDown(wxMouseEvent& evt)
{   
    SetFocus();
    
    bool handled = false; 

    if(m_pCurrHandlerRec)  {               
        _TRACE("h: " << (void*)dynamic_cast<CMouseZoomHandler*>(m_pCurrHandlerRec->m_pHandler) << " scale Mode: " << m_MouseZoomHandler.IsScaleMode() );

        if (dynamic_cast<CMouseZoomHandler*>(m_pCurrHandlerRec->m_pHandler) != NULL &&
            m_MouseZoomHandler.IsScaleMode()) {
            handled = x_DispatchEventToHandler(evt, m_pCurrHandlerRec);
        }
    }    

    if (!handled) {
        wxPoint pos = evt.GetPosition();
        int area = x_GetAreaByWindowPos(pos);
        if( ! x_Handlers_handle(evt, area)) {
            evt.Skip();
        }
    }

    // For some reaon on the mac, and with the phylo_tree drawing (not other views), after
    // a dialog is shown or after the window is re-docked, the next left-mouse-down event
    // can cause tooltips to disappear.  The way to get the tips back is by doing a hide-show
    // pair of calls.  We do this for every left mouse down on mac since we don't know in
    // in all cases which ones come after dialog events (and they are not visible to the
    // user anyway). The cause of the bug itself is undetermined - perhaps something simiar
    // to an activation event which can cause the same problem (on mac)
#if defined(__WXOSX_CARBON__) || defined(__WXMAC_CARBON__)
    m_MouseLeftDownEvent = true;
#endif
}

END_NCBI_SCOPE