]> git.saurik.com Git - wxWidgets.git/blob - src/generic/filectrlg.cpp
projects / wxWidgets.git / blob
? search:


1dfba4421c98fb4a73a3f4a316e1f204212424bf
[wxWidgets.git] / src / generic / filectrlg.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/filectrlg.cpp
3 // Purpose: wxGenericFileCtrl Implementation
4 // Author: Diaa M. Sami
5 // Created: 2007-07-07
6 // Copyright: (c) Diaa M. Sami
7 // Licence: wxWindows licence
8 ///////////////////////////////////////////////////////////////////////////////
9
10 #include "wx/wxprec.h"
11
12 #ifdef __BORLANDC__
13 #pragma hdrstop
14 #endif
15
16 #if wxUSE_FILECTRL
17
18 #include "wx/generic/filectrlg.h"
19
20 #ifndef WX_PRECOMP
21 #include "wx/settings.h"
22 #include "wx/sizer.h"
23 #include "wx/stattext.h"
24 #include "wx/checkbox.h"
25 #include "wx/msgdlg.h"
26 #include "wx/log.h"
27 #include "wx/filedlg.h"
28 #endif
29
30 #include "wx/clntdata.h"
31 #include "wx/file.h" // for wxS_IXXX constants only
32 #include "wx/generic/dirctrlg.h" // for wxFileIconsTable
33 #include "wx/dir.h"
34 #include "wx/tokenzr.h"
35 #include "wx/imaglist.h"
36
37 #ifdef __WINDOWS__
38 #include "wx/msw/wrapwin.h"
39 #endif
40
41 #if defined(__WXWINCE__)
42 #define IsTopMostDir(dir) (dir == wxT("\\") || dir == wxT("/"))
43 #elif (defined(__DOS__) || defined(__WINDOWS__) || defined (__OS2__))
44 #define IsTopMostDir(dir) (dir.empty())
45 #else
46 #define IsTopMostDir(dir) (dir == wxT("/"))
47 #endif
48
49
50 // ----------------------------------------------------------------------------
51 // private functions
52 // ----------------------------------------------------------------------------
53
54 static
55 int wxCALLBACK wxFileDataNameCompare( wxIntPtr data1, wxIntPtr data2, wxIntPtr sortOrder)
56 {
57 wxFileData *fd1 = (wxFileData *)wxUIntToPtr(data1);
58 wxFileData *fd2 = (wxFileData *)wxUIntToPtr(data2);
59
60 if (fd1->GetFileName() == wxT(".."))
61 return -sortOrder;
62 if (fd2->GetFileName() == wxT(".."))
63 return sortOrder;
64 if (fd1->IsDir() && !fd2->IsDir())
65 return -sortOrder;
66 if (fd2->IsDir() && !fd1->IsDir())
67 return sortOrder;
68
69 return sortOrder*wxStrcmp( fd1->GetFileName(), fd2->GetFileName() );
70 }
71
72 static
73 int wxCALLBACK wxFileDataSizeCompare(wxIntPtr data1, wxIntPtr data2, wxIntPtr sortOrder)
74 {
75 wxFileData *fd1 = (wxFileData *)wxUIntToPtr(data1);
76 wxFileData *fd2 = (wxFileData *)wxUIntToPtr(data2);
77
78 if (fd1->GetFileName() == wxT(".."))
79 return -sortOrder;
80 if (fd2->GetFileName() == wxT(".."))
81 return sortOrder;
82 if (fd1->IsDir() && !fd2->IsDir())
83 return -sortOrder;
84 if (fd2->IsDir() && !fd1->IsDir())
85 return sortOrder;
86 if (fd1->IsLink() && !fd2->IsLink())
87 return -sortOrder;
88 if (fd2->IsLink() && !fd1->IsLink())
89 return sortOrder;
90
91 return fd1->GetSize() > fd2->GetSize() ? sortOrder : -sortOrder;
92 }
93
94 static
95 int wxCALLBACK wxFileDataTypeCompare(wxIntPtr data1, wxIntPtr data2, wxIntPtr sortOrder)
96 {
97 wxFileData *fd1 = (wxFileData *)wxUIntToPtr(data1);
98 wxFileData *fd2 = (wxFileData *)wxUIntToPtr(data2);
99
100 if (fd1->GetFileName() == wxT(".."))
101 return -sortOrder;
102 if (fd2->GetFileName() == wxT(".."))
103 return sortOrder;
104 if (fd1->IsDir() && !fd2->IsDir())
105 return -sortOrder;
106 if (fd2->IsDir() && !fd1->IsDir())
107 return sortOrder;
108 if (fd1->IsLink() && !fd2->IsLink())
109 return -sortOrder;
110 if (fd2->IsLink() && !fd1->IsLink())
111 return sortOrder;
112
113 return sortOrder*wxStrcmp( fd1->GetFileType(), fd2->GetFileType() );
114 }
115
116 static
117 int wxCALLBACK wxFileDataTimeCompare(wxIntPtr data1, wxIntPtr data2, wxIntPtr sortOrder)
118 {
119 wxFileData *fd1 = (wxFileData *)wxUIntToPtr(data1);
120 wxFileData *fd2 = (wxFileData *)wxUIntToPtr(data2);
121
122 if (fd1->GetFileName() == wxT(".."))
123 return -sortOrder;
124 if (fd2->GetFileName() == wxT(".."))
125 return sortOrder;
126 if (fd1->IsDir() && !fd2->IsDir())
127 return -sortOrder;
128 if (fd2->IsDir() && !fd1->IsDir())
129 return sortOrder;
130
131 return fd1->GetDateTime().IsLaterThan(fd2->GetDateTime()) ? sortOrder : -sortOrder;
132 }
133
134 // defined in src/generic/dirctrlg.cpp
135 extern size_t wxGetAvailableDrives(wxArrayString &paths, wxArrayString &names, wxArrayInt &icon_ids);
136
137 //-----------------------------------------------------------------------------
138 // wxFileData
139 //-----------------------------------------------------------------------------
140
141 wxFileData::wxFileData( const wxString &filePath, const wxString &fileName, fileType type, int image_id )
142 {
143 Init();
144 m_fileName = fileName;
145 m_filePath = filePath;
146 m_type = type;
147 m_image = image_id;
148
149 ReadData();
150 }
151
152 void wxFileData::Init()
153 {
154 m_size = 0;
155 m_type = wxFileData::is_file;
156 m_image = wxFileIconsTable::file;
157 }
158
159 void wxFileData::Copy( const wxFileData& fileData )
160 {
161 m_fileName = fileData.GetFileName();
162 m_filePath = fileData.GetFilePath();
163 m_size = fileData.GetSize();
164 m_dateTime = fileData.GetDateTime();
165 m_permissions = fileData.GetPermissions();
166 m_type = fileData.GetType();
167 m_image = fileData.GetImageId();
168 }
169
170 void wxFileData::ReadData()
171 {
172 if (IsDrive())
173 {
174 m_size = 0;
175 return;
176 }
177
178 #if defined(__DOS__) || (defined(__WINDOWS__) && !defined(__WXWINCE__)) || defined(__OS2__)
179 // c:\.. is a drive don't stat it
180 if ((m_fileName == wxT("..")) && (m_filePath.length() <= 5))
181 {
182 m_type = is_drive;
183 m_size = 0;
184 return;
185 }
186 #endif // __DOS__ || __WINDOWS__
187
188 #ifdef __WXWINCE__
189
190 // WinCE
191
192 DWORD fileAttribs = GetFileAttributes(m_filePath.fn_str());
193 m_type |= (fileAttribs & FILE_ATTRIBUTE_DIRECTORY) != 0 ? is_dir : 0;
194
195 wxString p, f, ext;
196 wxFileName::SplitPath(m_filePath, & p, & f, & ext);
197 if (wxStricmp(ext, wxT("exe")) == 0)
198 m_type |= is_exe;
199
200 // Find out size
201 m_size = 0;
202 HANDLE fileHandle = CreateFile(m_filePath.fn_str(),
203 GENERIC_READ,
204 FILE_SHARE_READ,
205 NULL,
206 OPEN_EXISTING,
207 FILE_ATTRIBUTE_NORMAL,
208 NULL);
209
210 if (fileHandle != INVALID_HANDLE_VALUE)
211 {
212 m_size = GetFileSize(fileHandle, 0);
213 CloseHandle(fileHandle);
214 }
215
216 m_dateTime = wxFileModificationTime(m_filePath);
217
218 #else
219
220 // OTHER PLATFORMS
221
222 wxStructStat buff;
223
224 #if defined(__UNIX__) && (!defined( __OS2__ ) && !defined(__VMS))
225 const bool hasStat = lstat( m_filePath.fn_str(), &buff ) == 0;
226 if ( hasStat )
227 m_type |= S_ISLNK(buff.st_mode) ? is_link : 0;
228 #else // no lstat()
229 const bool hasStat = wxStat( m_filePath, &buff ) == 0;
230 #endif
231
232 if ( hasStat )
233 {
234 m_type |= (buff.st_mode & S_IFDIR) != 0 ? is_dir : 0;
235 m_type |= (buff.st_mode & wxS_IXUSR) != 0 ? is_exe : 0;
236
237 m_size = buff.st_size;
238
239 m_dateTime = buff.st_mtime;
240 }
241 #endif
242 // __WXWINCE__
243
244 #if defined(__UNIX__)
245 if ( hasStat )
246 {
247 m_permissions.Printf(wxT("%c%c%c%c%c%c%c%c%c"),
248 buff.st_mode & wxS_IRUSR ? wxT('r') : wxT('-'),
249 buff.st_mode & wxS_IWUSR ? wxT('w') : wxT('-'),
250 buff.st_mode & wxS_IXUSR ? wxT('x') : wxT('-'),
251 buff.st_mode & wxS_IRGRP ? wxT('r') : wxT('-'),
252 buff.st_mode & wxS_IWGRP ? wxT('w') : wxT('-'),
253 buff.st_mode & wxS_IXGRP ? wxT('x') : wxT('-'),
254 buff.st_mode & wxS_IROTH ? wxT('r') : wxT('-'),
255 buff.st_mode & wxS_IWOTH ? wxT('w') : wxT('-'),
256 buff.st_mode & wxS_IXOTH ? wxT('x') : wxT('-'));
257 }
258 #elif defined(__WIN32__)
259 DWORD attribs = ::GetFileAttributes(m_filePath.c_str());
260 if (attribs != (DWORD)-1)
261 {
262 m_permissions.Printf(wxT("%c%c%c%c"),
263 attribs & FILE_ATTRIBUTE_ARCHIVE ? wxT('A') : wxT(' '),
264 attribs & FILE_ATTRIBUTE_READONLY ? wxT('R') : wxT(' '),
265 attribs & FILE_ATTRIBUTE_HIDDEN ? wxT('H') : wxT(' '),
266 attribs & FILE_ATTRIBUTE_SYSTEM ? wxT('S') : wxT(' '));
267 }
268 #endif
269
270 // try to get a better icon
271 if (m_image == wxFileIconsTable::file)
272 {
273 if (m_fileName.Find(wxT('.'), true) != wxNOT_FOUND)
274 {
275 m_image = wxTheFileIconsTable->GetIconID( m_fileName.AfterLast(wxT('.')));
276 } else if (IsExe())
277 {
278 m_image = wxFileIconsTable::executable;
279 }
280 }
281 }
282
283 wxString wxFileData::GetFileType() const
284 {
285 if (IsDir())
286 return _("<DIR>");
287 else if (IsLink())
288 return _("<LINK>");
289 else if (IsDrive())
290 return _("<DRIVE>");
291 else if (m_fileName.Find(wxT('.'), true) != wxNOT_FOUND)
292 return m_fileName.AfterLast(wxT('.'));
293
294 return wxEmptyString;
295 }
296
297 wxString wxFileData::GetModificationTime() const
298 {
299 // want time as 01:02 so they line up nicely, no %r in WIN32
300 return m_dateTime.FormatDate() + wxT(" ") + m_dateTime.Format(wxT("%I:%M:%S %p"));
301 }
302
303 wxString wxFileData::GetHint() const
304 {
305 wxString s = m_filePath;
306 s += wxT(" ");
307
308 if (IsDir())
309 s += _("<DIR>");
310 else if (IsLink())
311 s += _("<LINK>");
312 else if (IsDrive())
313 s += _("<DRIVE>");
314 else // plain file
315 s += wxString::Format(wxPLURAL("%ld byte", "%ld bytes", m_size),
316 wxLongLong(m_size).ToString().c_str());
317
318 s += wxT(' ');
319
320 if ( !IsDrive() )
321 {
322 s << GetModificationTime()
323 << wxT(" ")
324 << m_permissions;
325 }
326
327 return s;
328 }
329
330 wxString wxFileData::GetEntry( fileListFieldType num ) const
331 {
332 wxString s;
333 switch ( num )
334 {
335 case FileList_Name:
336 s = m_fileName;
337 break;
338
339 case FileList_Size:
340 if (!IsDir() && !IsLink() && !IsDrive())
341 s = wxLongLong(m_size).ToString();
342 break;
343
344 case FileList_Type:
345 s = GetFileType();
346 break;
347
348 case FileList_Time:
349 if (!IsDrive())
350 s = GetModificationTime();
351 break;
352
353 #if defined(__UNIX__) || defined(__WIN32__)
354 case FileList_Perm:
355 s = m_permissions;
356 break;
357 #endif // defined(__UNIX__) || defined(__WIN32__)
358
359 default:
360 wxFAIL_MSG( wxT("unexpected field in wxFileData::GetEntry()") );
361 }
362
363 return s;
364 }
365
366 void wxFileData::SetNewName( const wxString &filePath, const wxString &fileName )
367 {
368 m_fileName = fileName;
369 m_filePath = filePath;
370 }
371
372 void wxFileData::MakeItem( wxListItem &item )
373 {
374 item.m_text = m_fileName;
375 item.ClearAttributes();
376 if (IsExe())
377 item.SetTextColour(*wxRED);
378 if (IsDir())
379 item.SetTextColour(*wxBLUE);
380
381 item.m_image = m_image;
382
383 if (IsLink())
384 {
385 wxColour dg = wxTheColourDatabase->Find( wxT("MEDIUM GREY") );
386 if ( dg.IsOk() )
387 item.SetTextColour(dg);
388 }
389 item.m_data = wxPtrToUInt(this);
390 }
391
392 //-----------------------------------------------------------------------------
393 // wxFileListCtrl
394 //-----------------------------------------------------------------------------
395
396 IMPLEMENT_DYNAMIC_CLASS(wxFileListCtrl,wxListCtrl)
397
398 BEGIN_EVENT_TABLE(wxFileListCtrl,wxListCtrl)
399 EVT_LIST_DELETE_ITEM(wxID_ANY, wxFileListCtrl::OnListDeleteItem)
400 EVT_LIST_DELETE_ALL_ITEMS(wxID_ANY, wxFileListCtrl::OnListDeleteAllItems)
401 EVT_LIST_END_LABEL_EDIT(wxID_ANY, wxFileListCtrl::OnListEndLabelEdit)
402 EVT_LIST_COL_CLICK(wxID_ANY, wxFileListCtrl::OnListColClick)
403 END_EVENT_TABLE()
404
405
406 wxFileListCtrl::wxFileListCtrl()
407 {
408 m_showHidden = false;
409 m_sort_forward = true;
410 m_sort_field = wxFileData::FileList_Name;
411 }
412
413 wxFileListCtrl::wxFileListCtrl(wxWindow *win,
414 wxWindowID id,
415 const wxString& wild,
416 bool showHidden,
417 const wxPoint& pos,
418 const wxSize& size,
419 long style,
420 const wxValidator &validator,
421 const wxString &name)
422 : wxListCtrl(win, id, pos, size, style, validator, name),
423 m_wild(wild)
424 {
425 wxImageList *imageList = wxTheFileIconsTable->GetSmallImageList();
426
427 SetImageList( imageList, wxIMAGE_LIST_SMALL );
428
429 m_showHidden = showHidden;
430
431 m_sort_forward = true;
432 m_sort_field = wxFileData::FileList_Name;
433
434 m_dirName = wxT("*");
435
436 if (style & wxLC_REPORT)
437 ChangeToReportMode();
438 }
439
440 void wxFileListCtrl::ChangeToListMode()
441 {
442 ClearAll();
443 SetSingleStyle( wxLC_LIST );
444 UpdateFiles();
445 }
446
447 void wxFileListCtrl::ChangeToReportMode()
448 {
449 ClearAll();
450 SetSingleStyle( wxLC_REPORT );
451
452 // do this since WIN32 does mm/dd/yy UNIX does mm/dd/yyyy
453 // don't hardcode since mm/dd is dd/mm elsewhere
454 int w, h;
455 wxDateTime dt(22, wxDateTime::Dec, 2002, 22, 22, 22);
456 wxString txt = dt.FormatDate() + wxT("22") + dt.Format(wxT("%I:%M:%S %p"));
457 GetTextExtent(txt, &w, &h);
458
459 InsertColumn( 0, _("Name"), wxLIST_FORMAT_LEFT, w );
460 InsertColumn( 1, _("Size"), wxLIST_FORMAT_LEFT, w/2 );
461 InsertColumn( 2, _("Type"), wxLIST_FORMAT_LEFT, w/2 );
462 InsertColumn( 3, _("Modified"), wxLIST_FORMAT_LEFT, w );
463 #if defined(__UNIX__)
464 GetTextExtent(wxT("Permissions 2"), &w, &h);
465 InsertColumn( 4, _("Permissions"), wxLIST_FORMAT_LEFT, w );
466 #elif defined(__WIN32__)
467 GetTextExtent(wxT("Attributes 2"), &w, &h);
468 InsertColumn( 4, _("Attributes"), wxLIST_FORMAT_LEFT, w );
469 #endif
470
471 UpdateFiles();
472 }
473
474 void wxFileListCtrl::ChangeToSmallIconMode()
475 {
476 ClearAll();
477 SetSingleStyle( wxLC_SMALL_ICON );
478 UpdateFiles();
479 }
480
481 void wxFileListCtrl::ShowHidden( bool show )
482 {
483 m_showHidden = show;
484 UpdateFiles();
485 }
486
487 long wxFileListCtrl::Add( wxFileData *fd, wxListItem &item )
488 {
489 long ret = -1;
490 item.m_mask = wxLIST_MASK_TEXT + wxLIST_MASK_DATA + wxLIST_MASK_IMAGE;
491 fd->MakeItem( item );
492 long my_style = GetWindowStyleFlag();
493 if (my_style & wxLC_REPORT)
494 {
495 ret = InsertItem( item );
496 for (int i = 1; i < wxFileData::FileList_Max; i++)
497 SetItem( item.m_itemId, i, fd->GetEntry((wxFileData::fileListFieldType)i) );
498 }
499 else if ((my_style & wxLC_LIST) || (my_style & wxLC_SMALL_ICON))
500 {
501 ret = InsertItem( item );
502 }
503 return ret;
504 }
505
506 void wxFileListCtrl::UpdateItem(const wxListItem &item)
507 {
508 wxFileData *fd = (wxFileData*)GetItemData(item);
509 wxCHECK_RET(fd, wxT("invalid filedata"));
510
511 fd->ReadData();
512
513 SetItemText(item, fd->GetFileName());
514 SetItemImage(item, fd->GetImageId());
515
516 if (GetWindowStyleFlag() & wxLC_REPORT)
517 {
518 for (int i = 1; i < wxFileData::FileList_Max; i++)
519 SetItem( item.m_itemId, i, fd->GetEntry((wxFileData::fileListFieldType)i) );
520 }
521 }
522
523 void wxFileListCtrl::UpdateFiles()
524 {
525 // don't do anything before ShowModal() call which sets m_dirName
526 if ( m_dirName == wxT("*") )
527 return;
528
529 wxBusyCursor bcur; // this may take a while...
530
531 DeleteAllItems();
532
533 wxListItem item;
534 item.m_itemId = 0;
535 item.m_col = 0;
536
537 #if (defined(__WINDOWS__) || defined(__DOS__) || defined(__WXMAC__) || defined(__OS2__)) && !defined(__WXWINCE__)
538 if ( IsTopMostDir(m_dirName) )
539 {
540 wxArrayString names, paths;
541 wxArrayInt icons;
542 const size_t count = wxGetAvailableDrives(paths, names, icons);
543
544 for ( size_t n = 0; n < count; n++ )
545 {
546 // use paths[n] as the drive name too as our HandleAction() can't
547 // deal with the drive names (of the form "System (C:)") currently
548 // as it mistakenly treats them as file names
549 //
550 // it would be preferable to show names, and not paths, in the
551 // dialog just as the native dialog does but for this we must:
552 // a) store the item type as item data and modify HandleAction()
553 // to use it instead of wxDirExists() to check whether the item
554 // is a directory
555 // b) store the drives by their drive letters and not their
556 // descriptions as otherwise it's pretty confusing to the user
557 wxFileData *fd = new wxFileData(paths[n], paths[n],
558 wxFileData::is_drive, icons[n]);
559 if (Add(fd, item) != -1)
560 item.m_itemId++;
561 else
562 delete fd;
563 }
564 }
565 else
566 #endif // defined(__DOS__) || defined(__WINDOWS__)
567 {
568 // Real directory...
569 if ( !IsTopMostDir(m_dirName) && !m_dirName.empty() )
570 {
571 wxString p(wxPathOnly(m_dirName));
572 #if (defined(__UNIX__) || defined(__WXWINCE__)) && !defined(__OS2__)
573 if (p.empty()) p = wxT("/");
574 #endif // __UNIX__
575 wxFileData *fd = new wxFileData(p, wxT(".."), wxFileData::is_dir, wxFileIconsTable::folder);
576 if (Add(fd, item) != -1)
577 item.m_itemId++;
578 else
579 delete fd;
580 }
581
582 wxString dirname(m_dirName);
583 #if defined(__DOS__) || defined(__WINDOWS__) || defined(__OS2__)
584 if (dirname.length() == 2 && dirname[1u] == wxT(':'))
585 dirname << wxT('\\');
586 #endif // defined(__DOS__) || defined(__WINDOWS__) || defined(__OS2__)
587
588 if (dirname.empty())
589 dirname = wxFILE_SEP_PATH;
590
591 wxLogNull logNull;
592 wxDir dir(dirname);
593
594 if ( dir.IsOpened() )
595 {
596 wxString dirPrefix(dirname);
597 if (dirPrefix.Last() != wxFILE_SEP_PATH)
598 dirPrefix += wxFILE_SEP_PATH;
599
600 int hiddenFlag = m_showHidden ? wxDIR_HIDDEN : 0;
601
602 bool cont;
603 wxString f;
604
605 // Get the directories first (not matched against wildcards):
606 cont = dir.GetFirst(&f, wxEmptyString, wxDIR_DIRS | hiddenFlag);
607 while (cont)
608 {
609 wxFileData *fd = new wxFileData(dirPrefix + f, f, wxFileData::is_dir, wxFileIconsTable::folder);
610 if (Add(fd, item) != -1)
611 item.m_itemId++;
612 else
613 delete fd;
614
615 cont = dir.GetNext(&f);
616 }
617
618 // Tokenize the wildcard string, so we can handle more than 1
619 // search pattern in a wildcard.
620 wxStringTokenizer tokenWild(m_wild, wxT(";"));
621 while ( tokenWild.HasMoreTokens() )
622 {
623 cont = dir.GetFirst(&f, tokenWild.GetNextToken(),
624 wxDIR_FILES | hiddenFlag);
625 while (cont)
626 {
627 wxFileData *fd = new wxFileData(dirPrefix + f, f, wxFileData::is_file, wxFileIconsTable::file);
628 if (Add(fd, item) != -1)
629 item.m_itemId++;
630 else
631 delete fd;
632
633 cont = dir.GetNext(&f);
634 }
635 }
636 }
637 }
638
639 SortItems(m_sort_field, m_sort_forward);
640 }
641
642 void wxFileListCtrl::SetWild( const wxString &wild )
643 {
644 if (wild.Find(wxT('|')) != wxNOT_FOUND)
645 return;
646
647 m_wild = wild;
648 UpdateFiles();
649 }
650
651 void wxFileListCtrl::MakeDir()
652 {
653 wxString new_name( _("NewName") );
654 wxString path( m_dirName );
655 path += wxFILE_SEP_PATH;
656 path += new_name;
657 if (wxFileExists(path))
658 {
659 // try NewName0, NewName1 etc.
660 int i = 0;
661 do {
662 new_name = _("NewName");
663 wxString num;
664 num.Printf( wxT("%d"), i );
665 new_name += num;
666
667 path = m_dirName;
668 path += wxFILE_SEP_PATH;
669 path += new_name;
670 i++;
671 } while (wxFileExists(path));
672 }
673
674 wxLogNull log;
675 if (!wxMkdir(path))
676 {
677 wxMessageDialog dialog(this, _("Operation not permitted."), _("Error"), wxOK | wxICON_ERROR );
678 dialog.ShowModal();
679 return;
680 }
681
682 wxFileData *fd = new wxFileData( path, new_name, wxFileData::is_dir, wxFileIconsTable::folder );
683 wxListItem item;
684 item.m_itemId = 0;
685 item.m_col = 0;
686 long itemid = Add( fd, item );
687
688 if (itemid != -1)
689 {
690 SortItems(m_sort_field, m_sort_forward);
691 itemid = FindItem( 0, wxPtrToUInt(fd) );
692 EnsureVisible( itemid );
693 EditLabel( itemid );
694 }
695 else
696 delete fd;
697 }
698
699 void wxFileListCtrl::GoToParentDir()
700 {
701 if (!IsTopMostDir(m_dirName))
702 {
703 size_t len = m_dirName.length();
704 if (wxEndsWithPathSeparator(m_dirName))
705 m_dirName.Remove( len-1, 1 );
706 wxString fname( wxFileNameFromPath(m_dirName) );
707 m_dirName = wxPathOnly( m_dirName );
708 #if defined(__DOS__) || defined(__WINDOWS__) || defined(__OS2__)
709 if (!m_dirName.empty())
710 {
711 if (m_dirName.Last() == wxT('.'))
712 m_dirName = wxEmptyString;
713 }
714 #elif defined(__UNIX__)
715 if (m_dirName.empty())
716 m_dirName = wxT("/");
717 #endif
718 UpdateFiles();
719 long id = FindItem( 0, fname );
720 if (id != wxNOT_FOUND)
721 {
722 SetItemState( id, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
723 EnsureVisible( id );
724 }
725 }
726 }
727
728 void wxFileListCtrl::GoToHomeDir()
729 {
730 wxString s = wxGetUserHome( wxString() );
731 GoToDir(s);
732 }
733
734 void wxFileListCtrl::GoToDir( const wxString &dir )
735 {
736 if (!wxDirExists(dir)) return;
737
738 m_dirName = dir;
739 UpdateFiles();
740
741 SetItemState( 0, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
742
743 EnsureVisible( 0 );
744 }
745
746 void wxFileListCtrl::FreeItemData(wxListItem& item)
747 {
748 if ( item.m_data )
749 {
750 wxFileData *fd = (wxFileData*)item.m_data;
751 delete fd;
752
753 item.m_data = 0;
754 }
755 }
756
757 void wxFileListCtrl::OnListDeleteItem( wxListEvent &event )
758 {
759 FreeItemData(event.m_item);
760 }
761
762 void wxFileListCtrl::OnListDeleteAllItems( wxListEvent & WXUNUSED(event) )
763 {
764 FreeAllItemsData();
765 }
766
767 void wxFileListCtrl::FreeAllItemsData()
768 {
769 wxListItem item;
770 item.m_mask = wxLIST_MASK_DATA;
771
772 item.m_itemId = GetNextItem( -1, wxLIST_NEXT_ALL );
773 while ( item.m_itemId != -1 )
774 {
775 GetItem( item );
776 FreeItemData(item);
777 item.m_itemId = GetNextItem( item.m_itemId, wxLIST_NEXT_ALL );
778 }
779 }
780
781 void wxFileListCtrl::OnListEndLabelEdit( wxListEvent &event )
782 {
783 wxFileData *fd = (wxFileData*)event.m_item.m_data;
784 wxASSERT( fd );
785
786 if ((event.GetLabel().empty()) ||
787 (event.GetLabel() == wxT(".")) ||
788 (event.GetLabel() == wxT("..")) ||
789 (event.GetLabel().First( wxFILE_SEP_PATH ) != wxNOT_FOUND))
790 {
791 wxMessageDialog dialog(this, _("Illegal directory name."), _("Error"), wxOK | wxICON_ERROR );
792 dialog.ShowModal();
793 event.Veto();
794 return;
795 }
796
797 wxString new_name( wxPathOnly( fd->GetFilePath() ) );
798 new_name += wxFILE_SEP_PATH;
799 new_name += event.GetLabel();
800
801 wxLogNull log;
802
803 if (wxFileExists(new_name))
804 {
805 wxMessageDialog dialog(this, _("File name exists already."), _("Error"), wxOK | wxICON_ERROR );
806 dialog.ShowModal();
807 event.Veto();
808 }
809
810 if (wxRenameFile(fd->GetFilePath(),new_name))
811 {
812 fd->SetNewName( new_name, event.GetLabel() );
813
814 SetItemState( event.GetItem(), wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
815
816 UpdateItem( event.GetItem() );
817 EnsureVisible( event.GetItem() );
818 }
819 else
820 {
821 wxMessageDialog dialog(this, _("Operation not permitted."), _("Error"), wxOK | wxICON_ERROR );
822 dialog.ShowModal();
823 event.Veto();
824 }
825 }
826
827 void wxFileListCtrl::OnListColClick( wxListEvent &event )
828 {
829 int col = event.GetColumn();
830
831 switch (col)
832 {
833 case wxFileData::FileList_Name :
834 case wxFileData::FileList_Size :
835 case wxFileData::FileList_Type :
836 case wxFileData::FileList_Time : break;
837 default : return;
838 }
839
840 if ((wxFileData::fileListFieldType)col == m_sort_field)
841 m_sort_forward = !m_sort_forward;
842 else
843 m_sort_field = (wxFileData::fileListFieldType)col;
844
845 SortItems(m_sort_field, m_sort_forward);
846 }
847
848 void wxFileListCtrl::SortItems(wxFileData::fileListFieldType field, bool forward)
849 {
850 m_sort_field = field;
851 m_sort_forward = forward;
852 const long sort_dir = forward ? 1 : -1;
853
854 switch (m_sort_field)
855 {
856 case wxFileData::FileList_Size :
857 wxListCtrl::SortItems(wxFileDataSizeCompare, sort_dir);
858 break;
859
860 case wxFileData::FileList_Type :
861 wxListCtrl::SortItems(wxFileDataTypeCompare, sort_dir);
862 break;
863
864 case wxFileData::FileList_Time :
865 wxListCtrl::SortItems(wxFileDataTimeCompare, sort_dir);
866 break;
867
868 case wxFileData::FileList_Name :
869 default :
870 wxListCtrl::SortItems(wxFileDataNameCompare, sort_dir);
871 break;
872 }
873 }
874
875 wxFileListCtrl::~wxFileListCtrl()
876 {
877 // Normally the data are freed via an EVT_LIST_DELETE_ALL_ITEMS event and
878 // wxFileListCtrl::OnListDeleteAllItems. But if the event is generated after
879 // the destruction of the wxFileListCtrl we need to free any data here:
880 FreeAllItemsData();
881 }
882
883 #define ID_CHOICE (wxID_FILECTRL + 1)
884 #define ID_TEXT (wxID_FILECTRL + 2)
885 #define ID_FILELIST_CTRL (wxID_FILECTRL + 3)
886 #define ID_CHECK (wxID_FILECTRL + 4)
887
888 ///////////////////////////////////////////////////////////////////////////////
889 // wxGenericFileCtrl implementation
890 ///////////////////////////////////////////////////////////////////////////////
891
892 IMPLEMENT_DYNAMIC_CLASS( wxGenericFileCtrl, wxNavigationEnabled<wxControl> )
893
894 BEGIN_EVENT_TABLE( wxGenericFileCtrl, wxNavigationEnabled<wxControl> )
895 EVT_LIST_ITEM_SELECTED( ID_FILELIST_CTRL, wxGenericFileCtrl::OnSelected )
896 EVT_LIST_ITEM_ACTIVATED( ID_FILELIST_CTRL, wxGenericFileCtrl::OnActivated )
897 EVT_CHOICE( ID_CHOICE, wxGenericFileCtrl::OnChoiceFilter )
898 EVT_TEXT_ENTER( ID_TEXT, wxGenericFileCtrl::OnTextEnter )
899 EVT_TEXT( ID_TEXT, wxGenericFileCtrl::OnTextChange )
900 EVT_CHECKBOX( ID_CHECK, wxGenericFileCtrl::OnCheck )
901 END_EVENT_TABLE()
902
903 bool wxGenericFileCtrl::Create( wxWindow *parent,
904 wxWindowID id,
905 const wxString& defaultDirectory,
906 const wxString& defaultFileName,
907 const wxString& wildCard,
908 long style,
909 const wxPoint& pos,
910 const wxSize& size,
911 const wxString& name )
912 {
913 this->m_style = style;
914 m_inSelected = false;
915 m_noSelChgEvent = false;
916 m_check = NULL;
917
918 // check that the styles are not contradictory
919 wxASSERT_MSG( !( ( m_style & wxFC_SAVE ) && ( m_style & wxFC_OPEN ) ),
920 wxT( "can't specify both wxFC_SAVE and wxFC_OPEN at once" ) );
921
922 wxASSERT_MSG( !( ( m_style & wxFC_SAVE ) && ( m_style & wxFC_MULTIPLE ) ),
923 wxT( "wxFC_MULTIPLE can't be used with wxFC_SAVE" ) );
924
925 wxNavigationEnabled<wxControl>::Create( parent, id,
926 pos, size,
927 wxTAB_TRAVERSAL,
928 wxDefaultValidator,
929 name );
930
931 m_dir = defaultDirectory;
932
933 m_ignoreChanges = true;
934
935 if ( ( m_dir.empty() ) || ( m_dir == wxT( "." ) ) )
936 {
937 m_dir = wxGetCwd();
938 if ( m_dir.empty() )
939 m_dir = wxFILE_SEP_PATH;
940 }
941
942 const size_t len = m_dir.length();
943 if ( ( len > 1 ) && ( wxEndsWithPathSeparator( m_dir ) ) )
944 m_dir.Remove( len - 1, 1 );
945
946 m_filterExtension = wxEmptyString;
947
948 // layout
949
950 const bool is_pda = ( wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA );
951
952 wxBoxSizer *mainsizer = new wxBoxSizer( wxVERTICAL );
953
954 wxBoxSizer *staticsizer = new wxBoxSizer( wxHORIZONTAL );
955 if ( is_pda )
956 staticsizer->Add( new wxStaticText( this, wxID_ANY, _( "Current directory:" ) ),
957 wxSizerFlags().DoubleBorder(wxRIGHT) );
958 m_static = new wxStaticText( this, wxID_ANY, m_dir );
959 staticsizer->Add( m_static, 1 );
960 mainsizer->Add( staticsizer, wxSizerFlags().Expand().Border());
961
962 long style2 = wxLC_LIST;
963 if ( !( m_style & wxFC_MULTIPLE ) )
964 style2 |= wxLC_SINGLE_SEL;
965
966 #ifdef __WXWINCE__
967 style2 |= wxSIMPLE_BORDER;
968 #else
969 style2 |= wxSUNKEN_BORDER;
970 #endif
971
972 m_list = new wxFileListCtrl( this, ID_FILELIST_CTRL,
973 wxEmptyString, false,
974 wxDefaultPosition, wxSize( 400, 140 ),
975 style2 );
976
977 m_text = new wxTextCtrl( this, ID_TEXT, wxEmptyString,
978 wxDefaultPosition, wxDefaultSize,
979 wxTE_PROCESS_ENTER );
980 m_choice = new wxChoice( this, ID_CHOICE );
981
982 if ( is_pda )
983 {
984 // PDAs have a different screen layout
985 mainsizer->Add( m_list, wxSizerFlags( 1 ).Expand().HorzBorder() );
986
987 wxBoxSizer *textsizer = new wxBoxSizer( wxHORIZONTAL );
988 textsizer->Add( m_text, wxSizerFlags( 1 ).Centre().Border() );
989 textsizer->Add( m_choice, wxSizerFlags( 1 ).Centre().Border() );
990 mainsizer->Add( textsizer, wxSizerFlags().Expand() );
991
992 }
993 else // !is_pda
994 {
995 mainsizer->Add( m_list, wxSizerFlags( 1 ).Expand().Border() );
996 mainsizer->Add( m_text, wxSizerFlags().Expand().Border() );
997
998 wxBoxSizer *choicesizer = new wxBoxSizer( wxHORIZONTAL );
999 choicesizer->Add( m_choice, wxSizerFlags( 1 ).Centre() );
1000
1001 if ( !( m_style & wxFC_NOSHOWHIDDEN ) )
1002 {
1003 m_check = new wxCheckBox( this, ID_CHECK, _( "Show &hidden files" ) );
1004 choicesizer->Add( m_check, wxSizerFlags().Centre().DoubleBorder(wxLEFT) );
1005 }
1006
1007 mainsizer->Add( choicesizer, wxSizerFlags().Expand().Border() );
1008 }
1009
1010 SetWildcard( wildCard );
1011
1012 SetAutoLayout( true );
1013 SetSizer( mainsizer );
1014
1015 if ( !is_pda )
1016 {
1017 mainsizer->Fit( this );
1018 }
1019
1020 m_list->GoToDir( m_dir );
1021 UpdateControls();
1022 m_text->SetValue( m_fileName );
1023
1024 m_ignoreChanges = false;
1025
1026 // must be after m_ignoreChanges = false
1027 SetFilename( defaultFileName );
1028
1029 return true;
1030 }
1031
1032 // NB: there is an unfortunate mismatch between wxFileName and wxFileDialog
1033 // method names but our GetDirectory() does correspond to wxFileName::
1034 // GetPath() while our GetPath() is wxFileName::GetFullPath()
1035 wxString wxGenericFileCtrl::GetPath() const
1036 {
1037 wxASSERT_MSG ( !(m_style & wxFC_MULTIPLE), "use GetPaths() instead" );
1038
1039 return DoGetFileName().GetFullPath();
1040 }
1041
1042 wxString wxGenericFileCtrl::GetFilename() const
1043 {
1044 wxASSERT_MSG ( !(m_style & wxFC_MULTIPLE), "use GetFilenames() instead" );
1045
1046 return DoGetFileName().GetFullName();
1047 }
1048
1049 wxString wxGenericFileCtrl::GetDirectory() const
1050 {
1051 // don't check for wxFC_MULTIPLE here, this one is probably safe to call in
1052 // any case as it can be always taken to mean "current directory"
1053 return DoGetFileName().GetPath();
1054 }
1055
1056 wxFileName wxGenericFileCtrl::DoGetFileName() const
1057 {
1058 wxFileName fn;
1059
1060 wxString value = m_text->GetValue();
1061 if ( value.empty() )
1062 {
1063 // nothing in the text control, get the selected file from the list
1064 wxListItem item;
1065 item.m_itemId = m_list->GetNextItem(-1, wxLIST_NEXT_ALL,
1066 wxLIST_STATE_SELECTED);
1067 m_list->GetItem(item);
1068
1069 fn.Assign(m_list->GetDir(), item.m_text);
1070 }
1071 else // user entered the value
1072 {
1073 // the path can be either absolute or relative
1074 fn.Assign(value);
1075 if ( fn.IsRelative() )
1076 fn.MakeAbsolute(m_list->GetDir());
1077 }
1078
1079 return fn;
1080 }
1081
1082 // helper used in DoGetFilenames() and needed because Borland can't compile
1083 // operator?: inline
1084 static inline wxString GetFileNameOrPath(const wxFileName& fn, bool fullPath)
1085 {
1086 return fullPath ? fn.GetFullPath() : fn.GetFullName();
1087 }
1088
1089 void
1090 wxGenericFileCtrl::DoGetFilenames(wxArrayString& filenames, bool fullPath) const
1091 {
1092 filenames.clear();
1093
1094 const wxString dir = m_list->GetDir();
1095
1096 const wxString value = m_text->GetValue();
1097 if ( !value.empty() )
1098 {
1099 wxFileName fn(value);
1100 if ( fn.IsRelative() )
1101 fn.MakeAbsolute(dir);
1102
1103 filenames.push_back(GetFileNameOrPath(fn, fullPath));
1104 return;
1105 }
1106
1107 const int numSel = m_list->GetSelectedItemCount();
1108 if ( !numSel )
1109 return;
1110
1111 filenames.reserve(numSel);
1112
1113 wxListItem item;
1114 item.m_mask = wxLIST_MASK_TEXT;
1115 item.m_itemId = -1;
1116 for ( ;; )
1117 {
1118 item.m_itemId = m_list->GetNextItem(item.m_itemId, wxLIST_NEXT_ALL,
1119 wxLIST_STATE_SELECTED);
1120
1121 if ( item.m_itemId == -1 )
1122 break;
1123
1124 m_list->GetItem(item);
1125
1126 const wxFileName fn(dir, item.m_text);
1127 filenames.push_back(GetFileNameOrPath(fn, fullPath));
1128 }
1129 }
1130
1131 bool wxGenericFileCtrl::SetDirectory( const wxString& dir )
1132 {
1133 m_ignoreChanges = true;
1134 m_list->GoToDir( dir );
1135 UpdateControls();
1136 m_ignoreChanges = false;
1137
1138 return wxFileName( dir ).SameAs( m_list->GetDir() );
1139 }
1140
1141 bool wxGenericFileCtrl::SetFilename( const wxString& name )
1142 {
1143 const long item = m_list->FindItem( -1, name );
1144
1145 if ( item == -1 ) // file not found either because it doesn't exist or the
1146 // current filter doesn't show it.
1147 return false;
1148
1149 m_noSelChgEvent = true;
1150
1151 // Deselect selected items
1152 {
1153 const int numSelectedItems = m_list->GetSelectedItemCount();
1154
1155 if ( numSelectedItems > 0 )
1156 {
1157 long itemIndex = -1;
1158
1159 for ( ;; )
1160 {
1161 itemIndex = m_list->GetNextItem( itemIndex, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED );
1162 if ( itemIndex == -1 )
1163 break;
1164
1165 m_list->SetItemState( itemIndex, 0, wxLIST_STATE_SELECTED );
1166 }
1167 }
1168 }
1169
1170 m_list->SetItemState( item, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
1171 m_list->EnsureVisible( item );
1172
1173 m_noSelChgEvent = false;
1174
1175 return true;
1176 }
1177
1178 void wxGenericFileCtrl::DoSetFilterIndex( int filterindex )
1179 {
1180 wxClientData *pcd = m_choice->GetClientObject( filterindex );
1181 if ( !pcd )
1182 return;
1183
1184 const wxString& str = ((static_cast<wxStringClientData *>(pcd))->GetData());
1185 m_list->SetWild( str );
1186 m_filterIndex = filterindex;
1187 if ( str.Left( 2 ) == wxT( "*." ) )
1188 {
1189 m_filterExtension = str.Mid( 1 );
1190 if ( m_filterExtension == wxT( ".*" ) )
1191 m_filterExtension.clear();
1192 }
1193 else
1194 {
1195 m_filterExtension.clear();
1196 }
1197
1198 GenerateFilterChangedEvent( this, this );
1199 }
1200
1201 void wxGenericFileCtrl::SetWildcard( const wxString& wildCard )
1202 {
1203 if ( wildCard.empty() || wildCard == wxFileSelectorDefaultWildcardStr )
1204 {
1205 m_wildCard = wxString::Format( _( "All files (%s)|%s" ),
1206 wxFileSelectorDefaultWildcardStr,
1207 wxFileSelectorDefaultWildcardStr );
1208 }
1209 else
1210 m_wildCard = wildCard;
1211
1212 wxArrayString wildDescriptions, wildFilters;
1213 const size_t count = wxParseCommonDialogsFilter( m_wildCard,
1214 wildDescriptions,
1215 wildFilters );
1216 wxCHECK_RET( count, wxT( "wxFileDialog: bad wildcard string" ) );
1217
1218 m_choice->Clear();
1219
1220 for ( size_t n = 0; n < count; n++ )
1221 {
1222 m_choice->Append(wildDescriptions[n], new wxStringClientData(wildFilters[n]));
1223 }
1224
1225 SetFilterIndex( 0 );
1226 }
1227
1228 void wxGenericFileCtrl::SetFilterIndex( int filterindex )
1229 {
1230 m_choice->SetSelection( filterindex );
1231
1232 DoSetFilterIndex( filterindex );
1233 }
1234
1235 void wxGenericFileCtrl::OnChoiceFilter( wxCommandEvent &event )
1236 {
1237 DoSetFilterIndex( ( int )event.GetInt() );
1238 }
1239
1240 void wxGenericFileCtrl::OnCheck( wxCommandEvent &event )
1241 {
1242 m_list->ShowHidden( event.GetInt() != 0 );
1243 }
1244
1245 void wxGenericFileCtrl::OnActivated( wxListEvent &event )
1246 {
1247 HandleAction( event.m_item.m_text );
1248 }
1249
1250 void wxGenericFileCtrl::OnTextEnter( wxCommandEvent &WXUNUSED( event ) )
1251 {
1252 HandleAction( m_text->GetValue() );
1253 }
1254
1255 void wxGenericFileCtrl::OnTextChange( wxCommandEvent &WXUNUSED( event ) )
1256 {
1257 if ( !m_ignoreChanges )
1258 {
1259 // Clear selections. Otherwise when the user types in a value they may
1260 // not get the file whose name they typed.
1261 if ( m_list->GetSelectedItemCount() > 0 )
1262 {
1263 long item = m_list->GetNextItem( -1, wxLIST_NEXT_ALL,
1264 wxLIST_STATE_SELECTED );
1265 while ( item != -1 )
1266 {
1267 m_list->SetItemState( item, 0, wxLIST_STATE_SELECTED );
1268 item = m_list->GetNextItem( item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED );
1269 }
1270 }
1271 }
1272 }
1273
1274 void wxGenericFileCtrl::OnSelected( wxListEvent &event )
1275 {
1276 if ( m_ignoreChanges )
1277 return;
1278
1279 if ( m_inSelected )
1280 return;
1281
1282 m_inSelected = true;
1283 const wxString filename( event.m_item.m_text );
1284
1285 #ifdef __WXWINCE__
1286 // No double-click on most WinCE devices, so do action immediately.
1287 HandleAction( filename );
1288 #else
1289 if ( filename == wxT( ".." ) )
1290 {
1291 m_inSelected = false;
1292 return;
1293 }
1294
1295 wxString dir = m_list->GetDir();
1296 if ( !IsTopMostDir( dir ) )
1297 dir += wxFILE_SEP_PATH;
1298 dir += filename;
1299 if ( wxDirExists( dir ) )
1300 {
1301 m_inSelected = false;
1302
1303 return;
1304 }
1305
1306
1307 m_ignoreChanges = true;
1308 m_text->SetValue( filename );
1309
1310 if ( m_list->GetSelectedItemCount() > 1 )
1311 {
1312 m_text->Clear();
1313 }
1314
1315 if ( !m_noSelChgEvent )
1316 GenerateSelectionChangedEvent( this, this );
1317
1318 m_ignoreChanges = false;
1319 #endif
1320 m_inSelected = false;
1321 }
1322
1323 void wxGenericFileCtrl::HandleAction( const wxString &fn )
1324 {
1325 if ( m_ignoreChanges )
1326 return;
1327
1328 wxString filename( fn );
1329 if ( filename.empty() )
1330 {
1331 return;
1332 }
1333 if ( filename == wxT( "." ) ) return;
1334
1335 wxString dir = m_list->GetDir();
1336
1337 // "some/place/" means they want to chdir not try to load "place"
1338 const bool want_dir = filename.Last() == wxFILE_SEP_PATH;
1339 if ( want_dir )
1340 filename = filename.RemoveLast();
1341
1342 if ( filename == wxT( ".." ) )
1343 {
1344 m_ignoreChanges = true;
1345 m_list->GoToParentDir();
1346
1347 GenerateFolderChangedEvent( this, this );
1348
1349 UpdateControls();
1350 m_ignoreChanges = false;
1351 return;
1352 }
1353
1354 #ifdef __UNIX__
1355 if ( filename == wxT( "~" ) )
1356 {
1357 m_ignoreChanges = true;
1358 m_list->GoToHomeDir();
1359
1360 GenerateFolderChangedEvent( this, this );
1361
1362 UpdateControls();
1363 m_ignoreChanges = false;
1364 return;
1365 }
1366
1367 if ( filename.BeforeFirst( wxT( '/' ) ) == wxT( "~" ) )
1368 {
1369 filename = wxString( wxGetUserHome() ) + filename.Remove( 0, 1 );
1370 }
1371 #endif // __UNIX__
1372
1373 if ( !( m_style & wxFC_SAVE ) )
1374 {
1375 if ( ( filename.Find( wxT( '*' ) ) != wxNOT_FOUND ) ||
1376 ( filename.Find( wxT( '?' ) ) != wxNOT_FOUND ) )
1377 {
1378 if ( filename.Find( wxFILE_SEP_PATH ) != wxNOT_FOUND )
1379 {
1380 wxMessageBox( _( "Illegal file specification." ),
1381 _( "Error" ), wxOK | wxICON_ERROR, this );
1382 return;
1383 }
1384 m_list->SetWild( filename );
1385 return;
1386 }
1387 }
1388
1389 if ( !IsTopMostDir( dir ) )
1390 dir += wxFILE_SEP_PATH;
1391 if ( !wxIsAbsolutePath( filename ) )
1392 {
1393 dir += filename;
1394 filename = dir;
1395 }
1396
1397 if ( wxDirExists( filename ) )
1398 {
1399 m_ignoreChanges = true;
1400 m_list->GoToDir( filename );
1401 UpdateControls();
1402
1403 GenerateFolderChangedEvent( this, this );
1404
1405 m_ignoreChanges = false;
1406 return;
1407 }
1408
1409 // they really wanted a dir, but it doesn't exist
1410 if ( want_dir )
1411 {
1412 wxMessageBox( _( "Directory doesn't exist." ), _( "Error" ),
1413 wxOK | wxICON_ERROR, this );
1414 return;
1415 }
1416
1417 // append the default extension to the filename if it doesn't have any
1418 //
1419 // VZ: the logic of testing for !wxFileExists() only for the open file
1420 // dialog is not entirely clear to me, why don't we allow saving to a
1421 // file without extension as well?
1422 if ( !( m_style & wxFC_OPEN ) || !wxFileExists( filename ) )
1423 {
1424 filename = wxFileDialogBase::AppendExtension( filename, m_filterExtension );
1425 GenerateFileActivatedEvent( this, this, wxFileName( filename ).GetFullName() );
1426 return;
1427 }
1428
1429 GenerateFileActivatedEvent( this, this );
1430 }
1431
1432 bool wxGenericFileCtrl::SetPath( const wxString& path )
1433 {
1434 if ( !wxFileName::FileExists( ( path ) ) )
1435 return false;
1436
1437 wxString ext;
1438 wxFileName::SplitPath( path, &m_dir, &m_fileName, &ext );
1439 if ( !ext.empty() )
1440 {
1441 m_fileName += wxT( "." );
1442 m_fileName += ext;
1443 }
1444
1445 SetDirectory( m_dir );
1446 SetFilename( m_fileName );
1447
1448 return true;
1449 }
1450
1451 void wxGenericFileCtrl::GetPaths( wxArrayString& paths ) const
1452 {
1453 DoGetFilenames( paths, true );
1454 }
1455
1456 void wxGenericFileCtrl::GetFilenames( wxArrayString& files ) const
1457 {
1458 DoGetFilenames( files, false );
1459 }
1460
1461 void wxGenericFileCtrl::UpdateControls()
1462 {
1463 const wxString dir = m_list->GetDir();
1464 m_static->SetLabel( dir );
1465 }
1466
1467 void wxGenericFileCtrl::GoToParentDir()
1468 {
1469 m_list->GoToParentDir();
1470 UpdateControls();
1471 }
1472
1473 void wxGenericFileCtrl::GoToHomeDir()
1474 {
1475 m_list->GoToHomeDir();
1476 UpdateControls();
1477 }
1478
1479 #endif // wxUSE_FILECTRL
wxWidgets (Impactor)