window_manager.cpp

来自「ncbi源码」· C++ 代码 · 共 766 行 · 第 1/2 页

        x_RemoveClient(p_client);
        x_PutClientInFrame(p_client);        
        x_UpdateObserver(p_client);
    }
}

void    CWindowManager::x_InsertClient(IWMClient* client, IWMContainer* container,
                                       const IWMPosition& pos)
{
    SClientRec* p_rec = x_GetClientRec(client);

    _ASSERT(p_rec->m_pContainer == NULL);

    p_rec->m_pContainer = container;
    Fl_Widget* widget = dynamic_cast<Fl_Widget*>(client);

    _ASSERT(widget);

    container->Insert(widget, pos);
}                                        

/// removes Client or container from specified position
void    CWindowManager::x_Remove(IWMContainer* container, const IWMPosition& pos)
{
    Fl_Widget* child = container->GetChild(pos);
    x_CascadeRemove(container, child);
}

/// removes widgets from it's container and recursiveli removes all its children
void    CWindowManager::x_CascadeRemove(IWMContainer* container, Fl_Widget* child)
{
    IWMClient* p_client = dynamic_cast<IWMClient*>(child);
    if(p_client)    {
        x_RemoveClient(p_client);
    } else {
        IWMContainer* p_cont = dynamic_cast<IWMContainer*>(child);
        if(p_cont)  {
            container->Remove(child);

            // remove child's children 
            vector<Fl_Widget*> children;
            p_cont->GetChildren(children);            

            for( size_t i = 0; i < children.size(); i++ )    {
                Fl_Widget* child = children[i];
                x_CascadeRemove(p_cont, child);
            }

            delete p_cont;
        } else _ASSERT(false); // unexpected
    }
}

void    CWindowManager::x_RemoveContainer(IWMContainer* container)
{
    if(container != m_pRootCont)   {
        Fl_Widget* widget = dynamic_cast<Fl_Widget*>(container);
        _ASSERT(widget);
        IWMContainer* parent_cont = dynamic_cast<IWMContainer*>(widget->parent());
        
        x_CascadeRemove(parent_cont, widget);
    }
}

void    CWindowManager::x_RemoveClient(IWMClient* client)
{
    SClientRec* p_rec = x_GetClientRec(client);
    if(p_rec)
        x_RemoveClient(p_rec);
}

// removes client from its current container, but does not unregister it
void    CWindowManager::x_RemoveClient(SClientRec* rec)
{
    _ASSERT(rec);
    if(rec->m_pClient == m_ActiveClient)   { // reset active client
        m_ActiveClient = NULL;
        m_PrevFocus = NULL;
    }
    
    CCommandTarget* target = dynamic_cast<CCommandTarget*>(rec->m_pClient);
    if(target)  { // disconnect from command routing
        RemoveChildCmdTarget(target);
    }

    // remove from the container
    Fl_Widget* widget = dynamic_cast<Fl_Widget*>(rec->m_pClient);
    if(rec->m_pContainer)   {
        rec->m_pContainer->Remove(widget);
    
        CWMFrameWindow* p_frame = dynamic_cast<CWMFrameWindow*>(rec->m_pContainer);
        if(p_frame) { // if container - frame, destroy it
            delete p_frame;
        }
        rec->m_pContainer = NULL;
        rec->m_bFrame = false;
    }
}

bool    CWindowManager::RemoveClient(IWMClient* client)
{
    TClientToRecMap::iterator it = m_ClientToRec.find(client);
    if(it != m_ClientToRec.end())   {
        SClientRec* p_rec = it->second;
        x_RemoveClient(p_rec);
        x_UnRegisterClient(client);
        x_ResetMenu();
        return true;
    }
    return false;
}

void    CWindowManager::RemoveAllClients()
{
    while(m_ClientToRec.size())  {
        SClientRec* p_rec = m_ClientToRec.begin()->second;
        x_RemoveClient(p_rec);
        x_UnRegisterClient(p_rec->m_pClient);
    }
    x_ResetMenu();
}

IWMClient*  CWindowManager::GetActiveClient()
{
    return m_ActiveClient;
}

/// Regenerate Window Manager's menu and request Frame Window to reset it's menu.
void    CWindowManager::x_ResetMenu()
{
    if(m_FrameWindow)   {
        m_MenuRoot = CreateMenuItems(BaseMenu);
        ITERATE(TClientToRecMap, it, m_ClientToRec) {
            SClientRec* p_rec = it->second;
            if(p_rec->m_pContainer)    { ///###
                const CMenuItem* root = p_rec->m_pClient->GetMenu();
                if(root)    { // merge Client's menu into Manager's menu
                    m_MenuRoot->Merge(*root);
                }
            }
        }
        
        // Reseting Frame Window's will automatically request the new menu from Window Manager
        // so that our changes to it will take effect
        m_FrameWindow->ResetMenu();
    }
}

// creates entry in m_ClientToRec table if it does not exist
bool    CWindowManager::x_RegisterClient(IWMClient* client)
{
    if(client  &&  m_ClientToRec.find(client) == m_ClientToRec.end())   {
        SClientRec* p_rec = new SClientRec;
        p_rec->m_pClient = client;
        p_rec->m_pContainer = NULL;
        p_rec->m_bFrame = false;
        
        m_ClientToRec[client] = p_rec;
        return true;
    }
    return false;
}

// deletes m_ClientToRec entry corresponding to the client
bool    CWindowManager::x_UnRegisterClient(IWMClient* client)
{
    TClientToRecMap::iterator it = m_ClientToRec.find(client);
    if(it != m_ClientToRec.end())   {
        delete it->second;
        m_ClientToRec.erase(it);
        return true;
    }
    return false;
}

CWindowManager::EClientState    CWindowManager::GetClientState(IWMClient* client)
{
    SClientRec* p_rec = x_GetClientRec(client);
    if(p_rec)   {
        if(p_rec->m_pContainer) {
            return p_rec->m_bFrame ? eFloating : eDocked;
        } else  return eHidden;
    }
    return eInvalid;
}

CWindowManager::SClientRec* CWindowManager::x_GetClientRec(IWMClient* client)
{
    TClientToRecMap::iterator it = m_ClientToRec.find(client);
    return (it == m_ClientToRec.end()) ? NULL : it->second;
}

/// Creates new CWMFrameWindow and inserts client into it.
void    CWindowManager::x_PutClientInFrame(IWMClient* client)
{    
    Fl_Widget* widget = dynamic_cast<Fl_Widget*>(client);
    SClientRec* p_rec = m_ClientToRec[client];

    _ASSERT(widget);
    
    CWMFrameWindow* p_frame = 
        new CWMFrameWindow(m_FrameX, m_FrameY, m_DefFrameW, m_DefFrameH, 
                           widget->label());
    m_FrameX += m_PosIncr;
    if(m_FrameX + m_DefFrameW > Fl::x() + Fl::w())  {
        m_FrameX = Fl::x();
    }
    m_FrameY += m_PosIncr;
    if(m_FrameY + m_DefFrameH > Fl::y() + Fl::h())  {
        m_FrameY = Fl::y();
    }
    
    CWMFrameWndPos* p_pos = new CWMFrameWndPos(true);
    bool b_ok = p_frame->Insert(widget, *p_pos);
    _ASSERT(b_ok);

    // filling SClientRec
    p_rec->m_pContainer = static_cast<IWMContainer*>(p_frame);
    p_rec->m_bFrame = true;

    p_frame->show();
}

void    CWindowManager::x_PutClientInTab(IWMClient* client)
{
    CWMTabControl* p_tab = dynamic_cast<CWMTabControl*>(m_pRootCont);
    _ASSERT(p_tab);
    int index = p_tab->GetTabsCount();
    CWMTabPos pos(index);
    
    x_InsertClient(client, m_pRootCont, pos);
}

void    CWindowManager::x_GetFramedClients(TClients& clients)
{
    clients.clear();

    ITERATE(TClientToRecMap, it, m_ClientToRec) {
        SClientRec* p_rec = it->second;
        if(p_rec->m_bFrame) {
            clients.push_back(it->first);
        }
    }
}

static int s_iColor = 0;
const static int kColors = 4;

static Fl_Color    GetRandomColor()
{
    s_iColor = (s_iColor + 1) % kColors;
    switch(s_iColor)    {
    case 0: return fl_rgb_color(192, 192, 255);
    case 1: return fl_rgb_color(255, 192, 192);
    case 2: return fl_rgb_color(192, 255, 192);
    case 3: return fl_rgb_color(255, 192, 255);
    }
    return FL_MAGENTA;
}

void    CWindowManager::x_InsertSplitter(IWMContainer* container, const IWMPosition& pos, 
                                         CSplitter::EMode mode)
{
    CWMSplitter* splitter = new CWMSplitter();
    splitter->SetManager(this);
    splitter->color(GetRandomColor());

    container->Insert(splitter, pos);
    
    switch(mode)    {
    case CSplitter::eHorizontal: splitter->Create(2, 1); break;
    case CSplitter::eVertical:   splitter->Create(1, 2); break;
    case CSplitter::eGrid:   splitter->Create(2, 2); break;
    }
}

void    CWindowManager::x_UpdateObserver(IWMClient* client)
{
    if(m_pObserver)
        m_pObserver->OnClientChanged(client);
}

const CMenuItem*    CWindowManager::GetMenu() const
{
    return m_MenuRoot;
}

void   CWindowManager::SetFrameWindow(CFrameWindow* frame)
{
    m_FrameWindow = frame;
}

bool   CWindowManager::x_ChildrenHandleCommand(const TCmdID cmd)
{
    // update pointer to active client
    Fl_Widget* focused = Fl::focus();
    if(focused != m_PrevFocus)  {
        m_PrevFocus = focused;
        m_ActiveClient = NULL;

        //check is focused widget is our client or a child of our client
        for( Fl_Widget* wid = focused; wid != NULL; wid = wid->parent())  {
            IWMClient* client = dynamic_cast<IWMClient*>(wid);
            if(client  &&  x_GetClientRec(client))  { // this our client
                m_ActiveClient = client;
                break;
            }
        }
    }
    bool b_handled = false;
    ///### overhead
    CCommandTarget* target = dynamic_cast<CCommandTarget*>(m_ActiveClient);
    if(target) {
        b_handled = target->OnCommand(cmd);
    }
    if(! b_handled) {
        NON_CONST_ITERATE(TChildTargets, it, m_ChildTargets)    {            
            if(*it != target  && (*it)->OnCommand(cmd))
                return true;
        }
    }
    return b_handled;
}

bool   CWindowManager::x_ChildrenUpdateCommand(const TCmdID cmd, ICmdUI* pCmdUI)
{
    // update pointer to active client
    Fl_Widget* focused = Fl::focus();
    if(focused != m_PrevFocus)  {
        m_PrevFocus = focused;
        m_ActiveClient = NULL;

        //check is focused widget is our client or a child of our client
        for( Fl_Widget* wid = focused; wid != NULL; wid = wid->parent())  {
            IWMClient* client = dynamic_cast<IWMClient*>(wid);
            if(client  &&  x_GetClientRec(client))  { // this our client
                m_ActiveClient = client;
                break;
            }
        }
    }
    bool b_handled = false;
    ///### overhead
    CCommandTarget* target = dynamic_cast<CCommandTarget*>(m_ActiveClient);
    if(target) {
        b_handled = target->OnUpdateCommand(cmd, pCmdUI);
    }
    if(! b_handled) {
        NON_CONST_ITERATE(TChildTargets, it, m_ChildTargets)    {            
            if(*it != target  && (*it)->OnUpdateCommand(cmd, pCmdUI))
                return true;
        }
    }
    return b_handled;
}

void    CWindowManager::OnInsertSplitter(TCmdID cmd)
{
    CWMTabPos pos(m_pRootCont->GetTabsCount());
    OnContainerCommand(m_pRootCont, pos, cmd);  
}

END_NCBI_SCOPE


/*
 * ===========================================================================
 * $Log: window_manager.cpp,v $
 * Revision 1000.1  2004/06/01 21:14:47  gouriano
 * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.3
 *
 * Revision 1.3  2004/05/21 22:27:56  gorelenk
 * Added PCH ncbi_pch.hpp
 *
 * Revision 1.2  2004/05/07 14:26:58  yazhuk
 * Inherited CWindowManager from Fl_Group, CCommandTarget; implemented IFrameWindowClient
 *
 * Revision 1.1  2004/02/04 19:41:55  yazhuk
 * Initial revision
 *
 * ===========================================================================
 */