manager.cpp

这是一个GPS相关的程序

        {
            //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<GetPageCount(); i++ )
    {
        wxPropertyGridState* pState = ((wxPropertyGridPage*)m_arrPages.Item(i))->GetStatePtr();
        wxPGId id = pState->GetPropertyByLabel(label);
        if ( wxPGIdIsOk(id) )
        {
            if ( ppState ) *ppState = pState;
            return id;
        }
    }
    return wxPGIdGen((wxPGProperty*)NULL);
}

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

bool wxPropertyGridManager::EnsureVisible( wxPGId id )
{
    wxPG_PROP_ID_CALL_PROLOG_RETVAL(false)

    wxPropertyGridState* parentState = p->GetParentState();

    // Select correct page.
    if ( m_pPropGrid->m_pState != parentState )
        DoSelectPage( GetPageByState(parentState) );

    return m_pPropGrid->EnsureVisible(id);
}

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

// TODO: Transfer name-argument methods to class as inlines.

#define wxPG_IMPLEMENT_PGMAN_METHOD_WRET0(NAME,RETVAL) \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME( wxPGId id ) \
{ \
    wxPGProperty* p = wxPGIdToPtr(id); \
    wxASSERT_MSG(p,wxT("invalid property id")); \
    if ( p ) \
    { \
        wxPropertyGridState* pState = p->GetParentState(); \
        wxASSERT( pState != (wxPropertyGridState*) NULL ); \
        if ( pState == m_pPropGrid->m_pState ) return m_pPropGrid->NAME(id); \
        return pState->NAME(p); \
    } \
    return ((RETVAL)0); \
} \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME( wxPGPropNameStr name ) \
{ \
    wxPGId id = GetPropertyByNameI(name); \
    if ( !wxPGIdIsOk(id) ) return ((RETVAL)0); \
    return NAME(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_MSG(p,wxT("invalid property id")); \
    if ( p ) \
    { \
        wxPropertyGridState* pState = p->GetParentState(); \
        wxASSERT( pState != (wxPropertyGridState*) NULL ); \
        if ( pState == m_pPropGrid->m_pState ) return m_pPropGrid->NAME(id,_av1_); \
        return pState->NAME(p,_av1_); \
    } \
    return ((RETVAL)0); \
} \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME( wxPGPropNameStr name, AT1 _av1_ ) \
{ \
    wxPGId id = GetPropertyByNameI(name); \
    if ( !wxPGIdIsOk(id) ) return ((RETVAL)0); \
    return NAME(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_MSG(p,wxT("invalid property id")); \
    if ( p ) \
    { \
        wxPropertyGridState* pState = p->GetParentState(); \
        wxASSERT( pState != (wxPropertyGridState*) NULL ); \
        if ( pState == m_pPropGrid->m_pState ) return m_pPropGrid->NAME(id,_av1_,_av2_); \
        return pState->NAME(p,_av1_,_av2_); \
    } \
    return ((RETVAL)0); \
} \
wxPG_IPAM_DECL RETVAL wxPropertyGridManager::NAME( wxPGPropNameStr name, AT1 _av1_, AT2 _av2_ ) \
{ \
    wxPGId id = GetPropertyByNameI(name); \
    if ( !wxPGIdIsOk(id) ) return ((RETVAL)0); \
    return NAME(id,_av1_,_av2_); \
}

#define wxPG_IMPLEMENT_PGMAN_METHOD_NORET0(NAME) \
wxPG_IPAM_DECL void wxPropertyGridManager::NAME( wxPGId id ) \
{ \
    wxPGProperty* p = wxPGIdToPtr(id); \
    wxASSERT_MSG(p,wxT("invalid property id")); \
    if ( p ) \
    { \
        wxPropertyGridState* pState = p->GetParentState(); \
        wxASSERT( pState != (wxPropertyGridState*) NULL ); \
        if ( pState == m_pPropGrid->m_pState ) m_pPropGrid->NAME(id); \
        else pState->NAME(p); \
    } \
} \
wxPG_IPAM_DECL void wxPropertyGridManager::NAME( wxPGPropNameStr name ) \
{ \
    wxPGId id = GetPropertyByNameI(name); \
    if ( !wxPGIdIsOk(id) ) return; \
    NAME(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_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(SetPropertyValueLong,long)
#ifndef __WXPYTHON__
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,int)
#endif
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValueDouble,double)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValueBool,bool)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValueString,const wxString&)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValueWxObjectPtr,wxObject*)
#ifndef __WXPYTHON__
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,void*)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValue,wxVariant&)
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1(SetPropertyValueArrstr2,const wxArrayString&)
#else
wxPG_IMPLEMENT_PGMAN_METHOD_NORET1_P1(SetPropertyValueArrstr2,const wxArrayString&)
#endif
#ifdef wxPG_COMPATIBILITY_1_0_0
wxPG_IMPLEMENT_PGMAN_METHOD_NORET0(SetPropertyValueUnspecified)
#else
wxPG_IMPLEMENT_PGMAN_METHOD_NORET0(SetPropertyUnspecified)
#endif

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

void wxPropertyGridManager::ClearModifiedStatus( wxPGId id )
{
    wxPG_PROP_ID_CALL_PROLOG()

    wxPropertyGridState* pState = p->GetParentState();
    wxASSERT ( pState != (wxPropertyGridState*) NULL );
    pState->ClearModifiedStatus(p);
}

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

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

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

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

        if ( id == ( baseId + ID_ADVTBITEMSBASE_OFFSET + 0 ) )
        {
            // Categorized mode.
            if ( m_pPropGrid->m_windowStyle & wxPG_HIDE_CATEGORIES )
                m_pPropGrid->EnableCategories( true );
        }
        else if ( id == ( baseId + ID_ADVTBITEMSBASE_OFFSET + 1 ) )
        {
            // Alphabetic mode.
            if ( !(m_pPropGrid->m_windowStyle & wxPG_HIDE_CATEGORIES) )
                m_pPropGrid->EnableCategories( false );
        }
        else
        {
            // Page Switching.

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

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

            wxASSERT( index >= 0 );

            if ( DoSelectPage( index ) )
            {

                // Event dispatching must be last.
                m_pPropGrid->SendEvent(  wxEVT_PG_PAGE_CHANGED, (wxPGProperty*) NULL );

            }
            else
            {
                // TODO: Depress the old button on toolbar.
            }

        }
    }
}

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

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::SetSplitterLeft( bool subProps, bool allPages )
{
    if ( !allPages )
    {
        m_pPropGrid->SetSplitterLeft(subProps);
    }
    else
    {
        wxClientDC dc(this);
        dc.SetFont(m_pPropGrid->m_font);

        int highest = 0;
        unsigned int i;

        for ( i=0; i<GetPageCount(); i++ )
        {
            int maxW = m_pState->GetLeftSplitterPos(dc, GetPageState(i)->m_properties, subProps );
            wxLogDebug(wxT("%i"),maxW);
            if ( maxW > highest )
                highest = maxW;
        }

        if ( highest > 0 )
            m_pPropGrid->SetSplitterPosition( highest );

        m_pPropGrid->m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
    }
}

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

void wxPropertyGridManager::OnPropertyGridSelect( wxPropertyGridEvent& event )
{
    // Check id.
    wxASSERT_MSG( GetId() == m_pPropGrid->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_pPropGrid->m_iFlags & wxPG_FL_HIDE_STATE) )
    {
        m_pPropGrid->Compact( true );
        m_pButCompactor->SetLabel( _("Expand >>") );
    }
    else
    {
        m_pPropGrid->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);
}

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

void wxPropertyGridManager::OnMouseEntry( wxMouseEvent& WXUNUSED(event) )
{
    // 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_pPropGrid->m_lineHeight;
#if wxUSE_TOOLBAR
        if ( m_pToolbar ) top_limit += m_pToolbar->GetSize().y;
#endif

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

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

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

                m_extraHeight -= change;
                InvalidateBestSize();
            }

        }

    }
    else
    {
        if ( y >= m_splitterY && y < (m_splitterY+m_splitterHeight+2) )
        {
            SetCursor ( m_cursorSizeNS );
            m_onSplitter = 1;
        }
        else
        {
            if ( m_onSplitter )
            {
                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 ( m_dragStatus == 0 )
        {
            //
            // Begin draggin the splitter
            //

            BEGIN_MOUSE_CAPTURE

            m_dragStatus = 1;

            m_dragOffset = y - m_splitterY;

        }
    }
}

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

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

    if ( m_dragStatus >= 1 )
    {
        //
        // End Splitter Dragging
        //

        int y = event.m_y;

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

        // 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 ( wxNullCursor );
        }

        m_dragStatus = 0;
    }
}

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