advprops.cpp

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

                      gs_cp_es_syscolour_values,
                      wx_cp_es_syscolours_len )
{
    wxPG_INIT_REQUIRED_TYPE(wxColourPropertyValue)

    if ( &value )
        Init(value.m_type,value.m_colour);
    else
        Init(0,*wxBLACK);

    DoSetValue ( m_value );
}

wxSystemColourPropertyClass::wxSystemColourPropertyClass( const wxString& label, const wxString& name,
    const wxChar** labels, const long* values, unsigned int itemcount,
    const wxColourPropertyValue& value )
    : wxEnumPropertyClass( label,name,labels,values,itemcount )
{
    if ( &value )
        Init(value.m_type,value.m_colour);
    else
        Init(wxPG_COLOUR_CUSTOM,*wxBLACK);
}

wxSystemColourPropertyClass::wxSystemColourPropertyClass( const wxString& label, const wxString& name,
    const wxChar** labels, const long* values, unsigned int itemcount,
    const wxColour& value )
    : wxEnumPropertyClass( label,name,labels,values,itemcount )
{
    Init(wxPG_COLOUR_CUSTOM,value);
}

wxSystemColourPropertyClass::~wxSystemColourPropertyClass () { }

int wxSystemColourPropertyClass::ColToInd ( const wxColour& colour )
{
    size_t i;
    size_t i_max = m_constants->GetCount() - 1;

    long pixval = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
    const wxArrayInt& arrValues = m_constants->GetValues();

    for ( i=0; i<i_max; i++ )
    {
        int ind = i;
        if ( arrValues.GetCount() )
            ind = arrValues[i];

        if ( GetColour(ind) == pixval )
        {
            /*wxLogDebug(wxT("%s(%s): Index %i for ( getcolour(%i,%i,%i), colour(%i,%i,%i))"),
                GetClassName(),GetLabel().c_str(),
                (int)i,(int)GetColour(ind).Red(),(int)GetColour(ind).Green(),(int)GetColour(ind).Blue(),
                (int)colour.Red(),(int)colour.Green(),(int)colour.Blue());*/
            return ind;
        }
    }
    return wxNOT_FOUND;
}

static inline wxColour wxColourFromPGLong ( long col )
{
    return wxColour((col&0xFF),((col>>8)&0xFF),((col>>16)&0xFF));
}

void wxSystemColourPropertyClass::DoSetValue ( wxPGVariant value )
{
    wxColourPropertyValue* pval = wxPGVariantToWxObjectPtr(value,wxColourPropertyValue);
    
    if ( pval == (wxColourPropertyValue*) NULL )
    {
        m_value.m_type = wxPG_COLOUR_CUSTOM;
        m_value.m_colour = *wxWHITE;
    }
    else if ( pval != &m_value )
        m_value = *pval;

    // If available, use matching list item instead.
    if ( m_value.m_type == wxPG_COLOUR_CUSTOM )
    {
        if ( (m_flags & wxPG_PROP_TRANSLATE_CUSTOM) )
        {
            int found_ind = ColToInd(m_value.m_colour);
            if ( found_ind != wxNOT_FOUND )
                m_value.m_type = found_ind;
        }
    }

    wxASSERT ( m_value.m_colour.Ok() );

    if ( m_value.m_type < wxPG_COLOUR_WEB_BASE )
    {
        m_value.m_colour = GetColour ( m_value.m_type );
        wxEnumPropertyClass::DoSetValue ( (long)m_value.m_type );
    }
    else
    {
        m_index = m_constants->GetCount()-1;
    }
}

long wxSystemColourPropertyClass::GetColour ( int index )
{
    wxColour colour = wxSystemSettings::GetColour ( (wxSystemColour)index );
    return wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
}

wxPGVariant wxSystemColourPropertyClass::DoGetValue () const
{
    return wxPGVariant(&m_value);
}

wxString wxSystemColourPropertyClass::GetValueAsString ( int ) const
{
    if ( m_value.m_type == wxPG_COLOUR_CUSTOM )
    {
        wxString temp;
        temp.Printf ( wxT("(%i,%i,%i)"),
            (int)m_value.m_colour.Red(),(int)m_value.m_colour.Green(),(int)m_value.m_colour.Blue());
        return temp;
    }
    return m_constants->GetLabel(m_index);
}

wxSize wxSystemColourPropertyClass::GetImageSize() const
{
    return wxSize(-1,-1);
}

// Need to do some extra event handling.
bool wxSystemColourPropertyClass::OnEvent ( wxPropertyGrid* propgrid, wxPGCtrlClass* primary, wxEvent& event )
{
#if wxPG_USE_CUSTOM_CONTROLS
    if ( event.GetEventType() == wxEVT_COMMAND_CHOICE_SELECTED )
#else
    if ( event.GetEventType() == wxEVT_COMMAND_COMBOBOX_SELECTED )
#endif
    {
        int index = m_index; // m_index has already been updated.
        int type = wxEnumPropertyClass::DoGetValue().GetRawLong();

        const wxArrayInt& arrValues = m_constants->GetValues();

        if ( ( arrValues.GetCount() && type == wxPG_COLOUR_CUSTOM ) ||
             ( !arrValues.GetCount() && index == (int)(m_constants->GetCount()-1) )
           )
        {
            m_value.m_type = wxPG_COLOUR_CUSTOM;

            wxColourData data;
            data.SetChooseFull(true);
            int i;
            for ( i = 0; i < 16; i++)
            {
                wxColour colour(i*16, i*16, i*16);
                data.SetCustomColour(i, colour);
            }

            wxColourDialog dialog(propgrid, &data);
            if ( dialog.ShowModal() == wxID_OK )
            {
                wxColourData retData = dialog.GetColourData();
                m_value.m_colour = retData.GetColour();
                wxSystemColourPropertyClass::DoSetValue(m_value);
            }

            // Update text in combo box (so it is "(R,G,B)" not "Custom").
            if ( primary )
                GetEditorClass()->SetControlStringValue(primary,GetValueAsString(0));

            return TRUE;
        }
        else
        {
            m_value.m_type = type;
            m_value.m_colour = GetColour( type );
        }
    }
    return FALSE;
}

void wxSystemColourPropertyClass::OnCustomPaint ( wxDC& dc,
    const wxRect& rect, wxPGPaintData& paintdata )
{
    if ( paintdata.m_choiceItem >= 0 && paintdata.m_choiceItem < (int)(GetItemCount()-1) )
    {
        int colind = paintdata.m_choiceItem;
        const wxArrayInt& values = m_constants->GetValues();
        if ( values.GetCount() )
             colind = values[paintdata.m_choiceItem];
        dc.SetBrush ( wxColour ( GetColour ( colind ) ) );
    }
    else if ( !(m_flags & wxPG_PROP_UNSPECIFIED) )
        dc.SetBrush ( m_value.m_colour );
    else
        dc.SetBrush ( *wxWHITE );

    dc.DrawRectangle ( rect );

}

bool wxSystemColourPropertyClass::SetValueFromString ( const wxString& text, int flags )
{
    wxColourPropertyValue val;
    if ( text[0] == wxT('(') )
    {
        // Custom colour.
        val.m_type = wxPG_COLOUR_CUSTOM;

        int r, g, b;
        wxSscanf(text.c_str(),wxT("(%i,%i,%i)"),&r,&g,&b);
        val.m_colour.Set(r,g,b);

        wxSystemColourPropertyClass::DoSetValue ( &val );

        return TRUE;
    }
    else
    {
        // Predefined colour.
        bool res = wxEnumPropertyClass::SetValueFromString(text,flags);
        if ( res )
        {
            val.m_type = m_index;
            const wxArrayInt& values = GetValues();
            if ( values.GetCount() )
                val.m_type = values[m_index];

            // Get proper colour for type.
            val.m_colour = wxColourFromPGLong(GetColour(val.m_type));

            wxSystemColourPropertyClass::DoSetValue ( &val );
            return TRUE;
        }
    }
    return FALSE;
}

// -----------------------------------------------------------------------
// wxColourProperty
// -----------------------------------------------------------------------

#define wx_cp_es_normcolours_len 19
static const wxChar* gs_cp_es_normcolour_labels[wx_cp_es_normcolours_len] = {
    wxT("Black"),
    wxT("Maroon"),
    wxT("Navy"),
    wxT("Purple"),
    wxT("Teal"),
    wxT("Gray"),
    wxT("Green"),
    wxT("Olive"),
    wxT("Brown"),
    wxT("Blue"),
    wxT("Fuchsia"),
    wxT("Red"),
    wxT("Orange"),
    wxT("Silver"),
    wxT("Lime"),
    wxT("Aqua"),
    wxT("Yellow"),
    wxT("White"),
    wxT("Custom")
};

static unsigned long gs_cp_es_normcolour_colours[wx_cp_es_normcolours_len] = {
    wxPG_COLOUR(0,0,0),
    wxPG_COLOUR(128,0,0),
    wxPG_COLOUR(0,0,128),
    wxPG_COLOUR(128,0,128),
    wxPG_COLOUR(0,128,128),
    wxPG_COLOUR(128,128,128),
    wxPG_COLOUR(0,128,0),
    wxPG_COLOUR(128,128,0),
    wxPG_COLOUR(166,124,81),
    wxPG_COLOUR(0,0,255),
    wxPG_COLOUR(255,0,255),
    wxPG_COLOUR(255,0,0),
    wxPG_COLOUR(247,148,28),
    wxPG_COLOUR(192,192,192),
    wxPG_COLOUR(0,255,0),
    wxPG_COLOUR(0,255,255),
    wxPG_COLOUR(255,255,0),
    wxPG_COLOUR(255,255,255),
    wxPG_COLOUR(0,0,0)
};

WX_PG_IMPLEMENT_CUSTOM_COLOUR_PROPERTY_USES_WXCOLOUR(wxColourProperty,
                                               gs_cp_es_normcolour_labels,
                                               (const long*)NULL,
                                               gs_cp_es_normcolour_colours,
                                               wx_cp_es_normcolours_len)

// -----------------------------------------------------------------------
// wxCursorProperty
// -----------------------------------------------------------------------

#define wxPG_CURSOR_IMAGE_WIDTH     32

#define wx_cp_es_syscursors_len 28
static const wxChar* gs_cp_es_syscursors_labels[wx_cp_es_syscursors_len] = {
    wxT("Default"),
    wxT("Arrow"),
    wxT("Right Arrow"),
    wxT("Blank"),
    wxT("Bullseye"),
    wxT("Character"),
    wxT("Cross"),
    wxT("Hand"),
    wxT("I-Beam"),
    wxT("Left Button"),
    wxT("Magnifier"),
    wxT("Middle Button"),
    wxT("No Entry"),
    wxT("Paint Brush"),
    wxT("Pencil"),
    wxT("Point Left"),
    wxT("Point Right"),
    wxT("Question Arrow"),
    wxT("Right Button"),
    wxT("Sizing NE-SW"),
    wxT("Sizing N-S"),
    wxT("Sizing NW-SE"),
    wxT("Sizing W-E"),
    wxT("Sizing"),
    wxT("Spraycan"),
    wxT("Wait"),
    wxT("Watch"),
    wxT("Wait Arrow"),
    //_("Cursor from File"),
    //_("Cursor from Resource")
};

static long gs_cp_es_syscursors_values[wx_cp_es_syscursors_len] = {
    wxCURSOR_NONE,
    wxCURSOR_ARROW,
    wxCURSOR_RIGHT_ARROW,
    wxCURSOR_BLANK,
    wxCURSOR_BULLSEYE,
    wxCURSOR_CHAR,
    wxCURSOR_CROSS,
    wxCURSOR_HAND,
    wxCURSOR_IBEAM,
    wxCURSOR_LEFT_BUTTON,
    wxCURSOR_MAGNIFIER,
    wxCURSOR_MIDDLE_BUTTON,
    wxCURSOR_NO_ENTRY,
    wxCURSOR_PAINT_BRUSH,
    wxCURSOR_PENCIL,
    wxCURSOR_POINT_LEFT,
    wxCURSOR_POINT_RIGHT,
    wxCURSOR_QUESTION_ARROW,
    wxCURSOR_RIGHT_BUTTON,
    wxCURSOR_SIZENESW,
    wxCURSOR_SIZENS,
    wxCURSOR_SIZENWSE,
    wxCURSOR_SIZEWE,
    wxCURSOR_SIZING,
    wxCURSOR_SPRAYCAN,
    wxCURSOR_WAIT,
    wxCURSOR_WATCH,
    wxCURSOR_ARROWWAIT,
    //wxPG_CURSOR_FROM_FILE,
    //wxPG_CURSOR_FROM_RESOURCE
};

WX_PG_IMPLEMENT_DERIVED_PROPERTY_CLASS(wxCursorProperty,int)

wxCursorPropertyClass::wxCursorPropertyClass ( const wxString& label, const wxString& name,
    int value )
    : wxEnumPropertyClass( label,
                           name,
                           gs_cp_es_syscursors_labels,
                           gs_cp_es_syscursors_values,
                           wx_cp_es_syscursors_len,
                           value )
{
    m_flags |= wxPG_PROP_STATIC_CHOICES; // Cursor selection cannot be changed.