← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/CGUIFileOpenDialog.cpp

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/Irrlicht/CGUIFileOpenDialog.cpp
 
1
// Copyright (C) 2002-2011 Nikolaus Gebhardt
 
2
// This file is part of the "Irrlicht Engine".
 
3
// For conditions of distribution and use, see copyright notice in irrlicht.h
 
4
 
 
5
#include "CGUIFileOpenDialog.h"
 
6
#ifdef _IRR_COMPILE_WITH_GUI_
 
7
 
 
8
#include <locale.h>
 
9
 
 
10
#include "IGUISkin.h"
 
11
#include "IGUIEnvironment.h"
 
12
#include "IVideoDriver.h"
 
13
#include "IGUIButton.h"
 
14
#include "IGUIStaticText.h"
 
15
#include "IGUIFont.h"
 
16
#include "IGUIFontBitmap.h"
 
17
#include "IFileList.h"
 
18
#include "os.h"
 
19
 
 
20
namespace irr
 
21
{
 
22
namespace gui
 
23
{
 
24
 
 
25
const s32 FOD_WIDTH = 350;
 
26
const s32 FOD_HEIGHT = 250;
 
27
 
 
28
 
 
29
//! constructor
 
30
CGUIFileOpenDialog::CGUIFileOpenDialog(const wchar_t* title,
 
31
                IGUIEnvironment* environment, IGUIElement* parent, s32 id)
 
32
: IGUIFileOpenDialog(environment, parent, id,
 
33
                core::rect<s32>((parent->getAbsolutePosition().getWidth()-FOD_WIDTH)/2,
 
34
                                        (parent->getAbsolutePosition().getHeight()-FOD_HEIGHT)/2,
 
35
                                        (parent->getAbsolutePosition().getWidth()-FOD_WIDTH)/2+FOD_WIDTH,
 
36
                                        (parent->getAbsolutePosition().getHeight()-FOD_HEIGHT)/2+FOD_HEIGHT)),
 
37
        FileNameText(0), FileList(0), Dragging(false)
 
38
{
 
39
        #ifdef _DEBUG
 
40
        IGUIElement::setDebugName("CGUIFileOpenDialog");
 
41
        #endif
 
42
 
 
43
        Text = title;
 
44
 
 
45
        IGUISkin* skin = Environment->getSkin();
 
46
        IGUISpriteBank* sprites = 0;
 
47
        video::SColor color(255,255,255,255);
 
48
        if (skin)
 
49
        {
 
50
                sprites = skin->getSpriteBank();
 
51
                color = skin->getColor(EGDC_WINDOW_SYMBOL);
 
52
        }
 
53
 
 
54
        const s32 buttonw = environment->getSkin()->getSize(EGDS_WINDOW_BUTTON_WIDTH);
 
55
        const s32 posx = RelativeRect.getWidth() - buttonw - 4;
 
56
 
 
57
        CloseButton = Environment->addButton(core::rect<s32>(posx, 3, posx + buttonw, 3 + buttonw), this, -1,
 
58
                L"", skin ? skin->getDefaultText(EGDT_WINDOW_CLOSE) : L"Close");
 
59
        CloseButton->setSubElement(true);
 
60
        CloseButton->setTabStop(false);
 
61
        if (sprites)
 
62
        {
 
63
                CloseButton->setSpriteBank(sprites);
 
64
                CloseButton->setSprite(EGBS_BUTTON_UP, skin->getIcon(EGDI_WINDOW_CLOSE), color);
 
65
                CloseButton->setSprite(EGBS_BUTTON_DOWN, skin->getIcon(EGDI_WINDOW_CLOSE), color);
 
66
        }
 
67
        CloseButton->setAlignment(EGUIA_LOWERRIGHT, EGUIA_LOWERRIGHT, EGUIA_UPPERLEFT, EGUIA_UPPERLEFT);
 
68
        CloseButton->grab();
 
69
 
 
70
        OKButton = Environment->addButton(
 
71
                core::rect<s32>(RelativeRect.getWidth()-80, 30, RelativeRect.getWidth()-10, 50),
 
72
                this, -1, skin ? skin->getDefaultText(EGDT_MSG_BOX_OK) : L"OK");
 
73
        OKButton->setSubElement(true);
 
74
        OKButton->setAlignment(EGUIA_LOWERRIGHT, EGUIA_LOWERRIGHT, EGUIA_UPPERLEFT, EGUIA_UPPERLEFT);
 
75
        OKButton->grab();
 
76
 
 
77
        CancelButton = Environment->addButton(
 
78
                core::rect<s32>(RelativeRect.getWidth()-80, 55, RelativeRect.getWidth()-10, 75),
 
79
                this, -1, skin ? skin->getDefaultText(EGDT_MSG_BOX_CANCEL) : L"Cancel");
 
80
        CancelButton->setSubElement(true);
 
81
        CancelButton->setAlignment(EGUIA_LOWERRIGHT, EGUIA_LOWERRIGHT, EGUIA_UPPERLEFT, EGUIA_UPPERLEFT);
 
82
        CancelButton->grab();
 
83
 
 
84
        FileBox = Environment->addListBox(core::rect<s32>(10, 55, RelativeRect.getWidth()-90, 230), this, -1, true);
 
85
        FileBox->setSubElement(true);
 
86
        FileBox->setAlignment(EGUIA_UPPERLEFT, EGUIA_LOWERRIGHT, EGUIA_UPPERLEFT, EGUIA_LOWERRIGHT);
 
87
        FileBox->grab();
 
88
 
 
89
        FileNameText = Environment->addEditBox(0, core::rect<s32>(10, 30, RelativeRect.getWidth()-90, 50), true, this);
 
90
        FileNameText->setSubElement(true);
 
91
        FileNameText->setAlignment(EGUIA_UPPERLEFT, EGUIA_LOWERRIGHT, EGUIA_UPPERLEFT, EGUIA_UPPERLEFT);
 
92
        FileNameText->grab();
 
93
 
 
94
        FileSystem = Environment->getFileSystem();
 
95
 
 
96
        if (FileSystem)
 
97
                FileSystem->grab();
 
98
 
 
99
        setTabGroup(true);
 
100
 
 
101
        fillListBox();
 
102
}
 
103
 
 
104
 
 
105
//! destructor
 
106
CGUIFileOpenDialog::~CGUIFileOpenDialog()
 
107
{
 
108
        if (CloseButton)
 
109
                CloseButton->drop();
 
110
 
 
111
        if (OKButton)
 
112
                OKButton->drop();
 
113
 
 
114
        if (CancelButton)
 
115
                CancelButton->drop();
 
116
 
 
117
        if (FileBox)
 
118
                FileBox->drop();
 
119
 
 
120
        if (FileNameText)
 
121
                FileNameText->drop();
 
122
 
 
123
        if (FileSystem)
 
124
                FileSystem->drop();
 
125
 
 
126
        if (FileList)
 
127
                FileList->drop();
 
128
}
 
129
 
 
130
 
 
131
//! returns the filename of the selected file. Returns NULL, if no file was selected.
 
132
const wchar_t* CGUIFileOpenDialog::getFileName() const
 
133
{
 
134
        return FileName.c_str();
 
135
}
 
136
 
 
137
//! Returns the directory of the selected file. Returns NULL, if no directory was selected.
 
138
const io::path& CGUIFileOpenDialog::getDirectoryName()
 
139
{
 
140
        FileSystem->flattenFilename ( FileDirectory );
 
141
        return FileDirectory;
 
142
}
 
143
 
 
144
 
 
145
//! called if an event happened.
 
146
bool CGUIFileOpenDialog::OnEvent(const SEvent& event)
 
147
{
 
148
        if (isEnabled())
 
149
        {
 
150
                switch(event.EventType)
 
151
                {
 
152
                case EET_GUI_EVENT:
 
153
                        switch(event.GUIEvent.EventType)
 
154
                        {
 
155
                        case EGET_ELEMENT_FOCUS_LOST:
 
156
                                Dragging = false;
 
157
                                break;
 
158
                        case EGET_BUTTON_CLICKED:
 
159
                                if (event.GUIEvent.Caller == CloseButton ||
 
160
                                        event.GUIEvent.Caller == CancelButton)
 
161
                                {
 
162
                                        sendCancelEvent();
 
163
                                        remove();
 
164
                                        return true;
 
165
                                }
 
166
                                else
 
167
                                if (event.GUIEvent.Caller == OKButton )
 
168
                                {
 
169
                                        if ( FileDirectory != L"" )
 
170
                                        {
 
171
                                                sendSelectedEvent( EGET_DIRECTORY_SELECTED );
 
172
                                        }
 
173
                                        if ( FileName != L"" )
 
174
                                        {
 
175
                                                sendSelectedEvent( EGET_FILE_SELECTED );
 
176
                                                remove();
 
177
                                                return true;
 
178
                                        }
 
179
                                }
 
180
                                break;
 
181
 
 
182
                        case EGET_LISTBOX_CHANGED:
 
183
                                {
 
184
                                        s32 selected = FileBox->getSelected();
 
185
                                        if (FileList && FileSystem)
 
186
                                        {
 
187
                                                if (FileList->isDirectory(selected))
 
188
                                                {
 
189
                                                        FileName = L"";
 
190
                                                        FileDirectory = FileList->getFullFileName(selected);
 
191
                                                }
 
192
                                                else
 
193
                                                {
 
194
                                                        FileDirectory = L"";
 
195
                                                        FileName = FileList->getFullFileName(selected);
 
196
                                                }
 
197
                                                return true;
 
198
                                        }
 
199
                                }
 
200
                                break;
 
201
 
 
202
                        case EGET_LISTBOX_SELECTED_AGAIN:
 
203
                                {
 
204
                                        const s32 selected = FileBox->getSelected();
 
205
                                        if (FileList && FileSystem)
 
206
                                        {
 
207
                                                if (FileList->isDirectory(selected))
 
208
                                                {
 
209
                                                        FileDirectory = FileList->getFullFileName(selected);
 
210
                                                        FileSystem->changeWorkingDirectoryTo(FileList->getFileName(selected));
 
211
                                                        fillListBox();
 
212
                                                        FileName = "";
 
213
                                                }
 
214
                                                else
 
215
                                                {
 
216
                                                        FileName = FileList->getFullFileName(selected);
 
217
                                                }
 
218
                                                return true;
 
219
                                        }
 
220
                                }
 
221
                                break;
 
222
                        case EGET_EDITBOX_ENTER:
 
223
                                if (event.GUIEvent.Caller == FileNameText)
 
224
                                {
 
225
                                        io::path dir( FileNameText->getText () );
 
226
                                        if ( FileSystem->changeWorkingDirectoryTo( dir ) )
 
227
                                        {
 
228
                                                fillListBox();
 
229
                                                FileName = L"";
 
230
                                        }
 
231
                                        return true;
 
232
                                }
 
233
                        break;
 
234
                        default:
 
235
                                break;
 
236
                        }
 
237
                        break;
 
238
                case EET_MOUSE_INPUT_EVENT:
 
239
                        switch(event.MouseInput.Event)
 
240
                        {
 
241
                        case EMIE_MOUSE_WHEEL:
 
242
                                return FileBox->OnEvent(event);
 
243
                        case EMIE_LMOUSE_PRESSED_DOWN:
 
244
                                DragStart.X = event.MouseInput.X;
 
245
                                DragStart.Y = event.MouseInput.Y;
 
246
                                Dragging = true;
 
247
                                Environment->setFocus(this);
 
248
                                return true;
 
249
                        case EMIE_LMOUSE_LEFT_UP:
 
250
                                Dragging = false;
 
251
                                return true;
 
252
                        case EMIE_MOUSE_MOVED:
 
253
 
 
254
                                if ( !event.MouseInput.isLeftPressed () )
 
255
                                        Dragging = false;
 
256
 
 
257
                                if (Dragging)
 
258
                                {
 
259
                                        // gui window should not be dragged outside its parent
 
260
                                        if (Parent)
 
261
                                                if (event.MouseInput.X < Parent->getAbsolutePosition().UpperLeftCorner.X +1 ||
 
262
                                                        event.MouseInput.Y < Parent->getAbsolutePosition().UpperLeftCorner.Y +1 ||
 
263
                                                        event.MouseInput.X > Parent->getAbsolutePosition().LowerRightCorner.X -1 ||
 
264
                                                        event.MouseInput.Y > Parent->getAbsolutePosition().LowerRightCorner.Y -1)
 
265
 
 
266
                                                        return true;
 
267
 
 
268
                                        move(core::position2d<s32>(event.MouseInput.X - DragStart.X, event.MouseInput.Y - DragStart.Y));
 
269
                                        DragStart.X = event.MouseInput.X;
 
270
                                        DragStart.Y = event.MouseInput.Y;
 
271
                                        return true;
 
272
                                }
 
273
                                break;
 
274
                        default:
 
275
                                break;
 
276
                        }
 
277
                default:
 
278
                        break;
 
279
                }
 
280
        }
 
281
 
 
282
        return IGUIElement::OnEvent(event);
 
283
}
 
284
 
 
285
 
 
286
//! draws the element and its children
 
287
void CGUIFileOpenDialog::draw()
 
288
{
 
289
        if (!IsVisible)
 
290
                return;
 
291
 
 
292
        IGUISkin* skin = Environment->getSkin();
 
293
 
 
294
        core::rect<s32> rect = AbsoluteRect;
 
295
 
 
296
        rect = skin->draw3DWindowBackground(this, true, skin->getColor(EGDC_ACTIVE_BORDER),
 
297
                rect, &AbsoluteClippingRect);
 
298
 
 
299
        if (Text.size())
 
300
        {
 
301
                rect.UpperLeftCorner.X += 2;
 
302
                rect.LowerRightCorner.X -= skin->getSize(EGDS_WINDOW_BUTTON_WIDTH) + 5;
 
303
 
 
304
                IGUIFont* font = skin->getFont(EGDF_WINDOW);
 
305
                if (font)
 
306
                        font->draw(Text.c_str(), rect,
 
307
                                        skin->getColor(EGDC_ACTIVE_CAPTION),
 
308
                                        false, true, &AbsoluteClippingRect);
 
309
        }
 
310
 
 
311
        IGUIElement::draw();
 
312
}
 
313
 
 
314
 
 
315
//! fills the listbox with files.
 
316
void CGUIFileOpenDialog::fillListBox()
 
317
{
 
318
        IGUISkin *skin = Environment->getSkin();
 
319
 
 
320
        if (!FileSystem || !FileBox || !skin)
 
321
                return;
 
322
 
 
323
        if (FileList)
 
324
                FileList->drop();
 
325
 
 
326
        FileBox->clear();
 
327
 
 
328
        FileList = FileSystem->createFileList();
 
329
        core::stringw s;
 
330
 
 
331
#if !defined(_IRR_WINDOWS_CE_PLATFORM_)
 
332
        setlocale(LC_ALL,"");
 
333
#endif
 
334
 
 
335
        if (FileList)
 
336
        {
 
337
                for (u32 i=0; i < FileList->getFileCount(); ++i)
 
338
                {
 
339
                        #ifndef _IRR_WCHAR_FILESYSTEM
 
340
                        const c8 *cs = (const c8 *)FileList->getFileName(i).c_str();
 
341
                        wchar_t *ws = new wchar_t[strlen(cs) + 1];
 
342
                        int len = mbstowcs(ws,cs,strlen(cs));
 
343
                        ws[len] = 0;
 
344
                        s = ws;
 
345
                        delete [] ws;
 
346
                        #else
 
347
                        s = FileList->getFileName(i).c_str();
 
348
                        #endif
 
349
                        FileBox->addItem(s.c_str(), skin->getIcon(FileList->isDirectory(i) ? EGDI_DIRECTORY : EGDI_FILE));
 
350
                }
 
351
        }
 
352
 
 
353
        if (FileNameText)
 
354
        {
 
355
                #ifndef _IRR_WCHAR_FILESYSTEM
 
356
                const c8 *cs = (const c8 *)FileSystem->getWorkingDirectory().c_str();
 
357
                wchar_t *ws = new wchar_t[strlen(cs) + 1];
 
358
                int len = mbstowcs(ws,cs,strlen(cs));
 
359
                ws[len] = 0;
 
360
                s = ws;
 
361
                delete [] ws;
 
362
                #else
 
363
                s = FileSystem->getWorkingDirectory();
 
364
                #endif
 
365
 
 
366
                FileDirectory = s;
 
367
                FileNameText->setText(s.c_str());
 
368
        }
 
369
}
 
370
 
 
371
 
 
372
//! sends the event that the file has been selected.
 
373
void CGUIFileOpenDialog::sendSelectedEvent( EGUI_EVENT_TYPE type)
 
374
{
 
375
        SEvent event;
 
376
        event.EventType = EET_GUI_EVENT;
 
377
        event.GUIEvent.Caller = this;
 
378
        event.GUIEvent.Element = 0;
 
379
        event.GUIEvent.EventType = type;
 
380
        Parent->OnEvent(event);
 
381
}
 
382
 
 
383
 
 
384
//! sends the event that the file choose process has been canceld
 
385
void CGUIFileOpenDialog::sendCancelEvent()
 
386
{
 
387
        SEvent event;
 
388
        event.EventType = EET_GUI_EVENT;
 
389
        event.GUIEvent.Caller = this;
 
390
        event.GUIEvent.Element = 0;
 
391
        event.GUIEvent.EventType = EGET_FILE_CHOOSE_DIALOG_CANCELLED;
 
392
        Parent->OnEvent(event);
 
393
}
 
394
 
 
395
} // end namespace gui
 
396
} // end namespace irr
 
397
 
 
398
#endif // _IRR_COMPILE_WITH_GUI_
 
399