]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/generic/dirctrlg.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
bracketing msw enhanced metafile usage
[wxWidgets.git] / src / generic / dirctrlg.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/generic/dirctrlg.cpp
3// Purpose: wxGenericDirCtrl
4// Author: Harm van der Heijden, Robert Roebling, Julian Smart
5// Modified by:
6// Created: 12/12/98
7// RCS-ID: $Id$
8// Copyright: (c) Harm van der Heijden, Robert Roebling and Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// For compilers that support precompilation, includes "wx.h".
13#include "wx/wxprec.h"
14
15#ifdef __BORLANDC__
16 #pragma hdrstop
17#endif
18
19#if wxUSE_DIRDLG || wxUSE_FILEDLG
20
21#include "wx/generic/dirctrlg.h"
22
23#ifndef WX_PRECOMP
24 #include "wx/hash.h"
25 #include "wx/intl.h"
26 #include "wx/log.h"
27 #include "wx/utils.h"
28 #include "wx/button.h"
29 #include "wx/icon.h"
30 #include "wx/settings.h"
31 #include "wx/msgdlg.h"
32 #include "wx/cmndata.h"
33 #include "wx/choice.h"
34 #include "wx/textctrl.h"
35 #include "wx/layout.h"
36 #include "wx/sizer.h"
37 #include "wx/textdlg.h"
38 #include "wx/gdicmn.h"
39 #include "wx/image.h"
40 #include "wx/module.h"
41#endif
42
43#include "wx/filename.h"
44#include "wx/filefn.h"
45#include "wx/imaglist.h"
46#include "wx/tokenzr.h"
47#include "wx/dir.h"
48#include "wx/artprov.h"
49#include "wx/mimetype.h"
50
51#if wxUSE_STATLINE
52 #include "wx/statline.h"
53#endif
54
55#if defined(__WXMAC__)
56 #include "wx/osx/private.h" // includes mac headers
57#endif
58
59#ifdef __WXMSW__
60#include <windows.h>
61#include "wx/msw/winundef.h"
62#include "wx/volume.h"
63
64// FIXME - Mingw32 1.0 has both _getdrive() and _chdrive(). For now, let's assume
65// older releases don't, but it should be verified and the checks modified
66// accordingly.
67#if !defined(__GNUWIN32__) || (defined(__MINGW32_MAJOR_VERSION) && __MINGW32_MAJOR_VERSION >= 1)
68#if !defined(__WXWINCE__)
69 #include <direct.h>
70#endif
71 #include <stdlib.h>
72 #include <ctype.h>
73#endif
74
75#endif
76
77#if defined(__OS2__) || defined(__DOS__)
78 #ifdef __OS2__
79 #define INCL_BASE
80 #include <os2.h>
81 #ifndef __EMX__
82 #include <direct.h>
83 #endif
84 #include <stdlib.h>
85 #include <ctype.h>
86 #endif
87#endif // __OS2__
88
89#if defined(__WXMAC__)
90// #include "MoreFilesX.h"
91#endif
92
93#ifdef __BORLANDC__
94 #include "dos.h"
95#endif
96
97extern WXDLLEXPORT_DATA(const char) wxFileSelectorDefaultWildcardStr[];
98
99// If compiled under Windows, this macro can cause problems
100#ifdef GetFirstChild
101#undef GetFirstChild
102#endif
103
104bool wxIsDriveAvailable(const wxString& dirName);
105
106// ----------------------------------------------------------------------------
107// wxGetAvailableDrives, for WINDOWS, DOS, OS2, MAC, UNIX (returns "/")
108// ----------------------------------------------------------------------------
109
110size_t wxGetAvailableDrives(wxArrayString &paths, wxArrayString &names, wxArrayInt &icon_ids)
111{
112#ifdef wxHAS_FILESYSTEM_VOLUMES
113
114#ifdef __WXWINCE__
115 // No logical drives; return "\"
116 paths.Add(wxT("\\"));
117 names.Add(wxT("\\"));
118 icon_ids.Add(wxFileIconsTable::computer);
119#elif defined(__WIN32__) && wxUSE_FSVOLUME
120 // TODO: this code (using wxFSVolumeBase) should be used for all platforms
121 // but unfortunately wxFSVolumeBase is not implemented everywhere
122 const wxArrayString as = wxFSVolumeBase::GetVolumes();
123
124 for (size_t i = 0; i < as.GetCount(); i++)
125 {
126 wxString path = as[i];
127 wxFSVolume vol(path);
128 int imageId;
129 switch (vol.GetKind())
130 {
131 case wxFS_VOL_FLOPPY:
132 if ( (path == wxT("a:\\")) || (path == wxT("b:\\")) )
133 imageId = wxFileIconsTable::floppy;
134 else
135 imageId = wxFileIconsTable::removeable;
136 break;
137 case wxFS_VOL_DVDROM:
138 case wxFS_VOL_CDROM:
139 imageId = wxFileIconsTable::cdrom;
140 break;
141 case wxFS_VOL_NETWORK:
142 if (path[0] == wxT('\\'))
143 continue; // skip "\\computer\folder"
144 imageId = wxFileIconsTable::drive;
145 break;
146 case wxFS_VOL_DISK:
147 case wxFS_VOL_OTHER:
148 default:
149 imageId = wxFileIconsTable::drive;
150 break;
151 }
152 paths.Add(path);
153 names.Add(vol.GetDisplayName());
154 icon_ids.Add(imageId);
155 }
156#elif defined(__OS2__)
157 APIRET rc;
158 ULONG ulDriveNum = 0;
159 ULONG ulDriveMap = 0;
160 rc = ::DosQueryCurrentDisk(&ulDriveNum, &ulDriveMap);
161 if ( rc == 0)
162 {
163 size_t i = 0;
164 while (i < 26)
165 {
166 if (ulDriveMap & ( 1 << i ))
167 {
168 const wxString path = wxFileName::GetVolumeString(
169 'A' + i, wxPATH_GET_SEPARATOR);
170 const wxString name = wxFileName::GetVolumeString(
171 'A' + i, wxPATH_NO_SEPARATOR);
172
173 // Note: If _filesys is unsupported by some compilers,
174 // we can always replace it by DosQueryFSAttach
175 char filesysname[20];
176#ifdef __WATCOMC__
177 ULONG cbBuffer = sizeof(filesysname);
178 PFSQBUFFER2 pfsqBuffer = (PFSQBUFFER2)filesysname;
179 APIRET rc = ::DosQueryFSAttach(name.fn_str(),0,FSAIL_QUERYNAME,pfsqBuffer,&cbBuffer);
180 if (rc != NO_ERROR)
181 {
182 filesysname[0] = '\0';
183 }
184#else
185 _filesys(name.fn_str(), filesysname, sizeof(filesysname));
186#endif
187 /* FAT, LAN, HPFS, CDFS, NFS */
188 int imageId;
189 if (path == wxT("A:\\") || path == wxT("B:\\"))
190 imageId = wxFileIconsTable::floppy;
191 else if (!strcmp(filesysname, "CDFS"))
192 imageId = wxFileIconsTable::cdrom;
193 else if (!strcmp(filesysname, "LAN") ||
194 !strcmp(filesysname, "NFS"))
195 imageId = wxFileIconsTable::drive;
196 else
197 imageId = wxFileIconsTable::drive;
198 paths.Add(path);
199 names.Add(name);
200 icon_ids.Add(imageId);
201 }
202 i ++;
203 }
204 }
205#else // !__WIN32__, !__OS2__
206 /* If we can switch to the drive, it exists. */
207 for ( char drive = 'A'; drive <= 'Z'; drive++ )
208 {
209 const wxString
210 path = wxFileName::GetVolumeString(drive, wxPATH_GET_SEPARATOR);
211
212 if (wxIsDriveAvailable(path))
213 {
214 paths.Add(path);
215 names.Add(wxFileName::GetVolumeString(drive, wxPATH_NO_SEPARATOR));
216 icon_ids.Add(drive <= 2 ? wxFileIconsTable::floppy
217 : wxFileIconsTable::drive);
218 }
219 }
220#endif // __WIN32__/!__WIN32__
221
222#elif defined(__WXMAC__) && wxOSX_USE_COCOA_OR_CARBON
223
224 ItemCount volumeIndex = 1;
225 OSErr err = noErr ;
226
227 while( noErr == err )
228 {
229 HFSUniStr255 volumeName ;
230 FSRef fsRef ;
231 FSVolumeInfo volumeInfo ;
232 err = FSGetVolumeInfo(0, volumeIndex, NULL, kFSVolInfoFlags , &volumeInfo , &volumeName, &fsRef);
233 if( noErr == err )
234 {
235 wxString path = wxMacFSRefToPath( &fsRef ) ;
236 wxString name = wxMacHFSUniStrToString( &volumeName ) ;
237
238 if ( (volumeInfo.flags & kFSVolFlagSoftwareLockedMask) || (volumeInfo.flags & kFSVolFlagHardwareLockedMask) )
239 {
240 icon_ids.Add(wxFileIconsTable::cdrom);
241 }
242 else
243 {
244 icon_ids.Add(wxFileIconsTable::drive);
245 }
246 // todo other removable
247
248 paths.Add(path);
249 names.Add(name);
250 volumeIndex++ ;
251 }
252 }
253
254#elif defined(__UNIX__) || defined(__WXPALMOS__)
255 paths.Add(wxT("/"));
256 names.Add(wxT("/"));
257 icon_ids.Add(wxFileIconsTable::computer);
258#else
259 #error "Unsupported platform in wxGenericDirCtrl!"
260#endif
261 wxASSERT_MSG( (paths.GetCount() == names.GetCount()), wxT("The number of paths and their human readable names should be equal in number."));
262 wxASSERT_MSG( (paths.GetCount() == icon_ids.GetCount()), wxT("Wrong number of icons for available drives."));
263 return paths.GetCount();
264}
265
266// ----------------------------------------------------------------------------
267// wxIsDriveAvailable
268// ----------------------------------------------------------------------------
269
270#if defined(__DOS__)
271
272bool wxIsDriveAvailable(const wxString& dirName)
273{
274 // FIXME_MGL - this method leads to hang up under Watcom for some reason
275#ifdef __WATCOMC__
276 wxUnusedVar(dirName);
277#else
278 if ( dirName.length() == 3 && dirName[1u] == wxT(':') )
279 {
280 wxString dirNameLower(dirName.Lower());
281 // VS: always return true for removable media, since Win95 doesn't
282 // like it when MS-DOS app accesses empty floppy drive
283 return (dirNameLower[0u] == wxT('a') ||
284 dirNameLower[0u] == wxT('b') ||
285 wxDirExists(dirNameLower));
286 }
287 else
288#endif
289 return true;
290}
291
292#elif defined(__WINDOWS__) || defined(__OS2__)
293
294int setdrive(int WXUNUSED_IN_WINCE(drive))
295{
296#ifdef __WXWINCE__
297 return 0;
298#elif defined(__GNUWIN32__) && \
299 (defined(__MINGW32_MAJOR_VERSION) && __MINGW32_MAJOR_VERSION >= 1)
300 return _chdrive(drive);
301#else
302 wxChar newdrive[4];
303
304 if (drive < 1 || drive > 31)
305 return -1;
306 newdrive[0] = (wxChar)(wxT('A') + drive - 1);
307 newdrive[1] = wxT(':');
308#ifdef __OS2__
309 newdrive[2] = wxT('\\');
310 newdrive[3] = wxT('\0');
311#else
312 newdrive[2] = wxT('\0');
313#endif
314#if defined(__WXMSW__)
315 if (::SetCurrentDirectory(newdrive))
316#else
317 // VA doesn't know what LPSTR is and has its own set
318 if (!DosSetCurrentDir((PSZ)newdrive))
319#endif
320 return 0;
321 else
322 return -1;
323#endif // !GNUWIN32
324}
325
326bool wxIsDriveAvailable(const wxString& WXUNUSED_IN_WINCE(dirName))
327{
328#ifdef __WXWINCE__
329 return false;
330#else
331#ifdef __WIN32__
332 UINT errorMode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
333#endif
334 bool success = true;
335
336 // Check if this is a root directory and if so,
337 // whether the drive is available.
338 if (dirName.length() == 3 && dirName[(size_t)1] == wxT(':'))
339 {
340 wxString dirNameLower(dirName.Lower());
341#if defined(__GNUWIN32__) && !(defined(__MINGW32_MAJOR_VERSION) && __MINGW32_MAJOR_VERSION >= 1)
342 success = wxDirExists(dirNameLower);
343#else
344 #if defined(__OS2__)
345 // Avoid changing to drive since no media may be inserted.
346 if (dirNameLower[(size_t)0] == 'a' || dirNameLower[(size_t)0] == 'b')
347 return success;
348 #endif
349 int currentDrive = _getdrive();
350 int thisDrive = (int) (dirNameLower[(size_t)0] - 'a' + 1) ;
351 int err = setdrive( thisDrive ) ;
352 setdrive( currentDrive );
353
354 if (err == -1)
355 {
356 success = false;
357 }
358#endif
359 }
360#ifdef __WIN32__
361 (void) SetErrorMode(errorMode);
362#endif
363
364 return success;
365#endif
366}
367#endif // __WINDOWS__ || __OS2__
368
369#endif // wxUSE_DIRDLG || wxUSE_FILEDLG
370
371
372
373#if wxUSE_DIRDLG
374
375// Function which is called by quick sort. We want to override the default wxArrayString behaviour,
376// and sort regardless of case.
377static int wxCMPFUNC_CONV wxDirCtrlStringCompareFunction(const wxString& strFirst, const wxString& strSecond)
378{
379 return strFirst.CmpNoCase(strSecond);
380}
381
382//-----------------------------------------------------------------------------
383// wxDirItemData
384//-----------------------------------------------------------------------------
385
386wxDirItemData::wxDirItemData(const wxString& path, const wxString& name,
387 bool isDir)
388{
389 m_path = path;
390 m_name = name;
391 /* Insert logic to detect hidden files here
392 * In UnixLand we just check whether the first char is a dot
393 * For FileNameFromPath read LastDirNameInThisPath ;-) */
394 // m_isHidden = (bool)(wxFileNameFromPath(*m_path)[0] == '.');
395 m_isHidden = false;
396 m_isExpanded = false;
397 m_isDir = isDir;
398}
399
400void wxDirItemData::SetNewDirName(const wxString& path)
401{
402 m_path = path;
403 m_name = wxFileNameFromPath(path);
404}
405
406bool wxDirItemData::HasSubDirs() const
407{
408 if (m_path.empty())
409 return false;
410
411 wxDir dir;
412 {
413 wxLogNull nolog;
414 if ( !dir.Open(m_path) )
415 return false;
416 }
417
418 return dir.HasSubDirs();
419}
420
421bool wxDirItemData::HasFiles(const wxString& WXUNUSED(spec)) const
422{
423 if (m_path.empty())
424 return false;
425
426 wxDir dir;
427 {
428 wxLogNull nolog;
429 if ( !dir.Open(m_path) )
430 return false;
431 }
432
433 return dir.HasFiles();
434}
435
436//-----------------------------------------------------------------------------
437// wxGenericDirCtrl
438//-----------------------------------------------------------------------------
439
440
441#if wxUSE_EXTENDED_RTTI
442WX_DEFINE_FLAGS( wxGenericDirCtrlStyle )
443
444wxBEGIN_FLAGS( wxGenericDirCtrlStyle )
445 // new style border flags, we put them first to
446 // use them for streaming out
447 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
448 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
449 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
450 wxFLAGS_MEMBER(wxBORDER_RAISED)
451 wxFLAGS_MEMBER(wxBORDER_STATIC)
452 wxFLAGS_MEMBER(wxBORDER_NONE)
453
454 // old style border flags
455 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
456 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
457 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
458 wxFLAGS_MEMBER(wxRAISED_BORDER)
459 wxFLAGS_MEMBER(wxSTATIC_BORDER)
460 wxFLAGS_MEMBER(wxBORDER)
461
462 // standard window styles
463 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
464 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
465 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
466 wxFLAGS_MEMBER(wxWANTS_CHARS)
467 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
468 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
469 wxFLAGS_MEMBER(wxVSCROLL)
470 wxFLAGS_MEMBER(wxHSCROLL)
471
472 wxFLAGS_MEMBER(wxDIRCTRL_DIR_ONLY)
473 wxFLAGS_MEMBER(wxDIRCTRL_3D_INTERNAL)
474 wxFLAGS_MEMBER(wxDIRCTRL_SELECT_FIRST)
475 wxFLAGS_MEMBER(wxDIRCTRL_MULTIPLE)
476
477wxEND_FLAGS( wxGenericDirCtrlStyle )
478
479IMPLEMENT_DYNAMIC_CLASS_XTI(wxGenericDirCtrl, wxControl,"wx/dirctrl.h")
480
481wxBEGIN_PROPERTIES_TABLE(wxGenericDirCtrl)
482 wxHIDE_PROPERTY( Children )
483 wxPROPERTY( DefaultPath , wxString , SetDefaultPath , GetDefaultPath , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
484 wxPROPERTY( Filter , wxString , SetFilter , GetFilter , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
485 wxPROPERTY( DefaultFilter , int , SetFilterIndex, GetFilterIndex, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
486 wxPROPERTY_FLAGS( WindowStyle, wxGenericDirCtrlStyle, long, SetWindowStyleFlag, GetWindowStyleFlag, EMPTY_MACROVALUE , 0, wxT("Helpstring"), wxT("group") )
487wxEND_PROPERTIES_TABLE()
488
489wxBEGIN_HANDLERS_TABLE(wxGenericDirCtrl)
490wxEND_HANDLERS_TABLE()
491
492wxCONSTRUCTOR_8( wxGenericDirCtrl , wxWindow* , Parent , wxWindowID , Id , wxString , DefaultPath ,
493 wxPoint , Position , wxSize , Size , long , WindowStyle , wxString , Filter , int , DefaultFilter )
494#else
495IMPLEMENT_DYNAMIC_CLASS(wxGenericDirCtrl, wxControl)
496#endif
497
498BEGIN_EVENT_TABLE(wxGenericDirCtrl, wxControl)
499 EVT_TREE_ITEM_EXPANDING (wxID_TREECTRL, wxGenericDirCtrl::OnExpandItem)
500 EVT_TREE_ITEM_COLLAPSED (wxID_TREECTRL, wxGenericDirCtrl::OnCollapseItem)
501 EVT_TREE_BEGIN_LABEL_EDIT (wxID_TREECTRL, wxGenericDirCtrl::OnBeginEditItem)
502 EVT_TREE_END_LABEL_EDIT (wxID_TREECTRL, wxGenericDirCtrl::OnEndEditItem)
503 EVT_SIZE (wxGenericDirCtrl::OnSize)
504END_EVENT_TABLE()
505
506wxGenericDirCtrl::wxGenericDirCtrl(void)
507{
508 Init();
509}
510
511void wxGenericDirCtrl::ExpandRoot()
512{
513 ExpandDir(m_rootId); // automatically expand first level
514
515 // Expand and select the default path
516 if (!m_defaultPath.empty())
517 {
518 ExpandPath(m_defaultPath);
519 }
520#ifdef __UNIX__
521 else
522 {
523 // On Unix, there's only one node under the (hidden) root node. It
524 // represents the / path, so the user would always have to expand it;
525 // let's do it ourselves
526 ExpandPath( wxT("/") );
527 }
528#endif
529}
530
531bool wxGenericDirCtrl::Create(wxWindow *parent,
532 const wxWindowID id,
533 const wxString& dir,
534 const wxPoint& pos,
535 const wxSize& size,
536 long style,
537 const wxString& filter,
538 int defaultFilter,
539 const wxString& name)
540{
541 if (!wxControl::Create(parent, id, pos, size, style, wxDefaultValidator, name))
542 return false;
543
544 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
545 SetForegroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
546
547 Init();
548
549 long treeStyle = wxTR_HAS_BUTTONS;
550
551 // On Windows CE, if you hide the root, you get a crash when
552 // attempting to access data for children of the root item.
553#ifndef __WXWINCE__
554 treeStyle |= wxTR_HIDE_ROOT;
555#endif
556
557#ifdef __WXGTK20__
558 treeStyle |= wxTR_NO_LINES;
559#endif
560
561 if (style & wxDIRCTRL_EDIT_LABELS)
562 treeStyle |= wxTR_EDIT_LABELS;
563
564 if (style & wxDIRCTRL_MULTIPLE)
565 treeStyle |= wxTR_MULTIPLE;
566
567 if ((style & wxDIRCTRL_3D_INTERNAL) == 0)
568 treeStyle |= wxNO_BORDER;
569
570 m_treeCtrl = CreateTreeCtrl(this, wxID_TREECTRL,
571 wxPoint(0,0), GetClientSize(), treeStyle);
572
573 if (!filter.empty())
574 m_filterListCtrl = new wxDirFilterListCtrl(this, wxID_FILTERLISTCTRL);
575
576 m_defaultPath = dir;
577 m_filter = filter;
578
579 if (m_filter.empty())
580 m_filter = wxFileSelectorDefaultWildcardStr;
581
582 SetFilterIndex(defaultFilter);
583
584 if (m_filterListCtrl)
585 m_filterListCtrl->FillFilterList(filter, defaultFilter);
586
587 m_treeCtrl->SetImageList(wxTheFileIconsTable->GetSmallImageList());
588
589 m_showHidden = false;
590 wxDirItemData* rootData = new wxDirItemData(wxEmptyString, wxEmptyString, true);
591
592 wxString rootName;
593
594#if defined(__WINDOWS__) || defined(__OS2__) || defined(__DOS__)
595 rootName = _("Computer");
596#else
597 rootName = _("Sections");
598#endif
599
600 m_rootId = m_treeCtrl->AddRoot( rootName, 3, -1, rootData);
601 m_treeCtrl->SetItemHasChildren(m_rootId);
602
603 ExpandRoot();
604
605 SetInitialSize(size);
606 DoResize();
607
608 return true;
609}
610
611wxGenericDirCtrl::~wxGenericDirCtrl()
612{
613}
614
615void wxGenericDirCtrl::Init()
616{
617 m_showHidden = false;
618 m_currentFilter = 0;
619 m_currentFilterStr = wxEmptyString; // Default: any file
620 m_treeCtrl = NULL;
621 m_filterListCtrl = NULL;
622}
623
624wxTreeCtrl* wxGenericDirCtrl::CreateTreeCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long treeStyle)
625{
626 return new wxTreeCtrl(parent, id, pos, size, treeStyle);
627}
628
629void wxGenericDirCtrl::ShowHidden( bool show )
630{
631 if ( m_showHidden == show )
632 return;
633
634 m_showHidden = show;
635
636 if ( HasFlag(wxDIRCTRL_MULTIPLE) )
637 {
638 wxArrayString paths;
639 GetPaths(paths);
640 ReCreateTree();
641 for ( unsigned n = 0; n < paths.size(); n++ )
642 {
643 ExpandPath(paths[n]);
644 }
645 }
646 else
647 {
648 wxString path = GetPath();
649 ReCreateTree();
650 SetPath(path);
651 }
652}
653
654const wxTreeItemId
655wxGenericDirCtrl::AddSection(const wxString& path, const wxString& name, int imageId)
656{
657 wxDirItemData *dir_item = new wxDirItemData(path,name,true);
658
659 wxTreeItemId id = AppendItem( m_rootId, name, imageId, -1, dir_item);
660
661 m_treeCtrl->SetItemHasChildren(id);
662
663 return id;
664}
665
666void wxGenericDirCtrl::SetupSections()
667{
668 wxArrayString paths, names;
669 wxArrayInt icons;
670
671 size_t n, count = wxGetAvailableDrives(paths, names, icons);
672
673#ifdef __WXGTK20__
674 wxString home = wxGetHomeDir();
675 AddSection( home, _("Home directory"), 1);
676 home += wxT("/Desktop");
677 AddSection( home, _("Desktop"), 1);
678#endif
679
680 for (n = 0; n < count; n++)
681 AddSection(paths[n], names[n], icons[n]);
682}
683
684void wxGenericDirCtrl::SetFocus()
685{
686 // we don't need focus ourselves, give it to the tree so that the user
687 // could navigate it
688 if (m_treeCtrl)
689 m_treeCtrl->SetFocus();
690}
691
692void wxGenericDirCtrl::OnBeginEditItem(wxTreeEvent &event)
693{
694 // don't rename the main entry "Sections"
695 if (event.GetItem() == m_rootId)
696 {
697 event.Veto();
698 return;
699 }
700
701 // don't rename the individual sections
702 if (m_treeCtrl->GetItemParent( event.GetItem() ) == m_rootId)
703 {
704 event.Veto();
705 return;
706 }
707}
708
709void wxGenericDirCtrl::OnEndEditItem(wxTreeEvent &event)
710{
711 if (event.IsEditCancelled())
712 return;
713
714 if ((event.GetLabel().empty()) ||
715 (event.GetLabel() == wxT(".")) ||
716 (event.GetLabel() == wxT("..")) ||
717 (event.GetLabel().Find(wxT('/')) != wxNOT_FOUND) ||
718 (event.GetLabel().Find(wxT('\\')) != wxNOT_FOUND) ||
719 (event.GetLabel().Find(wxT('|')) != wxNOT_FOUND))
720 {
721 wxMessageDialog dialog(this, _("Illegal directory name."), _("Error"), wxOK | wxICON_ERROR );
722 dialog.ShowModal();
723 event.Veto();
724 return;
725 }
726
727 wxTreeItemId id = event.GetItem();
728 wxDirItemData *data = (wxDirItemData*)m_treeCtrl->GetItemData( id );
729 wxASSERT( data );
730
731 wxString new_name( wxPathOnly( data->m_path ) );
732 new_name += wxString(wxFILE_SEP_PATH);
733 new_name += event.GetLabel();
734
735 wxLogNull log;
736
737 if (wxFileExists(new_name))
738 {
739 wxMessageDialog dialog(this, _("File name exists already."), _("Error"), wxOK | wxICON_ERROR );
740 dialog.ShowModal();
741 event.Veto();
742 }
743
744 if (wxRenameFile(data->m_path,new_name))
745 {
746 data->SetNewDirName( new_name );
747 }
748 else
749 {
750 wxMessageDialog dialog(this, _("Operation not permitted."), _("Error"), wxOK | wxICON_ERROR );
751 dialog.ShowModal();
752 event.Veto();
753 }
754}
755
756void wxGenericDirCtrl::OnExpandItem(wxTreeEvent &event)
757{
758 wxTreeItemId parentId = event.GetItem();
759
760 // VS: this is needed because the event handler is called from wxTreeCtrl
761 // ctor when wxTR_HIDE_ROOT was specified
762
763 if (!m_rootId.IsOk())
764 m_rootId = m_treeCtrl->GetRootItem();
765
766 ExpandDir(parentId);
767}
768
769void wxGenericDirCtrl::OnCollapseItem(wxTreeEvent &event )
770{
771 CollapseDir(event.GetItem());
772}
773
774void wxGenericDirCtrl::CollapseDir(wxTreeItemId parentId)
775{
776 wxTreeItemId child;
777
778 wxDirItemData *data = (wxDirItemData *) m_treeCtrl->GetItemData(parentId);
779 if (!data->m_isExpanded)
780 return;
781
782 data->m_isExpanded = false;
783
784 m_treeCtrl->Freeze();
785 if (parentId != m_treeCtrl->GetRootItem())
786 m_treeCtrl->CollapseAndReset(parentId);
787 m_treeCtrl->DeleteChildren(parentId);
788 m_treeCtrl->Thaw();
789}
790
791void wxGenericDirCtrl::PopulateNode(wxTreeItemId parentId)
792{
793 wxDirItemData *data = (wxDirItemData *) m_treeCtrl->GetItemData(parentId);
794
795 if (data->m_isExpanded)
796 return;
797
798 data->m_isExpanded = true;
799
800 if (parentId == m_treeCtrl->GetRootItem())
801 {
802 SetupSections();
803 return;
804 }
805
806 wxASSERT(data);
807
808 wxString search,path,filename;
809
810 wxString dirName(data->m_path);
811
812#if (defined(__WINDOWS__) && !defined(__WXWINCE__)) || defined(__DOS__) || defined(__OS2__)
813 // Check if this is a root directory and if so,
814 // whether the drive is avaiable.
815 if (!wxIsDriveAvailable(dirName))
816 {
817 data->m_isExpanded = false;
818 //wxMessageBox(wxT("Sorry, this drive is not available."));
819 return;
820 }
821#endif
822
823 // This may take a longish time. Go to busy cursor
824 wxBusyCursor busy;
825
826#if defined(__WINDOWS__) || defined(__DOS__) || defined(__OS2__)
827 if (dirName.Last() == ':')
828 dirName += wxString(wxFILE_SEP_PATH);
829#endif
830
831 wxArrayString dirs;
832 wxArrayString filenames;
833
834 wxDir d;
835 wxString eachFilename;
836
837 wxLogNull log;
838 d.Open(dirName);
839
840 if (d.IsOpened())
841 {
842 int style = wxDIR_DIRS;
843 if (m_showHidden) style |= wxDIR_HIDDEN;
844 if (d.GetFirst(& eachFilename, wxEmptyString, style))
845 {
846 do
847 {
848 if ((eachFilename != wxT(".")) && (eachFilename != wxT("..")))
849 {
850 dirs.Add(eachFilename);
851 }
852 }
853 while (d.GetNext(&eachFilename));
854 }
855 }
856 dirs.Sort(wxDirCtrlStringCompareFunction);
857
858 // Now do the filenames -- but only if we're allowed to
859 if (!HasFlag(wxDIRCTRL_DIR_ONLY))
860 {
861 d.Open(dirName);
862
863 if (d.IsOpened())
864 {
865 int style = wxDIR_FILES;
866 if (m_showHidden) style |= wxDIR_HIDDEN;
867 // Process each filter (ex: "JPEG Files (*.jpg;*.jpeg)|*.jpg;*.jpeg")
868 wxStringTokenizer strTok;
869 wxString curFilter;
870 strTok.SetString(m_currentFilterStr,wxT(";"));
871 while(strTok.HasMoreTokens())
872 {
873 curFilter = strTok.GetNextToken();
874 if (d.GetFirst(& eachFilename, curFilter, style))
875 {
876 do
877 {
878 if ((eachFilename != wxT(".")) && (eachFilename != wxT("..")))
879 {
880 filenames.Add(eachFilename);
881 }
882 }
883 while (d.GetNext(& eachFilename));
884 }
885 }
886 }
887 filenames.Sort(wxDirCtrlStringCompareFunction);
888 }
889
890 // Now we really know whether we have any children so tell the tree control
891 // about it.
892 m_treeCtrl->SetItemHasChildren(parentId, !dirs.empty() || !filenames.empty());
893
894 // Add the sorted dirs
895 size_t i;
896 for (i = 0; i < dirs.GetCount(); i++)
897 {
898 eachFilename = dirs[i];
899 path = dirName;
900 if (!wxEndsWithPathSeparator(path))
901 path += wxString(wxFILE_SEP_PATH);
902 path += eachFilename;
903
904 wxDirItemData *dir_item = new wxDirItemData(path,eachFilename,true);
905 wxTreeItemId id = AppendItem( parentId, eachFilename,
906 wxFileIconsTable::folder, -1, dir_item);
907 m_treeCtrl->SetItemImage( id, wxFileIconsTable::folder_open,
908 wxTreeItemIcon_Expanded );
909
910 // assume that it does have children by default as it can take a long
911 // time to really check for this (think remote drives...)
912 //
913 // and if we're wrong, we'll correct the icon later if
914 // the user really tries to open this item
915 m_treeCtrl->SetItemHasChildren(id);
916 }
917
918 // Add the sorted filenames
919 if (!HasFlag(wxDIRCTRL_DIR_ONLY))
920 {
921 for (i = 0; i < filenames.GetCount(); i++)
922 {
923 eachFilename = filenames[i];
924 path = dirName;
925 if (!wxEndsWithPathSeparator(path))
926 path += wxString(wxFILE_SEP_PATH);
927 path += eachFilename;
928 //path = dirName + wxString(wxT("/")) + eachFilename;
929 wxDirItemData *dir_item = new wxDirItemData(path,eachFilename,false);
930 int image_id = wxFileIconsTable::file;
931 if (eachFilename.Find(wxT('.')) != wxNOT_FOUND)
932 image_id = wxTheFileIconsTable->GetIconID(eachFilename.AfterLast(wxT('.')));
933 (void) AppendItem( parentId, eachFilename, image_id, -1, dir_item);
934 }
935 }
936}
937
938void wxGenericDirCtrl::ExpandDir(wxTreeItemId parentId)
939{
940 // ExpandDir() will not actually expand the tree node, just populate it
941 PopulateNode(parentId);
942}
943
944void wxGenericDirCtrl::ReCreateTree()
945{
946 CollapseDir(m_treeCtrl->GetRootItem());
947 ExpandRoot();
948}
949
950void wxGenericDirCtrl::CollapseTree()
951{
952 wxTreeItemIdValue cookie;
953 wxTreeItemId child = m_treeCtrl->GetFirstChild(m_rootId, cookie);
954 while (child.IsOk())
955 {
956 CollapseDir(child);
957 child = m_treeCtrl->GetNextChild(m_rootId, cookie);
958 }
959}
960
961// Find the child that matches the first part of 'path'.
962// E.g. if a child path is "/usr" and 'path' is "/usr/include"
963// then the child for /usr is returned.
964wxTreeItemId wxGenericDirCtrl::FindChild(wxTreeItemId parentId, const wxString& path, bool& done)
965{
966 wxString path2(path);
967
968 // Make sure all separators are as per the current platform
969 path2.Replace(wxT("\\"), wxString(wxFILE_SEP_PATH));
970 path2.Replace(wxT("/"), wxString(wxFILE_SEP_PATH));
971
972 // Append a separator to foil bogus substring matching
973 path2 += wxString(wxFILE_SEP_PATH);
974
975 // In MSW or PM, case is not significant
976#if defined(__WINDOWS__) || defined(__DOS__) || defined(__OS2__)
977 path2.MakeLower();
978#endif
979
980 wxTreeItemIdValue cookie;
981 wxTreeItemId childId = m_treeCtrl->GetFirstChild(parentId, cookie);
982 while (childId.IsOk())
983 {
984 wxDirItemData* data = (wxDirItemData*) m_treeCtrl->GetItemData(childId);
985
986 if (data && !data->m_path.empty())
987 {
988 wxString childPath(data->m_path);
989 if (!wxEndsWithPathSeparator(childPath))
990 childPath += wxString(wxFILE_SEP_PATH);
991
992 // In MSW and PM, case is not significant
993#if defined(__WINDOWS__) || defined(__DOS__) || defined(__OS2__)
994 childPath.MakeLower();
995#endif
996
997 if (childPath.length() <= path2.length())
998 {
999 wxString path3 = path2.Mid(0, childPath.length());
1000 if (childPath == path3)
1001 {
1002 if (path3.length() == path2.length())
1003 done = true;
1004 else
1005 done = false;
1006 return childId;
1007 }
1008 }
1009 }
1010
1011 childId = m_treeCtrl->GetNextChild(parentId, cookie);
1012 }
1013 wxTreeItemId invalid;
1014 return invalid;
1015}
1016
1017// Try to expand as much of the given path as possible,
1018// and select the given tree item.
1019bool wxGenericDirCtrl::ExpandPath(const wxString& path)
1020{
1021 bool done = false;
1022 wxTreeItemId id = FindChild(m_rootId, path, done);
1023 wxTreeItemId lastId = id; // The last non-zero id
1024 while (id.IsOk() && !done)
1025 {
1026 ExpandDir(id);
1027
1028 id = FindChild(id, path, done);
1029 if (id.IsOk())
1030 lastId = id;
1031 }
1032 if (!lastId.IsOk())
1033 return false;
1034
1035 wxDirItemData *data = (wxDirItemData *) m_treeCtrl->GetItemData(lastId);
1036 if (data->m_isDir)
1037 {
1038 m_treeCtrl->Expand(lastId);
1039 }
1040 if (HasFlag(wxDIRCTRL_SELECT_FIRST) && data->m_isDir)
1041 {
1042 // Find the first file in this directory
1043 wxTreeItemIdValue cookie;
1044 wxTreeItemId childId = m_treeCtrl->GetFirstChild(lastId, cookie);
1045 bool selectedChild = false;
1046 while (childId.IsOk())
1047 {
1048 data = (wxDirItemData*) m_treeCtrl->GetItemData(childId);
1049
1050 if (data && data->m_path != wxEmptyString && !data->m_isDir)
1051 {
1052 m_treeCtrl->SelectItem(childId);
1053 m_treeCtrl->EnsureVisible(childId);
1054 selectedChild = true;
1055 break;
1056 }
1057 childId = m_treeCtrl->GetNextChild(lastId, cookie);
1058 }
1059 if (!selectedChild)
1060 {
1061 m_treeCtrl->SelectItem(lastId);
1062 m_treeCtrl->EnsureVisible(lastId);
1063 }
1064 }
1065 else
1066 {
1067 m_treeCtrl->SelectItem(lastId);
1068 m_treeCtrl->EnsureVisible(lastId);
1069 }
1070
1071 return true;
1072}
1073
1074
1075bool wxGenericDirCtrl::CollapsePath(const wxString& path)
1076{
1077 bool done = false;
1078 wxTreeItemId id = FindChild(m_rootId, path, done);
1079 wxTreeItemId lastId = id; // The last non-zero id
1080
1081 while ( id.IsOk() && !done )
1082 {
1083 CollapseDir(id);
1084
1085 id = FindChild(id, path, done);
1086
1087 if ( id.IsOk() )
1088 lastId = id;
1089 }
1090
1091 if ( !lastId.IsOk() )
1092 return false;
1093
1094 m_treeCtrl->SelectItem(lastId);
1095 m_treeCtrl->EnsureVisible(lastId);
1096
1097 return true;
1098}
1099
1100
1101wxString wxGenericDirCtrl::GetPath() const
1102{
1103 // Allow calling GetPath() in multiple selection from OnSelFilter
1104 if (m_treeCtrl->HasFlag(wxTR_MULTIPLE))
1105 {
1106 wxArrayTreeItemIds items;
1107 m_treeCtrl->GetSelections(items);
1108 if (items.size() > 0)
1109 {
1110 // return first string only
1111 wxTreeItemId id = items[0];
1112 wxDirItemData* data = (wxDirItemData*) m_treeCtrl->GetItemData(id);
1113 return data->m_path;
1114 }
1115
1116 return wxEmptyString;
1117 }
1118
1119 wxTreeItemId id = m_treeCtrl->GetSelection();
1120 if (id)
1121 {
1122 wxDirItemData* data = (wxDirItemData*) m_treeCtrl->GetItemData(id);
1123 return data->m_path;
1124 }
1125 else
1126 return wxEmptyString;
1127}
1128
1129void wxGenericDirCtrl::GetPaths(wxArrayString& paths) const
1130{
1131 paths.clear();
1132
1133 wxArrayTreeItemIds items;
1134 m_treeCtrl->GetSelections(items);
1135 for ( unsigned n = 0; n < items.size(); n++ )
1136 {
1137 wxTreeItemId id = items[n];
1138 wxDirItemData* data = (wxDirItemData*) m_treeCtrl->GetItemData(id);
1139 paths.Add(data->m_path);
1140 }
1141}
1142
1143wxString wxGenericDirCtrl::GetFilePath() const
1144{
1145 wxTreeItemId id = m_treeCtrl->GetSelection();
1146 if (id)
1147 {
1148 wxDirItemData* data = (wxDirItemData*) m_treeCtrl->GetItemData(id);
1149 if (data->m_isDir)
1150 return wxEmptyString;
1151 else
1152 return data->m_path;
1153 }
1154 else
1155 return wxEmptyString;
1156}
1157
1158void wxGenericDirCtrl::GetFilePaths(wxArrayString& paths) const
1159{
1160 paths.clear();
1161
1162 wxArrayTreeItemIds items;
1163 m_treeCtrl->GetSelections(items);
1164 for ( unsigned n = 0; n < items.size(); n++ )
1165 {
1166 wxTreeItemId id = items[n];
1167 wxDirItemData* data = (wxDirItemData*) m_treeCtrl->GetItemData(id);
1168 if ( !data->m_isDir )
1169 paths.Add(data->m_path);
1170 }
1171}
1172
1173void wxGenericDirCtrl::SetPath(const wxString& path)
1174{
1175 m_defaultPath = path;
1176 if (m_rootId)
1177 ExpandPath(path);
1178}
1179
1180void wxGenericDirCtrl::SelectPath(const wxString& path, bool select)
1181{
1182 bool done = false;
1183 wxTreeItemId id = FindChild(m_rootId, path, done);
1184 wxTreeItemId lastId = id; // The last non-zero id
1185 while ( id.IsOk() && !done )
1186 {
1187 id = FindChild(id, path, done);
1188 if ( id.IsOk() )
1189 lastId = id;
1190 }
1191 if ( !lastId.IsOk() )
1192 return;
1193
1194 if ( done )
1195 {
1196 m_treeCtrl->SelectItem(id, select);
1197 }
1198}
1199
1200void wxGenericDirCtrl::SelectPaths(const wxArrayString& paths)
1201{
1202 if ( HasFlag(wxDIRCTRL_MULTIPLE) )
1203 {
1204 UnselectAll();
1205 for ( unsigned n = 0; n < paths.size(); n++ )
1206 {
1207 SelectPath(paths[n]);
1208 }
1209 }
1210}
1211
1212void wxGenericDirCtrl::UnselectAll()
1213{
1214 m_treeCtrl->UnselectAll();
1215}
1216
1217// Not used
1218#if 0
1219void wxGenericDirCtrl::FindChildFiles(wxTreeItemId id, int dirFlags, wxArrayString& filenames)
1220{
1221 wxDirItemData *data = (wxDirItemData *) m_treeCtrl->GetItemData(id);
1222
1223 // This may take a longish time. Go to busy cursor
1224 wxBusyCursor busy;
1225
1226 wxASSERT(data);
1227
1228 wxString search,path,filename;
1229
1230 wxString dirName(data->m_path);
1231
1232#if defined(__WXMSW__) || defined(__OS2__)
1233 if (dirName.Last() == ':')
1234 dirName += wxString(wxFILE_SEP_PATH);
1235#endif
1236
1237 wxDir d;
1238 wxString eachFilename;
1239
1240 wxLogNull log;
1241 d.Open(dirName);
1242
1243 if (d.IsOpened())
1244 {
1245 if (d.GetFirst(& eachFilename, m_currentFilterStr, dirFlags))
1246 {
1247 do
1248 {
1249 if ((eachFilename != wxT(".")) && (eachFilename != wxT("..")))
1250 {
1251 filenames.Add(eachFilename);
1252 }
1253 }
1254 while (d.GetNext(& eachFilename)) ;
1255 }
1256 }
1257}
1258#endif
1259
1260void wxGenericDirCtrl::SetFilterIndex(int n)
1261{
1262 m_currentFilter = n;
1263
1264 wxString f, d;
1265 if (ExtractWildcard(m_filter, n, f, d))
1266 m_currentFilterStr = f;
1267 else
1268#ifdef __UNIX__
1269 m_currentFilterStr = wxT("*");
1270#else
1271 m_currentFilterStr = wxT("*.*");
1272#endif
1273}
1274
1275void wxGenericDirCtrl::SetFilter(const wxString& filter)
1276{
1277 m_filter = filter;
1278
1279 if (!filter.empty() && !m_filterListCtrl)
1280 m_filterListCtrl = new wxDirFilterListCtrl(this, wxID_FILTERLISTCTRL);
1281 else if (filter.empty() && m_filterListCtrl)
1282 {
1283 m_filterListCtrl->Destroy();
1284 m_filterListCtrl = NULL;
1285 }
1286
1287 wxString f, d;
1288 if (ExtractWildcard(m_filter, m_currentFilter, f, d))
1289 m_currentFilterStr = f;
1290 else
1291#ifdef __UNIX__
1292 m_currentFilterStr = wxT("*");
1293#else
1294 m_currentFilterStr = wxT("*.*");
1295#endif
1296 // current filter index is meaningless after filter change, set it to zero
1297 SetFilterIndex(0);
1298 if (m_filterListCtrl)
1299 m_filterListCtrl->FillFilterList(m_filter, 0);
1300}
1301
1302// Extract description and actual filter from overall filter string
1303bool wxGenericDirCtrl::ExtractWildcard(const wxString& filterStr, int n, wxString& filter, wxString& description)
1304{
1305 wxArrayString filters, descriptions;
1306 int count = wxParseCommonDialogsFilter(filterStr, descriptions, filters);
1307 if (count > 0 && n < count)
1308 {
1309 filter = filters[n];
1310 description = descriptions[n];
1311 return true;
1312 }
1313
1314 return false;
1315}
1316
1317
1318void wxGenericDirCtrl::DoResize()
1319{
1320 wxSize sz = GetClientSize();
1321 int verticalSpacing = 3;
1322 if (m_treeCtrl)
1323 {
1324 wxSize filterSz ;
1325 if (m_filterListCtrl)
1326 {
1327 filterSz = m_filterListCtrl->GetSize();
1328 sz.y -= (filterSz.y + verticalSpacing);
1329 }
1330 m_treeCtrl->SetSize(0, 0, sz.x, sz.y);
1331 if (m_filterListCtrl)
1332 {
1333 m_filterListCtrl->SetSize(0, sz.y + verticalSpacing, sz.x, filterSz.y);
1334 // Don't know why, but this needs refreshing after a resize (wxMSW)
1335 m_filterListCtrl->Refresh();
1336 }
1337 }
1338}
1339
1340
1341void wxGenericDirCtrl::OnSize(wxSizeEvent& WXUNUSED(event))
1342{
1343 DoResize();
1344}
1345
1346wxTreeItemId wxGenericDirCtrl::AppendItem (const wxTreeItemId & parent,
1347 const wxString & text,
1348 int image, int selectedImage,
1349 wxTreeItemData * data)
1350{
1351 wxTreeCtrl *treeCtrl = GetTreeCtrl ();
1352
1353 wxASSERT (treeCtrl);
1354
1355 if (treeCtrl)
1356 {
1357 return treeCtrl->AppendItem (parent, text, image, selectedImage, data);
1358 }
1359 else
1360 {
1361 return wxTreeItemId();
1362 }
1363}
1364
1365
1366//-----------------------------------------------------------------------------
1367// wxDirFilterListCtrl
1368//-----------------------------------------------------------------------------
1369
1370IMPLEMENT_CLASS(wxDirFilterListCtrl, wxChoice)
1371
1372BEGIN_EVENT_TABLE(wxDirFilterListCtrl, wxChoice)
1373 EVT_CHOICE(wxID_ANY, wxDirFilterListCtrl::OnSelFilter)
1374END_EVENT_TABLE()
1375
1376bool wxDirFilterListCtrl::Create(wxGenericDirCtrl* parent,
1377 const wxWindowID id,
1378 const wxPoint& pos,
1379 const wxSize& size,
1380 long style)
1381{
1382 m_dirCtrl = parent;
1383
1384 // by default our border style is determined by the style of our parent
1385 if ( !(style & wxBORDER_MASK) )
1386 {
1387 style |= parent->HasFlag(wxDIRCTRL_3D_INTERNAL) ? wxBORDER_SUNKEN
1388 : wxBORDER_NONE;
1389 }
1390
1391 return wxChoice::Create(parent, id, pos, size, 0, NULL, style);
1392}
1393
1394void wxDirFilterListCtrl::Init()
1395{
1396 m_dirCtrl = NULL;
1397}
1398
1399void wxDirFilterListCtrl::OnSelFilter(wxCommandEvent& WXUNUSED(event))
1400{
1401 int sel = GetSelection();
1402
1403 if (m_dirCtrl->HasFlag(wxDIRCTRL_MULTIPLE))
1404 {
1405 wxArrayString paths;
1406 m_dirCtrl->GetPaths(paths);
1407
1408 m_dirCtrl->SetFilterIndex(sel);
1409
1410 // If the filter has changed, the view is out of date, so
1411 // collapse the tree.
1412 m_dirCtrl->ReCreateTree();
1413
1414 // Expand and select the previously selected paths
1415 for (unsigned int i = 0; i < paths.GetCount(); i++)
1416 {
1417 m_dirCtrl->ExpandPath(paths.Item(i));
1418 }
1419 }
1420 else
1421 {
1422 wxString currentPath = m_dirCtrl->GetPath();
1423
1424 m_dirCtrl->SetFilterIndex(sel);
1425 m_dirCtrl->ReCreateTree();
1426
1427 // Try to restore the selection, or at least the directory
1428 m_dirCtrl->ExpandPath(currentPath);
1429 }
1430}
1431
1432void wxDirFilterListCtrl::FillFilterList(const wxString& filter, int defaultFilter)
1433{
1434 Clear();
1435 wxArrayString descriptions, filters;
1436 size_t n = (size_t) wxParseCommonDialogsFilter(filter, descriptions, filters);
1437
1438 if (n > 0 && defaultFilter < (int) n)
1439 {
1440 for (size_t i = 0; i < n; i++)
1441 Append(descriptions[i]);
1442 SetSelection(defaultFilter);
1443 }
1444}
1445#endif // wxUSE_DIRDLG
1446
1447#if wxUSE_DIRDLG || wxUSE_FILEDLG
1448
1449// ----------------------------------------------------------------------------
1450// wxFileIconsTable icons
1451// ----------------------------------------------------------------------------
1452
1453#ifndef __WXGTK20__
1454/* Computer (c) Julian Smart */
1455static const char* const file_icons_tbl_computer_xpm[] = {
1456/* columns rows colors chars-per-pixel */
1457"16 16 42 1",
1458"r c #4E7FD0",
1459"$ c #7198D9",
1460"; c #DCE6F6",
1461"q c #FFFFFF",
1462"u c #4A7CCE",
1463"# c #779DDB",
1464"w c #95B2E3",
1465"y c #7FA2DD",
1466"f c #3263B4",
1467"= c #EAF0FA",
1468"< c #B1C7EB",
1469"% c #6992D7",
1470"9 c #D9E4F5",
1471"o c #9BB7E5",
1472"6 c #F7F9FD",
1473", c #BED0EE",
1474"3 c #F0F5FC",
1475"1 c #A8C0E8",
1476" c None",
1477"0 c #FDFEFF",
1478"4 c #C4D5F0",
1479"@ c #81A4DD",
1480"e c #4377CD",
1481"- c #E2EAF8",
1482"i c #9FB9E5",
1483"> c #CCDAF2",
1484"+ c #89A9DF",
1485"s c #5584D1",
1486"t c #5D89D3",
1487": c #D2DFF4",
1488"5 c #FAFCFE",
1489"2 c #F5F8FD",
1490"8 c #DFE8F7",
1491"& c #5E8AD4",
1492"X c #638ED5",
1493"a c #CEDCF2",
1494"p c #90AFE2",
1495"d c #2F5DA9",
1496"* c #5282D0",
1497"7 c #E5EDF9",
1498". c #A2BCE6",
1499"O c #8CACE0",
1500/* pixels */
1501" ",
1502" .XXXXXXXXXXX ",
1503" oXO++@#$%&*X ",
1504" oX=-;:>,<1%X ",
1505" oX23=-;:4,$X ",
1506" oX5633789:@X ",
1507" oX05623=78+X ",
1508" oXqq05623=OX ",
1509" oX,,,,,<<<$X ",
1510" wXXXXXXXXXXe ",
1511" XrtX%$$y@+O,, ",
1512" uyiiiiiiiii@< ",
1513" ouiiiiiiiiiip<a",
1514" rustX%$$y@+Ow,,",
1515" dfffffffffffffd",
1516" "
1517};
1518#endif // !GTK+ 2
1519
1520// ----------------------------------------------------------------------------
1521// wxFileIconsTable & friends
1522// ----------------------------------------------------------------------------
1523
1524// global instance of a wxFileIconsTable
1525wxFileIconsTable* wxTheFileIconsTable = NULL;
1526
1527// A module to allow icons table cleanup
1528
1529class wxFileIconsTableModule: public wxModule
1530{
1531DECLARE_DYNAMIC_CLASS(wxFileIconsTableModule)
1532public:
1533 wxFileIconsTableModule() {}
1534 bool OnInit() { wxTheFileIconsTable = new wxFileIconsTable; return true; }
1535 void OnExit()
1536 {
1537 wxDELETE(wxTheFileIconsTable);
1538 }
1539};
1540
1541IMPLEMENT_DYNAMIC_CLASS(wxFileIconsTableModule, wxModule)
1542
1543class wxFileIconEntry : public wxObject
1544{
1545public:
1546 wxFileIconEntry(int i) { id = i; }
1547
1548 int id;
1549};
1550
1551wxFileIconsTable::wxFileIconsTable()
1552{
1553 m_HashTable = NULL;
1554 m_smallImageList = NULL;
1555}
1556
1557wxFileIconsTable::~wxFileIconsTable()
1558{
1559 if (m_HashTable)
1560 {
1561 WX_CLEAR_HASH_TABLE(*m_HashTable);
1562 delete m_HashTable;
1563 }
1564 if (m_smallImageList) delete m_smallImageList;
1565}
1566
1567// delayed initialization - wait until first use (wxArtProv not created yet)
1568void wxFileIconsTable::Create()
1569{
1570 wxCHECK_RET(!m_smallImageList && !m_HashTable, wxT("creating icons twice"));
1571 m_HashTable = new wxHashTable(wxKEY_STRING);
1572 m_smallImageList = new wxImageList(16, 16);
1573
1574 // folder:
1575 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_FOLDER,
1576 wxART_CMN_DIALOG,
1577 wxSize(16, 16)));
1578 // folder_open
1579 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_FOLDER_OPEN,
1580 wxART_CMN_DIALOG,
1581 wxSize(16, 16)));
1582 // computer
1583#ifdef __WXGTK20__
1584 // GTK24 uses this icon in the file open dialog
1585 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_HARDDISK,
1586 wxART_CMN_DIALOG,
1587 wxSize(16, 16)));
1588#else
1589 m_smallImageList->Add(wxIcon(file_icons_tbl_computer_xpm));
1590#endif
1591 // drive
1592 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_HARDDISK,
1593 wxART_CMN_DIALOG,
1594 wxSize(16, 16)));
1595 // cdrom
1596 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_CDROM,
1597 wxART_CMN_DIALOG,
1598 wxSize(16, 16)));
1599 // floppy
1600 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_FLOPPY,
1601 wxART_CMN_DIALOG,
1602 wxSize(16, 16)));
1603 // removeable
1604 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_REMOVABLE,
1605 wxART_CMN_DIALOG,
1606 wxSize(16, 16)));
1607 // file
1608 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_NORMAL_FILE,
1609 wxART_CMN_DIALOG,
1610 wxSize(16, 16)));
1611 // executable
1612 if (GetIconID(wxEmptyString, wxT("application/x-executable")) == file)
1613 {
1614 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_EXECUTABLE_FILE,
1615 wxART_CMN_DIALOG,
1616 wxSize(16, 16)));
1617 delete m_HashTable->Get(wxT("exe"));
1618 m_HashTable->Delete(wxT("exe"));
1619 m_HashTable->Put(wxT("exe"), new wxFileIconEntry(executable));
1620 }
1621 /* else put into list by GetIconID
1622 (KDE defines application/x-executable for *.exe and has nice icon)
1623 */
1624}
1625
1626wxImageList *wxFileIconsTable::GetSmallImageList()
1627{
1628 if (!m_smallImageList)
1629 Create();
1630
1631 return m_smallImageList;
1632}
1633
1634#if wxUSE_MIMETYPE && wxUSE_IMAGE && (!defined(__WXMSW__) || wxUSE_WXDIB)
1635// VS: we don't need this function w/o wxMimeTypesManager because we'll only have
1636// one icon and we won't resize it
1637
1638static wxBitmap CreateAntialiasedBitmap(const wxImage& img)
1639{
1640 const unsigned int size = 16;
1641
1642 wxImage smallimg (size, size);
1643 unsigned char *p1, *p2, *ps;
1644 unsigned char mr = img.GetMaskRed(),
1645 mg = img.GetMaskGreen(),
1646 mb = img.GetMaskBlue();
1647
1648 unsigned x, y;
1649 unsigned sr, sg, sb, smask;
1650
1651 p1 = img.GetData(), p2 = img.GetData() + 3 * size*2, ps = smallimg.GetData();
1652 smallimg.SetMaskColour(mr, mr, mr);
1653
1654 for (y = 0; y < size; y++)
1655 {
1656 for (x = 0; x < size; x++)
1657 {
1658 sr = sg = sb = smask = 0;
1659 if (p1[0] != mr || p1[1] != mg || p1[2] != mb)
1660 sr += p1[0], sg += p1[1], sb += p1[2];
1661 else smask++;
1662 p1 += 3;
1663 if (p1[0] != mr || p1[1] != mg || p1[2] != mb)
1664 sr += p1[0], sg += p1[1], sb += p1[2];
1665 else smask++;
1666 p1 += 3;
1667 if (p2[0] != mr || p2[1] != mg || p2[2] != mb)
1668 sr += p2[0], sg += p2[1], sb += p2[2];
1669 else smask++;
1670 p2 += 3;
1671 if (p2[0] != mr || p2[1] != mg || p2[2] != mb)
1672 sr += p2[0], sg += p2[1], sb += p2[2];
1673 else smask++;
1674 p2 += 3;
1675
1676 if (smask > 2)
1677 ps[0] = ps[1] = ps[2] = mr;
1678 else
1679 {
1680 ps[0] = (unsigned char)(sr >> 2);
1681 ps[1] = (unsigned char)(sg >> 2);
1682 ps[2] = (unsigned char)(sb >> 2);
1683 }
1684 ps += 3;
1685 }
1686 p1 += size*2 * 3, p2 += size*2 * 3;
1687 }
1688
1689 return wxBitmap(smallimg);
1690}
1691
1692// This function is currently not unused anymore
1693#if 0
1694// finds empty borders and return non-empty area of image:
1695static wxImage CutEmptyBorders(const wxImage& img)
1696{
1697 unsigned char mr = img.GetMaskRed(),
1698 mg = img.GetMaskGreen(),
1699 mb = img.GetMaskBlue();
1700 unsigned char *dt = img.GetData(), *dttmp;
1701 unsigned w = img.GetWidth(), h = img.GetHeight();
1702
1703 unsigned top, bottom, left, right, i;
1704 bool empt;
1705
1706#define MK_DTTMP(x,y) dttmp = dt + ((x + y * w) * 3)
1707#define NOEMPTY_PIX(empt) if (dttmp[0] != mr || dttmp[1] != mg || dttmp[2] != mb) {empt = false; break;}
1708
1709 for (empt = true, top = 0; empt && top < h; top++)
1710 {
1711 MK_DTTMP(0, top);
1712 for (i = 0; i < w; i++, dttmp+=3)
1713 NOEMPTY_PIX(empt)
1714 }
1715 for (empt = true, bottom = h-1; empt && bottom > top; bottom--)
1716 {
1717 MK_DTTMP(0, bottom);
1718 for (i = 0; i < w; i++, dttmp+=3)
1719 NOEMPTY_PIX(empt)
1720 }
1721 for (empt = true, left = 0; empt && left < w; left++)
1722 {
1723 MK_DTTMP(left, 0);
1724 for (i = 0; i < h; i++, dttmp+=3*w)
1725 NOEMPTY_PIX(empt)
1726 }
1727 for (empt = true, right = w-1; empt && right > left; right--)
1728 {
1729 MK_DTTMP(right, 0);
1730 for (i = 0; i < h; i++, dttmp+=3*w)
1731 NOEMPTY_PIX(empt)
1732 }
1733 top--, left--, bottom++, right++;
1734
1735 return img.GetSubImage(wxRect(left, top, right - left + 1, bottom - top + 1));
1736}
1737#endif // #if 0
1738
1739#endif // wxUSE_MIMETYPE
1740
1741int wxFileIconsTable::GetIconID(const wxString& extension, const wxString& mime)
1742{
1743 if (!m_smallImageList)
1744 Create();
1745
1746#if wxUSE_MIMETYPE
1747 if (!extension.empty())
1748 {
1749 wxFileIconEntry *entry = (wxFileIconEntry*) m_HashTable->Get(extension);
1750 if (entry) return (entry -> id);
1751 }
1752
1753 wxFileType *ft = (mime.empty()) ?
1754 wxTheMimeTypesManager -> GetFileTypeFromExtension(extension) :
1755 wxTheMimeTypesManager -> GetFileTypeFromMimeType(mime);
1756
1757 wxIconLocation iconLoc;
1758 wxIcon ic;
1759
1760 {
1761 wxLogNull logNull;
1762 if ( ft && ft->GetIcon(&iconLoc) )
1763 {
1764 ic = wxIcon( iconLoc );
1765 }
1766 }
1767
1768 delete ft;
1769
1770 if ( !ic.Ok() )
1771 {
1772 int newid = file;
1773 m_HashTable->Put(extension, new wxFileIconEntry(newid));
1774 return newid;
1775 }
1776
1777 wxBitmap bmp;
1778 bmp.CopyFromIcon(ic);
1779
1780 if ( !bmp.Ok() )
1781 {
1782 int newid = file;
1783 m_HashTable->Put(extension, new wxFileIconEntry(newid));
1784 return newid;
1785 }
1786
1787 const unsigned int size = 16;
1788
1789 int id = m_smallImageList->GetImageCount();
1790 if ((bmp.GetWidth() == (int) size) && (bmp.GetHeight() == (int) size))
1791 {
1792 m_smallImageList->Add(bmp);
1793 }
1794#if wxUSE_IMAGE && (!defined(__WXMSW__) || wxUSE_WXDIB)
1795 else
1796 {
1797 wxImage img = bmp.ConvertToImage();
1798
1799 if ((img.GetWidth() != size*2) || (img.GetHeight() != size*2))
1800// m_smallImageList->Add(CreateAntialiasedBitmap(CutEmptyBorders(img).Rescale(size*2, size*2)));
1801 m_smallImageList->Add(CreateAntialiasedBitmap(img.Rescale(size*2, size*2)));
1802 else
1803 m_smallImageList->Add(CreateAntialiasedBitmap(img));
1804 }
1805#endif // wxUSE_IMAGE
1806
1807 m_HashTable->Put(extension, new wxFileIconEntry(id));
1808 return id;
1809
1810#else // !wxUSE_MIMETYPE
1811
1812 wxUnusedVar(mime);
1813 if (extension == wxT("exe"))
1814 return executable;
1815 else
1816 return file;
1817#endif // wxUSE_MIMETYPE/!wxUSE_MIMETYPE
1818}
1819
1820#endif // wxUSE_DIRDLG || wxUSE_FILEDLG
wxWidgets (Impactor)