src/gui/widgets/wx/group_map_widget.cpp

Go to the documentation of this file.

/*  $Id: group_map_widget.cpp 19865 2009-08-14 18:37:26Z kuznets $
 * ===========================================================================
 *
 *                            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:  Andrey Yazhuk
 *
 */

#include <ncbi_pch.hpp>
#include <corelib/ncbistd.hpp>

#include <gui/widgets/wx/group_map_widget.hpp>
#include <gui/widgets/wx/fileartprov.hpp>
#include <gui/widgets/wx/wx_utils.hpp>

#include <wx/dcbuffer.h>
#include <wx/sizer.h>


BEGIN_NCBI_SCOPE

///////////////////////////////////////////////////////////////////////////////
/// CGroupMapWidget

bool CGroupMapWidget::m_IconsRegistered = 0;

CGroupMapWidget::CGroupMapWidget(wxWindow* parent,
                                      wxWindowID id,
                                      const wxPoint& pos,
                                      const wxSize& size,
                                      long style,
                                      const wxString& name)
:   TParent(parent, id, pos, size, style, name)
{
    // register only once
    static bool icons_registered = false;
    if( ! m_IconsRegistered)    {
        wxFileArtProvider* provider = GetDefaultFileArtProvider();
        provider->RegisterFileAlias(_T("map::arrow_open"),
                                    _T("arrow_open.png"));
        provider->RegisterFileAlias(_T("map::arrow_close"),
                                    _T("arrow_close.png"));
        icons_registered = true;
    }

    m_OpenIcon = wxArtProvider::GetBitmap(_T("map::arrow_open"));
    m_ClosedIcon = wxArtProvider::GetBitmap(_T("map::arrow_close"));

    // Create and setup Map Control
    m_Control = new CMapControl(this);
    m_Control->SetStyle(CMapControl::fSingleSelection);

    // Adjust Map Control settings
    CMapControl::SProperties& props = m_Control->GetProperties();
    props.m_SingleColumn = false;
    props.m_ItemOffsetX = 1;
    props.m_ItemOffsetY = 0;
    props.m_SepLineWidth = 1;
    props.m_ColumnWidth = 200;
    props.m_SeparateGroups = false;
    props.m_SizePolicy = CMapControl::eAdjustVertSize;

    // adjust Map Control Item settings
    SwxMapItemProperties& it_props = m_Control->GetMapItemProperties();
    it_props.m_BackColor = m_Control->GetBackgroundColour();
    it_props.m_TextColor = wxColour(0, 0, 64);
    it_props.m_VertMargin = 2;
    it_props.m_HorzMargin = 2;

    wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add(m_Control, 1, wxEXPAND);
    SetSizer(sizer);
}


CGroupMapWidget::~CGroupMapWidget()
{
    Clear();
    //m_Control->RemoveListener(this);
}


void CGroupMapWidget::Init(const TGroupDescrVector& groups)
{
    Clear();

    for(size_t i = 0;  i < groups.size();  i++ )    {
        const SGroupDescr& grp = groups[i];
        AddGroup(grp.m_Label, grp.m_Expanded);

        const TItemDescrVector& items = grp.m_Items;
        for(  size_t j = 0;  j < items.size();  j++ )   {
            const SItemDescr& item = items[j];
            AddItem(grp.m_Label, item.m_Label, item.m_IconAlias);
        }
    }
    //m_Scroll->UpdateScrollBars();

    int n =  m_Control->GetItemsCount();
    if(n > 0)   {
        m_Control->SelectItem(0);
    }
}


void CGroupMapWidget::Clear()
{
    m_Control->DeleteAllItems();

    for( size_t i = 0;  i < m_Groups.size();  i++ ) {
        delete m_Groups[i];
    }
    m_Groups.clear();
}


void CGroupMapWidget::AddGroup(const string& label, bool expand)
{
    int index = x_GetGroupIndex(label);
    if(index == -1) {
        // add new group
        SGroup* grp = new SGroup();
        grp->m_GroupItem =
            new CGroupItem(label, expand ? m_OpenIcon : m_ClosedIcon, "", *this, true);
        grp->m_GroupItem->Expand(expand);
        m_Groups.push_back(grp);

        m_Control->AddItem(grp->m_GroupItem.GetPointer());
    } else {
        string s = "Group \"" + label + "\" already exist";
        NCBI_THROW(CException, eUnknown, s);
    }
}


typedef CMapControl::TIndex TIndex;

void CGroupMapWidget::AddItem(const string& group_label, const string& label,
                              const string& icon_alias)
{
    int index = x_GetGroupIndex(group_label);
    if(index != -1) {
        // add new group
        SGroup* grp = m_Groups[index];

        wxBitmap icon = wxArtProvider::GetBitmap(ToWxString(icon_alias));
        TItemRef    ref(new CGroupItem(label, icon, "", *this, false));
        grp->m_Items.push_back(ref);

        // update Control if needed
        if(grp->m_GroupItem->IsExpanded())  {
             TIndex i_grp = m_Control->GetItemIndex(*grp->m_GroupItem);
             TIndex ins = i_grp + grp->m_Items.size();
             m_Control->InsertItem(ins, ref.GetPointer());
        }
    } else {
        string s = "Group \"" + group_label + "\" does not exist.";
        NCBI_THROW(CException, eUnknown, s);
    }
}


void CGroupMapWidget::GetGroupLabels(vector<string>& groups) const
{
    for( size_t i = 0;  i < m_Groups.size();  i++ ) {
        const SGroup* grp = m_Groups[i];
        groups.push_back(grp->m_GroupItem->GetLabel());
    }
}


bool CGroupMapWidget::IsExpanded(const string& group) const
{
    int index = x_GetGroupIndex(group);
    if(index >= 0)  {
        const SGroup* grp = m_Groups[index];
        return grp->m_GroupItem->IsExpanded();
    } else {
        string s = "Group \"" + group + "\" does not exist.";
        NCBI_THROW(CException, eUnknown, s);
    }
    return false;
}


string CGroupMapWidget::GetSelectedItem() const
{
    int index = m_Control->GetSelectedIndex();
    if(index >=0 )  {
        CMapControl::TCItemRef item = m_Control->GetItem(index);
        const CGroupItem* grp_item = dynamic_cast<const CGroupItem*>(item.GetPointer());
        _ASSERT(grp_item);
        if(grp_item  &&  ! grp_item->IsGroupSeparator())    {
            return grp_item->GetLabel();
        }
    }
    return "";
}


void CGroupMapWidget::ExpandGroup(const string& /*label*/)
{
    _ASSERT(false); // TODO implement
}


CMapControl* CGroupMapWidget::GetMapControl()
{
    return m_Control;
}


int CGroupMapWidget::x_GetGroupIndex(const string& label) const
{
    for(size_t i = 0; i < m_Groups.size(); i++ )    {
        CGroupItem* item = m_Groups[i]->m_GroupItem;
        if(item->GetLabel() == label)   {
            return i;
        }
    }
    return -1;
}


void CGroupMapWidget::x_OnToggleGroup(CGroupItem& item)
{
    // find the group descriptor
    int grp_i = x_GetGroupIndex(item.GetLabel());
    _ASSERT(grp_i >= 0);
    TMapItems& v_items = m_Groups[grp_i]->m_Items;

    bool expand = ! item.IsExpanded();//  &&  ! v_item.size();
    item.Expand(expand);
    item.SetIcon(expand ? m_OpenIcon : m_ClosedIcon);

    // get group iem index in the Control
    TIndex index = m_Control->GetItemIndex(item);

    m_Control->LockUpdates(true);

    for( size_t i = 0;  i < v_items.size();  i++  ) {
        if(expand)  {
            TItemRef mp_it = v_items[i];
            m_Control->InsertItem(++index, mp_it.GetPointer());
        } else {
            m_Control->DeleteItem(index + 1);
        }
    }

    m_Control->LockUpdates(false);
    //m_Scroll->UpdateScrollBars();
}


void CGroupMapWidget::x_OnSelectItem(CGroupItem& item)
{
    wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, GetId());
    event.SetEventObject(this);
    event.SetString(ToWxString(item.GetLabel()));

    (void)GetEventHandler()->ProcessEvent(event);
}


///////////////////////////////////////////////////////////////////////////////
/// CGroupItem

CGroupMapWidget::CGroupItem::CGroupItem(const string& label,
                                              wxBitmap& icon,
                                              const string& description,
                                              CGroupMapWidget& widget,
                                              bool group)
:   CMapItem(label, icon, description, group),
    m_Widget(widget),
    m_Expanded(true),
    m_HotLabel(false)
{
}


bool CGroupMapWidget::CGroupItem::IsExpanded() const
{
    return m_Expanded;
}


void CGroupMapWidget::CGroupItem::Expand(bool exp)
{
    m_Expanded = exp;
}


int CGroupMapWidget::CGroupItem::PreferredHeight(wxDC& dc,
                                                   SwxMapItemProperties& props,
                                                   int width)
{
    int pref_h = 0;
    if(m_Icon.IsOk()) {
        pref_h = m_Icon.GetHeight();
    }

    int label_h = x_PreferredLabelHeight(dc, props, width);

    pref_h = max(pref_h, label_h);
    if(IsGroupSeparator())  {
        pref_h += 6;
    } else {
        pref_h += props.m_VertMargin * 2;
    }
    if(m_Separator) {
        pref_h += x_PreferredSeparatorHeight(dc);
    }
    return pref_h;
}


int CGroupMapWidget::CGroupItem::x_GetItemShift() const
{
    return IsGroupSeparator() ? 0 : 12;
}


void CGroupMapWidget::CGroupItem::Layout(wxDC& dc, SwxMapItemProperties& props)
{
    CMapItem::Layout(dc, props);

    wxFont font = props.m_Font;
    font.SetWeight(wxFONTWEIGHT_NORMAL);
    dc.SetFont(font);

    m_LabelRealW = x_CalculateRealTextWidth(dc, props, true);
}


void CGroupMapWidget::CGroupItem::Draw(wxDC& dc/*, const wxRect& rc*/, int state,
                                           SwxMapItemProperties& props)
{
    wxRect rc_back(m_Rect);
    rc_back.Inflate(-props.m_Border, -props.m_Border);

    // draw focus rectangle
    //x_DrawFocusRect(dc, rc_back, state, props); //rc

    // Fill background
    x_DrawBackground(dc, rc_back, state, props);

    bool selected = (state & CSelectionControl::fItemSelected) != 0;

    // Draw Icon
    if(m_Icon.Ok()) {
        dc.DrawBitmap(m_Icon, m_IconPos.x, m_IconPos.y, true);
    }

    if( ! m_Label.empty()  &&  m_LabelRect.width > 0  &&  m_LabelRect.height > 0)  {
        bool widget_focused = (state & CSelectionControl::fWidgetFocused) != 0;

        if(IsGroupSeparator())  {
            dc.SetFont(props.m_Font);
        } else {
            // TODO this can be optimized
            wxFont font = props.m_Font;
            font.SetWeight(wxFONTWEIGHT_NORMAL);
            dc.SetFont(font);
        }

        x_DrawText(dc, m_Label, m_LabelRect, selected, widget_focused, props);
        // Draw Description
        if( ! m_Descr.empty()  &&  m_DescrRect.width > 0  &&  m_DescrRect.height > 0)  {
            dc.SetFont(props.m_MinorFont);
            x_DrawText(dc, m_Descr, m_DescrRect, selected, widget_focused, props);
        }
    }
}


int CGroupMapWidget::CGroupItem::x_PreferredSeparatorHeight(wxDC& dc) const
{
    return 0;
}

void CGroupMapWidget::CGroupItem::x_DrawBackground(wxDC& dc, const wxRect& rc,
                                                       int state, SwxMapItemProperties& props)
{
    bool selected = (state & CSelectionControl::fItemSelected) != 0;
    wxColour cl_back = selected ? props.m_SelBackColor :
        (IsGroupSeparator() ? GetAverage(props.m_TextColor, props.m_BackColor, 0.10f)
                            : props.m_BackColor);
    
    if(!IsGroupSeparator() && m_HotLabel)  {
        const float     kBlueAdjustment = 0.1f;
        unsigned char   adjustedRed = cl_back.Red() * (1 - kBlueAdjustment);
        unsigned char   adjustedGreen = cl_back.Green() * (1 - kBlueAdjustment);
        cl_back.Set(adjustedRed, adjustedGreen, cl_back.Blue(), cl_back.Alpha());
    }

    wxBrush brush(cl_back);
    dc.SetBrush(brush);
    dc.DrawRectangle(rc.x, rc.y, rc.width, rc.height);
}


void CGroupMapWidget::CGroupItem::OnDefaultAction()
{
    if(IsGroupSeparator())  {
        m_Widget.x_OnToggleGroup(*this);
    } else {
        m_Widget.x_OnSelectItem(*this);
    }
}


bool CGroupMapWidget::CGroupItem::OnHotTrack(const wxPoint& ms_pos)
{
    if (IsGroupSeparator()) 
    {
        // make all separator hot clickable item (including icon)
        return true;
    }
    wxRect rc(m_LabelRect);
    rc.width = m_LabelRealW;
    m_HotLabel = rc.Contains(ms_pos);
    return m_HotLabel;
}


END_NCBI_SCOPE

---