manager.cpp

非常好用的可移植的多平台C/C++源代码编辑器

    int width, height;

    GetClientSize(&width,&height);

    RecalculatePositions(width,height);

    if ( was_shown )
        Show ( TRUE );
}

// -----------------------------------------------------------------------

wxPGId wxPropertyGridManager::DoGetPropertyByName ( wxPGNameStr name ) const
{
    return GetPropertyByName2(name, (wxPropertyGridState**)NULL );
}

// -----------------------------------------------------------------------

wxPGId wxPropertyGridManager::GetPropertyByName2 ( wxPGNameStr name, wxPropertyGridState** ppState ) const
{
    size_t i;
    for ( i=0; i<m_arrPages.GetCount(); i++ )
    {
        wxPropertyGridState* pState = &((wxPropertyGridPageData*)m_arrPages.Item(i))->m_state;
        wxPGId id = pState->BaseGetPropertyByName(name);
        if ( wxPGIdIsOk(id) )
        {
            if ( ppState ) *ppState = pState;
            return id;
        }
    }
    return wxPGIdGen((wxPGProperty*)NULL);
}

// -----------------------------------------------------------------------

wxPGId wxPropertyGridManager::GetPropertyByLabel ( const wxString& label, wxPropertyGridState** ppState ) const
{
    size_t i;
    for ( i=0; i<m_arrPages.GetCount(); i++ )
    {
        wxPropertyGridState* pState = &((wxPropertyGridPageData*)m_arrPages.Item(i))->m_state;
        wxPGId id = pState->GetPropertyByLabel(label);
        if ( wxPGIdIsOk(id) )
        {
            if ( ppState ) *ppState = pState;
            return id;
        }
    }
    return wxPGIdGen((wxPGProperty*)NULL);
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::SelectProperty ( wxPGId id, bool focus )
{
    wxPGProperty* p = wxPGIdToPtr(id);
    wxASSERT ( p );
    wxPropertyGridState* parent_state = p->GetParentState();
    if ( parent_state == m_propGrid.m_pState )
        m_propGrid.SelectProperty(p,focus);
    else
        parent_state->m_selected = p;
}

// -----------------------------------------------------------------------

bool wxPropertyGridManager::EnsureVisible ( wxPGId id, wxPropertyGridState* parent_state )
{
    // Select correct page.
    if ( m_propGrid.m_pState != parent_state )
        SelectPage( GetPageByState(parent_state) );

    return m_propGrid.EnsureVisible(id);
}

// -----------------------------------------------------------------------

#define wxPG_IMPLEMENT_PGMAN_METHOD_WRET0(NAME,RETVAL) \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME ( wxPGId id ) \
{ \
    wxPGProperty* p = wxPGIdToPtr(id); \
    wxASSERT ( p ); \
    wxPropertyGridState* pState = p->GetParentState(); \
    wxASSERT ( pState != (wxPropertyGridState*) NULL ); \
    if ( pState == m_propGrid.m_pState ) return m_propGrid.NAME(id); \
    return pState->NAME(p); \
} \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME ( wxPGNameStr name ) \
{ \
    wxPropertyGridState* pState; \
    wxPGId id = GetPropertyByName2(name,&pState); \
    wxASSERT ( pState != (wxPropertyGridState*) NULL ); \
    if ( pState == m_propGrid.m_pState ) return m_propGrid.NAME(id); \
    return pState->NAME(wxPGIdToPtr(id)); \
}

#define wxPG_IMPLEMENT_PGMAN_METHOD_WRET0(NAME,RETVAL) \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME ( wxPGId id ) \
{ \
    wxPGProperty* p = wxPGIdToPtr(id); \
    wxASSERT ( p ); \
    wxPropertyGridState* pState = p->GetParentState(); \
    wxASSERT ( pState != (wxPropertyGridState*) NULL ); \
    if ( pState == m_propGrid.m_pState ) return m_propGrid.NAME(id); \
    return pState->NAME(p); \
} \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME ( wxPGNameStr name ) \
{ \
    wxPropertyGridState* pState; \
    wxPGId id = GetPropertyByName2(name,&pState); \
    wxASSERT ( pState != (wxPropertyGridState*) NULL ); \
    if ( pState == m_propGrid.m_pState ) return m_propGrid.NAME(id); \
    return pState->NAME(wxPGIdToPtr(id)); \
}

#define wxPG_IMPLEMENT_PGMAN_METHOD_WRET1(NAME,RETVAL,AT1) \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME ( wxPGId id, AT1 _av1_ ) \
{ \
    wxPGProperty* p = wxPGIdToPtr(id); \
    wxASSERT ( p ); \
    wxPropertyGridState* pState = p->GetParentState(); \
    wxASSERT ( pState != (wxPropertyGridState*) NULL ); \
    if ( pState == m_propGrid.m_pState ) return m_propGrid.NAME(id,_av1_); \
    return pState->NAME(p,_av1_); \
} \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME ( wxPGNameStr name, AT1 _av1_ ) \
{ \
    wxPropertyGridState* pState; \
    wxPGId id = GetPropertyByName2(name,&pState); \
    wxASSERT ( pState != (wxPropertyGridState*) NULL ); \
    if ( pState == m_propGrid.m_pState ) return m_propGrid.NAME(id,_av1_); \
    return pState->NAME(wxPGIdToPtr(id),_av1_); \
}

#define wxPG_IMPLEMENT_PGMAN_METHOD_WRET2(NAME,RETVAL,AT1,AT2) \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME ( wxPGId id, AT1 _av1_, AT2 _av2_ ) \
{ \
    wxPGProperty* p = wxPGIdToPtr(id); \
    wxASSERT ( p ); \
    wxPropertyGridState* pState = p->GetParentState(); \
    wxASSERT ( pState != (wxPropertyGridState*) NULL ); \
    if ( pState == m_propGrid.m_pState ) return m_propGrid.NAME(id,_av1_,_av2_); \
    return pState->NAME(p,_av1_,_av2_); \
} \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME ( wxPGNameStr name, AT1 _av1_, AT2 _av2_ ) \
{ \
    wxPropertyGridState* pState; \
    wxPGId id = GetPropertyByName2(name,&pState); \
    wxASSERT ( pState != (wxPropertyGridState*) NULL ); \
    if ( pState == m_propGrid.m_pState ) return m_propGrid.NAME(id,_av1_,_av2_); \
    return pState->NAME(wxPGIdToPtr(id),_av1_,_av2_); \
}

#define wxPG_IMPLEMENT_PGMAN_METHOD_NORET0(NAME) \
wxPG_IPAM_DECL void wxPropertyGridManager::NAME ( wxPGId id ) \
{ \
    wxPGProperty* p = wxPGIdToPtr(id); \
    wxASSERT ( p ); \
    wxPropertyGridState* pState = p->GetParentState(); \
    wxASSERT ( pState != (wxPropertyGridState*) NULL ); \
    if ( pState == m_propGrid.m_pState ) m_propGrid.NAME(id); \
    else pState->NAME(p); \
} \
wxPG_IPAM_DECL void wxPropertyGridManager::NAME ( wxPGNameStr name ) \
{ \
    wxPropertyGridState* pState; \
    wxPGId id = GetPropertyByName2(name,&pState); \
    wxASSERT ( pState != (wxPropertyGridState*) NULL ); \
    if ( pState == m_propGrid.m_pState ) m_propGrid.NAME(id); \
    else pState->NAME(wxPGIdToPtr(id)); \
}

#undef wxPG_IPAM_DECL
#define wxPG_IPAM_DECL

wxPG_IMPLEMENT_PGMAN_METHOD_WRET0(ClearPropertyValue,bool)
wxPG_IMPLEMENT_PGMAN_METHOD_WRET0(Collapse,bool)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET0(Delete)
wxPG_IMPLEMENT_PGMAN_METHOD_WRET1(EnableProperty,bool,bool)
wxPG_IMPLEMENT_PGMAN_METHOD_WRET0(Expand,bool)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(LimitPropertyEditing,bool)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyLabel,const wxString&)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyPriority,int)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,long)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,int)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,double)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,bool)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,const wxString&)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,const wxArrayString&)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,wxObject*)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,void*)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,wxVariant&)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET0(SetPropertyValueUnspecified)

// -----------------------------------------------------------------------

void wxPropertyGridManager::ClearModifiedStatus ( wxPGId id )
{
    wxPropertyGridState* pState = wxPGIdToPtr(id)->GetParentState();
    wxASSERT ( pState != (wxPropertyGridState*) NULL );
    pState->ClearModifiedStatus(wxPGIdToPtr(id));
}

// -----------------------------------------------------------------------

size_t wxPropertyGridManager::GetChildrenCount ( int page_index )
{
    return GetChildrenCount( wxPGIdGen(GetPage(page_index)->m_state.m_properties) );
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::OnToolbarClick ( wxCommandEvent &event )
{
    int id = event.GetId();
    if ( id >= 0 )
    {
        int baseId = m_propGrid.GetId();
        if ( baseId < 0 )
            baseId = wxPG_MAN_ALTERNATE_BASE_ID;

        if ( id == ( baseId + ID_ADVTBITEMSBASE_OFFSET + 0 ) )
        {
            // Categorized mode.
            if ( m_propGrid.m_windowStyle & wxPG_HIDE_CATEGORIES )
                //SetWindowStyleFlag ( m_windowStyle & ~(wxPG_HIDE_CATEGORIES) );
                m_propGrid.EnableCategories ( TRUE );
        }
        else if ( id == ( baseId + ID_ADVTBITEMSBASE_OFFSET + 1 ) )
        {
            // Alphabetic mode.
            if ( !(m_propGrid.m_windowStyle & wxPG_HIDE_CATEGORIES) )
                //SetWindowStyleFlag ( m_windowStyle | wxPG_HIDE_CATEGORIES );
                m_propGrid.EnableCategories ( FALSE );
        }
        else
        {
            // Page Switching.

            int index = -1;
            size_t i;
            wxPropertyGridPageData* pdc;

            // Find page with given id.
            for ( i=0; i<m_arrPages.GetCount(); i++ )
            {
                pdc = (wxPropertyGridPageData*)m_arrPages.Item(i);
                if ( pdc->m_id == id )
                {
                    index = i;
                    break;
                }
            }

            wxASSERT ( index >= 0 );

            SelectPage ( index );

            // Event dispatching must be last.
            wxPropertyGridEvent evt( wxEVT_PG_PAGE_CHANGED, GetId() );
            evt.SetPropertyGrid (&m_propGrid);
            evt.SetEventObject (this);
            GetEventHandler()->AddPendingEvent(evt);

        }
    }
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::SetDescription ( const wxString& label, const wxString& content )
{
    if ( m_pTxtHelpCaption )
    {
        wxSize osz1 = m_pTxtHelpCaption->GetSize();
        wxSize osz2 = m_pTxtHelpContent->GetSize();

        m_pTxtHelpCaption->SetLabel(label);
        m_pTxtHelpContent->SetLabel(content);

        m_pTxtHelpCaption->SetSize(-1,osz1.y);
        m_pTxtHelpContent->SetSize(-1,osz2.y);

        if ( (m_iFlags & wxPG_FL_DESC_REFRESH_REQUIRED) || (osz2.x<(m_width-10)) )
            RefreshHelpBox( m_splitterY, m_width, m_height );
    }
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::SetDescribedProperty ( wxPGProperty* p )
{
    if ( m_pTxtHelpCaption )
    {
        if ( p )
            SetDescription( p->GetLabel(), p->GetHelpString() );
        else
        {
            m_pTxtHelpCaption->SetLabel(wxT(""));
            m_pTxtHelpContent->SetLabel(wxT(""));
        }
    }
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::OnPropertyGridSelect ( wxPropertyGridEvent& event )
{
    // Check id.
    wxASSERT_MSG ( GetId() == m_propGrid.GetId(),
        wxT("wxPropertyGridManager id must be set with wxPropertyGridManager::SetId (not wxWindow::SetId).") );

    SetDescribedProperty(event.GetPropertyPtr());
    event.Skip();
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::OnCompactorClick ( wxCommandEvent& WXUNUSED(event) )
{
    if ( !(m_propGrid.m_iFlags & wxPG_FL_HIDE_STATE) )
    {
        m_propGrid.Compact( TRUE );
        m_pButCompactor->SetLabel( _("Expand >>") );
    }
    else
    {
        m_propGrid.Compact( FALSE );
        m_pButCompactor->SetLabel( _("<< Compact") );
    }
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::OnResize ( wxSizeEvent& WXUNUSED(event) )
{

    int width, height;

    GetClientSize(&width,&height);

    if ( m_width == -12345 ) 
        RecreateControls();

    RecalculatePositions(width,height);

    //event.Skip();
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::OnMouseEntry ( wxMouseEvent& WXUNUSED(event) )
{
    //wxLogDebug(wxT("wxPropertyGridManager::OnMouseEntry"));

    // Correct cursor. This is required atleast for wxGTK, for which
    // setting button's cursor to *wxSTANDARD_CURSOR does not work.
    SetCursor( wxNullCursor );
    m_onSplitter = 0;
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::OnMouseMove ( wxMouseEvent &event )
{
    if ( !m_pTxtHelpCaption )
        return;

    int y = event.m_y;

    if ( m_dragStatus > 0 )
    {
        int sy = y - m_dragOffset;

        // Calculate drag limits
        int bottom_limit = m_height - m_splitterHeight + 1;
        if ( m_pButCompactor ) bottom_limit -= m_pButCompactor->GetSize().y;
        int top_limit = m_propGrid.m_lineHeight;
#if wxUSE_TOOLBAR
        if ( m_pToolbar ) top_limit += m_pToolbar->GetSize().y;
#endif

        if ( sy >= top_limit && sy < bottom_limit )
        {

            //wxLogDebug (wxT("...dragging continues..."));

            int change = sy - m_splitterY;
            if ( change )
            {
                m_splitterY = sy;

                m_propGrid.SetSize( m_width, m_splitterY - m_propGrid.GetPosition().y );
                RefreshHelpBox( m_splitterY, m_width, m_height );

                m_extraHeight -= change;
#if wxMINOR_VERSION > 5 || ( wxMINOR_VERSION == 5 && wxRELEASE_NUMBER >= 3 )
                InvalidateBestSize();
#endif
            }

        }

    }
    else
    {
        if ( y >= m_splitterY && y < (m_splitterY+m_splitterHeight+2) )
        {
            //if ( !m_onSplitter )
                SetCursor ( m_cursorSizeNS );
            m_onSplitter = 1;
        }
        else
        {
            if ( m_onSplitter )
            {
                //wxLogDebug(wxT("SetCursor ( *wxSTANDARD_CURSOR )"));
                //SetCursor ( *wxSTANDARD_CURSOR );
                SetCursor ( wxNullCursor );
            }
            m_onSplitter = 0;
        }
    }
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::OnMouseClick ( wxMouseEvent &event )
{
    int y = event.m_y;

    // Click on splitter.
    if ( y >= m_splitterY && y < (m_splitterY+m_splitterHeight+2) )
    {

        /*
        if ( event.m_eventType == wxEVT_LEFT_DCLICK )
        {
            // Double-clicking the splitter causes auto-centering
            CenterSplitter ( TRUE );
        }
        else
        */
        if ( m_dragStatus == 0 )
        {
        //
        // Begin draggin the splitter
        //

            BEGIN_MOUSE_CAPTURE

            m_dragStatus = 1;

            m_dragOffset = y - m_splitterY;

            /*
            Update(); // clear graphics mess
            DrawSplitterDragRow( this, m_splitterY, m_splitterHeight );
            m_splitterPrevDrawnWin = this;
            */

        }
    }
}

// -----------------------------------------------------------------------

void wxPropertyGridManager::OnMouseUp ( wxMouseEvent &event )
{
    // No event type check - basicly calling this method should
    // just stop dragging.
    // Left up after dragged?

    if ( m_dragStatus >= 1 )
    {
        int y = event.m_y;
    //
    // End Splitter Dragging
    //

        // DO NOT ENABLE FOLLOWING LINE!
        // (it is only here as a reminder to not to do it)
        //m_splitterY = y;

        //if ( m_splitterPrevDrawnWin )
        //    DrawSplitterDragRow( m_splitterPrevDrawnWin, m_splitterY, m_splitterHeight );

        // This is necessary to return cursor
        END_MOUSE_CAPTURE

        // Set back the default cursor, if necessary
        if ( y < m_splitterY || y >= (m_splitterY+m_splitterHeight+2) )
        {
            //SetCursor ( *wxSTANDARD_CURSOR );
            SetCursor ( wxNullCursor );
        }


        m_dragStatus = 0;
    }
}

// -----------------------------------------------------------------------