src/DirectoryTreeCtrl.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2003-2008 Robert Rostek ( tecxx@rrs.at )
   6 // Copyright (c) 2002-2008 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   7 //
   8 // Any parts of this program derived from the xMule, lMule or eMule project,
   9 // or contributed by third-party developers are copyrighted by their
  10 // respective authors.
  11 //
  12 // This program is free software; you can redistribute it and/or modify
  13 // it under the terms of the GNU General Public License as published by
  14 // the Free Software Foundation; either version 2 of the License, or
  15 // (at your option) any later version.
  16 //
  17 // This program is distributed in the hope that it will be useful,
  18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 // GNU General Public License for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License
  23 // along with this program; if not, write to the Free Software
  24 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  25 //
  26
  27 #include "DirectoryTreeCtrl.h"  // Interface declarations
  28
  29 #include <wx/app.h>
  30 #include <wx/filename.h>
  31 #include <wx/imaglist.h>
  32
  33 #include <common/StringFunctions.h>
  34 #include <common/FileFunctions.h>
  35 #include "amule.h"                      // Needed for theApp
  36 #include "muuli_wdr.h"          // Needed for amuleSpecial
  37
  38
  39 BEGIN_EVENT_TABLE(CDirectoryTreeCtrl, wxTreeCtrl)
  40         EVT_TREE_ITEM_RIGHT_CLICK(wxID_ANY,     CDirectoryTreeCtrl::OnRButtonDown)
  41         EVT_TREE_ITEM_ACTIVATED(wxID_ANY,       CDirectoryTreeCtrl::OnItemActivated)
  42         EVT_TREE_ITEM_EXPANDED(wxID_ANY,        CDirectoryTreeCtrl::OnItemExpanding)
  43 END_EVENT_TABLE()
  44
  45
  46 class CItemData : public wxTreeItemData
  47 {
  48         public:
  49                 CItemData(const CPath& pathComponent)
  50                         : m_path(pathComponent)
  51                 {
  52                 }
  53
  54                 ~CItemData() {}
  55
  56                 const CPath& GetPathComponent() const { return m_path; }
  57         private:
  58                 CPath   m_path;
  59 };
  60
  61
  62 CDirectoryTreeCtrl::CDirectoryTreeCtrl(wxWindow* parent, int id, const wxPoint& pos, wxSize siz, int flags)
  63         : wxTreeCtrl(parent,id,pos,siz,flags,wxDefaultValidator,wxT("ShareTree"))
  64 {
  65         m_IsInit = false;
  66 #ifdef CLIENT_GUI
  67         m_IsRemote = !theApp->m_connect->IsConnectedToLocalHost();
  68 #else
  69         m_IsRemote = false;
  70 #endif
  71 }
  72
  73
  74 CDirectoryTreeCtrl::~CDirectoryTreeCtrl()
  75 {
  76 }
  77
  78 enum {
  79         IMAGE_FOLDER = 0,
  80         IMAGE_FOLDER_SUB_SHARED
  81 };
  82
  83
  84 void CDirectoryTreeCtrl::Init()
  85 {
  86         // already done ?
  87         if (m_IsInit) {
  88                 return;
  89         }
  90         m_IsInit = true;
  91
  92         // init image(s)
  93         wxImageList* images = new wxImageList(16, 16);
  94         images->Add(wxBitmap(amuleSpecial(1)));
  95         images->Add(wxBitmap(amuleSpecial(2)));
  96         // Gives wxTreeCtrl ownership of the list
  97         AssignImageList(images);
  98
  99
 100         // Create an empty root item, which we can
 101         // safely append when creating a full path.
 102         m_root = AddRoot(wxEmptyString, IMAGE_FOLDER, -1,
 103                                         new CItemData(CPath()));
 104
 105         if (!m_IsRemote) {
 106         #ifndef __WXMSW__
 107                 AddChildItem(m_root, CPath(wxT("/")));
 108         #else
 109                 // this might take awhile, so change the cursor
 110                 ::wxSetCursor(*wxHOURGLASS_CURSOR);
 111                 // retrieve bitmask of all drives available
 112                 uint32 drives = GetLogicalDrives();
 113                 drives >>= 1;
 114                 for (char drive = 'C'; drive <= 'Z'; drive++) {
 115                         drives >>= 1;
 116                         if (! (drives & 1)) { // skip non existant drives
 117                                 continue;
 118                         }
 119                         wxString driveStr = wxString::Format(wxT("%c:"), drive);
 120                         uint32 type = GetDriveType(driveStr + wxT("\\"));
 121
 122                         // skip removable/undefined drives, share only fixed or remote drives
 123                         if ((type == 3 || type == 4)   // fixed drive / remote drive
 124                                 && CPath::DirExists(driveStr)) {
 125                                 AddChildItem(m_root, CPath(driveStr));
 126                         }
 127                 }
 128                 ::wxSetCursor(*wxSTANDARD_CURSOR);
 129         #endif
 130         }
 131
 132         HasChanged = false;
 133
 134         UpdateSharedDirectories();
 135 }
 136
 137
 138 void CDirectoryTreeCtrl::OnItemExpanding(wxTreeEvent& evt)
 139 {
 140         wxTreeItemId hItem = evt.GetItem();
 141
 142         // Force reloading of the path
 143         DeleteChildren(hItem);
 144         AddSubdirectories(hItem, GetFullPath(hItem));
 145
 146         SortChildren(hItem);
 147 }
 148
 149
 150 void CDirectoryTreeCtrl::OnItemActivated(wxTreeEvent& evt)
 151 {
 152         if (!m_IsRemote) {
 153                 CheckChanged(evt.GetItem(), !IsBold(evt.GetItem()), false);
 154                 HasChanged = true;
 155         }
 156 }
 157
 158
 159 void CDirectoryTreeCtrl::OnRButtonDown(wxTreeEvent& evt)
 160 {
 161         if (m_IsRemote) {
 162                 SelectItem(evt.GetItem()); // looks weird otherwise
 163         } else {
 164                 // this might take awhile, so change the cursor
 165                 ::wxSetCursor(*wxHOURGLASS_CURSOR);
 166                 MarkChildren(evt.GetItem(), !IsBold(evt.GetItem()), false);
 167                 ::wxSetCursor(*wxSTANDARD_CURSOR);
 168                 HasChanged = true;
 169         }
 170 }
 171
 172
 173 void CDirectoryTreeCtrl::MarkChildren(wxTreeItemId hChild, bool mark, bool recursed)
 174 {
 175         // Ensure that children are added, otherwise we might only get a "." entry.
 176         if (!IsExpanded(hChild) && ItemHasChildren(hChild)) {
 177                 DeleteChildren(hChild);
 178                 AddSubdirectories(hChild, GetFullPath(hChild));
 179                 SortChildren(hChild);
 180         }
 181
 182         wxTreeItemIdValue cookie;
 183         wxTreeItemId hChild2 = GetFirstChild(hChild, cookie);
 184         if (hChild2.IsOk()) {
 185                 SetHasSharedSubdirectory(hChild, mark);
 186         }
 187         while (hChild2.IsOk()) {
 188                 MarkChildren(hChild2, mark, true);
 189
 190                 hChild2 = GetNextSibling(hChild2);
 191         }
 192
 193         CheckChanged(hChild, mark, recursed);
 194 }
 195
 196
 197 void CDirectoryTreeCtrl::AddChildItem(wxTreeItemId hBranch, const CPath& item)
 198 {
 199         wxCHECK_RET(hBranch.IsOk(), wxT("Attempted to add children to invalid item"));
 200
 201         CPath fullPath = GetFullPath(hBranch).JoinPaths(item);
 202         wxTreeItemId treeItem = AppendItem(hBranch, item.GetPrintable(),
 203                                                 IMAGE_FOLDER, -1,
 204                                                 new CItemData(item));
 205
 206         if (IsShared(fullPath)) {
 207                 SetItemBold(treeItem, true);
 208         }
 209
 210         if (HasSharedSubdirectory(fullPath)) {
 211                 SetHasSharedSubdirectory(treeItem, true);
 212         }
 213
 214         if (HasSubdirectories(fullPath)) {
 215                 // Trick. will show + if it has subdirs
 216                 AppendItem(treeItem, wxT("."));
 217         }
 218 }
 219
 220
 221 CPath CDirectoryTreeCtrl::GetFullPath(wxTreeItemId hItem)
 222 {
 223         wxCHECK_MSG(hItem.IsOk(), CPath(), wxT("Invalid item in GetFullPath"));
 224
 225         CPath result;
 226         for (; hItem.IsOk(); hItem = GetItemParent(hItem)) {
 227                 CItemData* data = dynamic_cast<CItemData*>(GetItemData(hItem));
 228                 wxCHECK_MSG(data, CPath(), wxT("Missing data-item in GetFullPath"));
 229
 230                 result = data->GetPathComponent().JoinPaths(result);
 231         }
 232
 233         return result;
 234 }
 235
 236
 237 void CDirectoryTreeCtrl::AddSubdirectories(wxTreeItemId hBranch, const CPath& path)
 238 {
 239         wxCHECK_RET(path.IsOk(), wxT("Invalid path in AddSubdirectories"));
 240
 241         CDirIterator sharedDir(path);
 242
 243         CPath dirName = sharedDir.GetFirstFile(CDirIterator::Dir);
 244         while (dirName.IsOk()) {
 245                 AddChildItem(hBranch, dirName);
 246
 247                 dirName = sharedDir.GetNextFile();
 248         }
 249 }
 250
 251
 252 bool CDirectoryTreeCtrl::HasSubdirectories(const CPath& folder)
 253 {
 254         // Prevent error-messages if we try to traverse somewhere we have no access.
 255         wxLogNull logNo;
 256
 257         return CDirIterator(folder).HasSubDirs();
 258 }
 259
 260
 261 void CDirectoryTreeCtrl::GetSharedDirectories(PathList* list)
 262 {
 263         wxCHECK_RET(list, wxT("Invalid list in GetSharedDirectories"));
 264
 265         for (SharedMap::iterator it = m_lstShared.begin(); it != m_lstShared.end(); it++) {
 266                 list->push_back(it->second);
 267         }
 268 }
 269
 270
 271 void CDirectoryTreeCtrl::SetSharedDirectories(PathList* list)
 272 {
 273         wxCHECK_RET(list, wxT("Invalid list in SetSharedDirectories"));
 274
 275         m_lstShared.clear();
 276         for (PathList::iterator it = list->begin(); it != list->end(); it++) {
 277                 m_lstShared.insert(SharedMapItem(GetKey(*it), *it));
 278         }
 279
 280         if (m_IsInit) {
 281                 UpdateSharedDirectories();
 282         }
 283 }
 284
 285
 286 wxString CDirectoryTreeCtrl::GetKey(const CPath& path)
 287 {
 288         if (m_IsRemote) {
 289                 return path.GetRaw();
 290         }
 291
 292         // Sanity check, see IsSameAs() in Path.cpp
 293         const wxString cwd = wxGetCwd();
 294         const int flags = (wxPATH_NORM_ALL | wxPATH_NORM_CASE) & ~wxPATH_NORM_ENV_VARS;
 295         wxFileName fn(path.GetRaw());
 296         fn.Normalize(flags, cwd);
 297         return fn.GetFullPath();
 298 }
 299
 300
 301 void CDirectoryTreeCtrl::UpdateSharedDirectories()
 302 {
 303         // ugly hack to at least show shared dirs in remote gui
 304         if (m_IsRemote) {
 305                 DeleteChildren(m_root);
 306                 for (SharedMap::iterator it = m_lstShared.begin(); it != m_lstShared.end(); it++) {
 307                         AppendItem(m_root, it->second.GetPrintable(), IMAGE_FOLDER, -1, new CItemData(it->second));
 308                 }
 309                 return;
 310         }
 311
 312         // Mark all shared root items (on windows this can be multiple
 313         // drives, on unix there is only the root dir).
 314         wxTreeItemIdValue cookie;
 315         wxTreeItemId hChild = GetFirstChild(GetRootItem(), cookie);
 316
 317         while (hChild.IsOk()) {
 318                 // Does this drive have shared subfolders?
 319                 if (HasSharedSubdirectory(GetFullPath(hChild))) {
 320                         SetHasSharedSubdirectory(hChild, true);
 321                 }
 322
 323                 // Is this drive shared?
 324                 if (IsShared(GetFullPath(hChild))) {
 325                         SetItemBold(hChild, true);
 326                 }
 327
 328                 hChild = GetNextSibling(hChild);
 329         }
 330 }
 331
 332
 333 bool CDirectoryTreeCtrl::HasSharedSubdirectory(const CPath& path)
 334 {
 335         SharedMap::iterator it = m_lstShared.upper_bound(GetKey(path) + wxFileName::GetPathSeparator());
 336         if (it == m_lstShared.end()) {
 337                 return false;
 338         }
 339         // upper_bound() doesn't find the directory itself, so no need to check for that.
 340         return it->second.StartsWith(path);
 341 }
 342
 343
 344 void CDirectoryTreeCtrl::SetHasSharedSubdirectory(wxTreeItemId hItem, bool add)
 345 {
 346         SetItemImage(hItem, add ? IMAGE_FOLDER_SUB_SHARED : IMAGE_FOLDER);
 347 }
 348
 349
 350 void CDirectoryTreeCtrl::CheckChanged(wxTreeItemId hItem, bool bChecked, bool recursed)
 351 {
 352         if (IsBold(hItem) != bChecked) {
 353                 SetItemBold(hItem, bChecked);
 354
 355                 if (bChecked) {
 356                         AddShare(GetFullPath(hItem));
 357                 } else {
 358                         DelShare(GetFullPath(hItem));
 359                 }
 360
 361                 if (!recursed) {
 362                         UpdateParentItems(hItem, bChecked);
 363                 }
 364         }
 365 }
 366
 367
 368 bool CDirectoryTreeCtrl::IsShared(const CPath& path)
 369 {
 370         wxCHECK_MSG(path.IsOk(), false, wxT("Invalid path in IsShared"));
 371
 372         return m_lstShared.find(GetKey(path)) != m_lstShared.end();
 373 }
 374
 375
 376 void CDirectoryTreeCtrl::AddShare(const CPath& path)
 377 {
 378         wxCHECK_RET(path.IsOk(), wxT("Invalid path in AddShare"));
 379
 380         if (IsShared(path)) {
 381                 return;
 382         }
 383
 384         m_lstShared.insert(SharedMapItem(GetKey(path), path));
 385 }
 386
 387
 388 void CDirectoryTreeCtrl::DelShare(const CPath& path)
 389 {
 390         wxCHECK_RET(path.IsOk(), wxT("Invalid path in DelShare"));
 391
 392         m_lstShared.erase(GetKey(path));
 393 }
 394
 395
 396 void CDirectoryTreeCtrl::UpdateParentItems(wxTreeItemId hChild, bool add)
 397 {
 398         wxTreeItemId parent = hChild;
 399         while (parent != GetRootItem()) {
 400                 parent = GetItemParent(parent);
 401                 if (add) {
 402                         if (GetItemImage(parent) == IMAGE_FOLDER_SUB_SHARED) {
 403                                 // parent already marked -> so are all its parents, finished
 404                                 break;
 405                         } else {
 406                                 SetHasSharedSubdirectory(parent, true);
 407                         }
 408                 } else {
 409                         if (GetItemImage(parent) == IMAGE_FOLDER_SUB_SHARED) {
 410                                 // check if now there are still other shared dirs
 411                                 if (HasSharedSubdirectory(GetFullPath(parent))) {
 412                                         // yes, then further parents can stay red
 413                                         break;
 414                                 } else {
 415                                         // no, further parents have to be checked too
 416                                         SetHasSharedSubdirectory(parent, false);
 417                                 }
 418                         } else {  // should not happen (unmark child of which the parent is already unmarked
 419                                 break;
 420                         }
 421                 }
 422         }
 423 }
 424 // File_checked_for_headers