seqgraphic_render.cpp

来自「ncbi源码」· C++ 代码 · 共 755 行 · 第 1/2 页

/*
 * ===========================================================================
 * PRODUCTION $Log: seqgraphic_render.cpp,v $
 * PRODUCTION Revision 1000.7  2004/06/01 21:12:56  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.97
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: seqgraphic_render.cpp,v 1000.7 2004/06/01 21:12:56 gouriano Exp $
 * ===========================================================================
 *
 *                            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 <gui/widgets/seq_graphic/seqgraphic_render.hpp>
#include <gui/widgets/seq_graphic/seqgraphic_ds.hpp>
#include <gui/opengl/glutils.hpp>
#include <gui/widgets/seq_graphic/default_policy.hpp>
#include <gui/widgets/seq_graphic/compact_policy.hpp>
#include <gui/widgets/seq_graphic/genome_policy.hpp>

#include <gui/widgets/seq_graphic/default_layoutpolicy.hpp>
#include <gui/widgets/seq_graphic/genome_layoutpolicy.hpp>
#include <gui/opengl/glbackground.hpp>


#include <math.h>


BEGIN_NCBI_SCOPE



const TModelUnit kZoomFactorX     = 2.0;
const TModelUnit kLenseZoomFactor = 10.0;
const TVPUnit    kMaxPixelsBase   = 12;


CSeqGraphicRenderer::CSeqGraphicRenderer()
{
    m_DS           = NULL;
    m_NeedLensZoom = false;
    m_MinZoomX     = log(1.0f / kMaxPixelsBase);  // Enougth to fit seq. letters
    
    m_FP.SetMinScaleX(1.0f / kMaxPixelsBase);
    m_FP.EnableZoom(true, false);
    m_FP.SetAdjustToLimits(true, false);
    m_FP.EnableOffset(true);

    m_RP.SetMinScaleX(1.0f / kMaxPixelsBase);
    m_RP.EnableZoom(true, false);
    m_RP.SetAdjustToLimits(true, false);
    m_RP.EnableOffset(true);

    m_AllPanes.push_back(&m_RP);
    m_AllPanes.push_back(&m_FP);
    
    m_ScrollXPanes.push_back(&m_RP);
    m_ScrollXPanes.push_back(&m_FP);
    
    m_AllRenderers.push_back(&m_RulerPanel);
    m_AllRenderers.push_back(&m_FeatPanel);
}


CSeqGraphicRenderer::~CSeqGraphicRenderer()
{
}


void CSeqGraphicRenderer::SetConfig(CRef<CSeqGraphicConfig> config)
{
    m_ConfigSettings = config;
    m_FeatPanel.SetConfig(config);
    ConfigureRenderPolicy();
}


void CSeqGraphicRenderer::UpdateConfig()
{
    ConfigureRenderPolicy();
}


void CSeqGraphicRenderer::ConfigureRenderPolicy()
{
    if (m_ConfigSettings) {
        CRef<IPolicy> policy;
        CRef<ILayoutPolicy> layout_policy;
        switch (m_ConfigSettings->GetFeaturePanelRenderPolicy()) {
        
        case CRenderPolicyConfig::eRenderPolicyDefault :
            policy.Reset(new CDefaultPolicy);
            layout_policy.Reset(new CDefaultLayoutPolicy);
            break;
        
        case CRenderPolicyConfig::eRenderPolicyCompact :
            policy.Reset(new CCompactPolicy);
            layout_policy.Reset(new CDefaultLayoutPolicy);
            break;
            
        case CRenderPolicyConfig::eRenderPolicyInline :
            //policy.Reset(new CInlinePolicy);
            policy.Reset(new CDefaultPolicy);
            layout_policy.Reset(new CDefaultLayoutPolicy);
            break;
            
        case CRenderPolicyConfig::eRenderPolicyGenome :
            policy.Reset(new CGenomePolicy);   // Change when we get a Genome Policy.
            layout_policy.Reset(new CGenomeLayoutPolicy);
            break;
            
        default:
            return;
        }
        
        //layout_policy.Reset(new CGenomeLayoutPolicy);
        //policy.Reset(new CCompactPolicy);
        
        m_FeatPanel.SetRenderPolicy(policy);    
        m_FeatPanel.SetLayoutPolicy(layout_policy);
    }
}


TModelUnit CSeqGraphicRenderer::GetHeight()
{
    return m_FeatPanel.GetHeight(m_FP) + m_RulerPanel.GetPreferredSize().Y();
}


void CSeqGraphicRenderer::SetDataSource(const TVPRect& rc, CSeqGraphicDataSource* ds)
{
    m_DS = ds;

    m_FeatPanel.SetHandle(m_DS->GetBioseqHandle());
    m_FeatPanel.SetSelectedObjects(&m_SelectedObjects);
    
    m_RulerPanel.SetHorizontal(true, CRuler::eTop);
	m_RulerPanel.SetDisplayOptions(CRuler::fHideLabels |
								   CRuler::fShowMetric);								   

    x_SetupViewPorts(rc);
    x_SetupModelLimits();
    
    m_MaxZoomX = log(m_FP.GetModelLimitsRect().Width() / rc.Width());
}


void CSeqGraphicRenderer::x_SetupViewPorts(const TVPRect& rc)
{
    TModelUnit ruler_height = m_RulerPanel.GetPreferredSize().Y();
    //TModelUnit height = rc.Height();

    TVPRect ruler_viewport(rc.Left(),  rc.Top() - ruler_height,
                           rc.Right(), rc.Top());
    TVPRect feat_viewport(rc.Left(),  rc.Bottom(),
                          rc.Right(), rc.Top() - ruler_height);

    feat_viewport.Offset(0, -m_ConfigSettings->GetRulerSpacer());
    
    m_RP.SetViewport(ruler_viewport);
    m_FP.SetViewport(feat_viewport);

    _TRACE("ruler: "
           << ruler_viewport.Left() << ", "
           << ruler_viewport.Bottom() << ", "
           << ruler_viewport.Right() << ", "
           << ruler_viewport.Top());
    _TRACE("features: "
           << feat_viewport.Left() << ", "
           << feat_viewport.Bottom() << ", "
           << feat_viewport.Right() << ", "
           << feat_viewport.Top());


    /**
    size_t idx = 0;
    TVPUnit bottom = rc.Bottom() + rc.Height();
    NON_CONST_ITERATE(TGlPanes, iter, m_AllPanes) {
        CGlPane& pane = **iter;
        TVPUnit pref_height = m_AllRenderers[idx]->GetVPRect().Height();
        
        if (pref_height == 1) {
            // TVPRect adds 1 automatically
            pref_height = 0;
        }

        TVPRect rc_tmp(rc.Left(), bottom - pref_height, rc.Right(), bottom);
        _TRACE("viewport: "
               << rc_tmp.Left() << ", "
               << rc_tmp.Bottom() << ", "
               << rc_tmp.Right() << ", "
               << rc_tmp.Top());
        pane.SetViewport(rc_tmp);
        bottom -= pref_height;
        ++idx;
    }
    **/
}


void CSeqGraphicRenderer::x_SetupModelLimits()
{
    NON_CONST_ITERATE(TGlPanes, iter, m_AllPanes) {
        CGlPane& pane = **iter;
        
        TVPRect& vp = pane.GetViewport();
        TModelRect rc;
        if (*iter == &m_RP) {
            rc = TModelRect(0, 0, m_DS->GetSequenceLength() + 1, vp.Height());
        } else {
            rc = TModelRect(0, vp.Height(), m_DS->GetSequenceLength() + 1, 0);
            rc.Offset(0, -m_ConfigSettings->GetRulerSpacer());
        }

        pane.SetModelLimitsRect(rc);
        pane.SetVisibleRect    (rc);
    }
}


void CSeqGraphicRenderer::Render()
{
    x_Draw(NULL);
}


void CSeqGraphicRenderer::Render(TAreaVector& areas)
{
    x_Draw(&areas);
}


void CSeqGraphicRenderer::Render(TAreaVector* p_areas)
{
    x_Draw(p_areas);
}


void CSeqGraphicRenderer::x_Draw(TAreaVector* p_areas)
{
    try {
        CGlColor bg = m_ConfigSettings->GetElementColor(
                            CSeqGraphicColorConfig::eBackground);

        /**
        CGlBackground back;
        back.SetColor(bg);
        back.Draw(m_RP.GetViewport());
        back.Draw(m_FP.GetViewport());
        **/
        glClearColor(bg.GetRed(), bg.GetGreen(), bg.GetBlue(), 0.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        CGlColor ruler_label = m_ConfigSettings->GetElementColor(
                                CSeqGraphicColorConfig::eLabel_Ruler);
        CGlColor ruler_grid  = m_ConfigSettings->GetElementColor(
                                CSeqGraphicColorConfig::eRuler_Grid);
        
        m_RulerPanel.SetColor(CRuler::eBackground, bg);
        m_RulerPanel.SetColor(CRuler::eRuller, ruler_grid);
        m_RulerPanel.SetColor(CRuler::eText,   ruler_label);

        if ( !m_DS ) {
            return;
        }

        TModelRect& rcM = m_FP.GetModelLimitsRect();
        TModelRect  rcV = m_FP.GetVisibleRect();
    
        // retrieve and count data. This is temporary.
        TModelUnit rows = m_FeatPanel.GetHeight(m_FP); 

        // We have a "floating" model space. So, adjust the limits 
        rcM.SetBottom(rows);
        m_FP.SetModelLimitsRect(rcM);
        m_FP.SetVisibleRect(rcV);

        // Finally, draw all panels
        for (size_t idx = 0; idx != m_AllRenderers.size(); idx++) {
            m_AllRenderers[idx]->Render( *m_AllPanes[idx] );
        }

        // collect HTML active areas
        if(p_areas) 
        {
            m_FeatPanel.GetHTMLActiveAreas(m_FP, p_areas);
            // Offset by the height of Ruler Panel and Spacer
            NON_CONST_ITERATE (TAreaVector, iter, *p_areas) {
                // RulerBar
                (*iter).m_Bounds.Offset(0, m_RP.GetViewport().Height());
                
                // RulerBar spacer
                (*iter).m_Bounds.Offset(0, -m_ConfigSettings->GetRulerSpacer());
            }
        }

        // Draw Zoomed view
        if (m_NeedLensZoom) {
            x_DimDisplay();
            size_t idx = 1;
            NON_CONST_ITERATE(TGlPanes, iter, m_ScrollXPanes) {
                CGlPane& pane = **iter;
                TModelRect rc = pane.GetVisibleRect();

                pane.SetZoomFactor(kLenseZoomFactor);
                pane.ZoomIn(m_LensZoom);
            
                if (&pane == &m_FP) {
                    m_FeatPanel.GetHeight(m_FP);
                    m_FeatPanel.Render(pane);
                } else {
                    m_RulerPanel.Render(pane);
                }
                
                pane.SetZoomFactor(kZoomFactorX);
                pane.SetVisibleRect(rc);
                idx++;
            }
        }
    }
    catch (CException& e) {
        m_FP.Close();
        LOG_POST(Error << "Exception in CSeqGraphicRender::Render(): " << e.GetMsg());
    }

    CGlUtils::CheckGlError();
}


void CSeqGraphicRenderer::x_DimDisplay()
{
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glColor4f(1.0f, 1.0f, 1.0f, 0.9f);
    
    NON_CONST_ITERATE(TGlPanes, iter, m_ScrollXPanes) {
        CGlPane& pane = **iter;
        TVPRect& rc   = pane.GetViewport();
        
        pane.OpenPixels();
        glRecti(rc.Left(), rc.Bottom(), rc.Right()+1, rc.Top());
        pane.Close();
    }

    glDisable(GL_BLEND);
}


void CSeqGraphicRenderer::Resize(const TVPRect& rc)
{
    x_SetupViewPorts(rc);