default_policy.cpp

来自「ncbi源码」· C++ 代码 · 共 1,851 行 · 第 1/5 页

    case eDrawObjectLabel:
        if (inrc.Width() < pane.UnProjectWidth(m_MinLabelWidth)) {
            break;
        }

        if (selected) {
            x_Color(CSeqGraphicColorConfig::eSelLabel_Alignment);
        } else {
            x_Color(CSeqGraphicColorConfig::eLabel_Alignment);
        }

        {{
            string title;
            string out;
            // title = "alignment label"; // TESTING 
            x_GetTitle(align, &title);
            
            out = m_Font_Helv10.Truncate(title.c_str(), inrc.Width() / scaleX);
            GLfloat xM = x_CenterText(pane, inrc, 
                                      m_Font_Helv10.TextWidth(out.c_str()));

            GLfloat title_y  = row_y + m_Font_Helv10.TextHeight() + 1;
            m_Font_Helv10.TextOut(xM - offsetX, title_y - offsetY, out.c_str());
        }}

        break;
    }
}



void CDefaultPolicy::x_DrawSeqGraph(CGlPane& pane, const CLayoutGraph* graph,
                    GLfloat row_y, EObj_IterMode mode, bool selected) const
{
    const TModelRect& rcV = pane.GetVisibleRect();
    const CMappedGraph& gr = graph->GetGraph();
    const CSeq_graph::C_Graph& gr_data = gr.GetGraph();
    
    TModelUnit offsetX = pane.GetOffsetX();
    TModelUnit offsetY = pane.GetOffsetY();

    TSeqRange range = graph->GetLocation().GetTotalRange();
    TSeqPos from = range.GetFrom();
    TSeqPos to   = range.GetTo();
    
    TModelUnit one_row = x_GetRowHeight(pane, graph, selected);

    TModelRect frc;
    frc.SetLeft(from);
    frc.SetRight(to);
    TModelRect inrc = frc.IntersectWith(rcV);
    GLfloat scaleX = pane.GetScaleX();


    switch (mode) {
    default:
        break;

    case eDrawObjectLines:        
        x_Color(CSeqGraphicColorConfig::eFG_SeqGraph);

        switch (gr_data.Which()) {
        case CSeq_graph::TGraph::e_Byte:
            x_PreparePlot(pane, gr_data.GetByte(), range, row_y, one_row);
            break;

        case CSeq_graph::TGraph::e_Real:
            x_PreparePlot(pane, gr_data.GetReal(), range, row_y, one_row);
            break;

        case CSeq_graph::TGraph::e_Int:
            x_PreparePlot(pane, gr_data.GetInt(), range, row_y, one_row);
            break;

        default:
            return;
        }

        // Draw selection (two rows!)
        if (selected) {
            x_Color(CSeqGraphicColorConfig::eSelection_SeqGraph);
            x_DrawSelection(pane, from, row_y, to, row_y + one_row);
        }
        break;

    case eDrawObjectQuads:
        // blue quad for the graph
        x_Color(CSeqGraphicColorConfig::eBG_SeqGraph);
        x_DrawQuad(pane, from, row_y+1, to + 1, row_y + one_row-2);
        break;

    case eDrawObjectLabel:
        if (gr.IsSetTitle()) {
            if (selected) {
                x_Color(CSeqGraphicColorConfig::eSelLabel_SeqGraph);
            } else {
                x_Color(CSeqGraphicColorConfig::eLabel_SeqGraph);
            }
            int min_v = 0, max_v = 0;
            switch (gr_data.Which()) {
            case CSeq_graph::TGraph::e_Byte:
                    min_v = int(gr_data.GetByte().GetMin());
                    max_v = int(gr_data.GetByte().GetMax());
                    break;
                case CSeq_graph::TGraph::e_Real:
                    min_v = int(gr_data.GetReal().GetMin());
                    max_v = int(gr_data.GetReal().GetMax());
                    break;
                case CSeq_graph::TGraph::e_Int:
                    min_v = int(gr_data.GetInt().GetMin());
                    max_v = int(gr_data.GetInt().GetMax());
                    break;
            }

            string out;
            string title = gr.GetTitle() + "  Min: " + 
                    NStr::UIntToString(min_v) + " / Max: " + 
                    NStr::UIntToString(max_v);

            out = m_Font_Helv10.Truncate(title.c_str(), inrc.Width() / scaleX);
            GLfloat xM = x_CenterText(pane, inrc, 
                                  m_Font_Helv10.TextWidth(out.c_str()));

            GLfloat title_y  = row_y + m_Font_Helv10.TextHeight() + 1;
            m_Font_Helv10.TextOut(xM - offsetX, title_y - offsetY, out.c_str());
        }
        break;
    }
}


void 
CDefaultPolicy::x_DrawHistogram(CGlPane& pane, const CLayoutHistogram* hist,
                    GLfloat row_y, EObj_IterMode mode, bool selected) const
{
    //if (mode != eDrawObjectLabel) {
    if (mode == eDrawObjectLines) { // that's temporary, until a new EObj_IterMode model be ready
        const TVPRect&    rcP = pane.GetViewport();
        const TModelRect& rcV = pane.GetVisibleRect();
        
        glEnd();
        
        pane.Close();
        pane.OpenPixels();
    
        CGlColor color = m_ConfigSettings->GetColor(hist->Which(), 
                                                    hist->Subtype());
        glColor4f(color.GetRed(), color.GetGreen(), color.GetBlue(), 0.65f);
        
        GLfloat one_row = x_GetRowHeight(pane, hist, selected);
        GLfloat height = one_row - 2;  // two pixels space
        GLfloat yy2    = rcV.Bottom() + rcP.Bottom() - one_row - row_y + 1;
        
        glBegin(GL_LINES);
            glVertex2f(rcP.Left(),  yy2);
            glVertex2f(rcP.Right(), yy2);
        glEnd();
    
        TSeqPos x = 0;
        const CDensityMap<int>& densityMap = hist->GetDensityMap();
        GLfloat max_val = densityMap.GetMax();
        
        glBegin(GL_QUAD_STRIP);
        ITERATE(CDensityMap<int>, dens_it, densityMap) {
            GLfloat xx = x;
            GLfloat yy1 = yy2 + height * (*dens_it) / max_val;
            glVertex2f(xx, yy1);
            glVertex2f(xx, yy2);
            ++x;
        }
        glEnd();
        
        pane.Close();
        pane.OpenOrtho();
        glBegin(GL_LINES);
    }
}


void 
CDefaultPolicy::x_DrawSeqSegment(CGlPane& pane, const CLayoutSeqMap* seg,
                    GLfloat row_y, EObj_IterMode mode, bool selected) const
{
    TSeqPos from = seg->GetLocation().GetTotalRange().GetFrom();
    TSeqPos to   = seg->GetLocation().GetTotalRange().GetTo();

    TSeqPos rfrom = seg->GetRefLocation().GetTotalRange().GetFrom();
    TSeqPos rto   = seg->GetRefLocation().GetTotalRange().GetTo();

    GLfloat one_row = x_GetRowHeight(pane, seg, selected);
    GLfloat line_y1  = row_y + 1;
    GLfloat line_y2  = line_y1 + one_row - 2;

    switch (mode) {
    default:
        break;
    case eDrawObjectLines:
        // Draw selection
        if (selected) {
            x_Color(CSeqGraphicColorConfig::eSelection_SeqSegment);
            x_DrawSelection(pane, from, line_y1, to, line_y2);
        }
        break;
    case eDrawObjectQuads:
        x_Color(CSeqGraphicColorConfig::eFG_SeqSegmentExc);
        x_DrawQuad(pane, from, line_y1, to, line_y2);

        x_Color(CSeqGraphicColorConfig::eFG_SeqSegmentInc);        
        x_DrawQuad(pane, rfrom, line_y1, rto, line_y2);

        break;
    case eDrawObjectLabel:
        break;
    }
}


void 
CDefaultPolicy::x_DrawSequence(CGlPane& pane, const CLayoutSequence* seqs,
                    GLfloat row_y, EObj_IterMode mode, bool selected) const
{
    const TModelRect& rcV = pane.GetVisibleRect();
    //const TModelRect& rcM = pane.GetModelLimitsRect();
    
    TModelUnit offsetX = pane.GetOffsetX();
    TModelUnit offsetY = pane.GetOffsetY();

    TModelUnit left  = rcV.Left() - offsetX;
    TModelUnit right = rcV.Right() - offsetX + 1;
    TModelUnit top    = row_y - offsetY;
    TModelUnit bottom = row_y + 16 - offsetY;
    
    switch (mode) {
    default:
        break;
    case eDrawObjectLines:
        break;
    case eDrawObjectQuads:
        glColor3f(0.05f, 0.05f, 0.05f);
        glVertex2f(left,  top);
        glVertex2f(right, top);
        glVertex2f(right, bottom);
        glVertex2f(left,  bottom);
    
        glColor3f(0.5f, 0.5f, 0.5f);
        glVertex2f(left,  top + 1);
        glVertex2f(right, top + 1);
        glVertex2f(right, bottom - 1);
        glVertex2f(left,  bottom - 1);
        break;
    case eDrawObjectLabel:
        {{
            GLfloat y = row_y + m_Font_Bitmap9x15.TextHeight() + 2 - offsetY;
            string seq = seqs->GetSequence();

            GLfloat x = TSeqPos(rcV.Left()) - offsetX + 0.5;

            x_Color(CSeqGraphicColorConfig::eSeq_SequenceBar);
            m_Font_Bitmap9x15
                .ArrayTextOut(x, y, 1.0f, 0.0f, seq.c_str(), 
                              (float) pane.GetScaleX(), 0.0f);
        }}
        break;
    }
}

void 
CDefaultPolicy::x_DrawComments(CGlPane& pane, const CLayoutComment* comm,
                    GLfloat row_y, EObj_IterMode mode, bool selected) const
{
    const TModelRect& rcV = pane.GetVisibleRect();
    
    TModelUnit offsetX = pane.GetOffsetX();
    TModelUnit offsetY = pane.GetOffsetY();
    
    GLfloat th = m_Font_Helv10.TextHeight();
    GLfloat title_y = row_y + th + 1;
    GLfloat off     = pane.GetModelLimitsRect().Top() > 0 ? th - 1 : 0;

    switch (mode) {
    default:
        break;
    case eDrawObjectLines:
    case eDrawObjectQuads:
        break;
    case eDrawObjectLabel:
        const string& out = comm->GetComment();
        x_Color(CSeqGraphicColorConfig::eFG_Comment);
        m_Font_Helv10.TextOut(rcV.Left() - offsetX, title_y - off - offsetY, out.c_str());
        break;
    }
}


void CDefaultPolicy::x_DrawMatePair(CGlPane& pane, const CLayoutMatePair* pr,
                    GLfloat row_y, EObj_IterMode mode, bool selected) const
{
    const TModelRect& rcV = pane.GetVisibleRect();

    // It's a vector of CRefs
    const CLayoutMatePair::TAlignList& pw_aligns = pr->GetSeqAligns();

    TModelUnit offsetX = pane.GetOffsetX();
    TModelUnit offsetY = pane.GetOffsetY();

    TSeqPos from = pr->GetLocation().GetTotalRange().GetFrom();
    TSeqPos to   = pr->GetLocation().GetTotalRange().GetTo();

    TModelRect frc;
    frc.SetLeft(from);
    frc.SetRight(to);
    TModelRect inrc = frc.IntersectWith(rcV);

    GLfloat scaleX = pane.GetScaleX();
    GLfloat yy;
    if (m_ConfigSettings->GetShowPWAlignLabels()) {
        yy = row_y + m_Font_Helv10.TextHeight() + 4;
    } else {
        yy = row_y + 2;
    }
    
    // Set Colors based on Error code for Mate Pairs
    CSeqGraphicColorConfig::EDisplayElement c_fg, c_seq, c_mis;
    switch (pr->GetError()) {
        case CLayoutMatePair::eError_Orientation:
            c_fg  = CSeqGraphicColorConfig::eFG_MatePairOrientation;
            c_seq = CSeqGraphicColorConfig::eSeq_MatePairOrientation;
            c_mis = CSeqGraphicColorConfig::eSeq_MatePairMismatchOrientation;
            break;
        case CLayoutMatePair::eError_NonUnique:
            c_fg  = CSeqGraphicColorConfig::eFG_MatePairNonUnique;
            c_seq = CSeqGraphicColorConfig::eSeq_MatePairNonUnique;
            c_mis = CSeqGraphicColorConfig::eSeq_MatePairMismatchNonUnique;
            break;
        case CLayoutMatePair::eError_Distance:
            c_fg  = CSeqGraphicColorConfig::eFG_MatePairDistance;
            c_seq = CSeqGraphicColorConfig::eSeq_MatePairDistance;
            c_mis = CSeqGraphicColorConfig::eSeq_MatePairMismatchDistance;
            break;
        default:
            c_fg  = CSeqGraphicColorConfig::eFG_MatePairNo;
            c_seq = CSeqGraphicColorConfig::eSeq_MatePairNo;
            c_mis = CSeqGraphicColorConfig::eSeq_MatePairMismatchNo;            
            break;
    }
    
    switch (mode) {
    default:
        break;
    case eDrawObjectLines:
        // Draw each Pairwise  Alignment inside  
        ITERATE(CLayoutMatePair::TAlignList, iter, pw_aligns) {
            bool has_sel  = selected ? pr->IsSelected(iter->GetPointer()) :
                            selected;

            x_DrawPWAlignElem(pane, iter->GetPointer(), row_y, mode, 
                              has_sel, c_fg, c_seq, c_mis);
        }

        // draw link between mate pairs
        x_Color(CSeqGraphicColorConfig::eFG_MatePairLink);
        for(size_t i = 0;  i != pw_aligns.size() - 1;  i++) {
            TSeqRange r1 = pw_aligns[i]->GetLocation().GetTotalRange();
            TSeqRange r2 = pw_aligns[i+1]->GetLocation().GetTotalRange();

            TSeqPos from = r1.GetTo() < r2.GetFrom() ? 
                           r1.GetTo() : r2.GetTo();

            TSeqPos to   = r1.GetTo() < r2.GetFrom() ? 
                           r2.GetFrom() : r1.GetFrom();