intron_track.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  
 * ===========================================================================
 *
 *                            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:  Andrei Shkeda
 *
 * File Description:
 *
 */
 
#include <ncbi_pch.hpp>
 
#include <gui/widgets/seq_graphic/intron_track.hpp>
#include <gui/widgets/seq_graphic/intron_glyph.hpp>
 
BEGIN_NCBI_SCOPE
USING_SCOPE(objects); 
 
///////////////////////////////////////////////////////////////////////////////
/// CIntronTrack
///////////////////////////////////////////////////////////////////////////////
 
CIntronTrack::CIntronTrack(CSGFeatureDS* ds, CRenderingContext* r_cntx)
    : CFeatureTrack(ds, r_cntx)
    
{
    // commented out in hope for gbench implementation
    //x_RegisterIcon(SIconInfo(eIcon_Settings, "Settings", true, "track_settings"));
}
 
void CIntronTrack::x_OnIconClicked(TIconID id)
{
    // commented out in hope for gbench implementation
    switch (id) {
    case eIcon_Settings:
        x_OnSettingsIconClicked();
        break;
    default:
        // use default handlers
        CFeatureTrack::x_OnIconClicked(id);
    }
}
 
 
void CIntronTrack::x_OnSettingsIconClicked()
{
/* commented out in hope for gbench implementation
    wxMenu menu;
    UseDefaultMarginWidth(menu);
    int id_base = 10000;
    wxMenuItem* item = menu.AppendCheckItem(id_base, ToWxString("Hide introns with no splice junctions in the current view"));
    if (m_HideIntrons)
        item->Check();
    m_LTHost->LTH_PopupMenu(&menu);
    wxMenuItemList& item_list = menu.GetMenuItems();
    ITERATE(wxMenuItemList, iter, item_list) {
        if ((*iter)->GetId() == id_base) {
            m_HideIntrons = (*iter)->IsChecked();
            x_UpdateData();
        }
    }
*/
}
void CIntronTrack::x_LoadFeatures(const TSeqRange& range, int feat_limit)
{
    list<string> f;
    string tmp;
    if (m_HideIntrons) {
        tmp = "(from >= ";
        tmp += NStr::NumericToString(range.GetFrom());
        tmp += " or to <= ";
        tmp += NStr::NumericToString(range.GetTo());
        tmp += ")";
        f.push_back(tmp);
    }
    if (m_NoReadFilter == false) {
        if (m_ReadsCountMin > 0) {
            tmp = "reads >=";
            tmp += NStr::NumericToString(m_ReadsCountMin);
            f.push_back(tmp);
        }
        if (m_ReadsCountMax > 0) {
            tmp = "reads <=";
            tmp += NStr::NumericToString(m_ReadsCountMax);
            f.push_back(tmp);
        }
    }
    string filter = "";
    if (!f.empty())
        filter = NStr::Join(f, " and ");
 
    m_DS->SetSortBy(m_SortStrand ? "strand" : "");
    m_DS->LoadFeatures(m_FeatSel, range, m_Context->GetScale(), -1, feat_limit, m_LinkedFeat, filter);
}
 
 
void CIntronTrack::x_ParseSettings(const TKeyValuePairs& settings)
{
    CFeatureTrack::x_ParseSettings(settings);
    // feature track doesn't use profile
    ITERATE(TKeyValuePairs, iter, settings) {
        try {
            if (NStr::EqualNocase(iter->first, "sort_reads")) {
                m_SortReads = NStr::StringToBool(iter->second);
            } else if (NStr::EqualNocase(iter->first, "sort_strands")) {
                m_SortStrand = NStr::StringToBool(iter->second);
            } else if (NStr::EqualNocase(iter->first, "hide_feats")) {
                m_HideIntrons = NStr::StringToBool(iter->second);
            } else if (NStr::EqualNocase(iter->first, "read_range")) {
                string read_range = iter->second;
                if (!read_range.empty()) {
                    string range_min, range_max;
                    CTrackConfigUtils::DecodeValueRange(read_range, range_min, range_max, m_NoReadFilter);
                    if (!range_min.empty() && range_min != "inf") {
                        m_ReadsCountMin = NStr::StringToNumeric<float>(range_min, NStr::fConvErr_NoThrow);
                    }
                    if (!range_max.empty() && range_max != "inf") {
                        m_ReadsCountMax = NStr::StringToNumeric<float>(range_max, NStr::fConvErr_NoThrow);
                    }
                    if (m_ReadsCountMin > 0 && m_ReadsCountMax > 0 && m_ReadsCountMin > m_ReadsCountMax) {
                        swap(m_ReadsCountMin, m_ReadsCountMax);
                    }
                }
            }
        } catch (CException& e) {
            LOG_POST(Warning << "CIntronTrack::x_ParseSettings() " << e.GetMsg());
        }
    }
}
 
 
void CIntronTrack::x_OnLayoutPolicyChanged()
{
    CFeatureTrack::x_OnLayoutPolicyChanged();
    ILayoutPolicy::TSorter sorter = nullptr;
    if (m_SortReads) {
        sorter = [](const CRef<CSeqGlyph>& gl, const CRef<CSeqGlyph>& gr) {
            const auto& fl = *dynamic_cast<const CIntronGlyph*>(gl.GetPointer());
            const auto& fr = *dynamic_cast<const CIntronGlyph*>(gr.GetPointer());
            return fl.GetReadCount() > fr.GetReadCount();
        };
    }
    switch (m_Layout) {
        case eLayout_ExpandedByPos:
        case eLayout_ExpandedBySize:
            m_Simple->SetSorter(sorter);
            break;
        case eLayout_AdaptiveInline:
            m_Inline->SetSorter(sorter);        
            break;
        case eLayout_ExpandedColumn:
            m_Column->SetSorter(sorter);
            break;
        default:
            m_Layered->SetFillEmptySpaces(m_SortReads == false);
            m_Layered->SetSorter(sorter);
            break;
    }
 
}
void CIntronTrack::GetHTMLActiveAreas(TAreaVector *p_areas) const
{
    CFeatureTrack::GetHTMLActiveAreas(p_areas);
 
    if (m_NoReadFilter == false) {
        string msg = "Filtered (read count from ";
        msg += (m_ReadsCountMin > 0) ? to_string(m_ReadsCountMin) : "min";
        msg += " to ";
        msg += (m_ReadsCountMax > 0) ? to_string(m_ReadsCountMax) : "max";
        msg  += ")";
 
        CHTMLActiveArea area;
        CSeqGlyph::x_InitHTMLActiveArea(area);
        area.m_Bounds.SetTop(area.m_Bounds.Top() + x_GetTBHeight());
        // left = 1 right = 0, makes it right-aligned
        area.m_Bounds.SetLeft(1); 
        area.m_Bounds.SetRight(0);
        area.m_Flags = CHTMLActiveArea::fComment
            | CHTMLActiveArea::fDrawBackground
            | CHTMLActiveArea::fNoHighlight
            | CHTMLActiveArea::fNoSelection
            | CHTMLActiveArea::fTooltipEmbedded;
        area.m_ID = msg;
        area.m_ParentId = GetId();    
        // required, but nonsense fields
        area.m_PositiveStrand = true;
        area.m_SeqRange.SetFrom(0);
        area.m_SeqRange.SetTo(0);
        p_areas->push_back(area);
    }
    
}
 
void CIntronTrack::x_UpdateBoundingBox()
{
    CFeatureTrack::x_UpdateBoundingBox();
    // if read count filter is set and not in printing mode
    // then make room for "Filtered" message
    if (m_NoReadFilter == false) {
        IRender& gl = GetGl();
        if (gl.IsPrinterFriendly() == false) {
            m_Group.SetTop(m_Group.GetTop() + 16);
            SetHeight(GetHeight() + 16);
        }
    }
}
 
END_NCBI_SCOPE