src/gui/widgets/aln_crossaln/cross_aln_pane.cpp

Go to the documentation of this file.

/*  $Id: cross_aln_pane.cpp 14858 2007-08-25 16:22:34Z dicuccio $
 * ===========================================================================
 *
 *                            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:  Vlad Lebedev
 *
 */


#include <ncbi_pch.hpp>
#include "cross_aln_pane.hpp"

#include <gui/utils/fltk_utils.hpp>

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

#include <FL/glut.H>
#include <FL/fl_draw.H>


BEGIN_NCBI_SCOPE


const TModelUnit kMouseZoomFactor = 25.0;   // per pixel of mouse movement


CCrossAlnPane::CCrossAlnPane(int x, int y, int w, int h, const char* label)
    : CGlPaneWidgetChild(x, y, w, h, label)
{
    m_pCurrHandler = NULL;
    m_Renderer.Reset(new CCrossAlnRenderer());


    m_MouseZoomHandler.SetMode(CMouseZoomHandler::eHorz);
    m_MouseZoomHandler.SetHost(static_cast<IMouseZoomHandlerHost*>(this));

    m_SelHandler_Q.SetHost(static_cast<ISelHandlerHost*>(this));
    m_SelHandler_S.SetHost(static_cast<ISelHandlerHost*>(this));

    // Now register handlers with their designated areas
    x_AddHandler(dynamic_cast<IGlEventHandler*>(&m_MouseZoomHandler), fAllAreas);
    x_AddHandler(dynamic_cast<IGlEventHandler*>(&m_SelHandler_Q), fRuler1Area);
    x_AddHandler(dynamic_cast<IGlEventHandler*>(&m_SelHandler_S), fRuler2Area);

    // Finally, add self for all unhandled events
    x_AddHandler(dynamic_cast<IGlEventHandler*>(this), fAllAreas);

    m_Tooltip.EnableActiveMode(static_cast<ITooltipClient*>(this));
    m_Tooltip.SetMode(CTooltip::eHideOnMove);

    m_Event.StandardConfig();
}


CCrossAlnPane::~CCrossAlnPane()
{
}


// CGlPaneWidgetChild requirements
TVPPoint CCrossAlnPane::GetPortSize(void)
{
    return TVPPoint(0,0);
}


void CCrossAlnPane::SetDataSource(ICrossAlnDataSource* ds)
{
    //TVPRect rc(5, 5, w() - 5, h() - 5);
    TVPRect rc(0, 0, w(), h());

    m_SelHandler_Q.ResetSelection(false);
    m_SelHandler_S.ResetSelection(false);

    ResetObjectSelection();

    m_Renderer->SetDataSource(rc, ds);
    m_DS.Reset(ds);

    Update();
}


void CCrossAlnPane::SetWidget(CCrossAlnWidget* pParent)
{
    if(m_pParent)   { // disconnect old parent
        RemoveListener(m_pParent);
    }

    m_pParent = pParent;

    if(m_pParent)   {
        AddListener(m_pParent, ePool_Parent);
    }
}


ICrossAlnDataSource* CCrossAlnPane::GetDataSource()
{
    return m_DS;
}


void CCrossAlnPane::ColorBySegments()
{
    m_Renderer->ColorBySegments();

    redraw();
}


void CCrossAlnPane::ColorByScore(CConstRef<CObject_id> score_id)
{
    m_Renderer->ColorByScore(score_id);

    redraw();
}


CConstRef<CObject_id> CCrossAlnPane::GetScoreId() const
{
    return m_Renderer->GetScoreId();
}


void CCrossAlnPane::ResetObjectSelection()
{
    m_Renderer->ResetObjectSelection();

    redraw();
}


void CCrossAlnPane::GetObjectSelection(TConstObjects& objs) const
{
    m_Renderer->GetObjectSelection(objs);
}


void CCrossAlnPane::SetObjectSelection(const vector<const CSeq_align*> sel_aligns)
{
    m_Renderer->SetObjectSelection(sel_aligns);

    redraw();
}



const CCrossAlnPane::TRangeColl& CCrossAlnPane::GetQueryRangeSelection() const
{
    return m_SelHandler_Q.GetSelection();
}


const CCrossAlnPane::TRangeColl& CCrossAlnPane::GetSubjectRangeSelection() const
{
    return m_SelHandler_S.GetSelection();
}


void CCrossAlnPane::SetQueryRangeSelection(const TRangeColl& coll)
{
    m_SelHandler_Q.SetSelection(coll, true);
}


void CCrossAlnPane::SetSubjectRangeSelection(const TRangeColl& coll)
{
    m_SelHandler_S.SetSelection(coll, true);
}


void CCrossAlnPane::Update()
{
    m_Renderer->Update();

    invalidate();
    redraw();
}



void CCrossAlnPane::x_AdjustScrollBars(void)
{
    CScrollbar* scrollX_Q = (CScrollbar*)(parent()->child(0));
    CScrollbar* scrollX_S = (CScrollbar*)(parent()->child(1));

    scrollX_Q->SetListener(NULL);
    scrollX_S->SetListener(NULL);

    const TModelRect& rcVQ = m_Renderer->GetRP_Q().GetVisibleRect();
    const TModelRect& rcMQ = m_Renderer->GetRP_Q().GetModelLimitsRect();

    const TModelRect& rcVS = m_Renderer->GetRP_S().GetVisibleRect();
    const TModelRect& rcMS = m_Renderer->GetRP_S().GetModelLimitsRect();

    TModelUnit page_size_q = min(rcVQ.Right() - rcVQ.Left(), rcMQ.Right());
    TModelUnit page_size_s = min(rcVS.Right() - rcVS.Left(), rcMS.Right());

    scrollX_Q->SetRange( int(rcMQ.Left()), int(rcMQ.Right()) );
    scrollX_Q->SetPageSize( int(page_size_q) );
    scrollX_Q->SetValue( int(rcVQ.Left()) );

    scrollX_Q->SetLineInc( int(m_Renderer->GetScrollLineSize_Q()) );
    scrollX_Q->SetPageInc( int(m_Renderer->GetScrollLineSize_Q() * 10) );

    scrollX_S->SetRange( int(rcMS.Left()), int(rcMS.Right()) );
    scrollX_S->SetPageSize( int(page_size_s) );
    scrollX_S->SetValue( int(rcVS.Left()) );


    scrollX_S->SetLineInc( int(m_Renderer->GetScrollLineSize_S()) );
    scrollX_S->SetPageInc( int(m_Renderer->GetScrollLineSize_S() * 10) );

    scrollX_Q->SetListener(m_pParent);
    scrollX_S->SetListener(m_pParent);
}


// virtual from CGlPaneWidgetChild
int CCrossAlnPane::x_GetAreaByVPPos(int vp_x, int vp_y)
{
    if(m_Renderer->GetRP_Q().GetViewport().PtInRect(vp_x, vp_y)) {
        return fRuler1Area;
    } else if(m_Renderer->GetRP_S().GetViewport().PtInRect(vp_x, vp_y)) {
        return fRuler2Area;
    } else {
        return fCrossAlign;
    }
    return fOther;
}


int CCrossAlnPane::x_SetAlignAreaByVPPos(int vp_x, int vp_y)
{
    TVPRect rc = m_Renderer->GetCP().GetViewport();
    TVPUnit hg = rc.Height() / 2;

    // Upper and lower halfs of the pane
    TVPRect rcDown = TVPRect( rc.Left(), rc.Bottom(),
                              rc.Right(), rc.Top() - hg);
    TVPRect rcUp = TVPRect( rc.Left(), rc.Bottom() + hg,
                            rc.Right(), rc.Top() );

    if (rcUp.PtInRect(vp_x, vp_y)) {
        return fCrossAlignArea2;
    }

    if (rcDown.PtInRect(vp_x, vp_y)) {
        return fCrossAlignArea1;
    }

    return fOther;
}


void CCrossAlnPane::x_OnShowPopup()
{
    x_GetParent()->OnShowPopup();
    //CEvent evt(eShowPopup);
    //Send(&evt, eDispatch_Default, ePool_Parent);
}


void CCrossAlnPane::x_Render()
{
    if (!valid()) {
        TVPRect rc(0, 0, w(), h()); //TVPRect rc(5, 5, w() - 5, h() - 5);
        m_Renderer->resize(rc);
    }

    glClearColor(1, 1, 1, 0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    if ( !m_DS ) {
        return;
    }

    m_Renderer->draw();

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

    // ZoomHandler indicator
    m_MouseZoomHandler.Render(m_Renderer->GetRP_S());
    m_MouseZoomHandler.Render(m_Renderer->GetCP());
    m_MouseZoomHandler.Render(m_Renderer->GetRP_S());

    // draw linear selection
    m_SelHandler_Q.Render(m_Renderer->GetRP_Q());
    m_SelHandler_S.Render(m_Renderer->GetRP_S());

    glDisable(GL_BLEND);

    x_AdjustScrollBars();
}



void CCrossAlnPane::x_AddHandler(IGlEventHandler* handler, int area)
{
    _ASSERT(handler  &&  area);

    m_lsHandlers.push_back(make_pair(handler, area));
}

int CCrossAlnPane::handle(CGUIEvent& event, CGlPane& pane)
{
    int res = 0;
    switch(event.GetFLTKEvent())   {
    case FL_PUSH:    res =  x_OnMousePush(event); break;
    case FL_DRAG:    res =  x_OnMouseDrag(event); break;
    case FL_RELEASE: res =  x_OnMouseRelease(event); break;
    case FL_MOVE:    res =  x_OnMouseMove(); break;
    case FL_KEYDOWN: res =  x_OnKeyDown(event); break;
    case FL_KEYUP:   res =  x_OnKeyUp(); break;
    }

    m_Tooltip.Handle(event.GetFLTKEvent());
    return res;
}


////////////////////////////////////////////////////////////////////////////////
/// event handlers
int CCrossAlnPane::x_OnKeyDown(CGUIEvent& event)
{
    return 0;
}

int CCrossAlnPane::x_OnKeyUp(void)
{
    return 0;
}

int CCrossAlnPane::x_OnMousePush(CGUIEvent& event)
{
    CGUIEvent::EGUIState  state  = event.GetGUIState();

    if ((state == CGUIEvent::eSelectState  ||  state == CGUIEvent::eSelectIncState)
        && event.GetGUISignal() == CGUIEvent::eSelectSignal)
    {
        int x = Fl::event_x();
        int y = h() - Fl::event_y();

        m_PushArea = static_cast<EHandlerArea>(x_GetAreaByWindowPos(
                        Fl::event_x(), Fl::event_y()));

        m_CrossAlnHalf = static_cast<EHandlerArea>(x_SetAlignAreaByVPPos(
                        Fl::event_x(), Fl::event_y()));

        if (m_PushArea == fCrossAlign) {
            TRangeColl coll_q = m_SelHandler_Q.GetSelection();
            TRangeColl coll_s = m_SelHandler_S.GetSelection();
            // Distinguish selection and incremental selection
            if (state == CGUIEvent::eSelectState) {
                ResetObjectSelection();
                coll_q.clear();
                coll_s.clear();
            }

            // double click zooms on the feature/alignment/etc
            if (Fl::event_clicks()) {
                TModelRect rc = m_Renderer->HitTest(x, y);
                //ZoomOnRect(rc);
                SquareOnRect(rc);
            } else {
                TModelRect rc = m_Renderer->SelectHitTest(x, y);

                coll_q.CombineWith(TSeqRange(TSeqPos(rc.Left()),
                                   TSeqPos(rc.Right()-1)));
                coll_s.CombineWith(TSeqRange(TSeqPos(rc.Bottom()),
                                             TSeqPos(rc.Top()-1)));

                m_SelHandler_Q.SetSelection(coll_q, true);
                m_SelHandler_S.SetSelection(coll_s, true);

                // broadcast selection change
                CEvent evt(CEvent::eEvent_Message, CViewEvent::eWidgetSelectionChanged);
                Send(&evt, CEventHandler::eDispatch_Default,
                                CEventHandler::ePool_Parent);
            }

            redraw();
            return 1;
        } // ignore rulers
    } // selection events only
    return 0;
}

int CCrossAlnPane::x_OnMouseMove(void)
{
    return 0;
}

int CCrossAlnPane::x_OnMouseDrag(CGUIEvent& event)
{
    return 1; // always handle drags
}

int CCrossAlnPane::x_OnMouseRelease(CGUIEvent& event)
{
    return 0;
}


// event handling starts here
int CCrossAlnPane::handle(int event)
{
    if(event == FL_KEYDOWN  &&  Fl::event_key() == FL_Tab)  {
        return 0; // ignore
    }
    m_Event.OnFLTKEvent(event);

    int res = 0;
    switch(event)   {
    case FL_FOCUS:
    case FL_UNFOCUS:    redraw(); return 1;
    case FL_KEYDOWN:
    case FL_KEYUP:      res = x_HandleKeyEvent();     break;
    case FL_MOVE:       res = x_HandleMouseMove();    break;
    case FL_PUSH:       res = x_HandleMousePush();    break;
    case FL_DRAG:       res = x_HandleMouseDrag();    break;
    case FL_RELEASE:    res = x_HandleMouseRelease(); break;
    case FL_MOUSEWHEEL: res = x_HandleMouseWheel();   break;
    default:            res = CGlCanvas::handle(event);
    }

    return res;
}


int CCrossAlnPane::x_HandleKeyEvent()
{
    IGlEventHandler* pH = NULL; //dummy
    m_PushArea = static_cast<EHandlerArea>(x_GetAreaByWindowPos(
                        Fl::event_x(), Fl::event_y()));

    int res = x_Handlers_handle(m_PushArea, pH, false);

    if (res == 0  &&  m_Event.GetFLTKEvent() == FL_KEYDOWN) {
        switch(m_Event.GetGUISignal()) {
        case CGUIEvent::eZoomInSignal:  ZoomIn(); break;
        case CGUIEvent::eZoomOutSignal: ZoomOut(); break;
        case CGUIEvent::eZoomAllSignal: ZoomAll(); break;
        default: break;
        }
    }

    return res;
}


int CCrossAlnPane::x_HandleMouseMove()
{
    int res = 0;
    IGlEventHandler* pH = NULL; //dummy

    m_PushArea = static_cast<EHandlerArea>(x_GetAreaByWindowPos(
                        Fl::event_x(), Fl::event_y()));
    res = x_Handlers_handle(m_PushArea, pH);

    if(res == 0)    {
        fl_cursor(FL_CURSOR_DEFAULT, FL_BLACK, FL_WHITE);
    }

    m_pCurrHandler = NULL;
    return res;
}



int CCrossAlnPane::x_HandleMousePush()
{
    if(Fl::focus() != static_cast<Fl_Widget*>(this))    {
        take_focus();
        m_Event.OnFLTKEvent(FL_PUSH); // restore event state after focus handling
    }

    int res = 0;
    if(m_Event.GetGUISignal() == CGUIEvent::ePopupSignal)   {
        x_OnShowPopup();
        res = 1;
    } else {
        IGlEventHandler* pH = NULL; //dummy

        m_PushArea = static_cast<EHandlerArea>(x_GetAreaByWindowPos(
                        Fl::event_x(), Fl::event_y()));

        m_CrossAlnHalf = static_cast<EHandlerArea>(x_SetAlignAreaByVPPos(
                        Fl::event_x(), Fl::event_y()));

        res = x_Handlers_handle(m_PushArea, pH, true);

        m_pCurrHandler = pH;
    }
    if(res == 0)    {
        fl_cursor(FL_CURSOR_DEFAULT, FL_BLACK, FL_WHITE);
    }
    return res;
}


int CCrossAlnPane::x_HandleMouseDrag()
{
    int res = 0;
    if(m_pCurrHandler)  {
        res = m_pCurrHandler->handle(m_Event, m_CurrPane);
    }
    if(res ==0) {
        fl_cursor(FL_CURSOR_DEFAULT, FL_BLACK, FL_WHITE);
    }
    return res;
}


int CCrossAlnPane::x_HandleMouseRelease()
{
    if(m_Event.GetGUISignal() == CGUIEvent::ePopupSignal)   {
        x_OnShowPopup();
        return 1;
    } else return x_HandleMouseDrag();
}


int CCrossAlnPane::x_HandleMouseWheel()
{
    IGlEventHandler* pH = NULL; //dummy
    int res = x_Handlers_handle(fAllAreas, pH, false);
    if(! res)   {
        int d_x = Fl::event_dx();
        Scroll((TModelUnit) d_x, 0);
    }
    return res;
}


int CCrossAlnPane::x_Handlers_handle(int area,
                    IGlEventHandler*& handler, bool ignore_curr)
{
    int res = 0;

    switch (area) {
    case fRuler1Area:
        m_CurrPane = m_Renderer->GetRP_Q();
        break;
    case fRuler2Area:
        m_CurrPane = m_Renderer->GetRP_S();
        break;
    case fCrossAlign:
        if (m_CrossAlnHalf == fCrossAlignArea1)
                m_CurrPane = m_Renderer->GetRP_Q();
        if (m_CrossAlnHalf == fCrossAlignArea2)
                m_CurrPane = m_Renderer->GetRP_S();
        break;
    case fAllAreas:
    default:
        m_CurrPane = m_Renderer->GetCP();
    }


    IGlEventHandler* pFirst = ignore_curr ? NULL : m_pCurrHandler;
    if (pFirst)  {
        handler = m_pCurrHandler;
        res = m_pCurrHandler->handle(m_Event, m_CurrPane);
    }

    if (res == 0)    { // not handles by pFirst - iterate through over handlers
        NON_CONST_ITERATE(THandlerList, it, m_lsHandlers) {
            handler = it->first;
            if ( (it->second & area)  &&  (handler != pFirst) )    {
                res = handler->handle(m_Event, m_CurrPane);
                if (res) break;
            }
        }
    }
    if (res == 0)    handler = NULL;
    return res;
}




// IMouseZoomHandlerHost implementation
TModelUnit CCrossAlnPane::MZHH_GetScale(EScaleType type)
{
    m_CrossAlnHalf = static_cast<EHandlerArea>(x_SetAlignAreaByVPPos(
                        Fl::event_x(), Fl::event_y()));

    if (m_CrossAlnHalf == fCrossAlignArea1) {
        switch(type) {
        case eCurrent: return m_Renderer->GetRP_Q().GetScaleX();
        case eMin:     return m_Renderer->GetRP_Q().GetMinScaleX();
        case eMax:     return m_Renderer->GetRP_Q().GetZoomAllScaleX();
        default: _ASSERT(false); return -1;
        }
    } else {
        switch(type) {
        case eCurrent: return m_Renderer->GetRP_S().GetScaleX();
        case eMin:     return m_Renderer->GetRP_S().GetMinScaleX();
        case eMax:     return m_Renderer->GetRP_S().GetZoomAllScaleX();
        default: _ASSERT(false); return -1;
        }
    }
}


void CCrossAlnPane::MZHH_SetScale(TModelUnit scale, const TModelPoint& point)
{
    TModelUnit scale_y_q = m_Renderer->GetRP_Q().GetScaleY();
    TModelUnit scale_y_s = m_Renderer->GetRP_S().GetScaleY();

    if (!Fl::event_shift()) {
        TModelUnit sc_x1 = m_Renderer->GetRP_Q().GetScaleX();
        TModelUnit sc_x2 = m_Renderer->GetRP_S().GetScaleX();

        TModelUnit scale1, scale2;
        TModelPoint point1, point2;
        if (m_CrossAlnHalf == fCrossAlignArea1) {
            scale1 = scale;
            point1 = point;
            scale2 = scale1 * sc_x2 / sc_x1;

            // Re-project point from one pane to another
            TVPUnit tmp_vp = m_Renderer->GetRP_Q().ProjectX( point.X() );
            TModelUnit tmp_mu = m_Renderer->GetRP_S().UnProjectX( tmp_vp );
            point2 = TModelPoint(tmp_mu, point.Y());
        } else {
            scale2 = scale;
            scale1 = scale2 * sc_x1 / sc_x2;
            point2 = point;

            // Re-project point from one pane to another
            TVPUnit tmp_vp = m_Renderer->GetRP_S().ProjectX( point.X() );
            TModelUnit tmp_mu = m_Renderer->GetRP_Q().UnProjectX( tmp_vp );
            point1 = TModelPoint(tmp_mu, point.Y());
        }

        m_Renderer->SetScaleRef_Q(scale1, scale_y_q, point1);
        m_Renderer->SetScaleRef_S(scale2, scale_y_s, point2);

    } else {
        if (m_CrossAlnHalf == fCrossAlignArea1)
            m_Renderer->SetScaleRef_Q(scale, scale_y_q, point);
        else
            m_Renderer->SetScaleRef_S(scale, scale_y_s, point);
    }

    NotifyVisibleRangeChanged();
}


void CCrossAlnPane::MZHH_ZoomRect(const TModelRect& rect)
{
    TModelUnit l1, l2, r1, r2;
    if (m_CrossAlnHalf == fCrossAlignArea1) {
        l1 = rect.Left();
        r1 = rect.Right();

        TVPUnit lv1 = m_Renderer->GetRP_Q().ProjectX(l1);
        TVPUnit rv1 = m_Renderer->GetRP_Q().ProjectX(r1);

        l2 = m_Renderer->GetRP_S().UnProjectX(lv1);
        r2 = m_Renderer->GetRP_S().UnProjectX(rv1);
    } else {
        l2 = rect.Left();
        r2 = rect.Right();

        TVPUnit lv2 = m_Renderer->GetRP_S().ProjectX(l2);
        TVPUnit rv2 = m_Renderer->GetRP_S().ProjectX(r2);

        l1 = m_Renderer->GetRP_Q().UnProjectX(lv2);
        r1 = m_Renderer->GetRP_Q().UnProjectX(rv2);
    }

    ZoomOnRange_Q(l1, r1);
    ZoomOnRange_S(l2, r2);

    // translate the notification to the standard message
    NotifyVisibleRangeChanged();
}


void CCrossAlnPane::MZHH_ZoomPoint(const TModelPoint& point, TModelUnit factor)
{
    ERR_POST("CCrossAlnPane::MZHH_ZoomPoint() not implemented!");
    NotifyVisibleRangeChanged();
}

void CCrossAlnPane::MZHH_Scroll(TModelUnit d_x, TModelUnit d_y)
{
    const TModelRect& rc_q = m_Renderer->GetRP_Q().GetVisibleRect();
    const TModelRect& rc_s = m_Renderer->GetRP_S().GetVisibleRect();

    // the d_x here are in cross alignment pane model
    // space (which set to be 0 to 1). We need to recalculate to
    // proper values of ruler panes.
    if (!Fl::event_shift()) {
        TModelUnit dx_q, dx_s;
        if (m_CrossAlnHalf == fCrossAlignArea1) {
            dx_q = d_x;
            dx_s = dx_q * rc_s.Width() / rc_q.Width();
        } else {
            dx_s = d_x;
            dx_q = dx_s * rc_q.Width() / rc_s.Width();
        }
        Scroll(rc_q.Left() + dx_q, rc_s.Left() + dx_s);
    } else {
        if (m_CrossAlnHalf == fCrossAlignArea1) {
            Scroll(rc_q.Left() + d_x, rc_s.Left());
        } else {
            Scroll(rc_q.Left(), rc_s.Left() + d_x);
        }
    }

    // translate the notification to the standard message
    NotifyVisibleRangeChanged();
}


TVPUnit CCrossAlnPane::MZHH_GetVPPosByY(int y) const
{
    return h() - 1  - y;
}


void CCrossAlnPane::MZHH_Redraw(void)
{
    redraw();
}


void CCrossAlnPane::MZHH_EndOp()
{
    // translate the notification to the standard message
    NotifyVisibleRangeChanged();
}
// IMouseZoomHandlerHost end



// ISelHandlerHost
TModelUnit CCrossAlnPane::SHH_GetModelByWindow(int z, EOrientation orient)
{
    if (m_PushArea == fRuler1Area) {
        switch(orient)  {
        case eHorz: return m_Renderer->GetRP_Q().UnProjectX(z);
        case eVert: return m_Renderer->GetRP_Q().UnProjectY(h() - z);
        default:    _ASSERT(false); return -1;
        }
    } else {
        switch(orient)  {
        case eHorz: return m_Renderer->GetRP_S().UnProjectX(z);
        case eVert: return m_Renderer->GetRP_S().UnProjectY(h() - z);
        default:    _ASSERT(false); return -1;
        }
    }
}

TVPUnit CCrossAlnPane::SHH_GetWindowByModel(TModelUnit z, EOrientation orient)
{
    if (m_PushArea == fRuler1Area) {
        switch(orient)  {
        case eHorz: return m_Renderer->GetRP_Q().ProjectX(z);
        case eVert: return h() - m_Renderer->GetRP_Q().ProjectY(z);
        default:    _ASSERT(false); return -1;
        }
    } else {
        switch(orient)  {
        case eHorz: return m_Renderer->GetRP_S().ProjectX(z);
        case eVert: return h() - m_Renderer->GetRP_S().ProjectY(z);
        default:    _ASSERT(false); return -1;
        }
    }
}


void CCrossAlnPane::SHH_Redraw()
{
    redraw();
}


void CCrossAlnPane::SHH_OnChanged()
{
    if (!GetQueryRangeSelection().size()  ||
        !GetSubjectRangeSelection().size())
    {
        ResetObjectSelection();
    }

    redraw();
    // broadcast
    CEvent evt(CEvent::eEvent_Message, CViewEvent::eWidgetSelectionChanged);
    Send(&evt, CEventHandler::eDispatch_Default,
                              CEventHandler::ePool_Parent);
}
// ISelHandlerHost end


///////////////////////////////////////////////////////////////////////////////
/// ITooltip Implementation
bool CCrossAlnPane::TC_NeedTooltip(int x, int y)
{
    m_Renderer->GetTooltip(x, h() - y, &m_TooltipText);
    return m_TooltipText.length() > 0;
}


string CCrossAlnPane::TC_GetTooltip(int& x, int& y, int& w, int& h)
{
    return m_TooltipText;
}

// ITooltip end

// --- Scrolling --------------------------------------------------
void CCrossAlnPane::Scroll(TModelUnit x1, TModelUnit x2)
{
    // "lock" both scrollbars if Shift key is pressed. That will scroll all panels
    // together (withing each panel limits)
    if (!Fl::event_shift()) {
        const TModelRect& rc1 = m_Renderer->GetRP_Q().GetVisibleRect();
        const TModelRect& rc2 = m_Renderer->GetRP_S().GetVisibleRect();

        // Find the scroll "delta"
        int dX1 = int(x1 - rc1.Left());
        int dX2 = int(x2 - rc2.Left());

        if (dX1 != 0) x2 = x2 + dX1;
        if (dX2 != 0) x1 = x1 + dX2;
    }

    m_Renderer->Scroll(x1, x2);
    redraw();
}


void CCrossAlnPane::SquareOnRect(TModelRect rc)
{
    if (rc.Width() == 0 || rc.Height() == 0) return;

    m_Renderer->SquareOnRect(rc);

    NotifyVisibleRangeChanged();
}


void CCrossAlnPane::ZoomOnRect(TModelRect rc)
{
    if (rc.Width() == 0 || rc.Height() == 0) return;

    ZoomOnRange_Q( rc.Left(), rc.Right() );
    ZoomOnRange_S( rc.Bottom(), rc.Top() );

    NotifyVisibleRangeChanged();
}


void CCrossAlnPane::ZoomOnRange_Q(TModelUnit from, TModelUnit to)
{
    m_Renderer->ZoomOnRange_Q(from, to);
    NotifyVisibleRangeChanged();
}

void CCrossAlnPane::ZoomOnRange_S(TModelUnit from, TModelUnit to)
{
    m_Renderer->ZoomOnRange_S(from, to);
    NotifyVisibleRangeChanged();
}


void CCrossAlnPane::ZoomIn_Q()
{
    m_Renderer->ZoomIn_Q();
    NotifyVisibleRangeChanged();
}


void CCrossAlnPane::ZoomOut_Q()
{
    m_Renderer->ZoomOut_Q();
    NotifyVisibleRangeChanged();
}

void CCrossAlnPane::ZoomAll(void)
{
    ZoomAll_Q();
    ZoomAll_S();
}


void CCrossAlnPane::ZoomIn(void)
{
    ZoomIn_Q();
    ZoomIn_S();
}

void CCrossAlnPane::ZoomOut(void)
{
    ZoomOut_Q();
    ZoomOut_S();
}


void CCrossAlnPane::ZoomAll_Q(void)
{
    m_Renderer->ZoomAll_Q();
    NotifyVisibleRangeChanged();
}

void CCrossAlnPane::ZoomToSeq_Q(void)
{
    m_Renderer->ZoomToSeq_Q();
    NotifyVisibleRangeChanged();
}


// Subject
void CCrossAlnPane::ZoomIn_S()
{
    m_Renderer->ZoomIn_S();
    NotifyVisibleRangeChanged();
}


void CCrossAlnPane::ZoomOut_S()
{
    m_Renderer->ZoomOut_S();
    NotifyVisibleRangeChanged();
}


void CCrossAlnPane::ZoomAll_S(void)
{
    m_Renderer->ZoomAll_S();
    NotifyVisibleRangeChanged();
}

void CCrossAlnPane::ZoomToSeq_S(void)
{
    m_Renderer->ZoomToSeq_S();
    NotifyVisibleRangeChanged();
}


void CCrossAlnPane::NotifyVisibleRangeChanged()
{
    CEvent evt(CEvent::eEvent_Message, CViewEvent::eWidgetRangeChanged);
    Send(&evt, CEventHandler::eDispatch_Default,
                    CEventHandler::ePool_Parent);
    redraw();
}


END_NCBI_SCOPE

---