default_policy.cpp

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

                if (mode == eDrawObjectQuads) {
                    x_Color(c_fg);
                    x_DrawQuad(pane, start, yy, stop, yy + kPWAlignHeight);
                } else if (mode == eDrawObjectLabel) {
                    const CBioseq_Handle& mhndl = aln_mgr.GetBioseqHandle(anchor);
                    const CBioseq_Handle& hndl  = aln_mgr.GetBioseqHandle(row);
                    
                    CSeqVector ms_vec = mhndl.GetSeqVector(
                                        CBioseq_Handle::eCoding_Iupac);
                    CSeqVector s_vec  =  hndl.GetSeqVector(
                                        CBioseq_Handle::eCoding_Iupac);
                                        
                    string seq, mseq, tmp_seq;
                    s_vec.GetSeqData (chunk->GetRange().GetFrom(), 
                                      chunk->GetRange().GetTo() + 1, tmp_seq);
                    ms_vec.GetSeqData(start, stop + 1, mseq);
                    
                    if (neg_strand) {  // reverse&compiment sequence for negative strand
                        CSeqManip::ReverseComplement(tmp_seq, CSeqUtil::e_Iupacna,
                                   0, tmp_seq.length(), seq);
                    } else {
                        seq = tmp_seq;
                    }
                    
                    GLfloat y = yy + m_Font_Helv8.TextHeight() - 1 - offsetY;
                    char bases[2];
                    bases[1] = '\0';
                    for (TSeqPos bp = 0;  bp != seq.length();  bp++) {
                        if (seq[bp] != mseq[bp]) {  // Highlight mismatch
                            x_Color(c_mis);
                        } else {
                            x_Color(c_seq);
                        }
                        
                        bases[0] = seq[bp];
                        m_Font_Helv8.ArrayTextOut(start - offsetX + bp + 0.5, y, 1.0f, 0.0f, 
                            bases, (float) pane.GetScaleX(), 0.0f);
                    }

                }
            }
        }
        break;
    }    
}



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

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

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

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

    GLfloat scaleX = pane.GetScaleX();

    if (mode == eDrawObjectLabel  &&    
            inrc.Width() > pane.UnProjectWidth(m_MinLabelWidth)  &&
            m_ConfigSettings->GetShowPWAlignLabels() ) {
        string title;
        x_GetTitle(pw_aln, &title);
        
        string out = m_Font_Helv10.Truncate(title.c_str(), 
                                    inrc.Width() / scaleX);
        
        GLfloat xM = x_CenterText(pane, inrc, 
                            m_Font_Helv10.TextWidth(out.c_str()));

        x_Color(selected ? CSeqGraphicColorConfig::eSelLabel_PWAlign :
                           CSeqGraphicColorConfig::eLabel_PWAlign);

        GLfloat title_y  = row_y + m_Font_Helv10.TextHeight() + 1;
        m_Font_Helv10.TextOut(xM - offsetX, title_y - offsetY, out.c_str());
        
        if (scaleX > 1.0f / 6.0f) { 
            return;  // sequence would not fit
        }
    }
    
    x_DrawPWAlignElem(pane, pw_aln, row_y, mode, selected,
            CSeqGraphicColorConfig::eFG_PWAlign,
            CSeqGraphicColorConfig::eSeq_PWAlign,
            CSeqGraphicColorConfig::eSeq_PWAlignMismatch);
}



// This is exactly as it done in Sequin.
TSeqPos CDefaultPolicy::x_GetProtOffset(const CLayoutFeat* feat) const
{
    TSeqPos offset = 1; // translation offset
    const CCdregion& cdr = feat->GetFeature().GetData().GetCdregion();
    if (cdr.IsSetFrame ()) {
        switch (cdr.GetFrame ()) {
        case CCdregion::eFrame_two :
            offset = 2;
            break;
        case CCdregion::eFrame_three :
            offset = 3;
            break;
        default :
            break;
        }
    }
    return offset;
}



void 
CDefaultPolicy::x_DrawProteinProduct(CGlPane& pane, const CLayoutFeat* feat,
                    GLfloat row_y, EProtSeqType type, bool selected) const
{
    const TModelRect& rcV = pane.GetVisibleRect();
    const TModelRect& rcM = pane.GetModelLimitsRect();
    
    TModelUnit offsetX = pane.GetOffsetX();
    TModelUnit offsetY = pane.GetOffsetY();
    
    TSeqPos from = feat->GetLocation().GetTotalRange().GetFrom();
    TSeqPos to   = feat->GetLocation().GetTotalRange().GetTo();

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

    // do not do anything if there is no spac for even one letter
    if (inrc.Width() < pane.UnProjectWidth(m_MinLabelWidth)) {
        return;
    }

    GLfloat scaleX = pane.GetScaleX();    

    GLfloat th      = m_Font_Helv10.TextHeight();
    GLfloat title_y = row_y + th + 1;
    GLfloat line_y1 = title_y + 3;
    GLfloat bases_y = line_y1 + th;
    GLfloat off     = rcM.Top() > 0 ? th - 1 : 0;

    TSeqPos offset = x_GetProtOffset(feat); // initial translation offset

    // label for original protein only and when product is accessible
    if (type != eTranslatedSeq  &&  feat->GetFeature().IsSetProduct()) {
        const CSeq_loc& product = feat->GetFeature().GetProduct();
        string prot_label;
        CLabel::GetLabel(product, &prot_label,
                         CLabel::eDefault, &m_Handle.GetScope());
        string out = m_Font_Helv10.Truncate(prot_label.c_str(),
                                            inrc.Width() / scaleX);
        GLfloat xM = x_CenterText(pane, inrc, m_Font_Helv10.TextWidth(out.c_str()));

        //x_SetFeatureColor(feat);
        //x_Color(CSeqGraphicColorConfig::eSeq_ProtTranslated); // eSeq_ProtOriginal?
        if (selected) {
            x_Color(CSeqGraphicColorConfig::eSelLabel_ProtProduct);
        } else {
            x_Color(CSeqGraphicColorConfig::eLabel_ProtProduct);
        }

        m_Font_Helv10.TextOut(xM - offsetX, title_y - off - offsetY, out.c_str());
    }

    // // draw actual prot sequence if at the right zoom level
    if (x_IsSeqLettersFit(pane)) {  
        string prot_seq, trans_seq;

        CSeqVector vec = m_Handle.GetSeqVector(CBioseq_Handle::eCoding_Iupac);

        const CCdregion& cdr = feat->GetFeature().GetData().GetCdregion();        
        CCdregion_translate::TranslateCdregion(trans_seq, m_Handle,
                                               feat->GetLocation(),
                                               cdr, true, true);
        if (feat->GetFeature().IsSetProduct()) {
            const CSeq_loc& product = feat->GetFeature().GetProduct();
            CSeqVector prot_vec =
                m_Handle.GetSequenceView(product,
                                         CBioseq_Handle::eViewConstructed);
            prot_vec.SetCoding(CBioseq_Handle::eCoding_Iupac);
            prot_vec.GetSeqData (0, prot_vec.size(), prot_seq);
        } else {
            prot_seq = trans_seq;
        }

        TSeqPos seq_start;
        size_t idx = 0;

        for (CSeq_loc_CI lit(feat->GetLocation()); lit; ++lit) {
            TSeqPos ifrom = lit.GetRange().GetFrom();
            TSeqPos ito   = lit.GetRange().GetTo();
            
            char bases[2];
            bases[1] = '\0';

            bool neg = lit.GetStrand () == eNa_strand_minus;
            for (TSeqPos pos = neg ? ito : ifrom;
                 (neg ? (pos - offset >= ifrom) : (pos + offset <= ito))  && 
                 idx != prot_seq.length();
                 (neg ? pos -= 3 : pos += 3), ++idx) 
            {
                seq_start = neg ? pos - offset : pos + offset;

                x_Color( CSeqGraphicColorConfig::eSeq_ProtTranslated );
                if (type == eTranslatedSeq) {  // drawing translated sequence
                    bases[0] = trans_seq[idx];
                    if (prot_seq[idx] != trans_seq[idx]) {
                        x_Color(CSeqGraphicColorConfig::eSeq_ProtMismatch); // Mismatch
                    }
                } else { // drawing actual sequence
                    bases[0] = prot_seq[idx];
                }
                m_Font_Helv10.TextOut(seq_start - offsetX, bases_y - off - offsetY, bases);
                
                
                // for selected feature show original sequence below
                if (selected) {
                    x_Color( CSeqGraphicColorConfig::eSeq_ProtOriginal );
                    
                    string main_seq, tmp_seq;
                    vec.GetSeqData(seq_start - 1, seq_start + 2, tmp_seq);
                    
                    if (neg) {  // reverse sequence on negative strand
                        CSeqManip::Complement(tmp_seq, CSeqUtil::e_Iupacna,
                                   0, tmp_seq.length(), main_seq);
                    } else {
                        main_seq = tmp_seq;
                    }
                    
                    GLfloat s_start = seq_start - offsetX - 0.8f;
                    
                    for (TSeqPos bp = 0;  bp != main_seq.length();  bp++) {
                        bases[0] = main_seq[bp];
                        m_Font_Helv8.TextOut(s_start, bases_y + 9 - offsetY, bases);
                        s_start += 0.8f;
                    }
                }
            }

            // Use correct offset for the next interval
            int diff = neg ? seq_start - ifrom : ito - seq_start;
            if (diff == 2) {
                offset = 0;
            } else if (diff == 1) {
                offset = 1;
            } else if (diff == 0) {
                offset = 2;
            }
        } // for
    }  // done with protein sequence
}


GLfloat 
CDefaultPolicy::x_CenterText(CGlPane& pane, TModelRect rc, GLfloat width) const
{
    return rc.Left() + rc.Width() / 2.0f - 
        pane.UnProjectWidth(TVPUnit(width)) / 2.0f;
}



size_t CDefaultPolicy::x_GetSeqAnnotIndex(const CSeq_annot_Handle& annot) const
{
    TNamedAnnots::const_iterator iter = m_Annots.find(annot.GetName());
    if (iter == m_Annots.end()) {
        m_Annots[annot.GetName()] = m_Annots.size();
        iter = m_Annots.find(annot.GetName());
    }

    return iter->second;
}


void CDefaultPolicy::x_DrawQuad(CGlPane& pane,
    TModelUnit x1, TModelUnit y1, TModelUnit x2, TModelUnit y2) const
{
    TModelUnit offsetX = pane.GetOffsetX();
    TModelUnit offsetY = pane.GetOffsetY();

    glVertex2f(x1 - offsetX,     y1 - offsetY);
    glVertex2f(x2 - offsetX + 1, y1 - offsetY);
    glVertex2f(x2 - offsetX + 1, y2 - offsetY);
    glVertex2f(x1 - offsetX,     y2 - offsetY);
}


void CDefaultPolicy::x_DrawSelection(CGlPane& pane,
    TModelUnit x1, TModelUnit y1, TModelUnit x2, TModelUnit y2) const
{
    TModelUnit offsetX = pane.GetOffsetX();
    TModelUnit offsetY = pane.GetOffsetY();

    glVertex2f(x1 - offsetX, y1 - offsetY);
    glVertex2f(x1 - offsetX, y2 - offsetY);

    glVertex2f(x1 - offsetX, y2 - offsetY);
    glVertex2f(x2 - offsetX+1, y2 - offsetY);

    glVertex2f(x2 - offsetX+1, y2 - offsetY);
    glVertex2f(x2 - offsetX+1, y1 - offsetY);

    glVertex2f(x1 - offsetX, y1 - offsetY);
    glVertex2f(x2 - offsetX+1, y1 - offsetY);
}


// Is LayoutObject clicked? Uses model coordinates
bool CDefaultPolicy::x_IsObjectClicked(CGlPane& pane, const CLayoutObject* obj, 
        GLfloat row_y, bool selected) const
{
    TModelUnit height = GetRowHeight(pane, obj, selected);
    if (m_LastClick.Y() >=row_y &&  m_LastClick.Y() <= row_y + height) {
        return obj->GetObject( TSeqPos(m_LastClick.X()) ) != NULL;
    }
    return false;
}



// Is feature label clicked? Uses pixels. 
// Only in overview mode.
bool CDefaultPolicy::x_IsFeatLabelClicked(CGlPane& pane, 
                    const CLayoutFeatLabel* lbl, GLfloat row_y) const
{
    const TModelRect& rc = pane.GetVisibleRect();

    int label_width = kLabelsColWidth;
    TModelUnit width = pane.UnProjectWidth(label_width);
    TModelUnit offset = width * lbl->GetColumn();

    TModelRect rcM(rc.Left() + offset, row_y);
    rcM.SetSize(width, x_GetRowHeight(pane, lbl, false) );

    return rcM.PtInRect(m_LastClick.X(), m_LastClick.Y());
}


TModelUnit CDefaultPolicy::x_CalcAlignHeight(const CLayoutAlign* align) const
{
    const CAlnVec& aln_mgr = align->GetAlignMgr();
    TModelUnit height = m_Font_Helv10.TextHeight() + 4 +
                (kAlnElementHeight + 1) * (aln_mgr.GetNumRows() - 1);

    return height;
}


void CDefaultPolicy::x_Color(CSeqGraphicColorConfig::EDisplayElement e) const
{
    CGlColor color = m_ConfigSettings->GetElementColor(e);
    glColor3f(color.GetRed(), color.GetGreen(), color.GetBlue());
}



bool CDefaultPolicy::ProcessObject(CGlPane& pane, const CLayoutObject* obj,
                    TModelUnit row, EObj_IterMode mode, bool selected) const
{
    GLfloat row_y = row;