textaln_panel.cpp

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

/*
 * ===========================================================================
 * PRODUCTION $Log: textaln_panel.cpp,v $
 * PRODUCTION Revision 1000.2  2004/06/01 21:08:00  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: textaln_panel.cpp,v 1000.2 2004/06/01 21:08:00 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 "panel.hpp"
#include <gui/widgets/aln_data/align_ds.hpp>
#include <gui/opengl/glcolortable.hpp>
#include <gui/opengl/glbitmapfont.hpp>
#include <objects/seqloc/Seq_id.hpp>
#include <objmgr/util/feature.hpp>
#include <objmgr/util/sequence.hpp>

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



BEGIN_NCBI_SCOPE
USING_SCOPE(ncbi::objects);


const int  kFontSize      = 10;  // font size for labels and sequence
const int  kFontWidth     =  9;  // font width

const int  kCellWidth     = 10;  // size of one element in the grid
const int  kCellHeight    = 13;  // do not set less than that
// or features may not fit

const size_t      kUnknowIdx    = ((size_t) (-1));
const string      kLabels       = "Labels";
const string      kPosition     = "Position";

CTextAlnPanel::CTextAlnPanel(int x, int y, int w, int h, const char* label)
    : Fl_Gl_Window(x, y, w, h, label)
    , m_Font_8x13(CGlBitmapFont::eBitmap8x13)
{
    m_DS              = NULL;
    m_BackgroundColor = FL_WHITE;
    m_SelectionColor  = FL_BLUE;
    m_NumbersColor    = FL_BLUE;
    m_GridColor       = FL_GRAY;
    m_SequenceColor   = FL_BLACK;
    m_MismatchColor   = FL_RED;

    m_AlnWidth        = 0;
    m_AlnHeight       = 0;
    m_Anchor          = kUnknowIdx;
    m_ShowSeqAsDots   = false;
    m_featDisp        = CTextAlnView::eOff;
}


CTextAlnPanel::~CTextAlnPanel()
{
    // delete m_DS;
}

TSignedSeqPos CTextAlnPanel::x_GetStartAt(size_t idx, TNumseg seg) const
{
    return m_DS->GetAlnMgr().GetStart(idx, seg);
}



TSeqPos CTextAlnPanel::x_GetAlnWidth(void) const
{
    return m_DS->GetAlnMgr().GetAlnStop();
}


CTextAlnPanel::TDim CTextAlnPanel::x_GetAlnHeigth(void) const
{
    return m_DS->GetAlnMgr().GetNumRows();
}


void CTextAlnPanel::x_PrepareData(void)
{
    m_ScrX = 0;
    m_ScrY = 0;

    m_AlnWidth  = x_GetAlnWidth();
    m_AlnHeight = x_GetAlnHeigth();

    m_ParaG.clear();
    for (TNumrow idx = 0; idx != m_AlnHeight; idx++) {
        if (m_featDisp == CTextAlnView::eAll  ||  
            (m_featDisp == CTextAlnView::eBase && idx == 0)) {
            x_AddFeaturesAtIndex(idx);
        }

        CParaG para(CParaG::eSequence, idx);
        m_ParaG.push_back(para);

        x_AddInsertsAtIndex(idx);
    }
}


void CTextAlnPanel::x_AddInsertsAtIndex(size_t idx)
{
    CRef<CAlnMap::CAlnChunkVec> chunk_vec = m_DS->GetAlnMgr().GetAlnChunks
        (idx, CAlnMap::TSignedRange(0, m_AlnWidth), CAlnVec::fInsertsOnly);

    if (chunk_vec->size() > 0) {
        CParaG para(CParaG::eInsertion, idx);
        m_ParaG.push_back(para);
    }
}


void CTextAlnPanel::x_AddFeaturesAtIndex(size_t idx)
{
    const CBioseq_Handle& handle = m_DS->GetAlnMgr().GetBioseqHandle(idx);
    for (CFeat_CI feat_it(handle, 0, 0, CSeqFeatData::e_not_set);
         feat_it;  ++feat_it) {
        CSeqFeatData::E_Choice type = (*feat_it).GetData().Which();
        if (type == CSeqFeatData::e_Gene || type == CSeqFeatData::e_Rna ||
            type == CSeqFeatData::e_Cdregion || type == CSeqFeatData::e_Prot) {
            const CMappedFeat& feat = *feat_it;
            CParaG para(CParaG::eFeature, idx,
                        new CLayoutFeat(*new CMappedFeat(feat)));
            m_ParaG.push_back(para);
        }
    }
}

void CTextAlnPanel::ShowSequenceAsDots(bool show_dots)
{
    m_ShowSeqAsDots = show_dots;
    redraw();
}

void CTextAlnPanel::SetAnchor(size_t idx)
{
    m_Anchor = idx;
    m_DS->SetAlnMgr().SetAnchor(idx);
    x_PrepareData();
    invalidate();
    redraw();
}


void CTextAlnPanel::UnsetAnchor(void)
{
    m_Anchor = kUnknowIdx;
    m_DS->SetAlnMgr().UnsetAnchor();

    x_PrepareData();
    invalidate();
    redraw();
}

void CTextAlnPanel::SetDataSource(CAlignDataSource* ds)
{
    m_DS = ds;

    m_RowSelect.clear();  // reset selections
    m_ColSelect.clear();
    for (TNumrow idx = 0; idx != x_GetAlnHeigth(); idx++)
        m_RowSelect.push_back(false);

    for (size_t idx = 0; idx != x_GetAlnWidth(); idx++)
        m_ColSelect.push_back(false);

    x_PrepareData();

    invalidate();
    redraw();
}

void CTextAlnPanel::SelectAll(bool flag)
{
    if ( !m_DS ) return;
    for (size_t idx = 0; idx != m_RowSelect.size(); idx++)
        m_RowSelect[idx] = flag;
    if (!flag) for (size_t idx = 0; idx != m_ColSelect.size(); idx++)
        m_ColSelect[idx] = flag;
    redraw();
}


void CTextAlnPanel::x_DrawSelection(int size, ESelectionType type) const
{
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glColor4f(0.1f, 0.1f, 0.1f, 0.1f);
    glBegin(GL_QUADS);
    if (type == eRow) {
        for (TNumrow row = 0;  row != m_ParaG.size();  row++) {
            if (m_RowSelect[m_ParaG[row].GetIndex()]) {
                GLfloat yy = GLfloat(row - m_ScrY) * kCellHeight;
                glVertex2f(0.0f, yy + kCellHeight);
                glVertex2f(size, yy + kCellHeight);
                glVertex2f(size, yy);
                glVertex2f(0.0f, yy);
            }
        }
    } else {
        for (TSeqPos col = 0;  col != m_AlnWidth;  col++) {
            if (m_ColSelect[col]) {
                GLfloat xx = GLfloat(col - m_ScrX) * kCellWidth;
                glVertex2f(xx,              size);
                glVertex2f(xx + kCellWidth, size);
                glVertex2f(xx + kCellWidth, 0.0f);
                glVertex2f(xx,              0.0f);
            }
        }    
    }
    glEnd();
    glDisable(GL_BLEND);
}


void CTextAlnPanel::x_DrawGrid()
{
    gl_color(m_GridColor);
    glBegin(GL_LINES);
    for (TSeqPos col = 0;  col != m_AlnWidth + 1;  col++) {
        GLfloat xx = GLfloat(col - m_ScrX) * kCellWidth;
        glVertex2f(xx, 0.0f);
        glVertex2f(xx, m_Height);
    }
    for (TNumrow row = 0;  row != m_ParaG.size();  row++) {
        GLfloat yy = GLfloat(row - m_ScrY) * kCellHeight;
        glVertex2f(0.0f, yy);
        glVertex2f(m_BP[2], yy);
    }
    glEnd();

    x_DrawSelection(m_BP[2], eRow);
    x_DrawSelection(m_BP[3], eCol);
}


void CTextAlnPanel::x_DrawSequence(TNumrow row, size_t idx) const
{
    string seq_draw, seq_base;
    TSeqPos start  = m_ScrX;
    TSeqPos finish = m_ScrX + m_BP[2] / kCellWidth;

    m_DS->GetAlnMgr().GetAlnSeqString(seq_draw, idx, 
                                       CAlnMap::TSignedRange(start, finish));
    m_DS->GetAlnMgr().GetAlnSeqString(seq_base,   0, 
                                       CAlnMap::TSignedRange(start, finish));

    GLfloat yy = GLfloat(row - m_ScrY + 1) * kCellHeight + 1;
    for (TSeqPos x = 0;  x != seq_draw.length();  x++) {
        GLfloat xx = GLfloat(x * kCellWidth);
        string seq_this  = seq_draw.substr(x, 1);
        string seq_other = seq_base.substr(x, 1);
        if (seq_this == " ") seq_this = "-";  // AlnMgr problem fix

        if (seq_this != seq_other) {
            gl_color(m_MismatchColor);  // color mismatches
        } else {
            gl_color(m_SequenceColor);
            if (m_ShowSeqAsDots  &&  idx != 0  &&  seq_this != "-") {
                // draw dots instead (but not on the base sequence)
                seq_this = ".";
            }
        }
        m_Font_8x13.TextOut(xx, yy - 2, seq_this.c_str());
    }
}


void CTextAlnPanel::x_DrawFeatures(TNumrow row, size_t idx) const
{    
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    GLfloat width = 3;
    const CSeq_loc& loc = m_ParaG[row].Feature()->GetLocation();

    switch (m_ParaG[row].Feature()->GetFeature().GetData().Which()) {
    case CSeqFeatData::e_Gene:
        glColor4f(0.0f, 1.0f, 0.0f, 0.33f);
        width = 3.0f;
        break;
    case CSeqFeatData::e_Rna:
        glColor4f(0.0f, 0.0f, 1.0f, 0.5f);
        width = 5.0f;
        break;
    case CSeqFeatData::e_Cdregion:
        glColor4f(1.0f, 0.0f, 0.0f, 0.33f);
        width = 7.0f;
        break;
    case CSeqFeatData::e_Prot:
        glColor4f(1.0f, 1.0f, 1.0f, 0.5f);
        width = 9.0f;
        break;
    default:
        break;
    }

    TSignedSeqPos s_from = loc.GetTotalRange().GetFrom();
    TSignedSeqPos s_to   = loc.GetTotalRange().GetTo();

    TSignedSeqPos al_from = m_DS->GetAlnMgr().GetAlnPosFromSeqPos
        (idx, s_from);
    TSignedSeqPos al_to   = m_DS->GetAlnMgr().GetAlnPosFromSeqPos
        (idx, s_to);

    if (al_from == -1) al_from = 0;
    if (al_to   == -1) al_to   = m_AlnWidth;  // some times it happends            

    al_from = al_from - m_ScrX;  // adjust with scroll values
    al_to   = al_to   - m_ScrX + 1;
    if (al_from < 0) al_from = 0;


    GLfloat xx1 = al_from * kCellWidth;
    GLfloat xx2 = al_to   * kCellWidth;
    GLfloat yy  = GLfloat(row - m_ScrY) * kCellHeight + 
        GLfloat(kCellHeight / 2);

    x_DrawLine(xx1, yy, xx2, yy, width);
    glDisable(GL_BLEND);
}


void CTextAlnPanel::x_DrawInsertions(TNumrow row, size_t idx) const
{
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glLineWidth(1.5f);
    glEnable(GL_POLYGON_SMOOTH);
    glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST);

    CGlBitmapFont f(CGlBitmapFont::eHelvetica10);
    GLfloat yy = GLfloat(row - m_ScrY) * kCellHeight;

    CRef<CAlnMap::CAlnChunkVec> chunk_vec = m_DS->GetAlnMgr().GetAlnChunks
        (idx, CAlnMap::TSignedRange(0, m_AlnWidth), 
         CAlnVec::fInsertsOnly | CAlnVec::fIgnoreGaps);

    string ins_str;
    CGlColorTable table(chunk_vec->size(), 0.5f, 0.75f);
    for (int i = 0;  i < chunk_vec->size();  i++) {  // for each chunk
        CConstRef<CAlnMap::CAlnChunk> chunk = (*chunk_vec)[i];
        TSeqPos seq_from = chunk->GetRange().GetFrom();
        TSeqPos seq_to   = chunk->GetRange().GetTo();
        TSeqPos aln_from = chunk->GetAlnRange().GetFrom();

        m_DS->GetAlnMgr().GetSeqString(ins_str, idx, seq_from, seq_to);
        string to_draw = x_PreprocessSeq(ins_str);

        TSeqPos ins_len = ins_str.length();
        GLfloat ww = gl_width(to_draw.c_str());
        GLfloat xx = GLfloat((aln_from - m_ScrX - 1) * kCellWidth) - ww / 2.0f;

        CGlColor color = table.GetColor(i);
        glColor4f(color.GetRed(), color.GetGreen(), color.GetBlue(), 0.4f);

        glBegin(GL_TRIANGLE_FAN);
        glVertex2f(xx, yy);
        glVertex2f(xx, yy + kCellHeight);
        glVertex2f(xx + ww, yy + kCellHeight);
        glVertex2f(xx + ww, yy);
        glVertex2f(xx + ww / 2, yy - 6);
        glEnd();

        gl_color(FL_RED);  //m_SequenceColor); //  sequence
        f.TextOut(xx, yy + kCellHeight, to_draw.c_str());

        string label = NStr::UIntToString(ins_len);
        ww = gl_width(label.c_str());
        xx = GLfloat((aln_from - m_ScrX - 1) * kCellWidth) - ww / 2.0f;

        gl_color(FL_BLACK);  // size
        f.TextOut(xx, yy + kCellHeight / 2, label.c_str());
    }
    glLineWidth(1.0f);
    glDisable(GL_BLEND);
    glDisable(GL_POLYGON_SMOOTH);
}


void CTextAlnPanel::x_DrawTextPanel(void)
{
    x_ActivateViewPort(m_BP);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    x_DrawGrid();

    TNumrow startY  = m_ScrY;
    TNumrow finishY = m_ScrY + m_Height / kCellHeight;

    for (TNumrow row = startY; row != finishY && row < m_ParaG.size(); row++) {
        CParaG para = m_ParaG[row];

        switch(para.GetType()) {
        case CParaG::eFeature:
            x_DrawFeatures(row, para.GetIndex());
            break;
        case CParaG::eSequence:
            x_DrawSequence(row, para.GetIndex());
            break;
        case CParaG::eInsertion:
            x_DrawInsertions(row, para.GetIndex());
            break;
        }
    }
    glPopAttrib();
}