开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
label.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：24k
源码类别：

生物技术

开发平台：

C/C++

label.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: label.cpp,v $
  4.  * PRODUCTION Revision 1000.0  2004/06/01 21:20:46  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [GCC34_MSVC7] Dev-tree R1.4
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: label.cpp,v 1000.0 2004/06/01 21:20:46 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Authors:  Mike DiCuccio
  36.  *
  37.  * File Description:
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <gui/objutils/label.hpp>
  43. #include <corelib/ncbimtx.hpp>
  44. #include <objects/seq/Bioseq.hpp>
  45. #include <objects/seq/Seq_annot.hpp>
  46. #include <objects/seq/Annot_descr.hpp>
  47. #include <objects/seq/Annotdesc.hpp>
  48. #include <objects/seqalign/Seq_align.hpp>
  49. #include <objects/seqalign/Dense_seg.hpp>
  50. #include <objects/seqfeat/Seq_feat.hpp>
  51. #include <objects/seqloc/Seq_id.hpp>
  52. #include <objects/seqloc/Seq_loc.hpp>
  53. #include <objects/seqloc/Seq_interval.hpp>
  54. #include <objects/seqloc/Seq_point.hpp>
  55. #include <objects/seqset/Seq_entry.hpp>
  56. #include <objects/seqset/Bioseq_set.hpp>
  57. #include <objmgr/util/sequence.hpp>
  58. #include <objmgr/util/feature.hpp>
  60. BEGIN_NCBI_SCOPE
  61. USING_SCOPE(objects);
  64. DEFINE_STATIC_MUTEX(sm_Mutex);
  65. CLabel::TLabelMap CLabel::sm_LabelMap;
  68. void CLabel::GetLabel(const CObject& obj, string* label,
  69.                       ELabelType type, CScope* scope)
  70. {
  71.     if ( !label ) {
  72.         return;
  73.     }
  75.     const CSerialObject* so = dynamic_cast<const CSerialObject*>(&obj);
  76.     if (so) {
  77.         TLabelMap::const_iterator iter =
  78.             sm_LabelMap.find(so->GetThisTypeInfo()->GetName());
  79.         if (iter != sm_LabelMap.end()) {
  80.             iter->second->GetLabel(obj, label, type, scope);
  81.         } else {
  82.             *label = "CSerialObject";
  83.         }
  84.     } else {
  85.         *label = "CObject";
  86.     }
  87. }
  90. void CLabel::RegisterLabelHandler(const string& type,
  91.                                   ILabelHandler& handler)
  92. {
  93.     CMutexGuard LOCK(sm_Mutex);
  94.     sm_LabelMap[type] = CRef<ILabelHandler>(&handler);
  95. }
  98. void CLabel::RegisterLabelHandler(const CTypeInfo& type,
  99.                                   ILabelHandler& handler)
  100. {
  101.     CMutexGuard LOCK(sm_Mutex);
  102.     sm_LabelMap[type.GetName()] = CRef<ILabelHandler>(&handler);
  103. }
  105. //
  106. // label handlers
  107. //
  110. //
  111. // default format function for a seq-id
  112. // this is used by seq-id and seq-loc formatting
  113. //
  114. static inline
  115. void s_GetSeqLabel(const CSeq_id& id, string* label,
  116.                    CScope* scope, CLabel::ELabelType type)
  117. {
  118.     const CSeq_id* id_ptr = &id;
  119.     if (scope  &&  id_ptr->IsGi() ) {
  120.         CBioseq_Handle handle = scope->GetBioseqHandle(id);
  121.         if (handle) {
  122.             const CSeq_id& best_id =
  123.                 sequence::GetId(handle, sequence::eGetId_Best);
  124.             id_ptr = &best_id;
  125.         }
  126.     }
  128.     switch (type) {
  129.     case CLabel::eType:
  130.         id_ptr->GetLabel(label, CSeq_id::eType);
  131.         break;
  133.     default:
  134.     case CLabel::eTooltipBrief:
  135.     case CLabel::eContent:
  136.         id_ptr->GetLabel(label, CSeq_id::eContent);
  137.         break;
  139.     case CLabel::eTooltipDetailed:
  140.     case CLabel::eBoth:
  141.         id_ptr->GetLabel(label, CSeq_id::eBoth);
  142.         break;
  143.     }
  144. }
  147. //
  148. // process a seq-interval
  149. //
  150. static inline
  151. void s_GetSeq_intervalLabel(const CSeq_interval& interval, string* label,
  152.                             CScope* scope, CLabel::ELabelType type,
  153.                             const CSeq_id* last_id = NULL)
  154. {
  155.     if ( !last_id  ||  !interval.GetId().Match(*last_id)) {
  156.         if ( !label->empty() ) {
  157.             *label += "; ";
  158.         }
  159.         s_GetSeqLabel(interval.GetId(), label, scope, type);
  160.         *label += ": ";
  161.     }
  163.     *label += NStr::IntToString(interval.GetFrom());
  164.     *label += "-";
  165.     *label += NStr::IntToString(interval.GetTo());
  166.     if (interval.IsSetStrand()) {
  167.         switch (interval.GetStrand()) {
  168.         case eNa_strand_plus:
  169.             *label += " (+)";
  170.             break;
  171.         case eNa_strand_minus:
  172.             *label += " (-)";
  173.             break;
  174.         default:
  175.             *label += " (+)";
  176.             break;
  177.         }
  178.     }
  179. }
  183. //
  184. // internal processing of seq-loc labels
  185. // seq-locs frequently refer to GIs only - we need to use sequence accessions
  186. // to make a more friendly label
  187. //
  188. static inline
  189. const CSeq_id* s_GetLabel(const CSeq_loc& loc, string* label,
  190.                           CScope* scope, CLabel::ELabelType type,
  191.                           const CSeq_id* last_id = NULL)
  192. {
  193.     switch (loc.Which()) {
  194.     case CSeq_loc::e_Whole:
  195.         s_GetSeqLabel(loc.GetWhole(), label, scope, type);
  196.         return &loc.GetWhole();
  198.     case CSeq_loc::e_Int:
  199.         s_GetSeq_intervalLabel(loc.GetInt(), label, scope, type, last_id);
  200.         return &loc.GetInt().GetId();
  202.     case CSeq_loc::e_Packed_int:
  203.         {{
  204.             CConstRef<CSeq_id> id(last_id);
  205.             string str;
  206.             ITERATE (CSeq_loc::TPacked_int::Tdata, iter,
  207.                      loc.GetPacked_int().Get()) {
  208.                 const CSeq_interval& ival = **iter;
  209.                 if ( !str.empty() ) {
  210.                     str += ", ";
  211.                 }
  212.                 s_GetSeq_intervalLabel(ival, &str, scope, type, id.GetPointer());
  213.                 id.Reset(&ival.GetId());
  214.             }
  215.             *label += str;
  216.             return id.GetPointer();
  217.         }}
  219.     case CSeq_loc::e_Pnt:
  220.         {{
  221.             string str = NStr::IntToString(loc.GetPnt().GetPoint());
  222.             if ( !last_id  ||  !loc.GetPnt().GetId().Match(*last_id) ) {
  223.                 if ( !label->empty() ) {
  224.                     *label += "; ";
  225.                 }
  226.                 s_GetSeqLabel(loc.GetPnt().GetId(), label, scope, type);
  227.                 *label += ": ";
  228.             } else if ( !label->empty() ) {
  229.                 *label += ", ";
  230.             }
  231.             *label += str;
  232.             return &loc.GetPnt().GetId();
  233.         }}
  235.     case CSeq_loc::e_Packed_pnt:
  236.         {{
  237.             string str;
  238.             ITERATE (CSeq_loc::TPacked_pnt::TPoints, iter,
  239.                      loc.GetPacked_pnt().GetPoints()) {
  240.                 if ( !str.empty() ) {
  241.                     str += ", ";
  242.                 }
  243.                 str += NStr::IntToString(*iter);
  244.             }
  246.             if ( !last_id  ||  !loc.GetPnt().GetId().Match(*last_id) ) {
  247.                 if ( !label->empty() ) {
  248.                     *label += "; ";
  249.                 }
  250.                 s_GetSeqLabel(loc.GetPnt().GetId(), label, scope, type);
  251.                 *label += ": ";
  252.             } else if ( !label->empty() ) {
  253.                 *label += ", ";
  254.             }
  255.             *label += str;
  256.             return &loc.GetPnt().GetId();
  257.         }}
  259.     case CSeq_loc::e_Mix:
  260.         {{
  261.             string str;
  262.             ITERATE (CSeq_loc::TMix::Tdata, iter, loc.GetMix().Get()) {
  263.                 if ( !str.empty() ) {
  264.                     str += ", ";
  265.                 }
  266.                 last_id = s_GetLabel(**iter, &str, scope, type, last_id);
  267.             }
  268.             *label += str;
  269.             return last_id;
  270.         }}
  272.     default:
  273.         loc.GetLabel(label);
  274.         return NULL;
  275.     }
  276. }
  279. //
  280. //
  281. // seq-id handler
  282. //
  283. //
  284. class CSeq_idHandler : public ILabelHandler
  285. {
  286. public:
  287.     void GetLabel(const CObject& obj, string* label,
  288.                   CLabel::ELabelType type, CScope* scope) const
  289.     {
  290.         const CSeq_id* id = dynamic_cast<const CSeq_id*>(&obj);
  291.         if (id) {
  292.             s_GetSeqLabel(*id, label, scope, type);
  293.         }
  294.     }
  295. };
  298. //
  299. //
  300. // seq-loc handler
  301. //
  302. //
  303. class CSeq_locHandler : public ILabelHandler
  304. {
  305. public:
  306.     void GetLabel(const CObject& obj, string* label,
  307.                   CLabel::ELabelType type, CScope* scope) const
  308.     {
  309.         const CSeq_loc* loc = dynamic_cast<const CSeq_loc*>(&obj);
  310.         if (loc) {
  311.             s_GetLabel(*loc, label, scope, type);
  312.         }
  313.     }
  314. };
  318. //
  319. //
  320. // bioseq handler
  321. //
  322. //
  323. class CBioseqHandler : public ILabelHandler
  324. {
  325. public:
  326.     void GetLabel(const CObject& obj, string* label,
  327.                   CLabel::ELabelType type, CScope* scope) const
  328.     {
  329.         const CBioseq* bioseq = dynamic_cast<const CBioseq*>(&obj);
  330.         if (bioseq) {
  331.             switch (type) {
  332.             case CLabel::eType:
  333.                 bioseq->GetLabel(label, CBioseq::eType);
  334.                 break;
  335.             case CLabel::eContent:
  336.                 bioseq->GetLabel(label, CBioseq::eContent);
  337.                 break;
  339.             default:
  340.             case CLabel::eTooltipBrief:
  341.             case CLabel::eTooltipDetailed:
  342.             case CLabel::eBoth:
  343.                 bioseq->GetLabel(label, CBioseq::eBoth);
  344.                 break;
  345.             }
  346.         }
  347.     }
  348. };
  352. //
  353. //
  354. // Bioseq_set handler
  355. //
  356. //
  357. class CBioseq_setHandler : public ILabelHandler
  358. {
  359. public:
  360.     void GetLabel(const CObject& obj, string* label,
  361.                   CLabel::ELabelType type, CScope* scope) const
  362.     {
  363.         const CBioseq_set* bioseq_set = dynamic_cast<const CBioseq_set*>(&obj);
  364.         if (bioseq_set) {
  365.             switch (type) {
  366.             case CLabel::eType:
  367.                 bioseq_set->GetLabel(label, CBioseq_set::eType);
  368.                 break;
  369.             case CLabel::eContent:
  370.                 bioseq_set->GetLabel(label, CBioseq_set::eContent);
  371.                 break;
  373.             default:
  374.             case CLabel::eTooltipBrief:
  375.             case CLabel::eTooltipDetailed:
  376.             case CLabel::eBoth:
  377.                 bioseq_set->GetLabel(label, CBioseq_set::eBoth);
  378.                 break;
  379.             }
  380.         }
  381.     }
  382. };
  386. //
  387. //
  388. // seq-feat handler
  389. //
  390. //
  391. class CSeq_featHandler : public ILabelHandler
  392. {
  393. public:
  394.     void GetLabel(const CObject& obj, string* label,
  395.                   CLabel::ELabelType type, CScope* scope) const
  396.     {
  397.         const CSeq_feat* feat = dynamic_cast<const CSeq_feat*>(&obj);
  398.         if (feat) {
  399.             switch (type) {
  400.             case CLabel::eType:
  401.                 feature::GetLabel(*feat, label, feature::eType, scope);
  402.                 break;
  403.             case CLabel::eContent:
  404.                 feature::GetLabel(*feat, label, feature::eContent, scope);
  405.                 break;
  407.             default:
  408.             case CLabel::eTooltipBrief:
  409.             case CLabel::eTooltipDetailed:
  410.             case CLabel::eBoth:
  411.                 feature::GetLabel(*feat, label, feature::eBoth, scope);
  412.                 break;
  413.             }
  414.         }
  415.     }
  416. };
  419. //
  420. //
  421. // seq-entry handler
  422. //
  423. //
  424. class CSeq_entryHandler : public ILabelHandler
  425. {
  426. public:
  427.     void GetLabel(const CObject& obj, string* label,
  428.                   CLabel::ELabelType type, CScope* scope) const
  429.     {
  430.         const CSeq_entry* entry = dynamic_cast<const CSeq_entry*>(&obj);
  431.         if (entry) {
  432.             if (entry->IsSet()) {
  433.                 CLabel::GetLabel(entry->GetSet(), label, type, scope);
  434.             } else {
  435.                 CLabel::GetLabel(entry->GetSeq(), label, type, scope);
  436.             }
  437.         }
  438.     }
  439. };
  442. //
  443. //
  444. // seq-annots are complicated
  445. //
  446. //
  448. static void s_GetAnnotType(const CSeq_annot& annot, string* label)
  449. {
  450.     const CSeq_annot::TData& annot_data = annot.GetData();
  451.     switch (annot_data.Which()) {
  452.     case CSeq_annot::TData::e_Ftable:
  453.         *label += "Feature Table";
  454.         break;
  456.     case CSeq_annot::TData::e_Align:
  457.         *label += "Alignment";
  458.         break;
  460.     case CSeq_annot::TData::e_Graph:
  461.         *label += "Graph";
  462.         break;
  464.     case CSeq_annot::TData::e_Ids:
  465.         *label += "IDs";
  466.         break;
  467.     case CSeq_annot::TData::e_Locs:
  468.         *label += "Locations";
  469.         break;
  471.     default:
  472.         *label = "Annotation";
  473.         return;
  474.     }
  475. }
  478. static void s_GetAnnotContent(const CSeq_annot& annot, string* label)
  479. {
  480.     //
  481.     // check for formatted comments in descriptors first
  482.     //
  483.     if (annot.IsSetDesc()) {
  484.         ITERATE (CSeq_annot::TDesc::Tdata, iter, annot.GetDesc().Get()) {
  485.             switch ((*iter)->Which()) {
  486.             case CAnnotdesc::e_Title:
  487.                 *label = (*iter)->GetTitle();
  488.                 return;
  490.             default:
  491.                 break;
  492.             }
  493.         }
  494.     }
  496.     //
  497.     // default handling
  498.     //
  499.     string str;
  500.     size_t items = 0;
  501.     const CSeq_annot::TData& annot_data = annot.GetData();
  502.     switch (annot_data.Which()) {
  503.     case CSeq_annot::TData::e_Ftable:
  504.         str = "Feature Table, ";
  505.         items = annot_data.GetFtable().size();
  506.         break;
  508.     case CSeq_annot::TData::e_Align:
  509.         str = "Alignment, ";
  510.         items = annot_data.GetAlign().size();
  511.         break;
  513.     case CSeq_annot::TData::e_Graph:
  514.         str = "Graph, ";
  515.         items = annot_data.GetGraph().size();
  516.         break;
  518.     case CSeq_annot::TData::e_Ids:
  519.         str = "IDs, ";
  520.         items = annot_data.GetIds().size();
  521.         break;
  522.     case CSeq_annot::TData::e_Locs:
  523.         str = "Locations, ";
  524.         items = annot_data.GetLocs().size();
  525.         break;
  527.     default:
  528.         *label = "Annotation";
  529.         return;
  530.     }
  532.     str += NStr::IntToString(items);
  533.     if (items != 1) {
  534.         str += " entries";
  535.     } else {
  536.         str += " entry";
  537.     }
  539.     *label += str;
  541. }
  544. class CSeq_annotHandler : public ILabelHandler
  545. {
  546. public:
  547.     void GetLabel(const CObject& obj, string* label,
  548.                   CLabel::ELabelType type, CScope* scope) const
  549.     {
  550.         const CSeq_annot* annot  = dynamic_cast<const CSeq_annot*> (&obj);
  551.         if ( !annot ) {
  552.             return;
  553.         }
  555.         switch (type) {
  556.         case CLabel::eType:
  557.             s_GetAnnotType(*annot, label);
  558.             return;
  560.         case CLabel::eContent:
  561.             s_GetAnnotContent(*annot, label);
  562.             return;
  564.         case CLabel::eBoth:
  565.             s_GetAnnotType(*annot, label);
  566.             *label += ": ";
  567.             s_GetAnnotContent(*annot, label);
  568.             break;
  569.         }
  570.     }
  571. };
  574. static void s_GetAlignmentType(const CSeq_align& align, string* label)
  575. {
  576.     switch (align.GetSegs().Which()) {
  577.     default:
  578.     case CSeq_align::TSegs::e_not_set:
  579.         *label += "[Unknown]";
  580.         break;
  581.     case CSeq_align::TSegs::e_Denseg:
  582.         *label += "[Dense-seg]";
  583.         break;
  584.     case CSeq_align::TSegs::e_Dendiag:
  585.         *label += "[Dense-diag]";
  586.         break;
  587.     case CSeq_align::TSegs::e_Std:
  588.         *label += "[Standard-seg]";
  589.         break;
  590.     case CSeq_align::TSegs::e_Packed:
  591.         *label += "[Packed-seg]";
  592.         break;
  593.     case CSeq_align::TSegs::e_Disc:
  594.         *label += "[Discontinuous]";
  595.         break;
  596.     }
  597. }
  599. static void s_GetAlignmentContent(const CSeq_align& align, string* label,
  600.                                   CScope* scope)
  601. {
  602.     switch (align.GetSegs().Which()) {
  603.     default:
  604.     case CSeq_align::TSegs::e_not_set:
  605.         *label += "unknown contents";
  606.         break;
  607.     case CSeq_align::TSegs::e_Denseg:
  608.         {{
  609.             string str;
  610.             size_t seqs = align.GetSegs().GetDenseg().GetIds().size();
  611.             if (seqs < 4) {
  612.                 ITERATE (CDense_seg::TIds, iter,
  613.                          align.GetSegs().GetDenseg().GetIds()) {
  614.                     const CSeq_id* best_id = *iter;
  615.                     if (scope) {
  616.                         CBioseq_Handle handle =
  617.                             scope->GetBioseqHandle(**iter);
  618.                         if ( !handle ) {
  619.                             continue;
  620.                         }
  621.                         best_id = &sequence::GetId(handle,
  622.                                                    sequence::eGetId_Best);
  623.                     }
  624.                     if ( !str.empty() ) {
  625.                         str += " x ";
  626.                     }
  627.                     best_id->GetLabel(&str, CSeq_id::eContent);
  628.                 }
  629.             } else {
  630.                 str = NStr::IntToString(seqs) + " sequences.";
  631.             }
  633.             *label += str;
  634.         }}
  635.         break;
  636.     case CSeq_align::TSegs::e_Dendiag:
  637.         *label += "[Dense-diag]";
  638.         break;
  639.     case CSeq_align::TSegs::e_Std:
  640.         *label += "[Standard-seg]";
  641.         break;
  642.     case CSeq_align::TSegs::e_Packed:
  643.         *label += "[Packed-seg]";
  644.         break;
  645.     case CSeq_align::TSegs::e_Disc:
  646.         *label += "[Discontinuous]";
  647.         break;
  648.     }
  649. }
  652. class CSeq_alignHandler : public ILabelHandler
  653. {
  654. public:
  655.     void GetLabel(const CObject& obj, string* label,
  656.                   CLabel::ELabelType type, CScope* scope) const
  657.     {
  658.         const CSeq_align* align  = dynamic_cast<const CSeq_align*> (&obj);
  659.         if ( !align ) {
  660.             return;
  661.         }
  663.         switch (type) {
  664.         case CLabel::eType:
  665.             s_GetAlignmentType(*align, label);
  666.             return;
  668.         case CLabel::eContent:
  669.             s_GetAlignmentContent(*align, label, scope);
  670.             return;
  672.         case CLabel::eBoth:
  673.             s_GetAlignmentType(*align, label);
  674.             *label += ' ';
  675.             s_GetAlignmentContent(*align, label, scope);
  676.             break;
  677.         }
  678.     }
  679. };
  682. #if 0
  685. // retrieve a string label for an abstract object
  686. string CSeqUtils::GetLabel(const CObject& obj, CScope* scope)
  687. {
  688.     {{
  689.         // standard seq-annot label formatting
  690.         const CSeq_annot* annot  = dynamic_cast<const CSeq_annot*> (&obj);
  691.         if (annot) {
  692.             const CSeq_annot::TData& annot_data = annot->GetData();
  694.             string label;
  695.             size_t items = 0;
  696.             switch (annot_data.Which()) {
  697.             case CSeq_annot::TData::e_Ftable:
  698.                 label = "Feature Table, ";
  699.                 items = annot_data.GetFtable().size();
  700.                 break;
  702.             case CSeq_annot::TData::e_Align:
  703.                 label = "Alignment, ";
  704.                 items = annot_data.GetAlign().size();
  705.                 break;
  707.             case CSeq_annot::TData::e_Graph:
  708.                 label = "Graph, ";
  709.                 items = annot_data.GetGraph().size();
  710.                 break;
  712.             case CSeq_annot::TData::e_Ids:
  713.                 label = "IDs, ";
  714.                 items = annot_data.GetIds().size();
  715.                 break;
  716.             case CSeq_annot::TData::e_Locs:
  717.                 label = "Locations, ";
  718.                 items = annot_data.GetLocs().size();
  719.                 break;
  721.             default:
  722.                 return "Annotation";
  723.             }
  725.             label += NStr::IntToString(items);
  726.             if (items != 1) {
  727.                 label += " entries";
  728.             } else {
  729.                 label += " entry";
  730.             }
  732.             return label;
  733.         }
  735.     }}
  737.     {{
  738.         // standard seq-align label formatting
  739.         const CSeq_align* align  = dynamic_cast<const CSeq_align*> (&obj);
  740.         if (align) {
  741.             string label;
  743.             switch (align->GetSegs().Which()) {
  744.             case CSeq_align::TSegs::e_not_set:
  745.                 label = "Alignment: unknown type";
  746.                 break;
  748.             case CSeq_align::TSegs::e_Denseg:
  749.                 {{
  750.                     size_t seqs = align->GetSegs().GetDenseg().GetIds().size();
  751.                     if (seqs < 4) {
  752.                         ITERATE (CDense_seg::TIds, iter,
  753.                                  align->GetSegs().GetDenseg().GetIds()) {
  754.                             const CSeq_id* best_id = *iter;
  755.                             if (scope) {
  756.                                 CBioseq_Handle handle =
  757.                                     scope->GetBioseqHandle(**iter);
  758.                                 if ( !handle ) {
  759.                                     continue;
  760.                                 }
  761.                                 best_id =
  762.                                     &sequence::GetId(handle,
  763.                                                      sequence::eGetId_Best);
  764.                             }
  765.                             if ( !label.empty() ) {
  766.                                 label += " x ";
  767.                             }
  768.                             best_id->GetLabel(&label,
  769.                                               CSeq_id::eContent);
  770.                         }
  772.                         label = "Alignment: " + label;
  773.                     } else {
  774.                         label = "Alignment: " +
  775.                             NStr::IntToString(seqs) +
  776.                             " sequences.";
  777.                     }
  778.                 }}
  779.                 break;
  781.             case CSeq_align::TSegs::e_Dendiag:
  782.                 label = "Alignment: dense-diagonal";
  783.                 break;
  785.             case CSeq_align::TSegs::e_Std:
  786.                 label = "Alignment: standard-seg";
  787.                 break;
  789.             case CSeq_align::TSegs::e_Packed:
  790.                 label = "Alignment: packed-seg";
  791.                 break;
  793.             case CSeq_align::TSegs::e_Disc:
  794.                 label = "Alignment: discontinuous";
  795.                 break;
  796.             }
  798.             return label;
  799.         }
  801.     }}
  803.     {{
  804.         // generic unhandled CSerialObject
  805.         const CSerialObject* ser_obj =
  806.             dynamic_cast<const CSerialObject*> (&obj);
  807.         if (ser_obj) {
  808.             return ser_obj->GetThisTypeInfo()->GetName();
  809.         }
  810.     }}
  812.     /*{{  // should never be called that way: GetLabel(CLayoutObject obj);
  813.         // layout objects
  814.         const CLayoutObject* layout = dynamic_cast<const CLayoutObject*>(&obj);
  815.         if (layout) {
  816.             return GetLabel(layout->GetObject()), scope);
  817.         }
  818.     }}*/
  820.     // generic object handling
  821.     return ("Object");
  822. }
  825. #endif
  830. //
  831. // force registration at load
  832. //
  834. struct SForceRegister
  835. {
  836.     SForceRegister()
  837.     {
  838.         CLabel::RegisterLabelHandler(*CSeq_id::GetTypeInfo(),     *new CSeq_idHandler());
  839.         CLabel::RegisterLabelHandler(*CSeq_loc::GetTypeInfo(),    *new CSeq_locHandler());
  840.         CLabel::RegisterLabelHandler(*CBioseq::GetTypeInfo(),     *new CBioseqHandler());
  841.         CLabel::RegisterLabelHandler(*CBioseq_set::GetTypeInfo(), *new CBioseq_setHandler());
  842.         CLabel::RegisterLabelHandler(*CSeq_feat::GetTypeInfo(),   *new CSeq_featHandler());
  843.         CLabel::RegisterLabelHandler(*CSeq_entry::GetTypeInfo(),  *new CSeq_entryHandler());
  844.         CLabel::RegisterLabelHandler(*CSeq_annot::GetTypeInfo(),  *new CSeq_annotHandler());
  845.         CLabel::RegisterLabelHandler(*CSeq_align::GetTypeInfo(),  *new CSeq_alignHandler());
  846.     }
  847. };
  849. static SForceRegister sm_ForceRegistration;
  851. END_NCBI_SCOPE
  854. /*
  855.  * ===========================================================================
  856.  * $Log: label.cpp,v $
  857.  * Revision 1000.0  2004/06/01 21:20:46  gouriano
  858.  * PRODUCTION: IMPORTED [GCC34_MSVC7] Dev-tree R1.4
  859.  *
  860.  * Revision 1.4  2004/05/21 22:27:44  gorelenk
  861.  * Added PCH ncbi_pch.hpp
  862.  *
  863.  * Revision 1.3  2004/05/14 14:23:15  dicuccio
  864.  * When determining a label for a seq-id, only try to resolve GI-based seq-ids;
  865.  * all others can be considered "good enough"
  866.  *
  867.  * Revision 1.2  2004/05/07 15:38:54  dicuccio
  868.  * Fixed alignment labels lost in previous commit
  869.  *
  870.  * Revision 1.1  2004/04/30 11:48:16  dicuccio
  871.  * Initial commit - split out from src/gui/utils
  872.  *
  873.  * Revision 1.1  2004/04/20 19:16:33  dicuccio
  874.  * Initial revision
  875.  *
  876.  * ===========================================================================
  877.  */