src/gui/widgets/object_list/object_text.cpp

Go to the documentation of this file.

/*  $Id: object_text.cpp 20473 2009-12-02 15:20:11Z ucko $
 * ===========================================================================
 *
 *                            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: Yury Voronov
 *
 * File Description:
 *
 */

#include <ncbi_pch.hpp>

#include <gui/widgets/object_list/object_text.hpp>

#include <gui/widgets/text_widget/plain_text_item.hpp>
#include <gui/widgets/text_widget/composite_text_item.hpp>
#include <gui/widgets/text_widget/selection_helper.hpp>
#include <gui/widgets/wx/simple_clipboard.hpp>

#include <gui/objutils/label.hpp>

#include <objects/seqalign/Seq_align.hpp>
#include <objects/seqfeat/Seq_feat.hpp>
#include <objects/seqloc/Seq_loc.hpp>
#include <objects/general/Object_id.hpp>
#include <objects/general/User_object.hpp>
#include <objects/general/User_field.hpp>

#include <connect/ncbi_conn_stream.hpp>

#include <objects/seqalign/Seq_align_set.hpp>
#include <objects/seqalign/Dense_seg.hpp>
#include <objects/seqalign/Std_seg.hpp>

#include <serial/iterator.hpp>
#include <objmgr/util/sequence.hpp>
#include <objmgr/util/feature.hpp>
#include <objtools/format/flat_file_config.hpp>
#include <objtools/format/flat_file_generator.hpp>

#include <wx/sstream.h>
#include <wx/txtstrm.h>


BEGIN_NCBI_SCOPE
USING_SCOPE(objects);

class CSelectableMainGroup : public CCompositeTextItem
{
    DECLARE_EVENT_TABLE()
public:

    virtual void FillContextMenu( wxMenu& menu ) const;

    void OnMenuCommand( wxCommandEvent& event );
    void OnMenuCommandUpdateUI( wxUpdateUIEvent& event );
};

BEGIN_EVENT_TABLE( CSelectableMainGroup, CCompositeTextItem )
    EVT_MENU( wxID_COPY, CSelectableMainGroup::OnMenuCommand )
    EVT_UPDATE_UI( wxID_COPY, CSelectableMainGroup::OnMenuCommandUpdateUI )
END_EVENT_TABLE()


class CSelectableObjectItem : public CCompositeTextItem
{
    DECLARE_EVENT_TABLE()

public:
    CSelectableObjectItem( const CObject* object ) : m_Object( object ) {
    }

    virtual const CConstRef<CObject> GetAssosiatedObject() const { return m_Object; }
    virtual int GetTextOffset( CTextPanelContext* context ) const;

    virtual void FillContextMenu( wxMenu& menu ) const;

protected:
    void OnCopy( wxCommandEvent& event );
    void OnCopyUpdateUI( wxUpdateUIEvent& event );

private:
    CConstRef<CObject> m_Object;
};

BEGIN_EVENT_TABLE( CSelectableObjectItem, CCompositeTextItem )
    EVT_MENU( wxID_COPY, CSelectableObjectItem::OnCopy )
    EVT_UPDATE_UI( wxID_COPY, CSelectableObjectItem::OnCopyUpdateUI )

END_EVENT_TABLE()

void CSelectableMainGroup::FillContextMenu( wxMenu& menu ) const
{
    menu.Append( wxID_COPY, _T("&Copy") );
}

void CSelectableMainGroup::OnMenuCommand( wxCommandEvent& event )
{
    if( event.GetId() == wxID_COPY ){
        CTextItemPanel* panel = static_cast<CTextItemPanel*>( event.GetEventObject() );
        CTextPanelContext* context = panel->GetContext();
        if( panel->IsTextSelected() ){
            CTextBlock block = panel->GetTextSelection().Normalized();

            wxStringOutputStream stream;
            wxTextOutputStream os( stream );
            GetText( os, block, context );

            CSimpleClipboard::Instance().Set( stream.GetString() );
        }
    }
}

void CSelectableMainGroup::OnMenuCommandUpdateUI( wxUpdateUIEvent& event )
{
    if( event.GetId() == wxID_COPY ){
        CTextItemPanel* panel = (CTextItemPanel*)event.GetEventObject();
        event.Enable( panel->IsTextSelected() );
    }
}


int CSelectableObjectItem::GetTextOffset( CTextPanelContext* context ) const
{
    return
        CCompositeTextItem::GetTextOffset( context )
        + context->GetLeftMargin()
    ;
}

void CSelectableObjectItem::FillContextMenu( wxMenu& menu ) const
{
    menu.Append( wxID_COPY, _T("&Copy") );
}

void CSelectableObjectItem::OnCopy( wxCommandEvent& event )
{
    CTextItemPanel* panel = static_cast<CTextItemPanel*>( event.GetEventObject() );
    CTextPanelContext* context = panel->GetContext();
    if( panel->IsTextSelected() ){
        CTextBlock block = panel->GetTextSelection().Normalized();

        wxStringOutputStream stream;
        wxTextOutputStream os( stream );
        GetText( os, block, context );

        CSimpleClipboard::Instance().Set( stream.GetString() );
    }
}

void CSelectableObjectItem::OnCopyUpdateUI( wxUpdateUIEvent& event )
{
    CTextItemPanel* panel = (CTextItemPanel*)event.GetEventObject();
    event.Enable( panel->IsTextSelected() );
}

///////////////////////////////////////////////////////////////////////////////
/// CObjectTextWidget
CObjectTextWidget::CObjectTextWidget()
    : CTextItemPanel()
    , m_Brief( false )
    , m_Scope( NULL )
{
}

CObjectTextWidget::CObjectTextWidget(
    wxWindow* parent,
    wxWindowID id,
    const wxPoint& pos,
    const wxSize& size
)
    : CTextItemPanel( parent, id, pos, size )
    , m_Brief( false )
    , m_Scope( NULL )
{
    SetBackgroundColour( wxColor(_T("white")) );

    //x_UpdatePanelFont();
    int pointSize = 8;
    wxFontFamily fontFamily = wxFONTFAMILY_MODERN;
    SetFont(wxFont(pointSize, fontFamily, wxNORMAL, wxNORMAL));
}

void CObjectTextWidget::Init( TConstScopedObjects& objects, bool brief )
{
    m_Objects = objects;
    m_Brief = brief;

    if( objects.size() > 0 ){
       m_Scope = objects[0].scope;
    }

    vector<ITextItem*> items;

    x_GenerateTextItemsFromObjects( items );

    SetData( new CSelectableMainGroup(), new CTextPanelContext(2) );
    AddItems( items );
}

void CObjectTextWidget::GetSelection( TConstScopedObjects& objects )
{
    vector< CConstRef<CObject> > objs;

    GetContext()->GetSelectedObjects( objs );

    for( int i = 0; i < (int)objs.size(); ++i ){
        const CObject* obj = objs[i];
        objects.push_back( SConstScopedObject(*obj, *m_Scope) );
    }
}


//static const char* kObjectPrefix = "\n-----\n\n";

void CObjectTextWidget::x_GenerateTextItemsFromObjects( vector<ITextItem*>& items )
{
    int obj_num = m_Objects.size();

    for( int i = 0; i < obj_num; i++ ){
        if( i > 0 ){
            CPlainTextItem* item = new CPlainTextItem();
            item->AddLine( " " );
            items.push_back( item );
        }

        SConstScopedObject& obj = m_Objects[i];

        x_GetItems_Object( *obj.object, obj.scope, items );
    }
}

static void s_GetItems_PairwiseAlign(
    const CSeq_align& align, CScope* scope, vector<ITextItem*>& items
){
    string text;

    switch( align.GetSegs().Which() ){
    case CSeq_align::TSegs::e_Denseg:
        break;

    case CSeq_align::TSegs::e_Std:
        break;

    case CSeq_align::TSegs::e_Disc:
        {{
            /// each segment represents an exon, so we can format a text dump
            /// with this information
            ITERATE( CSeq_align::TSegs::TDisc::Tdata, iter, align.GetSegs().GetDisc().Get() ){
            }
        }}
        break;

    default:
        CLabel::GetLabel( align, &text, CLabel::eDescription, scope );
        break;
    }

    CPlainTextItem* item = new CPlainTextItem();
    item->AddLine( text );
    items.push_back( item );
}


static void s_GetItems_GenericAlign(
    const CSeq_align& align, CScope* scope, vector<ITextItem*>& items
){
    string text;
    CLabel::GetLabel( align, &text, CLabel::eDescription, scope );

    CPlainTextItem* item = new CPlainTextItem();
    item->AddLine( text );
    items.push_back( item );
}


static void s_GetItems_Align(
    const CSeq_align& align, CScope* scope, vector<ITextItem*>& items
){
    string preamble;
    string ids;

    set<CSeq_id_Handle> id_set;
    CTypeConstIterator<CSeq_id> id_iter( align );
    for( ; id_iter; ++id_iter ){
        CSeq_id_Handle idh = CSeq_id_Handle::GetHandle( *id_iter );
        if( id_set.insert(idh).second ){
            if( !ids.empty() ){
                ids += " x ";
            }

            if( scope ){
                idh = sequence::GetId( idh, *scope, sequence::eGetId_Best );
            }
            idh.GetSeqId()->GetLabel( &ids );
        }
    }

    string text;

    text = "Alignment: " + ids;
    CPlainTextItem* item = new CPlainTextItem();
    item->AddLine( text );
    items.push_back( item );

    if( id_set.size() == 2 ){
        s_GetItems_PairwiseAlign( align, scope, items );
    } else {
        s_GetItems_GenericAlign(align, scope, items );
    }
}


static void s_AccListToItem(const CUser_field::TData::TStrs& item_data,
                            const string& title,
                            CPlainTextItem* item)
{
    string s(title);
    if ( !s.empty() ) {
        s += ": ";
    }

    list<string> refseq;
    list<string> non_refseq;
    ITERATE (CUser_field::TData::TStrs, it, item_data) {
        CSeq_id::EAccessionInfo info = CSeq_id::IdentifyAccession(*it);
        if ((info & CSeq_id::eAcc_type_mask) == CSeq_id::e_Other) {
            refseq.push_back(*it);
        } else {
            non_refseq.push_back(*it);
        }
    }

    string accs;
    if (refseq.size()) {
        accs += NStr::Join(refseq, ", ");
    }

    if (non_refseq.size()) {
        if ( !accs.empty() ) {
            accs += ", ";
        }
        accs += NStr::Join(non_refseq, ", ");
    }

    if ( !accs.empty() ) {
        s += accs;
    } else {
        s += "<unknown>";
    }

    list<string> lines;
    NStr::Wrap(s, 78, lines);
    if ( !lines.empty() ) {
        ITERATE (list<string>, iter, lines) {
            if (iter != lines.begin()) {
                item->AddLine("    " + *iter);
            } else {
                item->AddLine(*iter);
            }
        }
    }
}

static void s_GetItems_Feat_Evidence(
    const CSeq_feat& feat, CScope* scope, vector<ITextItem*>& items)
{
    if ( !feat.IsSetExt()  &&  !feat.IsSetExts()) {
        return;
    }

    list< CConstRef<CUser_object> > objs;
    if (feat.IsSetExt()) {
        CConstRef<CUser_object> o(&feat.GetExt());
        if (o->IsSetType()  &&  o->GetType().IsStr()  && o->GetType().GetStr() == "CombinedFeatureUserObjects") {
            ITERATE (CUser_object::TData, it, o->GetData()) {
                const CUser_field& field = **it;
                CConstRef<CUser_object> sub_o(&field.GetData().GetObject());
                objs.push_back(sub_o);
            }
        } else {
            objs.push_back(o);
        }
    }
    if (feat.IsSetExts()) {
        copy(feat.GetExts().begin(), feat.GetExts().end(), back_inserter(objs));
    }

    CPlainTextItem* item = new CPlainTextItem();

    ITERATE (list< CConstRef<CUser_object> >, obj_it, objs) {
        const CUser_object& obj = **obj_it;
        if ( !obj.IsSetType()  ||
             !obj.GetType().IsStr()  ||
             obj.GetType().GetStr() != "ModelEvidence") {
            continue;
        }

        string s;
        CConstRef<CUser_field> f;

        item->AddLine("");

        ///
        /// generation method
        string method;
        s = "Model Generation Method: ";
        f = obj.GetFieldRef("Method");
        if (f) {
            method = f->GetData().GetStr();
            s += method;
        } else {
            s += "<unknown>";
        }
        item->AddLine(s);

        ///
        /// list of support
        if (method == "Chainer"  ||  method == "Gnomon") {

            ///
            /// scan for multiple 'Core' entries
            f = obj.GetFieldRef("Support");
            if (f) {
                string core;
                ITERATE (CUser_field::TData::TFields, it, f->GetData().GetFields()) {
                    const CUser_field& this_f = **it;
                    if (this_f.GetLabel().GetStr() == "Core") {
                        if ( !core.empty() ) {
                            core += ", ";
                        }
                        core += this_f.GetData().GetStr();
                    }
                }
                if ( !core.empty() ) {
                    s = "Model Based On: ";
                    s += core;
                    item->AddLine(s);
                }
            }

            ///
            /// supporting proteins
            f = obj.GetFieldRef("Support.Proteins");
            if (f) {
                s_AccListToItem(f->GetData().GetStrs(),
                                "Source Proteins", item);
            }

            ///
            /// supporting proteins
            f = obj.GetFieldRef("Support.mRNAs");
            if (f) {
                s_AccListToItem(f->GetData().GetStrs(),
                                "Source mRNAs", item);
            }
        }
    }

    items.push_back( item );
}



static void s_GetItems_Feat(
    const CSeq_feat& feat, CScope* scope, vector<ITextItem*>& items
){
    string text;
    CPlainTextItem* item;

    try {
        /// start with the description text
        CLabel::GetLabel( feat, &text, CLabel::eDescription, scope );
        item = new CPlainTextItem();
        item->AddLine( text );
        items.push_back( item );

        /// add information about the feature's location
        TSeqRange range = feat.GetLocation().GetTotalRange();
        text = "Total Range:  ";
        switch( sequence::GetStrand(feat.GetLocation(), scope) ){
        case eNa_strand_plus:
            text += "(+) ";
            break;
        case eNa_strand_minus:
            text += "(-) ";
            break;

        default:
            break;
        }

        text += NStr::IntToString(range.GetFrom() + 1, NStr::fWithCommas);
        text += " - ";
        text += NStr::IntToString(range.GetTo() + 1, NStr::fWithCommas);

        item = new CPlainTextItem();
        item->AddLine( text );
        items.push_back( item );

        text = "Total Length:  ";
        text += NStr::IntToString(range.GetLength(), NStr::fWithCommas);

        item = new CPlainTextItem();
        item->AddLine( text );
        items.push_back( item );

        text = "Processed Length:  ";
        text += NStr::IntToString(sequence::GetLength(feat.GetLocation(), scope),
                                  NStr::fWithCommas);

        item = new CPlainTextItem();
        item->AddLine( text );
        items.push_back( item );

        if (feat.IsSetProduct()  &&  scope) {
            try {
                string prod_len_str;
                CBioseq_Handle h = scope->GetBioseqHandle(feat.GetProduct());
                if (h) {
                    text = "Product Length: ";
                    text += NStr::IntToString(h.GetBioseqLength(),
                                              NStr::fWithCommas);

                    item = new CPlainTextItem();
                    item->AddLine( text );
                    items.push_back( item );
                }
            }
            catch (CException&) {
            }
        }

        item = new CPlainTextItem();
        item->AddLine( " " );
        items.push_back( item );

        /// next, include the flat file text for this feature
        CFlatFileConfig cfg;
        cfg.SetNeverTranslateCDS();

        if( scope ){
            string s = CFlatFileGenerator::GetSeqFeatText(feat, *scope, cfg);
            string::size_type pos = s.find_first_not_of(" \n\r\t");
            if( pos != string::npos ){
                s.erase(0, pos);
            }

            item = new CPlainTextItem();

            string::size_type lpos = -1;
            do {
                pos = lpos +1;
                lpos = s.find_first_of("\n\r", pos );

                if( lpos == string::npos ){
                    text = s.substr( pos );
                } else {
                    text = s.substr( pos, lpos - pos );
                }
                item->AddLine( text );

            } while( lpos != string::npos );

            items.push_back( item );
        }

        /// lastly, add items relating to model evidence
        s_GetItems_Feat_Evidence(feat, scope, items);
    }
    catch (CException&) {
    }
}

static void s_GetItems_Loc(
    const CSeq_loc& loc, CScope* scope, vector<ITextItem*>& items
){
    string text;
    CLabel::GetLabel( loc, &text, CLabel::eDescription, scope );

    CPlainTextItem* item = new CPlainTextItem();
    item->AddLine( text );
    items.push_back( item );
}

void CObjectTextWidget::x_GetItems_Object(
    const CObject& object, CScope* scope, vector<ITextItem*>& items
){
    if( m_Brief ){
        string text;
        CLabel::GetLabel(
            object, &text, CLabel::eDescriptionBrief, scope
            );

        CPlainTextItem* item = new CPlainTextItem();
        item->AddLine( text );
        items.push_back( item );
    } else {
        const CSerialObject* cso = dynamic_cast<const CSerialObject*>(&object);

        if( cso ){

            CSelectableObjectItem* comp_item = new CSelectableObjectItem( cso );
            vector<ITextItem*> comp_items;

            if( cso->GetThisTypeInfo() == CSeq_align::GetTypeInfo() ){
                s_GetItems_Align((const CSeq_align&)*cso, scope, comp_items);

            } else if (cso->GetThisTypeInfo() == CSeq_feat::GetTypeInfo()) {
                s_GetItems_Feat((const CSeq_feat&)*cso, scope, comp_items);

            } else if (cso->GetThisTypeInfo() == CSeq_loc::GetTypeInfo()) {
                s_GetItems_Loc((const CSeq_loc&)*cso, scope, comp_items);
            } else {
                string text;
                CLabel::GetLabel( object, &text, CLabel::eDescription, scope );

                CPlainTextItem* item = new CPlainTextItem();
                item->AddLine( text );
                comp_items.push_back( item );
            }

            NON_CONST_ITERATE( vector<ITextItem*>, item_iter, comp_items ){
                comp_item->AddItem( *item_iter );
            }

            items.push_back( comp_item );
        }
    }
}

END_NCBI_SCOPE

---