← Back to branch summary

~ubuntu-branches/ubuntu/hardy/codeblocks/hardy-backports

« back to all changes in this revision

Viewing changes to src/plugins/contrib/wxSmith/wxwidgets/wxsnewwindowdlg.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Casadevall
  • Date: 2008-07-17 04:39:23 UTC
  • Revision ID: james.westby@ubuntu.com-20080717043923-gmsy5cwkdjswghkm
Tags: upstream-8.02
Import upstream version 8.02

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/contrib/wxSmith/wxwidgets/wxsnewwindowdlg.cpp
 
1
/*
 
2
* This file is part of wxSmith plugin for Code::Blocks Studio
 
3
* Copyright (C) 2006-2007  Bartlomiej Swiecki
 
4
*
 
5
* wxSmith is free software; you can redistribute it and/or modify
 
6
* it under the terms of the GNU General Public License as published by
 
7
* the Free Software Foundation; either version 3 of the License, or
 
8
* (at your option) any later version.
 
9
*
 
10
* wxSmith is distributed in the hope that it will be useful,
 
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
13
* GNU General Public License for more details.
 
14
*
 
15
* You should have received a copy of the GNU General Public License
 
16
* along with wxSmith. If not, see <http://www.gnu.org/licenses/>.
 
17
*
 
18
* $Revision: 4850 $
 
19
* $Id: wxsnewwindowdlg.cpp 4850 2008-01-29 21:45:49Z byo $
 
20
* $HeadURL: svn://svn.berlios.de/codeblocks/tags/8.02/src/plugins/contrib/wxSmith/wxwidgets/wxsnewwindowdlg.cpp $
 
21
*/
 
22
 
 
23
#include "wxsnewwindowdlg.h"
 
24
#include "wxwidgetsres.h"
 
25
#include "wxsdialogres.h"
 
26
#include "wxsframeres.h"
 
27
#include "wxspanelres.h"
 
28
#include "wxwidgetsgui.h"
 
29
#include "wxsitemresdata.h"
 
30
#include "../wxsmith.h"
 
31
#include "../wxsproject.h"
 
32
 
 
33
#include <logmanager.h>
 
34
#include <projectmanager.h>
 
35
#include <cbproject.h>
 
36
#include <projectfile.h>
 
37
 
 
38
//(*InternalHeaders(wxsNewWindowDlg)
 
39
#include <wx/intl.h>
 
40
#include <wx/string.h>
 
41
//*)
 
42
 
 
43
namespace
 
44
{
 
45
    // Don't want to use wxFileName since it breaks slashes/backslashes stuff
 
46
 
 
47
    wxString GetPathPart(const wxString& FileName)
 
48
    {
 
49
        for ( size_t i=FileName.Length(); i-->0; )
 
50
        {
 
51
            switch ( FileName[i] )
 
52
            {
 
53
                case _T('/'):
 
54
                case _T('\\'):
 
55
                    return FileName.Mid(0,i+1);
 
56
            }
 
57
        }
 
58
 
 
59
        return wxEmptyString;
 
60
    }
 
61
 
 
62
    wxString GetNoExt(const wxString& FileName)
 
63
    {
 
64
        for ( size_t i=FileName.Length(); i-->0; )
 
65
        {
 
66
            switch ( FileName[i] )
 
67
            {
 
68
                case _T('/'):
 
69
                case _T('\\'):
 
70
                    return FileName;
 
71
 
 
72
                case _T('.'):
 
73
                    return FileName.Mid(0,i);
 
74
            }
 
75
        }
 
76
        return FileName;
 
77
    }
 
78
}
 
79
 
 
80
//(*IdInit(wxsNewWindowDlg)
 
81
const long wxsNewWindowDlg::ID_STATICTEXT1 = wxNewId();
 
82
const long wxsNewWindowDlg::ID_TEXTCTRL1 = wxNewId();
 
83
const long wxsNewWindowDlg::ID_STATICTEXT2 = wxNewId();
 
84
const long wxsNewWindowDlg::ID_TEXTCTRL2 = wxNewId();
 
85
const long wxsNewWindowDlg::ID_STATICTEXT3 = wxNewId();
 
86
const long wxsNewWindowDlg::ID_TEXTCTRL3 = wxNewId();
 
87
const long wxsNewWindowDlg::ID_CHECKBOX1 = wxNewId();
 
88
const long wxsNewWindowDlg::ID_TEXTCTRL4 = wxNewId();
 
89
const long wxsNewWindowDlg::ID_CHECKBOX3 = wxNewId();
 
90
const long wxsNewWindowDlg::ID_BUTTON1 = wxNewId();
 
91
const long wxsNewWindowDlg::ID_CHECKBOX2 = wxNewId();
 
92
const long wxsNewWindowDlg::ID_COMBOBOX1 = wxNewId();
 
93
const long wxsNewWindowDlg::ID_STATICTEXT11 = wxNewId();
 
94
const long wxsNewWindowDlg::ID_TEXTCTRL8 = wxNewId();
 
95
const long wxsNewWindowDlg::ID_CHECKBOX4 = wxNewId();
 
96
const long wxsNewWindowDlg::ID_TEXTCTRL5 = wxNewId();
 
97
const long wxsNewWindowDlg::ID_STATICTEXT4 = wxNewId();
 
98
const long wxsNewWindowDlg::ID_TEXTCTRL6 = wxNewId();
 
99
const long wxsNewWindowDlg::ID_STATICTEXT7 = wxNewId();
 
100
const long wxsNewWindowDlg::ID_STATICTEXT8 = wxNewId();
 
101
const long wxsNewWindowDlg::ID_STATICTEXT9 = wxNewId();
 
102
const long wxsNewWindowDlg::ID_STATICTEXT10 = wxNewId();
 
103
const long wxsNewWindowDlg::ID_BUTTON2 = wxNewId();
 
104
const long wxsNewWindowDlg::ID_BUTTON3 = wxNewId();
 
105
const long wxsNewWindowDlg::ID_BUTTON4 = wxNewId();
 
106
const long wxsNewWindowDlg::ID_STATICTEXT5 = wxNewId();
 
107
const long wxsNewWindowDlg::ID_CHECKBOX5 = wxNewId();
 
108
const long wxsNewWindowDlg::ID_CHECKBOX9 = wxNewId();
 
109
const long wxsNewWindowDlg::ID_CHECKBOX6 = wxNewId();
 
110
const long wxsNewWindowDlg::ID_CHECKBOX10 = wxNewId();
 
111
const long wxsNewWindowDlg::ID_CHECKBOX7 = wxNewId();
 
112
const long wxsNewWindowDlg::ID_CHECKBOX11 = wxNewId();
 
113
const long wxsNewWindowDlg::ID_CHECKBOX8 = wxNewId();
 
114
const long wxsNewWindowDlg::ID_CHECKBOX12 = wxNewId();
 
115
const long wxsNewWindowDlg::ID_STATICTEXT6 = wxNewId();
 
116
const long wxsNewWindowDlg::ID_TEXTCTRL7 = wxNewId();
 
117
const long wxsNewWindowDlg::ID_CHECKBOX14 = wxNewId();
 
118
const long wxsNewWindowDlg::ID_CHECKBOX13 = wxNewId();
 
119
//*)
 
120
 
 
121
BEGIN_EVENT_TABLE(wxsNewWindowDlg,wxDialog)
 
122
    //(*EventTable(wxsNewWindowDlg)
 
123
    //*)
 
124
    EVT_BUTTON(wxID_OK,wxsNewWindowDlg::OnCreate)
 
125
    EVT_BUTTON(wxID_CANCEL,wxsNewWindowDlg::OnCancel)
 
126
END_EVENT_TABLE()
 
127
 
 
128
wxsNewWindowDlg::wxsNewWindowDlg(wxWindow* parent,const wxString& ResType,wxsProject* Project):
 
129
    m_SourceNotTouched(true),
 
130
    m_HeaderNotTouched(true),
 
131
    m_XrcNotTouched(true),
 
132
    m_BlockText(false),
 
133
    m_AdvOpsShown(true),
 
134
    m_Type(ResType),
 
135
    m_Project(Project)
 
136
{
 
137
    //(*Initialize(wxsNewWindowDlg)
 
138
    wxStaticText* StaticText2;
 
139
    wxStaticText* StaticText1;
 
140
    wxStaticText* StaticText3;
 
141
 
 
142
    Create(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE, _T("wxID_ANY"));
 
143
    m_RootSizer = new wxBoxSizer(wxVERTICAL);
 
144
    StaticBoxSizer3 = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Options"));
 
145
    FlexGridSizer1 = new wxFlexGridSizer(0, 2, 5, 5);
 
146
    FlexGridSizer1->AddGrowableCol(1);
 
147
    StaticText1 = new wxStaticText(this, ID_STATICTEXT1, _("Class Name:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT1"));
 
148
    FlexGridSizer1->Add(StaticText1, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
149
    m_Class = new wxTextCtrl(this, ID_TEXTCTRL1, wxEmptyString, wxDefaultPosition, wxSize(80,-1), 0, wxDefaultValidator, _T("ID_TEXTCTRL1"));
 
150
    FlexGridSizer1->Add(m_Class, 0, wxEXPAND|wxALIGN_LEFT|wxALIGN_TOP, 5);
 
151
    StaticText2 = new wxStaticText(this, ID_STATICTEXT2, _("Header file:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT2"));
 
152
    FlexGridSizer1->Add(StaticText2, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
153
    m_Header = new wxTextCtrl(this, ID_TEXTCTRL2, wxEmptyString, wxDefaultPosition, wxSize(80,-1), 0, wxDefaultValidator, _T("ID_TEXTCTRL2"));
 
154
    FlexGridSizer1->Add(m_Header, 0, wxEXPAND|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
155
    StaticText3 = new wxStaticText(this, ID_STATICTEXT3, _("Source file:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT3"));
 
156
    FlexGridSizer1->Add(StaticText3, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
157
    m_Source = new wxTextCtrl(this, ID_TEXTCTRL3, wxEmptyString, wxDefaultPosition, wxSize(80,-1), 0, wxDefaultValidator, _T("ID_TEXTCTRL3"));
 
158
    FlexGridSizer1->Add(m_Source, 0, wxEXPAND|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
159
    m_UseXrc = new wxCheckBox(this, ID_CHECKBOX1, _("Xrc File:"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX1"));
 
160
    m_UseXrc->SetValue(false);
 
161
    FlexGridSizer1->Add(m_UseXrc, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
162
    m_Xrc = new wxTextCtrl(this, ID_TEXTCTRL4, wxEmptyString, wxDefaultPosition, wxSize(80,-1), 0, wxDefaultValidator, _T("ID_TEXTCTRL4"));
 
163
    FlexGridSizer1->Add(m_Xrc, 0, wxEXPAND|wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
164
    FlexGridSizer1->Add(10,6,1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
165
    m_XRCAutoload = new wxCheckBox(this, ID_CHECKBOX3, _("Add XRC file to autoload list"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX3"));
 
166
    m_XRCAutoload->SetValue(false);
 
167
    m_XRCAutoload->Disable();
 
168
    FlexGridSizer1->Add(m_XRCAutoload, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
169
    StaticBoxSizer3->Add(FlexGridSizer1, 1, wxALL|wxEXPAND|wxALIGN_LEFT|wxALIGN_TOP, 0);
 
170
    m_RootSizer->Add(StaticBoxSizer3, 0, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
 
171
    m_AdvOps = new wxButton(this, ID_BUTTON1, _("+ Advanced options"), wxDefaultPosition, wxDefaultSize, wxBU_LEFT|wxNO_BORDER, wxDefaultValidator, _T("ID_BUTTON1"));
 
172
    m_RootSizer->Add(m_AdvOps, 0, wxLEFT|wxRIGHT|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
 
173
    m_AdvancedOptionsSizer = new wxStaticBoxSizer(wxVERTICAL, this, wxEmptyString);
 
174
    FlexGridSizer2 = new wxFlexGridSizer(0, 2, 5, 5);
 
175
    FlexGridSizer2->AddGrowableCol(1);
 
176
    m_UsePCH = new wxCheckBox(this, ID_CHECKBOX2, _("Use PCH:"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX2"));
 
177
    m_UsePCH->SetValue(false);
 
178
    FlexGridSizer2->Add(m_UsePCH, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
179
    m_Pch = new wxComboBox(this, ID_COMBOBOX1, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, 0, 0, wxDefaultValidator, _T("ID_COMBOBOX1"));
 
180
    FlexGridSizer2->Add(m_Pch, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
181
    BoxSizer1 = new wxBoxSizer(wxHORIZONTAL);
 
182
    BoxSizer1->Add(21,16,0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
 
183
    StaticText11 = new wxStaticText(this, ID_STATICTEXT11, _("PCH guard define:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT11"));
 
184
    BoxSizer1->Add(StaticText11, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 0);
 
185
    FlexGridSizer2->Add(BoxSizer1, 0, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
 
186
    m_PchGuard = new wxTextCtrl(this, ID_TEXTCTRL8, _("WX_PRECOMP"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL8"));
 
187
    FlexGridSizer2->Add(m_PchGuard, 0, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
 
188
    m_UseInitFunc = new wxCheckBox(this, ID_CHECKBOX4, _("Init code in function:"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX4"));
 
189
    m_UseInitFunc->SetValue(false);
 
190
    FlexGridSizer2->Add(m_UseInitFunc, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
191
    m_InitFunc = new wxTextCtrl(this, ID_TEXTCTRL5, _("BuildContent"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL5"));
 
192
    m_InitFunc->Disable();
 
193
    FlexGridSizer2->Add(m_InitFunc, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
194
    StaticText4 = new wxStaticText(this, ID_STATICTEXT4, _("Base class name:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT4"));
 
195
    FlexGridSizer2->Add(StaticText4, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
196
    m_BaseClass = new wxTextCtrl(this, ID_TEXTCTRL6, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL6"));
 
197
    FlexGridSizer2->Add(m_BaseClass, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
198
    StaticText7 = new wxStaticText(this, ID_STATICTEXT7, _("Scopes:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT7"));
 
199
    FlexGridSizer2->Add(StaticText7, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 0);
 
200
    FlexGridSizer4 = new wxFlexGridSizer(0, 3, 0, 5);
 
201
    FlexGridSizer4->AddGrowableCol(0);
 
202
    FlexGridSizer4->AddGrowableCol(1);
 
203
    FlexGridSizer4->AddGrowableCol(2);
 
204
    StaticText8 = new wxStaticText(this, ID_STATICTEXT8, _("IDs:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT8"));
 
205
    FlexGridSizer4->Add(StaticText8, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
206
    StaticText9 = new wxStaticText(this, ID_STATICTEXT9, _("Members:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT9"));
 
207
    FlexGridSizer4->Add(StaticText9, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
208
    StaticText10 = new wxStaticText(this, ID_STATICTEXT10, _("Handlers:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT10"));
 
209
    FlexGridSizer4->Add(StaticText10, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
210
    m_ScopeIds = new wxButton(this, ID_BUTTON2, _("Public"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON2"));
 
211
    FlexGridSizer4->Add(m_ScopeIds, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
212
    m_ScopeMembers = new wxButton(this, ID_BUTTON3, _("Public"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON3"));
 
213
    FlexGridSizer4->Add(m_ScopeMembers, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
214
    m_ScopeHandlers = new wxButton(this, ID_BUTTON4, _("Public"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON4"));
 
215
    FlexGridSizer4->Add(m_ScopeHandlers, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
216
    FlexGridSizer2->Add(FlexGridSizer4, 0, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0);
 
217
    StaticText5 = new wxStaticText(this, ID_STATICTEXT5, _("Constructor arguments:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT5"));
 
218
    FlexGridSizer2->Add(StaticText5, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
219
    FlexGridSizer3 = new wxFlexGridSizer(0, 2, 0, 10);
 
220
    FlexGridSizer3->AddGrowableCol(0);
 
221
    m_CtorParent = new wxCheckBox(this, ID_CHECKBOX5, _("Parent"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX5"));
 
222
    m_CtorParent->SetValue(true);
 
223
    FlexGridSizer3->Add(m_CtorParent, 0, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
224
    m_CtorParentDef = new wxCheckBox(this, ID_CHECKBOX9, _("Def. value"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX9"));
 
225
    m_CtorParentDef->SetValue(false);
 
226
    FlexGridSizer3->Add(m_CtorParentDef, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
227
    m_CtorId = new wxCheckBox(this, ID_CHECKBOX6, _("Id"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX6"));
 
228
    m_CtorId->SetValue(true);
 
229
    FlexGridSizer3->Add(m_CtorId, 0, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
230
    m_CtorIdDef = new wxCheckBox(this, ID_CHECKBOX10, _("Def. value"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX10"));
 
231
    m_CtorIdDef->SetValue(true);
 
232
    FlexGridSizer3->Add(m_CtorIdDef, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
233
    m_CtorPos = new wxCheckBox(this, ID_CHECKBOX7, _("Position"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX7"));
 
234
    m_CtorPos->SetValue(false);
 
235
    FlexGridSizer3->Add(m_CtorPos, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
236
    m_CtorPosDef = new wxCheckBox(this, ID_CHECKBOX11, _("Def. value"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX11"));
 
237
    m_CtorPosDef->SetValue(true);
 
238
    m_CtorPosDef->Disable();
 
239
    FlexGridSizer3->Add(m_CtorPosDef, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
240
    m_CtorSize = new wxCheckBox(this, ID_CHECKBOX8, _("Size"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX8"));
 
241
    m_CtorSize->SetValue(false);
 
242
    FlexGridSizer3->Add(m_CtorSize, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
243
    m_CtorSizeDef = new wxCheckBox(this, ID_CHECKBOX12, _("Def. value"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX12"));
 
244
    m_CtorSizeDef->SetValue(true);
 
245
    m_CtorSizeDef->Disable();
 
246
    FlexGridSizer3->Add(m_CtorSizeDef, 1, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
247
    FlexGridSizer2->Add(FlexGridSizer3, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
248
    StaticText6 = new wxStaticText(this, ID_STATICTEXT6, _("Custom arguments:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT6"));
 
249
    FlexGridSizer2->Add(StaticText6, 1, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
 
250
    m_CtorCustom = new wxTextCtrl(this, ID_TEXTCTRL7, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_TEXTCTRL7"));
 
251
    FlexGridSizer2->Add(m_CtorCustom, 1, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
252
    m_AdvancedOptionsSizer->Add(FlexGridSizer2, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
253
    m_UseFwdDecl = new wxCheckBox(this, ID_CHECKBOX14, _("Use forward declarations"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX14"));
 
254
    m_UseFwdDecl->SetValue(false);
 
255
    m_AdvancedOptionsSizer->Add(m_UseFwdDecl, 0, wxLEFT|wxRIGHT|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
256
    m_AddWxs = new wxCheckBox(this, ID_CHECKBOX13, _("Add wxs file to project"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX13"));
 
257
    m_AddWxs->SetValue(false);
 
258
    m_AdvancedOptionsSizer->Add(m_AddWxs, 0, wxBOTTOM|wxLEFT|wxRIGHT|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
259
    m_RootSizer->Add(m_AdvancedOptionsSizer, 0, wxLEFT|wxRIGHT|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
260
    m_RootSizer->Add(300,5,0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
261
    StdDialogButtonSizer1 = new wxStdDialogButtonSizer();
 
262
    StdDialogButtonSizer1->AddButton(new wxButton(this, wxID_OK, wxEmptyString));
 
263
    StdDialogButtonSizer1->AddButton(new wxButton(this, wxID_CANCEL, wxEmptyString));
 
264
    StdDialogButtonSizer1->Realize();
 
265
    m_RootSizer->Add(StdDialogButtonSizer1, 0, wxBOTTOM|wxLEFT|wxRIGHT|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
 
266
    SetSizer(m_RootSizer);
 
267
    m_RootSizer->Fit(this);
 
268
    m_RootSizer->SetSizeHints(this);
 
269
 
 
270
    Connect(ID_TEXTCTRL1,wxEVT_COMMAND_TEXT_UPDATED,(wxObjectEventFunction)&wxsNewWindowDlg::OnClassChanged);
 
271
    Connect(ID_TEXTCTRL2,wxEVT_COMMAND_TEXT_UPDATED,(wxObjectEventFunction)&wxsNewWindowDlg::OnHeaderChanged);
 
272
    Connect(ID_TEXTCTRL3,wxEVT_COMMAND_TEXT_UPDATED,(wxObjectEventFunction)&wxsNewWindowDlg::OnSourceChanged);
 
273
    Connect(ID_CHECKBOX1,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnUseXrcChange);
 
274
    Connect(ID_TEXTCTRL4,wxEVT_COMMAND_TEXT_UPDATED,(wxObjectEventFunction)&wxsNewWindowDlg::OnXrcChanged);
 
275
    Connect(ID_BUTTON1,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnAdvOpsClick);
 
276
    Connect(ID_CHECKBOX2,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnUsePCHClick);
 
277
    Connect(ID_CHECKBOX4,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnUseInitFuncClick);
 
278
    Connect(ID_BUTTON2,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnScopeIdsClick);
 
279
    Connect(ID_BUTTON3,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnScopeMembersClick);
 
280
    Connect(ID_BUTTON4,wxEVT_COMMAND_BUTTON_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnScopeHandlersClick);
 
281
    Connect(ID_CHECKBOX5,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorParentClick);
 
282
    Connect(ID_CHECKBOX9,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorParentDefClick);
 
283
    Connect(ID_CHECKBOX6,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorIdClick);
 
284
    Connect(ID_CHECKBOX10,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorIdDefClick);
 
285
    Connect(ID_CHECKBOX7,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorPosClick);
 
286
    Connect(ID_CHECKBOX11,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorPosDefClick);
 
287
    Connect(ID_CHECKBOX8,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorSizeClick);
 
288
    Connect(ID_CHECKBOX12,wxEVT_COMMAND_CHECKBOX_CLICKED,(wxObjectEventFunction)&wxsNewWindowDlg::OnCtorSizeDefClick);
 
289
    //*)
 
290
 
 
291
    ConfigManager* Cfg = Manager::Get()->GetConfigManager(_T("wxsmith"));
 
292
 
 
293
    m_BlockText = true;
 
294
    m_SourceDirectory = Cfg->Read(_T("/newresource/sourcedirectory"),_T(""));
 
295
 
 
296
    wxString StrippedName = ResType.Mid(2);
 
297
    wxString ResName = wxString::Format(_("New%s"),StrippedName.c_str());
 
298
    m_Class->SetValue(ResName);
 
299
    m_Source->SetValue(m_SourceDirectory + ResName+_T(".cpp"));
 
300
    m_Header->SetValue(m_SourceDirectory + ResName+_T(".h"));
 
301
    m_Xrc   ->SetValue(m_SourceDirectory + ResName+_T(".xrc"));
 
302
    m_Xrc->Disable();
 
303
    SetTitle(wxString::Format(_("New %s resource"),ResType.c_str()));
 
304
    DetectPchFile();
 
305
    m_BaseClass->SetValue(ResType);
 
306
    wxCommandEvent event;
 
307
    OnAdvOpsClick(event);
 
308
    Center();
 
309
    m_AppManaged =
 
310
        m_Project->GetGUI() &&
 
311
        m_Project->GetGUI()->GetName()==_T("wxWidgets") &&
 
312
        m_Project->GetGUI()->CheckIfApplicationManaged();
 
313
    m_XRCAutoload->SetValue(m_AppManaged);
 
314
 
 
315
    m_UseInitFunc->SetValue(Cfg->ReadBool(_T("/newresource/useinitfunc"),m_UseInitFunc->GetValue()));
 
316
    m_InitFunc->Enable(m_UseInitFunc->GetValue());
 
317
    m_InitFunc->SetValue(Cfg->Read(_T("/newresource/initfunc"),m_InitFunc->GetValue()));
 
318
    m_CtorParent->SetValue(Cfg->ReadBool(_T("/newresource/ctorparent"),m_CtorParent->GetValue()));
 
319
    m_CtorParentDef->Enable(m_CtorParent->GetValue());
 
320
    m_CtorParentDef->SetValue(Cfg->ReadBool(_T("/newresource/ctorparentdef"),m_CtorParentDef->GetValue()));
 
321
    m_CtorId->SetValue(Cfg->ReadBool(_T("/newresource/ctorid"),m_CtorId->GetValue()));
 
322
    m_CtorIdDef->Enable(m_CtorId->GetValue());
 
323
    m_CtorIdDef->SetValue(Cfg->ReadBool(_T("/newresource/ctorid"),m_CtorIdDef->GetValue()));
 
324
    m_CtorPos->SetValue(Cfg->ReadBool(_T("/newresource/ctorpos"),m_CtorPos->GetValue()));
 
325
    m_CtorPosDef->Enable(m_CtorPos->GetValue());
 
326
    m_CtorPosDef->SetValue(Cfg->ReadBool(_T("/newresource/ctorpos"),m_CtorPosDef->GetValue()));
 
327
    m_CtorSize->SetValue(Cfg->ReadBool(_T("/newresource/ctorsize"),m_CtorSize->GetValue()));
 
328
    m_CtorSizeDef->Enable(m_CtorSize->GetValue());
 
329
    m_CtorSizeDef->SetValue(Cfg->ReadBool(_T("/newresource/ctorsize"),m_CtorSizeDef->GetValue()));
 
330
    m_UseXrc->SetValue(Cfg->ReadBool(_T("/newresource/usexrc"),m_UseXrc->GetValue()));
 
331
    m_Xrc->Enable(m_UseXrc->GetValue());
 
332
    m_XRCAutoload->SetValue(Cfg->ReadBool(_T("/newresource/xrcautoloag"),m_XRCAutoload->GetValue()));
 
333
    m_AddWxs->SetValue(Cfg->ReadBool(_T("/newresource/addwxs"),m_AddWxs->GetValue()));
 
334
    m_ScopeIdsVal = (wxsItemRes::NewResourceParams::Scope)Cfg->ReadInt(_T("/newresource/scopeids"),(int)wxsItemRes::NewResourceParams::Protected);
 
335
    m_ScopeMembersVal = (wxsItemRes::NewResourceParams::Scope)Cfg->ReadInt(_T("/newresource/scopemembers"),(int)wxsItemRes::NewResourceParams::Public);
 
336
    m_ScopeHandlersVal = (wxsItemRes::NewResourceParams::Scope)Cfg->ReadInt(_T("/newresource/scopehandlers"),(int)wxsItemRes::NewResourceParams::Private);
 
337
    m_UseFwdDecl->SetValue(Cfg->ReadBool(_T("/newresource/usefwddecl"),m_UseFwdDecl->GetValue()));
 
338
    m_PchGuard->SetValue(Cfg->Read(_T("/newresource/pchguard"),m_PchGuard->GetValue()));
 
339
    UpdateScopeButtons();
 
340
    OnUseXrcChange(event);
 
341
 
 
342
    m_BlockText = false;
 
343
 
 
344
}
 
345
 
 
346
wxsNewWindowDlg::~wxsNewWindowDlg()
 
347
{
 
348
    //(*Destroy(wxsNewWindowDlg)
 
349
    //*)
 
350
}
 
351
 
 
352
void wxsNewWindowDlg::OnCancel(wxCommandEvent& event)
 
353
{
 
354
    EndModal(wxID_CANCEL);
 
355
}
 
356
 
 
357
void wxsNewWindowDlg::OnCreate(wxCommandEvent& event)
 
358
{
 
359
        bool CreateXrc = m_UseXrc->GetValue();
 
360
    cbProject* cbProj = m_Project->GetCBProject();
 
361
 
 
362
    wxsItemRes::NewResourceParams Params;
 
363
    Params.Class          = m_Class->GetValue();
 
364
    Params.Src            = m_Source->GetValue();
 
365
    Params.Hdr            = m_Header->GetValue();
 
366
    Params.Xrc            = CreateXrc ? m_Xrc->GetValue() : _T("");
 
367
    Params.Pch            = m_Pch->GetValue();
 
368
    Params.Wxs            = _T("");
 
369
    Params.InitFunc       = m_InitFunc->GetValue();
 
370
    Params.BaseClass      = m_BaseClass->GetValue();
 
371
    Params.CustomCtorArgs = m_CtorCustom->GetValue();
 
372
    Params.UsePch         = m_UsePCH->GetValue();
 
373
    Params.UseInitFunc    = m_UseInitFunc->GetValue();
 
374
    Params.CtorParent     = m_CtorParent->GetValue();
 
375
    Params.CtorParentDef  = m_CtorParentDef->GetValue();
 
376
    Params.CtorId         = m_CtorId->GetValue();
 
377
    Params.CtorIdDef      = m_CtorIdDef->GetValue();
 
378
    Params.CtorPos        = m_CtorPos->GetValue();
 
379
    Params.CtorPosDef     = m_CtorPosDef->GetValue();
 
380
    Params.CtorSize       = m_CtorSize->GetValue();
 
381
    Params.CtorSizeDef    = m_CtorSizeDef->GetValue();
 
382
    Params.ScopeIds       = m_ScopeIdsVal;
 
383
    Params.ScopeMembers   = m_ScopeMembersVal;
 
384
    Params.ScopeHandlers  = m_ScopeHandlersVal;
 
385
    Params.UseFwdDecl     = m_UseFwdDecl->GetValue();
 
386
    Params.PchGuard       = m_PchGuard->GetValue();
 
387
 
 
388
    // Need to do some checks
 
389
    // Validating name
 
390
    // TODO: Do not use fixed language
 
391
    if ( !wxsCodeMarks::ValidateIdentifier(wxsCPP,Params.Class) )
 
392
    {
 
393
        wxMessageBox(_("Invalid class name"));
 
394
        return;
 
395
    }
 
396
 
 
397
    // Validating base class
 
398
    if ( !wxsCodeMarks::ValidateIdentifier(wxsCPP,Params.BaseClass) )
 
399
    {
 
400
        wxMessageBox(_("Invalid name of base class"));
 
401
        return;
 
402
    }
 
403
 
 
404
    // Validating init function name
 
405
    if ( Params.UseInitFunc && !wxsCodeMarks::ValidateIdentifier(wxsCPP,Params.InitFunc) )
 
406
    {
 
407
        wxMessageBox(_("Invalid name of init function"));
 
408
        return;
 
409
    }
 
410
 
 
411
    // Checking if there's given resoure in current project
 
412
    if ( m_Project->FindResource(Params.Class) )
 
413
    {
 
414
        wxMessageBox(wxString::Format(_("Resource '%s' already exists"),Params.Class.c_str()));
 
415
        return;
 
416
    }
 
417
 
 
418
    // Validating PCH guard if needed
 
419
    if ( Params.UsePch && (Params.PchGuard.IsEmpty() || !wxsCodeMarks::ValidateIdentifier(wxsCPP,Params.PchGuard)) )
 
420
    {
 
421
        wxMessageBox(_("Invalid name of pch guard"));
 
422
        return;
 
423
    }
 
424
 
 
425
    // Checking if files already exist
 
426
    wxString ProjectPrefix = m_Project->GetProjectPath();
 
427
    Params.GenHdr = true;
 
428
    if ( wxFileName::FileExists(ProjectPrefix+Params.Hdr) )
 
429
    {
 
430
        switch ( wxMessageBox(wxString::Format(
 
431
            _("File '%s' already exists. Overwrite it ?"),Params.Hdr.c_str()),
 
432
            _("File exists"),
 
433
            wxYES_NO|wxCANCEL|wxICON_ERROR) )
 
434
        {
 
435
            case wxCANCEL: return;
 
436
            case wxNO: Params.GenHdr = false; break;
 
437
        }
 
438
    }
 
439
 
 
440
    Params.GenSrc = true;
 
441
    if ( wxFileName::FileExists(ProjectPrefix+Params.Src) )
 
442
    {
 
443
        switch ( wxMessageBox(wxString::Format(
 
444
            _("File '%s' already exists. Overwrite it ?"),Params.Src.c_str()),
 
445
            _("File exists"),wxYES_NO|wxCANCEL|wxICON_ERROR) )
 
446
        {
 
447
            case wxCANCEL: return;
 
448
            case wxNO: Params.GenSrc = false; break;
 
449
        }
 
450
    }
 
451
 
 
452
    Params.GenXrc = CreateXrc;
 
453
    if ( wxFileName::FileExists(ProjectPrefix+Params.Xrc) )
 
454
    {
 
455
        // We will add new resource to existing one creating multi-resource xrc
 
456
        Params.GenXrc = false;
 
457
    }
 
458
 
 
459
    // Disable button to prevent more clicks while resource is created
 
460
    wxWindow* OkBtn = FindWindowById(wxID_OK);
 
461
    if ( OkBtn )
 
462
    {
 
463
        OkBtn->Disable();
 
464
    }
 
465
 
 
466
    // Creating new resource
 
467
    wxsItemRes* NewResource = 0;
 
468
 
 
469
    if ( m_Type == _T("wxDialog") )
 
470
    {
 
471
        NewResource = new wxsDialogRes(m_Project);
 
472
    }
 
473
    else if ( m_Type == _T("wxFrame") )
 
474
    {
 
475
        NewResource = new wxsFrameRes(m_Project);
 
476
    }
 
477
    else if ( m_Type == _T("wxPanel") )
 
478
    {
 
479
        NewResource = new wxsPanelRes(m_Project);
 
480
    }
 
481
    else
 
482
    {
 
483
        Manager::Get()->GetLogManager()->DebugLog(_T("wxSmith: Internal error: unknown type when creating resource"));
 
484
        EndModal(wxID_CANCEL);
 
485
        return;
 
486
    }
 
487
 
 
488
    // Building new data
 
489
    if ( !NewResource->CreateNewResource(Params) )
 
490
    {
 
491
        delete NewResource;
 
492
        Manager::Get()->GetLogManager()->DebugLog(_T("wxSmith: Couldn't generate new resource"));
 
493
        EndModal(wxID_CANCEL);
 
494
        return;
 
495
    }
 
496
 
 
497
    wxsItemResData* Data = NewResource->BuildResData(0);
 
498
    Data->BeginChange();
 
499
 
 
500
    // Updating content of resource
 
501
    // This is done to allow XRC loader load proper data
 
502
    if ( !PrepareResource(NewResource,Data) )
 
503
    {
 
504
        wxMessageBox(_("Error while initializing resource"));
 
505
        Data->EndChange();
 
506
        delete Data;
 
507
        delete NewResource;
 
508
        EndModal(wxID_CANCEL);
 
509
        return;
 
510
    }
 
511
 
 
512
    if ( !m_Project->AddResource(NewResource) )
 
513
    {
 
514
        wxMessageBox(_("Error while adding new resource into project"));
 
515
        Data->EndChange();
 
516
        delete Data;
 
517
        delete NewResource;
 
518
        EndModal(wxID_CANCEL);
 
519
        return;
 
520
    }
 
521
 
 
522
    Data->EndChange();
 
523
    Data->Save();
 
524
    delete Data;
 
525
 
 
526
    // Register xrc file in autoload list if needed
 
527
    if ( m_AppManaged && CreateXrc && m_XRCAutoload->GetValue() && !Params.Xrc.IsEmpty() )
 
528
    {
 
529
        wxWidgetsGUI* GUI = wxDynamicCast(m_Project->GetGUI(),wxWidgetsGUI);
 
530
        if ( GUI )
 
531
        {
 
532
            wxArrayString& AutoList = GUI->GetLoadedResources();
 
533
            if ( AutoList.Index(Params.Xrc) == wxNOT_FOUND )
 
534
            {
 
535
                AutoList.Add(Params.Xrc);
 
536
                GUI->RebuildApplicationCode();
 
537
            }
 
538
        }
 
539
    }
 
540
 
 
541
    // Adding new files to project
 
542
    wxArrayInt Targets;
 
543
    Manager::Get()->GetProjectManager()->AddFileToProject(Params.Hdr,cbProj,Targets);
 
544
    if (Targets.GetCount() != 0)
 
545
    {
 
546
        Manager::Get()->GetProjectManager()->AddFileToProject(Params.Src,cbProj,Targets);
 
547
        if ( !Params.Wxs.IsEmpty() && m_AddWxs->GetValue() )
 
548
        {
 
549
            Manager::Get()->GetProjectManager()->AddFileToProject(Params.Wxs,cbProj,Targets);
 
550
        }
 
551
    }
 
552
    Manager::Get()->GetProjectManager()->RebuildTree();
 
553
 
 
554
    // Opening editor for this resource
 
555
    NewResource->EditOpen();
 
556
 
 
557
    // Saving configuration
 
558
 
 
559
    ConfigManager* Cfg = Manager::Get()->GetConfigManager(_T("wxsmith"));
 
560
    Cfg->Write(_T("/newresource/useinitfunc"),m_UseInitFunc->GetValue());
 
561
    Cfg->Write(_T("/newresource/initfunc"),m_InitFunc->GetValue());
 
562
    Cfg->Write(_T("/newresource/ctorparent"),m_CtorParent->GetValue());
 
563
    Cfg->Write(_T("/newresource/ctorparentdef"),m_CtorParentDef->GetValue());
 
564
    Cfg->Write(_T("/newresource/ctorid"),m_CtorId->GetValue());
 
565
    Cfg->Write(_T("/newresource/ctorid"),m_CtorIdDef->GetValue());
 
566
    Cfg->Write(_T("/newresource/ctorpos"),m_CtorPos->GetValue());
 
567
    Cfg->Write(_T("/newresource/ctorpos"),m_CtorPosDef->GetValue());
 
568
    Cfg->Write(_T("/newresource/ctorsize"),m_CtorSize->GetValue());
 
569
    Cfg->Write(_T("/newresource/ctorsize"),m_CtorSizeDef->GetValue());
 
570
    Cfg->Write(_T("/newresource/usexrc"),m_UseXrc->GetValue());
 
571
    Cfg->Write(_T("/newresource/xrcautoloag"),m_XRCAutoload->GetValue());
 
572
    Cfg->Write(_T("/newresource/addwxs"),m_AddWxs->GetValue());
 
573
    Cfg->Write(_T("/newresource/scopeids"),(int)m_ScopeIdsVal);
 
574
    Cfg->Write(_T("/newresource/scopemembers"),(int)m_ScopeMembersVal);
 
575
    Cfg->Write(_T("/newresource/scopehandlers"),(int)m_ScopeHandlersVal);
 
576
    Cfg->Write(_T("/newresource/sourcedirectory"),m_SourceDirectory);
 
577
    Cfg->Write(_T("/newresource/usefwddecl"),m_UseFwdDecl->GetValue());
 
578
    Cfg->Write(_T("/newresource/pchguard"),m_PchGuard->GetValue());
 
579
 
 
580
    EndModal(wxID_OK);
 
581
}
 
582
 
 
583
void wxsNewWindowDlg::OnClassChanged(wxCommandEvent& event)
 
584
{
 
585
    if ( m_BlockText ) return;
 
586
    m_BlockText = true;
 
587
    if ( m_HeaderNotTouched ) m_Header->SetValue(m_SourceDirectory + m_Class->GetValue() + _T(".h"));
 
588
    if ( m_SourceNotTouched ) m_Source->SetValue(m_SourceDirectory + m_Class->GetValue() + _T(".cpp"));
 
589
    if ( m_XrcNotTouched    ) m_Xrc->   SetValue(m_SourceDirectory + m_Class->GetValue() + _T(".xrc"));
 
590
    m_BlockText = false;
 
591
}
 
592
 
 
593
void wxsNewWindowDlg::OnSourceChanged(wxCommandEvent& event)
 
594
{
 
595
    if ( m_BlockText ) return;
 
596
    m_BlockText = true;
 
597
    m_SourceNotTouched = false;
 
598
    m_BlockText = false;
 
599
}
 
600
 
 
601
void wxsNewWindowDlg::OnHeaderChanged(wxCommandEvent& event)
 
602
{
 
603
    if ( m_BlockText ) return;
 
604
    m_BlockText = true;
 
605
    m_SourceDirectory = GetPathPart(m_Header->GetValue());
 
606
    wxString Base = GetNoExt(m_Header->GetValue());
 
607
    if ( m_SourceNotTouched )
 
608
    {
 
609
        m_Source->SetValue(Base+_T(".cpp"));
 
610
    }
 
611
    if ( m_XrcNotTouched )
 
612
    {
 
613
        m_Xrc->SetValue(Base+_T(".h"));
 
614
    }
 
615
    m_HeaderNotTouched = false;
 
616
    m_BlockText = false;
 
617
}
 
618
 
 
619
void wxsNewWindowDlg::OnUseXrcChange(wxCommandEvent& event)
 
620
{
 
621
    m_Xrc->Enable(m_UseXrc->GetValue());
 
622
    m_XRCAutoload->Enable(m_UseXrc->GetValue() && m_AppManaged);
 
623
 
 
624
    if ( m_UseXrc->GetValue() )
 
625
    {
 
626
        m_CtorParent->SetValue(true);
 
627
        m_CtorId->SetValue(false);
 
628
        m_CtorPos->SetValue(false);
 
629
        m_CtorSize->SetValue(false);
 
630
        m_CtorParent->Disable();
 
631
        m_CtorId->Disable();
 
632
        m_CtorPos->Disable();
 
633
        m_CtorSize->Disable();
 
634
        m_CtorParentDef->Enable();
 
635
        m_CtorIdDef->Disable();
 
636
        m_CtorPosDef->Disable();
 
637
        m_CtorSizeDef->Disable();
 
638
    }
 
639
    else
 
640
    {
 
641
        m_CtorParent->Enable();
 
642
        m_CtorId->Enable();
 
643
        m_CtorPos->Enable();
 
644
        m_CtorSize->Enable();
 
645
    }
 
646
}
 
647
 
 
648
void wxsNewWindowDlg::OnXrcChanged(wxCommandEvent& event)
 
649
{
 
650
    if ( m_BlockText ) return;
 
651
    m_BlockText = true;
 
652
    m_XrcNotTouched = false;
 
653
    m_BlockText = false;
 
654
}
 
655
 
 
656
wxString wxsNewWindowDlg::DetectPchFile()
 
657
{
 
658
    // Searching for files that are good candidates for pch files
 
659
    cbProject* Proj = m_Project->GetCBProject();
 
660
    for ( int i=0; i<Proj->GetFilesCount(); i++ )
 
661
    {
 
662
        ProjectFile* File = Proj->GetFile(i);
 
663
        if ( File && File->file.GetExt()==_T("h") && File->compile )
 
664
        {
 
665
            int Index = m_Pch->Append(File->relativeFilename);
 
666
            if ( File->file.GetFullName() == _T("wx_pch.h") )
 
667
            {
 
668
                // Since wx_pch.h is default pch file generated
 
669
                // by wizard, it's preffered as pch choice
 
670
                m_Pch->SetSelection(Index);
 
671
            }
 
672
        }
 
673
    }
 
674
 
 
675
    // Updating the rest of stuff
 
676
    if ( m_Pch->GetCount() == 0 )
 
677
    {
 
678
        m_UsePCH->SetValue(false);
 
679
        m_Pch->Disable();
 
680
    }
 
681
    else
 
682
    {
 
683
        m_UsePCH->SetValue(true);
 
684
        if ( m_Pch->GetSelection() == wxNOT_FOUND )
 
685
        {
 
686
            m_Pch->SetSelection(0);
 
687
        }
 
688
    }
 
689
 
 
690
    return m_Pch->GetStringSelection();
 
691
}
 
692
 
 
693
void wxsNewWindowDlg::OnUsePCHClick(wxCommandEvent& event)
 
694
{
 
695
    m_Pch->Enable(m_UsePCH->GetValue());
 
696
    m_PchGuard->Enable(m_UsePCH->GetValue());
 
697
}
 
698
 
 
699
void wxsNewWindowDlg::OnCtorParentClick(wxCommandEvent& event)
 
700
{
 
701
    m_CtorParentDef->Enable(m_CtorParent->GetValue());
 
702
}
 
703
 
 
704
void wxsNewWindowDlg::OnCtorIdClick(wxCommandEvent& event)
 
705
{
 
706
    m_CtorIdDef->Enable(m_CtorId->GetValue());
 
707
}
 
708
 
 
709
void wxsNewWindowDlg::OnCtorPosClick(wxCommandEvent& event)
 
710
{
 
711
    m_CtorPosDef->Enable(m_CtorPos->GetValue());
 
712
}
 
713
 
 
714
void wxsNewWindowDlg::OnCtorSizeClick(wxCommandEvent& event)
 
715
{
 
716
    m_CtorSizeDef->Enable(m_CtorSize->GetValue());
 
717
}
 
718
 
 
719
void wxsNewWindowDlg::OnCtorParentDefClick(wxCommandEvent& event)
 
720
{
 
721
    if ( m_CtorParentDef->GetValue() )
 
722
    {
 
723
        m_CtorIdDef->SetValue(true);
 
724
        m_CtorPosDef->SetValue(true);
 
725
        m_CtorSizeDef->SetValue(true);
 
726
    }
 
727
    else
 
728
    {
 
729
    }
 
730
}
 
731
 
 
732
void wxsNewWindowDlg::OnCtorIdDefClick(wxCommandEvent& event)
 
733
{
 
734
    if ( m_CtorIdDef->GetValue() )
 
735
    {
 
736
        m_CtorPosDef->SetValue(true);
 
737
        m_CtorSizeDef->SetValue(true);
 
738
    }
 
739
    else
 
740
    {
 
741
        m_CtorParentDef->SetValue(false);
 
742
    }
 
743
}
 
744
 
 
745
void wxsNewWindowDlg::OnCtorPosDefClick(wxCommandEvent& event)
 
746
{
 
747
    if ( m_CtorPosDef->GetValue() )
 
748
    {
 
749
        m_CtorSizeDef->SetValue(true);
 
750
    }
 
751
    else
 
752
    {
 
753
        m_CtorIdDef->SetValue(false);
 
754
        m_CtorParentDef->SetValue(false);
 
755
    }
 
756
}
 
757
 
 
758
void wxsNewWindowDlg::OnCtorSizeDefClick(wxCommandEvent& event)
 
759
{
 
760
    if ( m_CtorSizeDef->GetValue() )
 
761
    {
 
762
    }
 
763
    else
 
764
    {
 
765
        m_CtorIdDef->SetValue(false);
 
766
        m_CtorParentDef->SetValue(false);
 
767
        m_CtorPosDef->SetValue(false);
 
768
    }
 
769
}
 
770
 
 
771
void wxsNewWindowDlg::OnUseInitFuncClick(wxCommandEvent& event)
 
772
{
 
773
    m_InitFunc->Enable(m_UseInitFunc->GetValue());
 
774
}
 
775
 
 
776
void wxsNewWindowDlg::OnAdvOpsClick(wxCommandEvent& event)
 
777
{
 
778
    Freeze();
 
779
    m_AdvOpsShown = !m_AdvOpsShown;
 
780
    wxString BaseLabel = _("Advanced options");
 
781
    if ( m_AdvOpsShown )
 
782
    {
 
783
        m_RootSizer->Show(m_AdvancedOptionsSizer);
 
784
        m_AdvOps->SetLabel(_T("- ") + BaseLabel);
 
785
    }
 
786
    else
 
787
    {
 
788
        m_RootSizer->Hide(m_AdvancedOptionsSizer);
 
789
        m_AdvOps->SetLabel(_T("+ ") + BaseLabel);
 
790
    }
 
791
    SetMinSize(wxSize(10,10));
 
792
    SetSize(wxSize(10,10));
 
793
    Layout();
 
794
    m_RootSizer->Fit(this);
 
795
    m_RootSizer->SetSizeHints(this);
 
796
    Thaw();
 
797
}
 
798
 
 
799
bool wxsNewWindowDlg::PrepareResource(wxsItemRes* Res,wxsItemResData* Data)
 
800
{
 
801
    wxsBaseProperties* Props = Data->GetRootItem()->GetBaseProps();
 
802
 
 
803
    Props->m_ParentFromArg   = m_CtorParent->GetValue();
 
804
    Props->m_IdFromArg       = m_CtorId->GetValue();
 
805
    Props->m_PositionFromArg = m_CtorPos->GetValue();
 
806
    Props->m_SizeFromArg     = m_CtorSize->GetValue();
 
807
 
 
808
    return true;
 
809
}
 
810
 
 
811
void wxsNewWindowDlg::OnScopeIdsClick(wxCommandEvent& event)
 
812
{
 
813
    switch ( m_ScopeIdsVal )
 
814
    {
 
815
        case wxsItemRes::NewResourceParams::Public:    m_ScopeIdsVal = wxsItemRes::NewResourceParams::Protected; break;
 
816
        case wxsItemRes::NewResourceParams::Protected: m_ScopeIdsVal = wxsItemRes::NewResourceParams::Private; break;
 
817
        default:                                       m_ScopeIdsVal = wxsItemRes::NewResourceParams::Public; break;
 
818
    }
 
819
    UpdateScopeButtons();
 
820
}
 
821
 
 
822
void wxsNewWindowDlg::OnScopeMembersClick(wxCommandEvent& event)
 
823
{
 
824
    switch ( m_ScopeMembersVal )
 
825
    {
 
826
        case wxsItemRes::NewResourceParams::Public:    m_ScopeMembersVal = wxsItemRes::NewResourceParams::Protected; break;
 
827
        case wxsItemRes::NewResourceParams::Protected: m_ScopeMembersVal = wxsItemRes::NewResourceParams::Private; break;
 
828
        default:                                       m_ScopeMembersVal = wxsItemRes::NewResourceParams::Public; break;
 
829
    }
 
830
    UpdateScopeButtons();
 
831
}
 
832
 
 
833
void wxsNewWindowDlg::OnScopeHandlersClick(wxCommandEvent& event)
 
834
{
 
835
    switch ( m_ScopeHandlersVal )
 
836
    {
 
837
        case wxsItemRes::NewResourceParams::Public:    m_ScopeHandlersVal = wxsItemRes::NewResourceParams::Protected; break;
 
838
        case wxsItemRes::NewResourceParams::Protected: m_ScopeHandlersVal = wxsItemRes::NewResourceParams::Private; break;
 
839
        default:                                       m_ScopeHandlersVal = wxsItemRes::NewResourceParams::Public; break;
 
840
    }
 
841
    UpdateScopeButtons();
 
842
}
 
843
 
 
844
void wxsNewWindowDlg::UpdateScopeButtons()
 
845
{
 
846
    switch ( m_ScopeIdsVal )
 
847
    {
 
848
        case wxsItemRes::NewResourceParams::Public:    m_ScopeIds->SetLabel(_T("Public")); break;
 
849
        case wxsItemRes::NewResourceParams::Protected: m_ScopeIds->SetLabel(_T("Protected")); break;
 
850
        default:                                       m_ScopeIds->SetLabel(_T("Private")); break;
 
851
    }
 
852
    switch ( m_ScopeMembersVal )
 
853
    {
 
854
        case wxsItemRes::NewResourceParams::Public:    m_ScopeMembers->SetLabel(_T("Public")); break;
 
855
        case wxsItemRes::NewResourceParams::Protected: m_ScopeMembers->SetLabel(_T("Protected")); break;
 
856
        default:                                       m_ScopeMembers->SetLabel(_T("Private")); break;
 
857
    }
 
858
    switch ( m_ScopeHandlersVal )
 
859
    {
 
860
        case wxsItemRes::NewResourceParams::Public:    m_ScopeHandlers->SetLabel(_T("Public")); break;
 
861
        case wxsItemRes::NewResourceParams::Protected: m_ScopeHandlers->SetLabel(_T("Protected")); break;
 
862
        default:                                       m_ScopeHandlers->SetLabel(_T("Private")); break;
 
863
    }
 
864
}