← Back to branch summary

~registry/codeblocks/trunk

« back to all changes in this revision

Viewing changes to src/plugins/contrib/wxSmith/wxwidgets/defitems/wxsbitmapcombobox.cpp

  • Committer: mortenmacfly
  • Date: 2012-02-22 14:40:26 UTC
  • Revision ID: svn-v4:98b59c6a-2706-0410-b7d6-d2fa1a1880c9:trunk:7835
* merged wxSmith branch into trunk
* this brings tons of new wxSmith items, including KWIC, wxImagePanel, wxGridBagSizer and more
* based on work of the community, mainly cryogen
* for more information, see changelog of wxSmith branch
* also, re-factoring of contributed wxWidgets items for wxSmith
* PLEASE DO A CLEAN CHECKOUT AND RE-BUILD EVERYTHING FROM SCRATCH!

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/contrib/wxSmith/wxwidgets/defitems/wxsbitmapcombobox.cpp
1
 
/** \file wxsbitmapcombobox.cpp
2
 
*
 
1
/*
3
2
* This file is part of wxSmith plugin for Code::Blocks Studio
4
 
* Copyright (C) 2010 Gary Harris
 
3
* Copyright (C) 2006-2007  Bartlomiej Swiecki
5
4
*
6
5
* wxSmith is free software; you can redistribute it and/or modify
7
6
* it under the terms of the GNU General Public License as published by
16
15
* You should have received a copy of the GNU General Public License
17
16
* along with wxSmith. If not, see <http://www.gnu.org/licenses/>.
18
17
*
 
18
* $Revision$
 
19
* $Id$
 
20
* $HeadURL$
19
21
*/
20
22
 
21
 
#include <wx/bmpcbox.h>
 
23
 
 
24
#include <wx/bmpbuttn.h>
22
25
#include "wxsbitmapcombobox.h"
23
 
#include "wxsimagelist.h"
24
 
#include "../properties/wxsimagelistdlg.h"
 
26
 
 
27
 
 
28
//------------------------------------------------------------------------------
25
29
 
26
30
 
27
31
namespace
28
32
{
29
 
    wxsRegisterItem<wxsBitmapComboBox> Reg(_T("BitmapComboBox"), wxsTWidget, _T("Standard"), 350);
30
 
 
31
 
 
32
 
    WXS_ST_BEGIN(wxsBitmapComboBoxStyles, wxEmptyString)
33
 
    WXS_ST_CATEGORY("wxBitmapComboBox")
34
 
    WXS_ST(wxCB_READONLY)
35
 
    WXS_ST(wxCB_SORT)
36
 
    WXS_ST(wxTE_PROCESS_ENTER)
37
 
    WXS_ST_DEFAULTS()
 
33
 
 
34
 
 
35
    wxsRegisterItem<wxsBitmapComboBox> Reg(_T("BitmapComboBox"),wxsTWidget,_T("Standard"),50);
 
36
//    wxsRegisterItem<wxsBitmapComboBox> Reg(
 
37
//        _T("wxBitmapComboBox"),         // Class name
 
38
//        wxsTWidget,                     // Item type
 
39
//        _T("wxWindows"),                // License
 
40
//        _T("Ron Collins"),              // Author
 
41
//        _T("rcoll@theriver.com"),       // Author's email
 
42
//        _T(""),                         // Item's homepage
 
43
//        _T("Standard"),                 // Category in palette
 
44
//        50,                             // Priority in palette
 
45
//        _T("ComboBox"),                 // Base part of names for new items
 
46
//        wxsCPP,                         // List of coding languages supported by this item
 
47
//        1, 0,                           // Version
 
48
//        _T("wxBitmapCombo32.png"),    // 32x32 bitmap
 
49
//        _T("wxBitmapCombo16.png"),    // 16x16 bitmap
 
50
//        false);                         // We do not allow this item inside XRC files
 
51
 
 
52
 
 
53
    WXS_ST_BEGIN(wxsBitmapComboBoxStyles,_T("wxBU_AUTODRAW"))
 
54
        WXS_ST_CATEGORY("wxBitmapComboBox")
 
55
        WXS_ST(wxCB_SIMPLE)
 
56
        WXS_ST(wxCB_SORT)
 
57
        WXS_ST(wxCB_READONLY)
 
58
        WXS_ST(wxCB_DROPDOWN)
 
59
        WXS_ST(wxTE_PROCESS_ENTER)
 
60
        WXS_ST_DEFAULTS()
38
61
    WXS_ST_END()
39
62
 
 
63
 
40
64
    WXS_EV_BEGIN(wxsBitmapComboBoxEvents)
41
 
                WXS_EVI(EVT_COMBOBOX, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEvent, Selected)
42
 
                WXS_EVI(EVT_TEXT, wxEVT_COMMAND_TEXT_UPDATED, wxCommandEvent, TextUpdated)
43
 
                WXS_EVI(EVT_TEXT_ENTER, wxEVT_COMMAND_TEXT_ENTER, wxCommandEvent, TextEnter)
 
65
        WXS_EVI(EVT_COMBOBOX,wxEVT_COMMAND_COMBOBOX_SELECTED,wxCommandEvent,Select)
 
66
        WXS_EVI(EVT_TEXT,wxEVT_COMMAND_TEXT_UPDATED,wxCommandEvent,Text)
 
67
        WXS_EVI(EVT_TEXT_ENTER,wxEVT_COMMAND_TEXT_ENTER,wxCommandEvent,TextEnter)
44
68
    WXS_EV_END()
45
69
}
46
70
 
47
 
/*! \brief Ctor
48
 
 *
49
 
 * \param Data wxsItemResData*  The control's resource data.
50
 
 *
51
 
 */
52
 
wxsBitmapComboBox::wxsBitmapComboBox(wxsItemResData *Data):
 
71
//------------------------------------------------------------------------------
 
72
 
 
73
wxsBitmapComboBox::wxsBitmapComboBox(wxsItemResData* Data):
53
74
    wxsWidget(
54
75
        Data,
55
76
        &Reg.Info,
56
77
        wxsBitmapComboBoxEvents,
57
 
        wxsBitmapComboBoxStyles),
58
 
    m_defaultSelection(-1)
59
 
{
60
 
}
61
 
 
62
 
/*! \brief Create the initial control.
63
 
 *
64
 
 * \return void
65
 
 *
66
 
 */
67
 
void wxsBitmapComboBox::OnBuildCreatingCode()
68
 
{
69
 
    switch(GetLanguage())
70
 
    {
71
 
        case wxsCPP:
72
 
            {
73
 
                AddHeader(_T("<wx/bmpcbox.h>"), GetInfo().ClassName, hfInPCH);
74
 
                Codef(_T("%C(%W, %I, wxEmptyString, %P, %S, 0, 0, %T, %V, %N);\n"));
75
 
 
76
 
                for(size_t i = 0; i <  m_arrChoices.GetCount(); ++i)
77
 
                {
78
 
                    if(m_defaultSelection == (int)i)
79
 
                    {
80
 
                        Codef(_T("%ASetSelection( "));
81
 
                    }
82
 
#if wxCHECK_VERSION(2, 9, 0)
83
 
                    Codef(_T("%AAppend(%t)"), m_arrChoices[i].wx_str());
84
 
#else
85
 
                    Codef(_T("%AAppend(%t)"), m_arrChoices[i].c_str());
86
 
#endif
87
 
                    if(m_defaultSelection == (int)i)
88
 
                    {
89
 
                        Codef(_T(" )"));
90
 
                    }
91
 
                    Codef(_T(";\n"));
92
 
                }
93
 
 
94
 
                                // Find the image list.
95
 
                                wxsImageList *imageList = (wxsImageList *) wxsImageListDlg::FindTool(this, m_sImageList);
96
 
                                int iItemcount = m_arrChoices.GetCount();
97
 
 
98
 
                                wxString vv = GetVarName();
99
 
                                if(imageList){
100
 
                                        wxString tt;
101
 
                                        wxString ss = imageList->GetVarName();
102
 
                                        int iImgCount = imageList->GetCount();
103
 
                                        if(iImgCount > 0){
104
 
                                                AddEventCode(_("\n"));
105
 
                                        }
106
 
                                        for(int i = 0;i < iImgCount;i++){
107
 
                                                // Keep within the size limits of the combo box.
108
 
                                                if(i >= iItemcount){
109
 
                                                        break;
110
 
                                                }
111
 
#if wxCHECK_VERSION(2, 9, 0)
112
 
                                                tt.Printf(_("%s->SetItemBitmap(%d, %s->GetBitmap(%d));\n"), vv.wx_str(), i, ss.wx_str(), i);
113
 
#else
114
 
                                                tt.Printf(_("%s->SetItemBitmap(%d, %s->GetBitmap(%d));\n"), vv.c_str(), i, ss.c_str(), i);
115
 
#endif
116
 
                                                // add all the bitmaps at the bottom of the code... after the wxsImage's and wxsImageList's have been coded
117
 
                                                AddEventCode(tt);
118
 
                                        }
119
 
                                        if(iImgCount > 0){
120
 
                                                AddEventCode(_("\n"));
121
 
                                        }
122
 
                                }
123
 
 
124
 
               BuildSetupWindowCode();
125
 
                return;
126
 
            }
127
 
 
128
 
        default:
129
 
            {
130
 
                wxsCodeMarks::Unknown(_T("wxsBitmapComboBox::OnBuildCreatingCode"), GetLanguage());
131
 
            }
132
 
    }
133
 
}
134
 
 
135
 
/*! \brief      Build the control preview.
136
 
 *
137
 
 * \param parent wxWindow*      The parent window.
138
 
 * \param flags long                            The control flags.
139
 
 * \return wxObject*                            The constructed control.
140
 
 *
141
 
 */
142
 
wxObject *wxsBitmapComboBox::OnBuildPreview(wxWindow *Parent, long Flags)
143
 
{
144
 
    wxBitmapComboBox *preview = new wxBitmapComboBox(Parent, GetId(), wxEmptyString, Pos(Parent), Size(Parent), m_arrChoices, Style());
145
 
 
146
 
        // Find the image list.
147
 
        wxsImageList *imageList = (wxsImageList *) wxsImageListDlg::FindTool(this, m_sImageList);
148
 
 
149
 
        int count = preview->GetCount();
150
 
        if(imageList){
151
 
                for(int i = 0;i < imageList->GetCount();i++){
152
 
                        // Keep within the size limits of the combo box.
153
 
                        if(i >= count){
154
 
                                break;
155
 
                        }
156
 
                        // SetItemBitmap() uses an unsigned int.
157
 
                        preview->SetItemBitmap((unsigned)i, imageList->GetPreview(i));
158
 
                }
159
 
        }
160
 
 
161
 
    if(m_defaultSelection != -1){
162
 
                preview->SetSelection(m_defaultSelection);
163
 
    }
164
 
 
165
 
    return SetupWindow(preview, Flags);
166
 
}
167
 
 
168
 
/*! \brief Enumerate the control's properties.
169
 
 *
170
 
 * \param flags long    The control flags.
171
 
 * \return void
172
 
 *
173
 
 */
174
 
void wxsBitmapComboBox::OnEnumWidgetProperties(long Flags)
175
 
{
176
 
    WXS_ARRAYSTRING(wxsBitmapComboBox, m_arrChoices, _("Choices"), _T("content"), _T("item"))
177
 
    WXS_LONG(wxsBitmapComboBox, m_defaultSelection, _("Selection"), _T("selection"), -1)
178
 
 
179
 
        static const wxChar     *pImageNames[128];
180
 
        static long                                     iImageNames[128];
181
 
        int                                                                     i, n, iResCount;
182
 
        wxsItemResData         *resData;
183
 
        wxsTool                                 *tool;
184
 
        wxString                                                s;
185
 
        wxsImageList            *imageList;
186
 
        static const wxString   sNone(_("<none>"));
187
 
 
188
 
        // find available images, and pointer to current imagelist
189
 
    imageList = NULL;
190
 
    resData = GetResourceData();
191
 
    n = 0;
192
 
    m_arrImageListNames[n] = sNone;
193
 
    pImageNames[n] = (const wxChar *) m_arrImageListNames[n];
194
 
    n += 1;
195
 
    iResCount = resData->GetToolsCount();
196
 
    for(i = 0;i < iResCount;i++){
197
 
        tool = resData->GetTool(i);
198
 
        s = tool->GetUserClass();
199
 
 
200
 
        if((s == _T("wxImageList")) && (n < 127)){
201
 
            s = tool->GetVarName();
202
 
            m_arrImageListNames[n] = s;
203
 
            pImageNames[n] = (const wxChar *) m_arrImageListNames[n];
204
 
            iImageNames[n] = n;
205
 
            n += 1;
206
 
 
207
 
            if(s == m_sImageList){
208
 
                imageList = (wxsImageList *) tool;
209
 
            }
210
 
        }
211
 
    }
 
78
        wxsBitmapComboBoxStyles)
 
79
{
 
80
int         i,n;
 
81
wxString    ss;
 
82
 
 
83
// default values
 
84
 
 
85
    mImageList = _("<none>");
 
86
    mItems.Clear();
 
87
 
 
88
}
 
89
 
 
90
//------------------------------------------------------------------------------
 
91
 
 
92
void wxsBitmapComboBox::OnBuildCreatingCode() {
 
93
int         i,n;
 
94
wxString    ss, tt, vv;
 
95
bool        ilist;
 
96
 
 
97
// we only handle C++ constructs here
 
98
 
 
99
    if (GetLanguage() != wxsCPP) wxsCodeMarks::Unknown(_T("wxsBitmapComboBox"),GetLanguage());
 
100
 
 
101
// header files
 
102
 
 
103
    AddHeader(_T("<wx/bmpcbox.h>"),GetInfo().ClassName,hfInPCH);
 
104
 
 
105
// the basic constructor
 
106
 
 
107
    vv = GetVarName();
 
108
    Codef(_T("%C(%W, %I, wxEmptyString, %P, %S, 0, NULL, %T, %V, %N);\n"));
 
109
 
 
110
// was a valid image-list specified?
 
111
 
 
112
    ilist = (wxsImageListEditorDlg::FindTool(this, mImageList) != NULL);
 
113
 
 
114
// add all text items, and the bitmaps at the bottom of the code
 
115
// bitmaps have to added after the wxsImages' and wxsImageList's were added
 
116
// note: first 2 items in mItems are used only in the dialog
 
117
 
 
118
    for(i=2; i<mItems.GetCount(); i++) {
 
119
        ss = mItems.Item(i);
 
120
        ParseComboItem(ss, tt, n);
 
121
 
 
122
// add the text item
 
123
 
 
124
        Codef(_T("%s->Append(_T(\"%s\"));\n"), vv.c_str(), tt.c_str());
 
125
 
 
126
// add the bitmap at the bottom of the code
 
127
 
 
128
        if ((ilist) && (n >= 0)) {
 
129
            tt.Printf(_T("%s->SetItemBitmap(%d, %s->GetBitmap(%d));\n"), vv.c_str(), i-2, mImageList.c_str(), n);
 
130
            AddEventCode(tt);
 
131
        };
 
132
    };
 
133
 
 
134
    AddEventCode(_T("\n"));
 
135
 
 
136
// finish setup
 
137
 
 
138
    BuildSetupWindowCode();
 
139
 
 
140
}
 
141
 
 
142
//------------------------------------------------------------------------------
 
143
 
 
144
wxObject* wxsBitmapComboBox::OnBuildPreview(wxWindow* Parent,long Flags) {
 
145
int                 i,n;
 
146
wxBitmapComboBox    *combo;
 
147
wxsImageList        *ilist;
 
148
wxString            ss, tt;
 
149
wxBitmap            bmp;
 
150
 
 
151
// the basic button
 
152
 
 
153
    combo = new wxBitmapComboBox(Parent, GetId(), _T(""), Pos(Parent),Size(Parent),0, NULL, Style());
 
154
 
 
155
// a valid image-list specified?
 
156
 
 
157
    ilist = (wxsImageList *) wxsImageListEditorDlg::FindTool(this, mImageList);
 
158
 
 
159
// make sure there is no random junk
 
160
 
 
161
    combo->Clear();
 
162
 
 
163
// add items to combo-box
 
164
// note: first 2 items are used only in the dialog
 
165
 
 
166
    for(i=2; i<mItems.GetCount(); i++) {
 
167
        ss = mItems.Item(i);
 
168
        ParseComboItem(ss, tt, n);
 
169
 
 
170
        combo->Append(tt);
 
171
 
 
172
        if ((ilist != NULL) && (n >= 0)) combo->SetItemBitmap(i-2, ilist->GetPreview(n));
 
173
    };
 
174
 
 
175
// done
 
176
 
 
177
    return SetupWindow(combo, Flags);
 
178
}
 
179
 
 
180
//------------------------------------------------------------------------------
 
181
 
 
182
void wxsBitmapComboBox::OnEnumWidgetProperties(long Flags) {
 
183
static wxString         sImageNames[128];
 
184
static const wxChar    *pImageNames[128];
 
185
 
 
186
int                     i,n;
 
187
wxString                ss, tt;
 
188
wxArrayString           aa;
 
189
 
 
190
// find available image lists and store them in our local static arrays
 
191
 
 
192
    FindAllImageLists(aa);
 
193
    n = aa.GetCount();
 
194
    if (n > 127) n = 127;
 
195
 
 
196
    for(i=0; i<n; i++) {
 
197
        ss = aa.Item(i);
 
198
        sImageNames[i] = ss;
 
199
        pImageNames[i] = (const wxChar *) sImageNames[i];
 
200
    };
212
201
    pImageNames[n] = NULL;
213
 
    WXS_EDITENUM(wxsBitmapComboBox, m_sImageList, _("Image List"), _T("image_list"), pImageNames, sNone)
214
 
}
 
202
 
 
203
    WXS_EDITENUM(wxsBitmapComboBox, mImageList, _("Image List"), _("mImageList"), pImageNames, _("<none>"))
 
204
 
 
205
// the list of items to appear in the combo box
 
206
 
 
207
    UpdateComboItemList();
 
208
 
 
209
    WXS_IMAGECOMBO(wxsBitmapComboBox, mItems, _("Combo Items"), _("mItems"));
 
210
    WXS_ARRAYSTRING(wxsBitmapComboBox, mItems, _("Items as Text"), _("mItemsText"), _("item2"));
 
211
}
 
212
 
 
213
//------------------------------------------------------------------------------
 
214
// find all tools that are image lists and return their names
 
215
 
 
216
void wxsBitmapComboBox::FindAllImageLists(wxArrayString &aNames) {
 
217
int             i,n;
 
218
wxsItemResData  *res;
 
219
wxsTool         *tool;
 
220
wxsImageList    *ilist;
 
221
wxString        ss, tt;
 
222
 
 
223
// start the list with a chance to de-select any old list
 
224
 
 
225
    aNames.Clear();
 
226
    aNames.Add(_("<none>"));
 
227
 
 
228
// find all tools that are "wxImageList"
 
229
 
 
230
    res = GetResourceData();
 
231
    n   = res->GetToolsCount();
 
232
    for(i=0; i<n; i++) {
 
233
        tool = res->GetTool(i);
 
234
        ss   = tool->GetUserClass();
 
235
 
 
236
        if ((ss == _("wxImageList")) && (n < 127)) {
 
237
            ss = tool->GetVarName();
 
238
            aNames.Add(ss);
 
239
        };
 
240
    };
 
241
}
 
242
 
 
243
//------------------------------------------------------------------------------
 
244
// update the list of combo items to send to the wsxImageComboEditDialog
 
245
 
 
246
void wxsBitmapComboBox::UpdateComboItemList(void) {
 
247
int             i,n;
 
248
wxString        ss, tt;
 
249
wxArrayString   aa;
 
250
 
 
251
// first 2 items are always our var name and the name of the image list
 
252
 
 
253
    aa.Clear();
 
254
    ss = GetVarName();
 
255
    aa.Add(ss);
 
256
    ss = mImageList;
 
257
    aa.Add(ss);
 
258
 
 
259
// then copy over everything else the user entered last time
 
260
 
 
261
    n = mItems.GetCount();
 
262
    for(i=2; i<n; i++) {
 
263
        ss = mItems.Item(i);
 
264
        aa.Add(ss);
 
265
    };
 
266
 
 
267
// then put back in original list
 
268
 
 
269
    mItems.Clear();
 
270
    n = aa.GetCount();
 
271
    for(i=0; i<n; i++) {
 
272
        ss = aa.Item(i);
 
273
        mItems.Add(ss);
 
274
    };
 
275
 
 
276
// make sure that FindTool has a valid wxsItem* to work from in the dialog
 
277
 
 
278
    wxsImageListEditorDlg::FindTool(this, mImageList);
 
279
}
 
280
 
 
281
//------------------------------------------------------------------------------
 
282
 
 
283
void wxsBitmapComboBox::ParseComboItem(wxString inSource, wxString &outItem, int &outIndex) {
 
284
int         i,n;
 
285
long        ll;
 
286
wxString    ss, tt;
 
287
 
 
288
// working copy
 
289
 
 
290
    ss = inSource;
 
291
 
 
292
// a "," separates the image index from the text of the item
 
293
 
 
294
    i = ss.Find(_(","));
 
295
 
 
296
// if a "," was found, parse the index from the text
 
297
// if no ",", then no index and the entire string is text
 
298
 
 
299
    if (i != wxNOT_FOUND) {
 
300
        tt = ss.Left(i);
 
301
        ss.erase(0, i+1);
 
302
        outItem = ss;
 
303
        outIndex = -1;
 
304
        if (tt.ToLong(&ll)) outIndex = ll;
 
305
    }
 
306
    else {
 
307
        outIndex = -1;
 
308
        outItem = ss;
 
309
    };
 
310
}
 
311
 
 
312
 
 
313
 
 
314
 
 
315
 
 
316
 
215
317