]> git.saurik.com Git - wxWidgets.git/blob - src/generic/dirctrlg.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Watcom compilation fix
[wxWidgets.git] / src / generic / dirctrlg.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: 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 #ifdef __GNUG__
13 #pragma implementation "dirctrlg.h"
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #if wxUSE_DIRDLG
24
25 #include "wx/generic/dirctrlg.h"
26
27 #include "wx/module.h"
28 #include "wx/utils.h"
29 #include "wx/button.h"
30 #include "wx/layout.h"
31 #include "wx/msgdlg.h"
32 #include "wx/textctrl.h"
33 #include "wx/textdlg.h"
34 #include "wx/filefn.h"
35 #include "wx/cmndata.h"
36 #include "wx/gdicmn.h"
37 #include "wx/intl.h"
38 #include "wx/imaglist.h"
39 #include "wx/icon.h"
40 #include "wx/log.h"
41 #include "wx/sizer.h"
42 #include "wx/tokenzr.h"
43 #include "wx/dir.h"
44 #include "wx/settings.h"
45 #include "wx/artprov.h"
46 #include "wx/hash.h"
47 #include "wx/mimetype.h"
48 #include "wx/image.h"
49 #include "wx/choice.h"
50 #include "wx/filedlg.h" // for wxFileDialogBase::ParseWildcard
51
52 #if wxUSE_STATLINE
53 #include "wx/statline.h"
54 #endif
55
56 #if defined(__WXMAC__)
57 #include "wx/mac/private.h" // includes mac headers
58 #endif
59
60 #ifdef __WXMSW__
61 #include <windows.h>
62
63 // FIXME - Mingw32 1.0 has both _getdrive() and _chdrive(). For now, let's assume
64 // older releases don't, but it should be verified and the checks modified
65 // accordingly.
66 #if !defined(__GNUWIN32__) || (defined(__MINGW32_MAJOR_VERSION) && __MINGW32_MAJOR_VERSION >= 1)
67 #if !defined(__WXWINCE__)
68 #include <direct.h>
69 #endif
70 #include <stdlib.h>
71 #include <ctype.h>
72 #endif
73
74 #endif
75
76 #ifdef __WXPM__
77
78 #define INCL_BASE
79 #include <os2.h>
80 #ifndef __EMX__
81 #include <direct.h>
82 #endif
83 #include <stdlib.h>
84 #include <ctype.h>
85 extern bool wxIsDriveAvailable(const wxString& dirName);
86 #endif // __WXPM__
87
88 #if defined(__WXMAC__)
89 # ifdef __DARWIN__
90 # include "MoreFilesX.h"
91 # else
92 # include "MoreFilesExtras.h"
93 # endif
94 #endif
95
96 #ifdef __BORLANDC__
97 #include "dos.h"
98 #endif
99
100 // If compiled under Windows, this macro can cause problems
101 #ifdef GetFirstChild
102 #undef GetFirstChild
103 #endif
104
105 // ----------------------------------------------------------------------------
106 // wxGetAvailableDrives, for WINDOWS, DOS, WXPM, MAC, UNIX (returns "/")
107 // ----------------------------------------------------------------------------
108
109 size_t wxGetAvailableDrives(wxArrayString &paths, wxArrayString &names, wxArrayInt &icon_ids)
110 {
111 #if defined(__WINDOWS__) || defined(__DOS__) || defined(__WXPM__)
112
113 #ifdef __WXWINCE__
114 // No logical drives; return "\"
115 paths.Add(wxT("\\"));
116 names.Add(wxT("\\"));
117 return 1;
118 #elif defined(__WIN32__)
119 wxChar driveBuffer[256];
120 size_t n = (size_t) GetLogicalDriveStrings(255, driveBuffer);
121 size_t i = 0;
122 while (i < n)
123 {
124 wxString path, name;
125 path.Printf(wxT("%c:\\"), driveBuffer[i]);
126 name.Printf(wxT("%c:"), driveBuffer[i]);
127
128 int imageId = wxFileIconsTable::drive;
129 int driveType = ::GetDriveType(path);
130 switch (driveType)
131 {
132 case DRIVE_REMOVABLE:
133 if (path == wxT("a:\\") || path == wxT("b:\\"))
134 imageId = wxFileIconsTable::floppy;
135 else
136 imageId = wxFileIconsTable::removeable;
137 break;
138 case DRIVE_CDROM:
139 imageId = wxFileIconsTable::cdrom;
140 break;
141 case DRIVE_REMOTE:
142 case DRIVE_FIXED:
143 default:
144 imageId = wxFileIconsTable::drive;
145 break;
146 }
147
148 paths.Add(path);
149 names.Add(name);
150 icon_ids.Add(imageId);
151
152 while (driveBuffer[i] != wxT('\0'))
153 i ++;
154 i ++;
155 if (driveBuffer[i] == wxT('\0'))
156 break;
157 }
158 #else // !__WIN32__
159 int drive;
160
161 /* If we can switch to the drive, it exists. */
162 for( drive = 1; drive <= 26; drive++ )
163 {
164 wxString path, name;
165 path.Printf(wxT("%c:\\"), (char) (drive + 'a' - 1));
166 name.Printf(wxT("%c:"), (char) (drive + 'A' - 1));
167
168 if (wxIsDriveAvailable(path))
169 {
170 paths.Add(path);
171 names.Add(name);
172 icon_ids.Add((drive <= 2) ? wxFileIconsTable::floppy : wxFileIconsTable::drive);
173 }
174 }
175 #endif // __WIN32__/!__WIN32__
176
177 #elif defined(__WXMAC__)
178 #ifdef __DARWIN__
179 FSRef **theVolRefs;
180 ItemCount theVolCount;
181 char thePath[FILENAME_MAX];
182
183 if (FSGetMountedVolumes(&theVolRefs, &theVolCount) == noErr) {
184 ItemCount index;
185 ::HLock( (Handle)theVolRefs ) ;
186 for (index = 0; index < theVolCount; ++index) {
187 // get the POSIX path associated with the FSRef
188 if ( FSRefMakePath(&((*theVolRefs)[index]),
189 (UInt8 *)thePath, sizeof(thePath)) != noErr ) {
190 continue;
191 }
192 // add path separator at end if necessary
193 wxString path( thePath ) ;
194 if (path.Last() != wxFILE_SEP_PATH) {
195 path += wxFILE_SEP_PATH;
196 }
197 // get Mac volume name for display
198 FSVolumeRefNum vRefNum ;
199 HFSUniStr255 volumeName ;
200
201 if ( FSGetVRefNum(&((*theVolRefs)[index]), &vRefNum) != noErr ) {
202 continue;
203 }
204 if ( FSGetVInfo(vRefNum, &volumeName, NULL, NULL) != noErr ) {
205 continue;
206 }
207 // get C string from Unicode HFS name
208 // see: http://developer.apple.com/carbon/tipsandtricks.html
209 CFStringRef cfstr = CFStringCreateWithCharacters( kCFAllocatorDefault,
210 volumeName.unicode,
211 volumeName.length );
212 // Do something with str
213 char *cstr = NewPtr(CFStringGetLength(cfstr) + 1);
214 if (( cstr == NULL ) ||
215 !CFStringGetCString(cfstr, cstr, CFStringGetLength(cfstr) + 1,
216 kCFStringEncodingMacRoman))
217 {
218 CFRelease( cstr );
219 continue;
220 }
221 wxString name( cstr );
222 DisposePtr( cstr );
223 CFRelease( cfstr );
224
225 GetVolParmsInfoBuffer volParmsInfo;
226 UInt32 actualSize;
227 if ( FSGetVolParms(vRefNum, sizeof(volParmsInfo), &volParmsInfo, &actualSize) != noErr ) {
228 continue;
229 }
230
231 paths.Add(path);
232 names.Add(name);
233
234 if ( VolIsEjectable(&volParmsInfo) )
235 icon_ids.Add(wxFileIconsTable::cdrom);
236 else
237 icon_ids.Add(wxFileIconsTable::drive);
238 }
239 ::HUnlock( (Handle)theVolRefs );
240 ::DisposeHandle( (Handle)theVolRefs );
241 }
242 #else // !__DARWIN__
243 FSSpec volume;
244 short index = 1;
245 while(1)
246 {
247 short actualCount = 0 ;
248 if (OnLine(&volume, 1, &actualCount, &index ) != noErr || actualCount==0)
249 {
250 break;
251 }
252
253 wxString name = wxMacFSSpec2MacFilename( &volume );
254 paths.Add(name + wxFILE_SEP_PATH);
255 names.Add(name);
256 icon_ids.Add(wxFileIconsTable::drive);
257 }
258 #endif // __DARWIN__
259
260 #elif defined(__UNIX__)
261 paths.Add(wxT("/"));
262 names.Add(wxT("/"));
263 icon_ids.Add(wxFileIconsTable::computer);
264 #else
265 #error "Unsupported platform in wxGenericDirCtrl!"
266 #endif
267 return paths.GetCount();
268 }
269
270 // ----------------------------------------------------------------------------
271 // wxIsDriveAvailable
272 // ----------------------------------------------------------------------------
273
274 #if defined(__DOS__)
275
276 bool wxIsDriveAvailable(const wxString& dirName)
277 {
278 // FIXME_MGL - this method leads to hang up under Watcom for some reason
279 #ifndef __WATCOMC__
280 if ( dirName.Len() == 3 && dirName[1u] == wxT(':') )
281 {
282 wxString dirNameLower(dirName.Lower());
283 // VS: always return TRUE for removable media, since Win95 doesn't
284 // like it when MS-DOS app accesses empty floppy drive
285 return (dirNameLower[0u] == wxT('a') ||
286 dirNameLower[0u] == wxT('b') ||
287 wxPathExists(dirNameLower));
288 }
289 else
290 #endif
291 return TRUE;
292 }
293
294 #elif defined(__WINDOWS__) || defined(__WXPM__)
295
296 int setdrive(int drive)
297 {
298 #ifdef __WXWINCE__
299 return 0;
300 #elif defined(__GNUWIN32__) && \
301 (defined(__MINGW32_MAJOR_VERSION) && __MINGW32_MAJOR_VERSION >= 1)
302 return _chdrive(drive);
303 #else
304 wxChar newdrive[3];
305
306 if (drive < 1 || drive > 31)
307 return -1;
308 newdrive[0] = (wxChar)(wxT('A') + drive - 1);
309 newdrive[1] = wxT(':');
310 newdrive[2] = wxT('\0');
311 #if defined(__WXMSW__)
312 if (::SetCurrentDirectory(newdrive))
313 #else
314 // VA doesn't know what LPSTR is and has its own set
315 if (DosSetCurrentDir((PSZ)newdrive))
316 #endif
317 return 0;
318 else
319 return -1;
320 #endif // !GNUWIN32
321 }
322
323 bool wxIsDriveAvailable(const wxString& dirName)
324 {
325 #ifdef __WXWINCE__
326 return FALSE;
327 #else
328 #ifdef __WIN32__
329 UINT errorMode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
330 #endif
331 bool success = TRUE;
332
333 // Check if this is a root directory and if so,
334 // whether the drive is available.
335 if (dirName.Len() == 3 && dirName[(size_t)1] == wxT(':'))
336 {
337 wxString dirNameLower(dirName.Lower());
338 #if defined(__GNUWIN32__) && !(defined(__MINGW32_MAJOR_VERSION) && __MINGW32_MAJOR_VERSION >= 1)
339 success = wxPathExists(dirNameLower);
340 #else
341 int currentDrive = _getdrive();
342 int thisDrive = (int) (dirNameLower[(size_t)0] - 'a' + 1) ;
343 int err = setdrive( thisDrive ) ;
344 setdrive( currentDrive );
345
346 if (err == -1)
347 {
348 success = FALSE;
349 }
350 #endif
351 }
352 #ifdef __WIN32__
353 (void) SetErrorMode(errorMode);
354 #endif
355
356 return success;
357 #endif
358 }
359 #endif // __WINDOWS__ || __WXPM__
360
361
362 // Function which is called by quick sort. We want to override the default wxArrayString behaviour,
363 // and sort regardless of case.
364 static int LINKAGEMODE wxDirCtrlStringCompareFunction(wxString* strFirst, wxString* strSecond)
365 {
366 return strFirst->CmpNoCase(*strSecond);
367 }
368
369 //-----------------------------------------------------------------------------
370 // wxDirItemData
371 //-----------------------------------------------------------------------------
372
373 wxDirItemData::wxDirItemData(const wxString& path, const wxString& name,
374 bool isDir)
375 {
376 m_path = path;
377 m_name = name;
378 /* Insert logic to detect hidden files here
379 * In UnixLand we just check whether the first char is a dot
380 * For FileNameFromPath read LastDirNameInThisPath ;-) */
381 // m_isHidden = (bool)(wxFileNameFromPath(*m_path)[0] == '.');
382 m_isHidden = FALSE;
383 m_isExpanded = FALSE;
384 m_isDir = isDir;
385 }
386
387 wxDirItemData::~wxDirItemData()
388 {
389 }
390
391 void wxDirItemData::SetNewDirName(const wxString& path)
392 {
393 m_path = path;
394 m_name = wxFileNameFromPath(path);
395 }
396
397 bool wxDirItemData::HasSubDirs() const
398 {
399 if (m_path.IsEmpty())
400 return FALSE;
401
402 wxDir dir;
403 {
404 wxLogNull nolog;
405 if ( !dir.Open(m_path) )
406 return FALSE;
407 }
408
409 return dir.HasSubDirs();
410 }
411
412 bool wxDirItemData::HasFiles(const wxString& WXUNUSED(spec)) const
413 {
414 if (m_path.IsEmpty())
415 return FALSE;
416
417 wxDir dir;
418 {
419 wxLogNull nolog;
420 if ( !dir.Open(m_path) )
421 return FALSE;
422 }
423
424 return dir.HasFiles();
425 }
426
427 //-----------------------------------------------------------------------------
428 // wxGenericDirCtrl
429 //-----------------------------------------------------------------------------
430
431 IMPLEMENT_DYNAMIC_CLASS(wxGenericDirCtrl, wxControl)
432
433 BEGIN_EVENT_TABLE(wxGenericDirCtrl, wxControl)
434 EVT_TREE_ITEM_EXPANDING (-1, wxGenericDirCtrl::OnExpandItem)
435 EVT_TREE_ITEM_COLLAPSED (-1, wxGenericDirCtrl::OnCollapseItem)
436 EVT_TREE_BEGIN_LABEL_EDIT (-1, wxGenericDirCtrl::OnBeginEditItem)
437 EVT_TREE_END_LABEL_EDIT (-1, wxGenericDirCtrl::OnEndEditItem)
438 EVT_SIZE (wxGenericDirCtrl::OnSize)
439 END_EVENT_TABLE()
440
441 wxGenericDirCtrl::wxGenericDirCtrl(void)
442 {
443 Init();
444 }
445
446 bool wxGenericDirCtrl::Create(wxWindow *parent,
447 const wxWindowID id,
448 const wxString& dir,
449 const wxPoint& pos,
450 const wxSize& size,
451 long style,
452 const wxString& filter,
453 int defaultFilter,
454 const wxString& name)
455 {
456 if (!wxControl::Create(parent, id, pos, size, style, wxDefaultValidator, name))
457 return FALSE;
458
459 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
460
461 Init();
462
463 long treeStyle = wxTR_HAS_BUTTONS | wxTR_HIDE_ROOT;
464
465 if (style & wxDIRCTRL_EDIT_LABELS)
466 treeStyle |= wxTR_EDIT_LABELS;
467
468 if ((style & wxDIRCTRL_3D_INTERNAL) == 0)
469 treeStyle |= wxNO_BORDER;
470 else
471 treeStyle |= wxBORDER_SUNKEN;
472
473 long filterStyle = 0;
474 if ((style & wxDIRCTRL_3D_INTERNAL) == 0)
475 filterStyle |= wxNO_BORDER;
476 else
477 filterStyle |= wxBORDER_SUNKEN;
478
479 m_treeCtrl = new wxTreeCtrl(this, wxID_TREECTRL, pos, size, treeStyle);
480
481 if (!filter.IsEmpty() && (style & wxDIRCTRL_SHOW_FILTERS))
482 m_filterListCtrl = new wxDirFilterListCtrl(this, wxID_FILTERLISTCTRL, wxDefaultPosition, wxDefaultSize, filterStyle);
483
484 m_defaultPath = dir;
485 m_filter = filter;
486
487 SetFilterIndex(defaultFilter);
488
489 if (m_filterListCtrl)
490 m_filterListCtrl->FillFilterList(filter, defaultFilter);
491
492 m_treeCtrl->SetImageList(wxTheFileIconsTable->GetSmallImageList());
493
494 m_showHidden = FALSE;
495 wxDirItemData* rootData = new wxDirItemData(wxT(""), wxT(""), TRUE);
496
497 wxString rootName;
498
499 #if defined(__WINDOWS__) || defined(__WXPM__) || defined(__DOS__)
500 rootName = _("Computer");
501 #else
502 rootName = _("Sections");
503 #endif
504
505 m_rootId = m_treeCtrl->AddRoot( rootName, 3, -1, rootData);
506 m_treeCtrl->SetItemHasChildren(m_rootId);
507 ExpandDir(m_rootId); // automatically expand first level
508
509 // Expand and select the default path
510 if (!m_defaultPath.IsEmpty())
511 ExpandPath(m_defaultPath);
512
513 DoResize();
514
515 return TRUE;
516 }
517
518 wxGenericDirCtrl::~wxGenericDirCtrl()
519 {
520 }
521
522 void wxGenericDirCtrl::Init()
523 {
524 m_showHidden = FALSE;
525 m_currentFilter = 0;
526 m_currentFilterStr = wxEmptyString; // Default: any file
527 m_treeCtrl = NULL;
528 m_filterListCtrl = NULL;
529 }
530
531 void wxGenericDirCtrl::ShowHidden( bool show )
532 {
533 m_showHidden = show;
534
535 wxString path = GetPath();
536 ReCreateTree();
537 SetPath(path);
538 }
539
540 const wxTreeItemId
541 wxGenericDirCtrl::AddSection(const wxString& path, const wxString& name, int imageId)
542 {
543 wxDirItemData *dir_item = new wxDirItemData(path,name,TRUE);
544
545 wxTreeItemId id = AppendItem( m_rootId, name, imageId, -1, dir_item);
546
547 m_treeCtrl->SetItemHasChildren(id);
548
549 return id;
550 }
551
552 void wxGenericDirCtrl::SetupSections()
553 {
554 wxArrayString paths, names;
555 wxArrayInt icons;
556
557 size_t n, count = wxGetAvailableDrives(paths, names, icons);
558
559 for (n = 0; n < count; n++)
560 {
561 AddSection(paths[n], names[n], icons[n]);
562 }
563 }
564
565 void wxGenericDirCtrl::OnBeginEditItem(wxTreeEvent &event)
566 {
567 // don't rename the main entry "Sections"
568 if (event.GetItem() == m_rootId)
569 {
570 event.Veto();
571 return;
572 }
573
574 // don't rename the individual sections
575 if (m_treeCtrl->GetItemParent( event.GetItem() ) == m_rootId)
576 {
577 event.Veto();
578 return;
579 }
580 }
581
582 void wxGenericDirCtrl::OnEndEditItem(wxTreeEvent &event)
583 {
584 if ((event.GetLabel().IsEmpty()) ||
585 (event.GetLabel() == _(".")) ||
586 (event.GetLabel() == _("..")) ||
587 (event.GetLabel().Find(wxT('/')) != wxNOT_FOUND) ||
588 (event.GetLabel().Find(wxT('\\')) != wxNOT_FOUND) ||
589 (event.GetLabel().Find(wxT('|')) != wxNOT_FOUND))
590 {
591 wxMessageDialog dialog(this, _("Illegal directory name."), _("Error"), wxOK | wxICON_ERROR );
592 dialog.ShowModal();
593 event.Veto();
594 return;
595 }
596
597 wxTreeItemId id = event.GetItem();
598 wxDirItemData *data = (wxDirItemData*)m_treeCtrl->GetItemData( id );
599 wxASSERT( data );
600
601 wxString new_name( wxPathOnly( data->m_path ) );
602 new_name += wxString(wxFILE_SEP_PATH);
603 new_name += event.GetLabel();
604
605 wxLogNull log;
606
607 if (wxFileExists(new_name))
608 {
609 wxMessageDialog dialog(this, _("File name exists already."), _("Error"), wxOK | wxICON_ERROR );
610 dialog.ShowModal();
611 event.Veto();
612 }
613
614 if (wxRenameFile(data->m_path,new_name))
615 {
616 data->SetNewDirName( new_name );
617 }
618 else
619 {
620 wxMessageDialog dialog(this, _("Operation not permitted."), _("Error"), wxOK | wxICON_ERROR );
621 dialog.ShowModal();
622 event.Veto();
623 }
624 }
625
626 void wxGenericDirCtrl::OnExpandItem(wxTreeEvent &event)
627 {
628 wxTreeItemId parentId = event.GetItem();
629
630 // VS: this is needed because the event handler is called from wxTreeCtrl
631 // ctor when wxTR_HIDE_ROOT was specified
632
633 if (!m_rootId.IsOk())
634
635 m_rootId = m_treeCtrl->GetRootItem();
636
637 ExpandDir(parentId);
638 }
639
640 void wxGenericDirCtrl::OnCollapseItem(wxTreeEvent &event )
641 {
642 CollapseDir(event.GetItem());
643 }
644
645 void wxGenericDirCtrl::CollapseDir(wxTreeItemId parentId)
646 {
647 wxTreeItemId child;
648
649 wxDirItemData *data = (wxDirItemData *) m_treeCtrl->GetItemData(parentId);
650 if (!data->m_isExpanded)
651 return;
652
653 data->m_isExpanded = FALSE;
654 wxTreeItemIdValue cookie;
655 /* Workaround because DeleteChildren has disapeared (why?) and
656 * CollapseAndReset doesn't work as advertised (deletes parent too) */
657 child = m_treeCtrl->GetFirstChild(parentId, cookie);
658 while (child.IsOk())
659 {
660 m_treeCtrl->Delete(child);
661 /* Not GetNextChild below, because the cookie mechanism can't
662 * handle disappearing children! */
663 child = m_treeCtrl->GetFirstChild(parentId, cookie);
664 }
665 }
666
667 void wxGenericDirCtrl::ExpandDir(wxTreeItemId parentId)
668 {
669 wxDirItemData *data = (wxDirItemData *) m_treeCtrl->GetItemData(parentId);
670
671 if (data->m_isExpanded)
672 return;
673
674 data->m_isExpanded = TRUE;
675
676 if (parentId == m_treeCtrl->GetRootItem())
677 {
678 SetupSections();
679 return;
680 }
681
682 wxASSERT(data);
683
684 wxString search,path,filename;
685
686 wxString dirName(data->m_path);
687
688 #if defined(__WINDOWS__) || defined(__DOS__) || defined(__WXPM__)
689 // Check if this is a root directory and if so,
690 // whether the drive is avaiable.
691 if (!wxIsDriveAvailable(dirName))
692 {
693 data->m_isExpanded = FALSE;
694 //wxMessageBox(wxT("Sorry, this drive is not available."));
695 return;
696 }
697 #endif
698
699 // This may take a longish time. Go to busy cursor
700 wxBusyCursor busy;
701
702 #if defined(__WINDOWS__) || defined(__DOS__) || defined(__WXPM__)
703 if (dirName.Last() == ':')
704 dirName += wxString(wxFILE_SEP_PATH);
705 #endif
706
707 wxArrayString dirs;
708 wxArrayString filenames;
709
710 wxDir d;
711 wxString eachFilename;
712
713 wxLogNull log;
714 d.Open(dirName);
715
716 if (d.IsOpened())
717 {
718 int style = wxDIR_DIRS;
719 if (m_showHidden) style |= wxDIR_HIDDEN;
720 if (d.GetFirst(& eachFilename, wxEmptyString, style))
721 {
722 do
723 {
724 if ((eachFilename != wxT(".")) && (eachFilename != wxT("..")))
725 {
726 dirs.Add(eachFilename);
727 }
728 }
729 while (d.GetNext(& eachFilename));
730 }
731 }
732 dirs.Sort(wxDirCtrlStringCompareFunction);
733
734 // Now do the filenames -- but only if we're allowed to
735 if ((GetWindowStyle() & wxDIRCTRL_DIR_ONLY) == 0)
736 {
737 wxLogNull log;
738
739 d.Open(dirName);
740
741 if (d.IsOpened())
742 {
743 if (d.GetFirst(& eachFilename, m_currentFilterStr, wxDIR_FILES))
744 {
745 do
746 {
747 if ((eachFilename != wxT(".")) && (eachFilename != wxT("..")))
748 {
749 filenames.Add(eachFilename);
750 }
751 }
752 while (d.GetNext(& eachFilename));
753 }
754 }
755 filenames.Sort(wxDirCtrlStringCompareFunction);
756 }
757
758 // Add the sorted dirs
759 size_t i;
760 for (i = 0; i < dirs.Count(); i++)
761 {
762 wxString eachFilename(dirs[i]);
763 path = dirName;
764 if (!wxEndsWithPathSeparator(path))
765 path += wxString(wxFILE_SEP_PATH);
766 path += eachFilename;
767
768 wxDirItemData *dir_item = new wxDirItemData(path,eachFilename,TRUE);
769 wxTreeItemId id = AppendItem( parentId, eachFilename,
770 wxFileIconsTable::folder, -1, dir_item);
771 m_treeCtrl->SetItemImage( id, wxFileIconsTable::folder_open,
772 wxTreeItemIcon_Expanded );
773
774 // Has this got any children? If so, make it expandable.
775 // (There are two situations when a dir has children: either it
776 // has subdirectories or it contains files that weren't filtered
777 // out. The latter only applies to dirctrl with files.)
778 if ( dir_item->HasSubDirs() ||
779 (((GetWindowStyle() & wxDIRCTRL_DIR_ONLY) == 0) &&
780 dir_item->HasFiles(m_currentFilterStr)) )
781 {
782 m_treeCtrl->SetItemHasChildren(id);
783 }
784 }
785
786 // Add the sorted filenames
787 if ((GetWindowStyle() & wxDIRCTRL_DIR_ONLY) == 0)
788 {
789 for (i = 0; i < filenames.Count(); i++)
790 {
791 wxString eachFilename(filenames[i]);
792 path = dirName;
793 if (!wxEndsWithPathSeparator(path))
794 path += wxString(wxFILE_SEP_PATH);
795 path += eachFilename;
796 //path = dirName + wxString(wxT("/")) + eachFilename;
797 wxDirItemData *dir_item = new wxDirItemData(path,eachFilename,FALSE);
798 int image_id = wxFileIconsTable::file;
799 if (eachFilename.Find(wxT('.')) != wxNOT_FOUND)
800 image_id = wxTheFileIconsTable->GetIconID(eachFilename.AfterLast(wxT('.')));
801 (void) AppendItem( parentId, eachFilename, image_id, -1, dir_item);
802 }
803 }
804 }
805
806 void wxGenericDirCtrl::ReCreateTree()
807 {
808 CollapseDir(m_treeCtrl->GetRootItem());
809 ExpandDir(m_treeCtrl->GetRootItem());
810 }
811
812 // Find the child that matches the first part of 'path'.
813 // E.g. if a child path is "/usr" and 'path' is "/usr/include"
814 // then the child for /usr is returned.
815 wxTreeItemId wxGenericDirCtrl::FindChild(wxTreeItemId parentId, const wxString& path, bool& done)
816 {
817 wxString path2(path);
818
819 // Make sure all separators are as per the current platform
820 path2.Replace(wxT("\\"), wxString(wxFILE_SEP_PATH));
821 path2.Replace(wxT("/"), wxString(wxFILE_SEP_PATH));
822
823 // Append a separator to foil bogus substring matching
824 path2 += wxString(wxFILE_SEP_PATH);
825
826 // In MSW or PM, case is not significant
827 #if defined(__WINDOWS__) || defined(__DOS__) || defined(__WXPM__)
828 path2.MakeLower();
829 #endif
830
831 wxTreeItemIdValue cookie;
832 wxTreeItemId childId = m_treeCtrl->GetFirstChild(parentId, cookie);
833 while (childId.IsOk())
834 {
835 wxDirItemData* data = (wxDirItemData*) m_treeCtrl->GetItemData(childId);
836
837 if (data && !data->m_path.IsEmpty())
838 {
839 wxString childPath(data->m_path);
840 if (!wxEndsWithPathSeparator(childPath))
841 childPath += wxString(wxFILE_SEP_PATH);
842
843 // In MSW and PM, case is not significant
844 #if defined(__WINDOWS__) || defined(__DOS__) || defined(__WXPM__)
845 childPath.MakeLower();
846 #endif
847
848 if (childPath.Len() <= path2.Len())
849 {
850 wxString path3 = path2.Mid(0, childPath.Len());
851 if (childPath == path3)
852 {
853 if (path3.Len() == path2.Len())
854 done = TRUE;
855 else
856 done = FALSE;
857 return childId;
858 }
859 }
860 }
861
862 childId = m_treeCtrl->GetNextChild(parentId, cookie);
863 }
864 wxTreeItemId invalid;
865 return invalid;
866 }
867
868 // Try to expand as much of the given path as possible,
869 // and select the given tree item.
870 bool wxGenericDirCtrl::ExpandPath(const wxString& path)
871 {
872 bool done = FALSE;
873 wxTreeItemId id = FindChild(m_rootId, path, done);
874 wxTreeItemId lastId = id; // The last non-zero id
875 while (id.IsOk() && !done)
876 {
877 ExpandDir(id);
878
879 id = FindChild(id, path, done);
880 if (id.IsOk())
881 lastId = id;
882 }
883 if (lastId.IsOk())
884 {
885 wxDirItemData *data = (wxDirItemData *) m_treeCtrl->GetItemData(lastId);
886 if (data->m_isDir)
887 {
888 m_treeCtrl->Expand(lastId);
889 }
890 if ((GetWindowStyle() & wxDIRCTRL_SELECT_FIRST) && data->m_isDir)
891 {
892 // Find the first file in this directory
893 wxTreeItemIdValue cookie;
894 wxTreeItemId childId = m_treeCtrl->GetFirstChild(lastId, cookie);
895 bool selectedChild = FALSE;
896 while (childId.IsOk())
897 {
898 wxDirItemData* data = (wxDirItemData*) m_treeCtrl->GetItemData(childId);
899
900 if (data && data->m_path != wxT("") && !data->m_isDir)
901 {
902 m_treeCtrl->SelectItem(childId);
903 m_treeCtrl->EnsureVisible(childId);
904 selectedChild = TRUE;
905 break;
906 }
907 childId = m_treeCtrl->GetNextChild(lastId, cookie);
908 }
909 if (!selectedChild)
910 {
911 m_treeCtrl->SelectItem(lastId);
912 m_treeCtrl->EnsureVisible(lastId);
913 }
914 }
915 else
916 {
917 m_treeCtrl->SelectItem(lastId);
918 m_treeCtrl->EnsureVisible(lastId);
919 }
920
921 return TRUE;
922 }
923 else
924 return FALSE;
925 }
926
927 wxString wxGenericDirCtrl::GetPath() const
928 {
929 wxTreeItemId id = m_treeCtrl->GetSelection();
930 if (id)
931 {
932 wxDirItemData* data = (wxDirItemData*) m_treeCtrl->GetItemData(id);
933 return data->m_path;
934 }
935 else
936 return wxEmptyString;
937 }
938
939 wxString wxGenericDirCtrl::GetFilePath() const
940 {
941 wxTreeItemId id = m_treeCtrl->GetSelection();
942 if (id)
943 {
944 wxDirItemData* data = (wxDirItemData*) m_treeCtrl->GetItemData(id);
945 if (data->m_isDir)
946 return wxEmptyString;
947 else
948 return data->m_path;
949 }
950 else
951 return wxEmptyString;
952 }
953
954 void wxGenericDirCtrl::SetPath(const wxString& path)
955 {
956 m_defaultPath = path;
957 if (m_rootId)
958 ExpandPath(path);
959 }
960
961 // Not used
962 #if 0
963 void wxGenericDirCtrl::FindChildFiles(wxTreeItemId id, int dirFlags, wxArrayString& filenames)
964 {
965 wxDirItemData *data = (wxDirItemData *) m_treeCtrl->GetItemData(id);
966
967 // This may take a longish time. Go to busy cursor
968 wxBusyCursor busy;
969
970 wxASSERT(data);
971
972 wxString search,path,filename;
973
974 wxString dirName(data->m_path);
975
976 #if defined(__WXMSW__) || defined(__WXPM__)
977 if (dirName.Last() == ':')
978 dirName += wxString(wxFILE_SEP_PATH);
979 #endif
980
981 wxDir d;
982 wxString eachFilename;
983
984 wxLogNull log;
985 d.Open(dirName);
986
987 if (d.IsOpened())
988 {
989 if (d.GetFirst(& eachFilename, m_currentFilterStr, dirFlags))
990 {
991 do
992 {
993 if ((eachFilename != wxT(".")) && (eachFilename != wxT("..")))
994 {
995 filenames.Add(eachFilename);
996 }
997 }
998 while (d.GetNext(& eachFilename)) ;
999 }
1000 }
1001 }
1002 #endif
1003
1004 void wxGenericDirCtrl::SetFilterIndex(int n)
1005 {
1006 m_currentFilter = n;
1007
1008 wxString f, d;
1009 if (ExtractWildcard(m_filter, n, f, d))
1010 m_currentFilterStr = f;
1011 else
1012 m_currentFilterStr = wxT("*.*");
1013 }
1014
1015 void wxGenericDirCtrl::SetFilter(const wxString& filter)
1016 {
1017 m_filter = filter;
1018
1019 wxString f, d;
1020 if (ExtractWildcard(m_filter, m_currentFilter, f, d))
1021 m_currentFilterStr = f;
1022 else
1023 m_currentFilterStr = wxT("*.*");
1024 }
1025
1026 // Extract description and actual filter from overall filter string
1027 bool wxGenericDirCtrl::ExtractWildcard(const wxString& filterStr, int n, wxString& filter, wxString& description)
1028 {
1029 wxArrayString filters, descriptions;
1030 int count = ParseFilter(filterStr, filters, descriptions);
1031 if (count > 0 && n < count)
1032 {
1033 filter = filters[n];
1034 description = descriptions[n];
1035 return TRUE;
1036 }
1037
1038 return FALSE;
1039 }
1040
1041 // Parses the global filter, returning the number of filters.
1042 // Returns 0 if none or if there's a problem.
1043 // filterStr is in the form: "All files (*.*)|*.*|JPEG Files (*.jpeg)|*.jpg"
1044
1045 int wxGenericDirCtrl::ParseFilter(const wxString& filterStr, wxArrayString& filters, wxArrayString& descriptions)
1046 {
1047 return wxFileDialogBase::ParseWildcard(filterStr, descriptions, filters );
1048 }
1049
1050 void wxGenericDirCtrl::DoResize()
1051 {
1052 wxSize sz = GetClientSize();
1053 int verticalSpacing = 3;
1054 if (m_treeCtrl)
1055 {
1056 wxSize filterSz ;
1057 if (m_filterListCtrl)
1058 {
1059 #ifdef __WXMSW__
1060 // For some reason, this is required in order for the
1061 // correct control height to always be returned, rather
1062 // than the drop-down list height which is sometimes returned.
1063 wxSize oldSize = m_filterListCtrl->GetSize();
1064 m_filterListCtrl->SetSize(-1, -1, oldSize.x+10, -1, wxSIZE_USE_EXISTING);
1065 m_filterListCtrl->SetSize(-1, -1, oldSize.x, -1, wxSIZE_USE_EXISTING);
1066 #endif
1067 filterSz = m_filterListCtrl->GetSize();
1068 sz.y -= (filterSz.y + verticalSpacing);
1069 }
1070 m_treeCtrl->SetSize(0, 0, sz.x, sz.y);
1071 if (m_filterListCtrl)
1072 {
1073 m_filterListCtrl->SetSize(0, sz.y + verticalSpacing, sz.x, filterSz.y);
1074 // Don't know why, but this needs refreshing after a resize (wxMSW)
1075 m_filterListCtrl->Refresh();
1076 }
1077 }
1078 }
1079
1080
1081 void wxGenericDirCtrl::OnSize(wxSizeEvent& WXUNUSED(event))
1082 {
1083 DoResize();
1084 }
1085
1086 wxTreeItemId wxGenericDirCtrl::AppendItem (const wxTreeItemId & parent,
1087 const wxString & text,
1088 int image, int selectedImage,
1089 wxTreeItemData * data)
1090 {
1091 wxTreeCtrl *treeCtrl = GetTreeCtrl ();
1092
1093 wxASSERT (treeCtrl);
1094
1095 if (treeCtrl)
1096 {
1097 return treeCtrl->AppendItem (parent, text, image, selectedImage, data);
1098 }
1099 else
1100 {
1101 return wxTreeItemId();
1102 }
1103 }
1104
1105
1106 //-----------------------------------------------------------------------------
1107 // wxDirFilterListCtrl
1108 //-----------------------------------------------------------------------------
1109
1110 IMPLEMENT_CLASS(wxDirFilterListCtrl, wxChoice)
1111
1112 BEGIN_EVENT_TABLE(wxDirFilterListCtrl, wxChoice)
1113 EVT_CHOICE(-1, wxDirFilterListCtrl::OnSelFilter)
1114 END_EVENT_TABLE()
1115
1116 bool wxDirFilterListCtrl::Create(wxGenericDirCtrl* parent, const wxWindowID id,
1117 const wxPoint& pos,
1118 const wxSize& size,
1119 long style)
1120 {
1121 m_dirCtrl = parent;
1122 return wxChoice::Create(parent, id, pos, size, 0, NULL, style);
1123 }
1124
1125 void wxDirFilterListCtrl::Init()
1126 {
1127 m_dirCtrl = NULL;
1128 }
1129
1130 void wxDirFilterListCtrl::OnSelFilter(wxCommandEvent& WXUNUSED(event))
1131 {
1132 int sel = GetSelection();
1133
1134 wxString currentPath = m_dirCtrl->GetPath();
1135
1136 m_dirCtrl->SetFilterIndex(sel);
1137
1138 // If the filter has changed, the view is out of date, so
1139 // collapse the tree.
1140 m_dirCtrl->ReCreateTree();
1141
1142 // Try to restore the selection, or at least the directory
1143 m_dirCtrl->ExpandPath(currentPath);
1144 }
1145
1146 void wxDirFilterListCtrl::FillFilterList(const wxString& filter, int defaultFilter)
1147 {
1148 Clear();
1149 wxArrayString descriptions, filters;
1150 size_t n = (size_t) m_dirCtrl->ParseFilter(filter, filters, descriptions);
1151
1152 if (n > 0 && defaultFilter < (int) n)
1153 {
1154 size_t i = 0;
1155 for (i = 0; i < n; i++)
1156 Append(descriptions[i]);
1157 SetSelection(defaultFilter);
1158 }
1159 }
1160
1161
1162 // ----------------------------------------------------------------------------
1163 // wxFileIconsTable icons
1164 // ----------------------------------------------------------------------------
1165
1166 /* Open folder */
1167 static const char * file_icons_tbl_folder_open_xpm[] = {
1168 /* width height ncolors chars_per_pixel */
1169 "16 16 6 1",
1170 /* colors */
1171 " s None c None",
1172 ". c #000000",
1173 "+ c #c0c0c0",
1174 "@ c #808080",
1175 "# c #ffff00",
1176 "$ c #ffffff",
1177 /* pixels */
1178 " ",
1179 " @@@@@ ",
1180 " @$$$$$@ ",
1181 " @$#+#+#$@@@@@@ ",
1182 " @$+#+#+$$$$$$@.",
1183 " @$#+#+#+#+#+#@.",
1184 "@@@@@@@@@@@@@#@.",
1185 "@$$$$$$$$$$@@+@.",
1186 "@$#+#+#+#+##.@@.",
1187 " @$#+#+#+#+#+.@.",
1188 " @$+#+#+#+#+#.@.",
1189 " @$+#+#+#+##@..",
1190 " @@@@@@@@@@@@@.",
1191 " .............",
1192 " ",
1193 " "};
1194
1195 /* Computer */
1196 static const char * file_icons_tbl_computer_xpm[] = {
1197 "16 16 7 1",
1198 " s None c None",
1199 ". c #808080",
1200 "X c #c0c0c0",
1201 "o c Black",
1202 "O c Gray100",
1203 "+ c #008080",
1204 "@ c Blue",
1205 " ........... ",
1206 " .XXXXXXXXXX.o",
1207 " .OOOOOOOOO..o",
1208 " .OoooooooX..o",
1209 " .Oo+...@+X..o",
1210 " .Oo+XXX.+X..o",
1211 " .Oo+....+X..o",
1212 " .Oo++++++X..o",
1213 " .OXXXXXXXX.oo",
1214 " ..........o.o",
1215 " ...........Xo",
1216 " .XXXXXXXXXX.o",
1217 " .o.o.o.o.o...o",
1218 " .oXoXoXoXoXo.o ",
1219 ".XOXXXXXXXXX.o ",
1220 "............o "};
1221
1222 /* Drive */
1223 static const char * file_icons_tbl_drive_xpm[] = {
1224 "16 16 7 1",
1225 " s None c None",
1226 ". c #808080",
1227 "X c #c0c0c0",
1228 "o c Black",
1229 "O c Gray100",
1230 "+ c Green",
1231 "@ c #008000",
1232 " ",
1233 " ",
1234 " ",
1235 " ",
1236 " ............. ",
1237 " .XXXXXXXXXXXX.o",
1238 ".OOOOOOOOOOOO..o",
1239 ".XXXXXXXXX+@X..o",
1240 ".XXXXXXXXXXXX..o",
1241 ".X..........X..o",
1242 ".XOOOOOOOOOOX..o",
1243 "..............o ",
1244 " ooooooooooooo ",
1245 " ",
1246 " ",
1247 " "};
1248
1249 /* CD-ROM */
1250 static const char *file_icons_tbl_cdrom_xpm[] = {
1251 "16 16 10 1",
1252 " s None c None",
1253 ". c #808080",
1254 "X c #c0c0c0",
1255 "o c Yellow",
1256 "O c Blue",
1257 "+ c Black",
1258 "@ c Gray100",
1259 "# c #008080",
1260 "$ c Green",
1261 "% c #008000",
1262 " ... ",
1263 " ..XoX.. ",
1264 " .O.XoXXX+ ",
1265 " ...O.oXXXX+ ",
1266 " .O..X.XXXX+ ",
1267 " ....X.+..XXX+",
1268 " .XXX.+@+.XXX+",
1269 " .X@XX.+.X@@X+",
1270 " .....X...#XX@+ ",
1271 ".@@@...XXo.O@X+ ",
1272 ".@XXX..XXoXOO+ ",
1273 ".@++++..XoX+++ ",
1274 ".@$%@@XX+++X.+ ",
1275 ".............+ ",
1276 " ++++++++++++ ",
1277 " "};
1278
1279 /* Floppy */
1280 static const char * file_icons_tbl_floppy_xpm[] = {
1281 "16 16 7 1",
1282 " s None c None",
1283 ". c #808080",
1284 "X c Gray100",
1285 "o c #c0c0c0",
1286 "O c Black",
1287 "+ c Cyan",
1288 "@ c Red",
1289 " ......X",
1290 " .ooooooO",
1291 " .+++++OO",
1292 " .++++++O",
1293 " .++++++O",
1294 " .ooooooO",
1295 " .......o....oO",
1296 " .oooooo.o.O.XoO",
1297 ".XXXXXXXXOOOOOO ",
1298 ".ooooooooo@o..O ",
1299 ".ooo....oooo..O ",
1300 ".o..OOOO...o..O ",
1301 ".oooXXXXoooo..O ",
1302 ".............O ",
1303 " OOOOOOOOOOOO ",
1304 " "};
1305
1306 /* Removeable */
1307 static const char * file_icons_tbl_removeable_xpm[] = {
1308 "16 16 7 1",
1309 " s None c None",
1310 ". c #808080",
1311 "X c #c0c0c0",
1312 "o c Black",
1313 "O c Gray100",
1314 "+ c Red",
1315 "@ c #800000",
1316 " ",
1317 " ",
1318 " ",
1319 " ............. ",
1320 " .XXXXXXXXXXXX.o",
1321 ".OOOOOOOOOOOO..o",
1322 ".OXXXXXXXXXXX..o",
1323 ".O+@.oooooo.X..o",
1324 ".OXXOooooooOX..o",
1325 ".OXXXOOOOOOXX..o",
1326 ".OXXXXXXXXXXX..o",
1327 ".O............o ",
1328 " ooooooooooooo ",
1329 " ",
1330 " ",
1331 " "};
1332
1333 // ----------------------------------------------------------------------------
1334 // wxFileIconsTable & friends
1335 // ----------------------------------------------------------------------------
1336
1337 // global instance of a wxFileIconsTable
1338 wxFileIconsTable* wxTheFileIconsTable = (wxFileIconsTable *)NULL;
1339
1340 // A module to allow icons table cleanup
1341
1342 class wxFileIconsTableModule: public wxModule
1343 {
1344 DECLARE_DYNAMIC_CLASS(wxFileIconsTableModule)
1345 public:
1346 wxFileIconsTableModule() {}
1347 bool OnInit() { wxTheFileIconsTable = new wxFileIconsTable; return TRUE; }
1348 void OnExit()
1349 {
1350 if (wxTheFileIconsTable)
1351 {
1352 delete wxTheFileIconsTable;
1353 wxTheFileIconsTable = NULL;
1354 }
1355 }
1356 };
1357
1358 IMPLEMENT_DYNAMIC_CLASS(wxFileIconsTableModule, wxModule)
1359
1360 class wxFileIconEntry : public wxObject
1361 {
1362 public:
1363 wxFileIconEntry(int i) { id = i; }
1364
1365 int id;
1366 };
1367
1368 wxFileIconsTable::wxFileIconsTable()
1369 {
1370 m_HashTable = NULL;
1371 m_smallImageList = NULL;
1372 }
1373
1374 wxFileIconsTable::~wxFileIconsTable()
1375 {
1376 if (m_HashTable)
1377 {
1378 WX_CLEAR_HASH_TABLE(*m_HashTable);
1379 delete m_HashTable;
1380 }
1381 if (m_smallImageList) delete m_smallImageList;
1382 }
1383
1384 // delayed initialization - wait until first use (wxArtProv not created yet)
1385 void wxFileIconsTable::Create()
1386 {
1387 wxCHECK_RET(!m_smallImageList && !m_HashTable, wxT("creating icons twice"));
1388 m_HashTable = new wxHashTable(wxKEY_STRING);
1389 m_smallImageList = new wxImageList(16, 16);
1390
1391 // folder:
1392 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_FOLDER, wxART_CMN_DIALOG));
1393 // folder_open
1394 m_smallImageList->Add(wxIcon(file_icons_tbl_folder_open_xpm));
1395 // computer
1396 m_smallImageList->Add(wxIcon(file_icons_tbl_computer_xpm));
1397 // drive
1398 m_smallImageList->Add(wxIcon(file_icons_tbl_drive_xpm));
1399 // cdrom
1400 m_smallImageList->Add(wxIcon(file_icons_tbl_cdrom_xpm));
1401 // floppy
1402 m_smallImageList->Add(wxIcon(file_icons_tbl_floppy_xpm));
1403 // removeable
1404 m_smallImageList->Add(wxIcon(file_icons_tbl_removeable_xpm));
1405 // file
1406 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_NORMAL_FILE, wxART_CMN_DIALOG));
1407 // executable
1408 if (GetIconID(wxEmptyString, _T("application/x-executable")) == file)
1409 {
1410 m_smallImageList->Add(wxArtProvider::GetBitmap(wxART_EXECUTABLE_FILE, wxART_CMN_DIALOG));
1411 delete m_HashTable->Get(_T("exe"));
1412 m_HashTable->Delete(_T("exe"));
1413 m_HashTable->Put(_T("exe"), new wxFileIconEntry(executable));
1414 }
1415 /* else put into list by GetIconID
1416 (KDE defines application/x-executable for *.exe and has nice icon)
1417 */
1418 }
1419
1420 wxImageList *wxFileIconsTable::GetSmallImageList()
1421 {
1422 if (!m_smallImageList)
1423 Create();
1424
1425 return m_smallImageList;
1426 }
1427
1428 #if wxUSE_MIMETYPE
1429 // VS: we don't need this function w/o wxMimeTypesManager because we'll only have
1430 // one icon and we won't resize it
1431
1432 static wxBitmap CreateAntialiasedBitmap(const wxImage& img)
1433 {
1434 wxImage smallimg (16, 16);
1435 unsigned char *p1, *p2, *ps;
1436 unsigned char mr = img.GetMaskRed(),
1437 mg = img.GetMaskGreen(),
1438 mb = img.GetMaskBlue();
1439
1440 unsigned x, y;
1441 unsigned sr, sg, sb, smask;
1442
1443 p1 = img.GetData(), p2 = img.GetData() + 3 * 32, ps = smallimg.GetData();
1444 smallimg.SetMaskColour(mr, mr, mr);
1445
1446 for (y = 0; y < 16; y++)
1447 {
1448 for (x = 0; x < 16; x++)
1449 {
1450 sr = sg = sb = smask = 0;
1451 if (p1[0] != mr || p1[1] != mg || p1[2] != mb)
1452 sr += p1[0], sg += p1[1], sb += p1[2];
1453 else smask++;
1454 p1 += 3;
1455 if (p1[0] != mr || p1[1] != mg || p1[2] != mb)
1456 sr += p1[0], sg += p1[1], sb += p1[2];
1457 else smask++;
1458 p1 += 3;
1459 if (p2[0] != mr || p2[1] != mg || p2[2] != mb)
1460 sr += p2[0], sg += p2[1], sb += p2[2];
1461 else smask++;
1462 p2 += 3;
1463 if (p2[0] != mr || p2[1] != mg || p2[2] != mb)
1464 sr += p2[0], sg += p2[1], sb += p2[2];
1465 else smask++;
1466 p2 += 3;
1467
1468 if (smask > 2)
1469 ps[0] = ps[1] = ps[2] = mr;
1470 else
1471 ps[0] = sr >> 2, ps[1] = sg >> 2, ps[2] = sb >> 2;
1472 ps += 3;
1473 }
1474 p1 += 32 * 3, p2 += 32 * 3;
1475 }
1476
1477 return wxBitmap(smallimg);
1478 }
1479
1480 // finds empty borders and return non-empty area of image:
1481 static wxImage CutEmptyBorders(const wxImage& img)
1482 {
1483 unsigned char mr = img.GetMaskRed(),
1484 mg = img.GetMaskGreen(),
1485 mb = img.GetMaskBlue();
1486 unsigned char *dt = img.GetData(), *dttmp;
1487 unsigned w = img.GetWidth(), h = img.GetHeight();
1488
1489 unsigned top, bottom, left, right, i;
1490 bool empt;
1491
1492 #define MK_DTTMP(x,y) dttmp = dt + ((x + y * w) * 3)
1493 #define NOEMPTY_PIX(empt) if (dttmp[0] != mr || dttmp[1] != mg || dttmp[2] != mb) {empt = FALSE; break;}
1494
1495 for (empt = TRUE, top = 0; empt && top < h; top++)
1496 {
1497 MK_DTTMP(0, top);
1498 for (i = 0; i < w; i++, dttmp+=3)
1499 NOEMPTY_PIX(empt)
1500 }
1501 for (empt = TRUE, bottom = h-1; empt && bottom > top; bottom--)
1502 {
1503 MK_DTTMP(0, bottom);
1504 for (i = 0; i < w; i++, dttmp+=3)
1505 NOEMPTY_PIX(empt)
1506 }
1507 for (empt = TRUE, left = 0; empt && left < w; left++)
1508 {
1509 MK_DTTMP(left, 0);
1510 for (i = 0; i < h; i++, dttmp+=3*w)
1511 NOEMPTY_PIX(empt)
1512 }
1513 for (empt = TRUE, right = w-1; empt && right > left; right--)
1514 {
1515 MK_DTTMP(right, 0);
1516 for (i = 0; i < h; i++, dttmp+=3*w)
1517 NOEMPTY_PIX(empt)
1518 }
1519 top--, left--, bottom++, right++;
1520
1521 return img.GetSubImage(wxRect(left, top, right - left + 1, bottom - top + 1));
1522 }
1523 #endif // wxUSE_MIMETYPE
1524
1525 int wxFileIconsTable::GetIconID(const wxString& extension, const wxString& mime)
1526 {
1527 if (!m_smallImageList)
1528 Create();
1529
1530 #if wxUSE_MIMETYPE
1531 if (!extension.IsEmpty())
1532 {
1533 wxFileIconEntry *entry = (wxFileIconEntry*) m_HashTable->Get(extension);
1534 if (entry) return (entry -> id);
1535 }
1536
1537 wxFileType *ft = (mime.IsEmpty()) ?
1538 wxTheMimeTypesManager -> GetFileTypeFromExtension(extension) :
1539 wxTheMimeTypesManager -> GetFileTypeFromMimeType(mime);
1540
1541 wxIconLocation iconLoc;
1542 wxIcon ic;
1543 if ( ft && ft->GetIcon(&iconLoc) )
1544 {
1545 ic = wxIcon(iconLoc);
1546 }
1547
1548 delete ft;
1549
1550 if ( !ic.Ok() )
1551 {
1552 int newid = file;
1553 m_HashTable->Put(extension, new wxFileIconEntry(newid));
1554 return newid;
1555 }
1556
1557 wxBitmap tmpBmp;
1558 tmpBmp.CopyFromIcon(ic);
1559 wxImage img = tmpBmp.ConvertToImage();
1560
1561 int id = m_smallImageList->GetImageCount();
1562 if (img.GetWidth() == 16 && img.GetHeight() == 16)
1563 m_smallImageList->Add(wxBitmap(img));
1564 else
1565 {
1566 if (img.GetWidth() != 32 || img.GetHeight() != 32)
1567 m_smallImageList->Add(CreateAntialiasedBitmap(CutEmptyBorders(img).Rescale(32, 32)));
1568 else
1569 m_smallImageList->Add(CreateAntialiasedBitmap(img));
1570 }
1571 m_HashTable->Put(extension, new wxFileIconEntry(id));
1572 return id;
1573
1574 #else // !wxUSE_MIMETYPE
1575
1576 if (extension == wxT("exe"))
1577 return executable;
1578 else
1579 return file;
1580 #endif // wxUSE_MIMETYPE/!wxUSE_MIMETYPE
1581 }
1582
1583 #endif // wxUSE_DIRDLG
wxWidgets (Impactor)