ryzom/tools/leveldesign/master/MasterTree.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 // MasterTree.cpp : implementation file
  18 //
  19
  20 #include "stdafx.h"
  21 #include "master.h"
  22 #include "MasterTree.h"
  23 #include "Mainfrm.h"
  24 #include "nel/misc/types_nl.h"
  25 #ifdef NL_NEW
  26         #undef new
  27 #endif
  28 using namespace std;
  29
  30 #ifdef _DEBUG
  31 #define new DEBUG_NEW
  32 #undef THIS_FILE
  33 static char THIS_FILE[] = __FILE__;
  34 #endif
  35
  36 // ---------------------------------------------------------------------------
  37
  38 #define IDC_TREE                                        0x1000
  39
  40 // Top level menus
  41 #define ID_MENU_CONTINENT_NEW                   0x0044
  42
  43 #define ID_MENU_SORT_NAME_INC                   0x0047
  44 #define ID_MENU_SORT_NAME_DEC                   0x0048
  45 #define ID_MENU_SORT_DATE_INC                   0x0049
  46 #define ID_MENU_SORT_DATE_DEC                   0x0050
  47
  48 // Continent menus (a level under the top)
  49
  50 #define ID_MENU_CONTINENT_DELETE                0x0064
  51 #define ID_MENU_CONTINENT_OPEN                  0x0066
  52 #define ID_MENU_CONTINENT_PROPERTIES    0x0067
  53 #define ID_MENU_CONTINENT_NEW_REGION    0x0068
  54
  55 #define ID_MENU_REGION_OPEN                             0x0070
  56 #define ID_MENU_REGION_RENAME                   0x0071
  57 #define ID_MENU_REGION_NEW_SUBREGION    0x0072
  58 #define ID_MENU_REGION_NEW_PRIM                 0x0073
  59 #define ID_MENU_REGION_NEW_GEORGES              0x0074
  60 #define ID_MENU_REGION_DELETE                   0x0075
  61
  62 #define ID_MENU_FILE_OPEN                               0x0080
  63 #define ID_MENU_FILE_RENAME                             0x0081
  64 #define ID_MENU_FILE_DELETE                             0x0082
  65
  66 // ---------------------------------------------------------------------------
  67
  68 /////////////////////////////////////////////////////////////////////////////
  69 // CMasterTreeDlg dialog
  70 /////////////////////////////////////////////////////////////////////////////
  71
  72 BEGIN_MESSAGE_MAP (CMasterTree, CTreeCtrl)
  73
  74         ON_WM_TIMER()
  75
  76         ON_NOTIFY_REFLECT(TVN_BEGINDRAG, OnLBeginDrag)
  77
  78         ON_WM_MOUSEMOVE()
  79         ON_WM_LBUTTONDBLCLK()
  80         ON_WM_LBUTTONDOWN()
  81         ON_WM_LBUTTONUP()
  82         ON_WM_RBUTTONDOWN()
  83
  84         ON_COMMAND(ID_MENU_CONTINENT_NEW,                       OnMenuNewContinent)
  85
  86         ON_COMMAND(ID_MENU_CONTINENT_DELETE,            OnMenuContinentDelete)
  87         ON_COMMAND(ID_MENU_CONTINENT_OPEN,                      OnMenuContinentOpen)
  88         ON_COMMAND(ID_MENU_CONTINENT_PROPERTIES,        OnMenuContinentProperties)
  89         ON_COMMAND(ID_MENU_CONTINENT_NEW_REGION,        OnMenuContinentNewRegion)
  90
  91         ON_COMMAND(ID_MENU_REGION_OPEN,                         OnMenuRegionOpen)
  92         ON_COMMAND(ID_MENU_REGION_RENAME,                       OnMenuRegionRename)
  93         ON_COMMAND(ID_MENU_REGION_NEW_PRIM,                     OnMenuRegionNewPrim)
  94         ON_COMMAND(ID_MENU_REGION_NEW_GEORGES,          OnMenuRegionNewGeorges)
  95         ON_COMMAND(ID_MENU_REGION_DELETE,                       OnMenuRegionDelete)
  96         ON_COMMAND(ID_MENU_REGION_NEW_SUBREGION,        OnMenuRegionNewSubRegion)
  97
  98         ON_COMMAND(ID_MENU_FILE_OPEN,                           OnMenuFileOpen)
  99         ON_COMMAND(ID_MENU_FILE_RENAME,                         OnMenuFileRename)
 100         ON_COMMAND(ID_MENU_FILE_DELETE,                         OnMenuFileDelete)
 101
 102 END_MESSAGE_MAP()
 103
 104 // ---------------------------------------------------------------------------
 105 CMasterTree::CMasterTree ()
 106 {
 107         _LDrag = false;
 108         _LastItemSelected = NULL;
 109         _LastActiveContinent = NULL;
 110 }
 111
 112 // ---------------------------------------------------------------------------
 113 void CMasterTree::OnTimer (UINT nIDEvent)
 114 {
 115         if( nIDEvent != m_nTimerID )
 116         {
 117                 CTreeCtrl::OnTimer(nIDEvent);
 118                 return;
 119         }
 120
 121         // Doesn't matter that we didn't initialize m_timerticks
 122         m_timerticks++;
 123
 124         POINT pt;
 125         GetCursorPos (&pt);
 126         RECT rect;
 127         GetClientRect (&rect);
 128         ClientToScreen (&rect);
 129
 130         if( pt.y < rect.top + 10 )
 131         {
 132                 CImageList::DragShowNolock (FALSE);
 133                 SendMessage (WM_VSCROLL, SB_LINEUP);
 134                 CImageList::DragShowNolock (TRUE);
 135         }
 136         else if( pt.y > rect.bottom - 10 )
 137         {
 138                 CImageList::DragShowNolock (FALSE);
 139                 SendMessage (WM_VSCROLL, SB_LINEDOWN);
 140                 CImageList::DragShowNolock (TRUE);
 141         }
 142 }
 143
 144 // ---------------------------------------------------------------------------
 145 void CMasterTree::OnLBeginDrag (NMHDR* pNMHDR, LRESULT* pResult)
 146 {
 147         NMTREEVIEW *pNMTV = (NMTREEVIEW*)pNMHDR;
 148         _DragItem = pNMTV->itemNew.hItem;
 149         HTREEITEM hParent = GetParentItem (_DragItem);
 150         if (hParent == NULL)
 151         {
 152                 *pResult = true;
 153                 return;
 154         }
 155         _LDrag = true;
 156         m_nTimerID = SetTimer (1, 50, NULL);
 157         _DragImg = CreateDragImage (_DragItem);
 158         _DragImg->BeginDrag (0, CPoint (8, 8));
 159         _DragImg->DragEnter (this, ((NM_TREEVIEW *)pNMHDR)->ptDrag);
 160         SetCapture ();
 161         Invalidate ();
 162         *pResult = false;
 163 }
 164
 165 // ---------------------------------------------------------------------------
 166 void CMasterTree::OnLButtonDown (UINT nFlags, CPoint point)
 167 {
 168         /*HTREEITEM NewItem = HitTest (point);
 169
 170         if (NewItem == NULL)
 171                 return;
 172         */
 173         CTreeCtrl::OnLButtonDown (nFlags, point);
 174 /*
 175         HTREEITEM LastContinent, LastRegion;
 176         HTREEITEM NewContinent, NewRegion;
 177         LastContinent = getContinent (_LastItemSelected);
 178         LastRegion = getRegion (_LastItemSelected);
 179
 180         NewContinent = getContinent (NewItem);
 181         NewRegion = getRegion (NewItem);
 182
 183         if (LastRegion != NewRegion)
 184         {
 185                 Expand (LastRegion, TVE_COLLAPSE);
 186                 Expand (NewRegion, TVE_EXPAND);
 187         }
 188
 189         if (LastContinent != NewContinent)
 190         {
 191                 Expand (LastContinent, TVE_COLLAPSE);
 192                 Expand (NewContinent, TVE_EXPAND);
 193         }
 194
 195         _LastItemSelected = NewItem;
 196         Expand (NewItem, TVE_EXPAND);
 197         Select (NewItem, TVGN_CARET);*/
 198 }
 199 // ---------------------------------------------------------------------------
 200 void CMasterTree::OnLButtonDblClk (UINT nFlags, CPoint point)
 201 {
 202         CTreeCtrl::OnLButtonDblClk (nFlags, point);
 203
 204         HTREEITEM hItem = HitTest (point);
 205
 206         if (hItem != NULL)
 207         {
 208                 CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 209
 210                 if (isFile(hItem))
 211                 {
 212                         pDlg->openFile (getPath(hItem));
 213                 }
 214         }
 215 }
 216
 217 // ---------------------------------------------------------------------------
 218 void CMasterTree::OnLButtonUp (UINT nFlags, CPoint point)
 219 {
 220         if (_LDrag)
 221         {
 222                 SelectDropTarget (NULL);
 223                 _DragImg->DragLeave (this);
 224                 _DragImg->EndDrag ();
 225                 ReleaseCapture ();
 226                 KillTimer (m_nTimerID);
 227                 _LDrag = false;
 228                 delete _DragImg;
 229                 Invalidate ();
 230
 231                 HTREEITEM dragEndItem = HitTest (point);
 232                 if ((_DragItem == NULL) || (dragEndItem == NULL))
 233                         return;
 234
 235                 if (isFile(dragEndItem))
 236                         return;
 237
 238                 Select (dragEndItem, TVGN_CARET);
 239
 240                 CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 241                 pDlg->copy (getPath(_DragItem), getPath(dragEndItem));
 242         }
 243 }
 244
 245 // ---------------------------------------------------------------------------
 246 void CMasterTree::OnMouseMove (UINT nFlags, CPoint point)
 247 {
 248         if (_LDrag)
 249         {
 250                 _DragImg->DragMove (point);
 251                 _DragImg->DragShowNolock (FALSE);
 252
 253                 UINT Flags;
 254                 HTREEITEM hItem = HitTest (point, &Flags);
 255                 HTREEITEM hParent = GetParentItem (hItem) ;
 256
 257                 if ((_DragItem == NULL) || (hItem == NULL))
 258                         return;
 259
 260                 if (!isFile(hItem))
 261                         SelectDropTarget (hItem);
 262
 263                 _DragImg->DragShowNolock (TRUE);
 264         }
 265 }
 266
 267 // ---------------------------------------------------------------------------
 268 void CMasterTree::OnRButtonDown (UINT nFlags, CPoint point)
 269 {
 270         UINT uFlags;
 271         HTREEITEM hItem = HitTest (point, &uFlags);
 272         HTREEITEM hParent = GetParentItem (hItem);
 273         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 274
 275         CRect r;
 276         this->GetWindowRect (r);
 277
 278         CMenu *pMenu = new CMenu;
 279         pMenu->CreatePopupMenu ();
 280
 281         if (hItem == NULL)
 282         {
 283                 pMenu->AppendMenu (MF_STRING, ID_MENU_CONTINENT_NEW, "&New Continent");
 284                 pMenu->AppendMenu (MF_SEPARATOR);
 285                 pMenu->AppendMenu (MF_STRING, ID_MENU_SORT_NAME_DEC, "Sort By Name (A-Z)");
 286                 pMenu->AppendMenu (MF_STRING, ID_MENU_SORT_NAME_INC, "Sort By Name (Z-A)");
 287                 pMenu->AppendMenu (MF_STRING, ID_MENU_SORT_DATE_INC, "Sort By Date (New-Old)");
 288                 pMenu->AppendMenu (MF_STRING, ID_MENU_SORT_DATE_DEC, "Sort By Date (Old-New)");
 289         }
 290         else if (TVHT_ONITEM & uFlags)
 291         {
 292                 Select (hItem, TVGN_CARET);
 293
 294                 // System roots == continents
 295                 if (hParent == NULL)
 296                 {
 297                         pMenu->AppendMenu (MF_STRING, ID_MENU_CONTINENT_OPEN, "&Open");
 298                         pMenu->AppendMenu (MF_STRING, ID_MENU_CONTINENT_PROPERTIES, "&Properties");
 299                         pMenu->AppendMenu (MF_STRING, ID_MENU_CONTINENT_NEW_REGION, "New &Region");
 300                         pMenu->AppendMenu (MF_STRING, ID_MENU_CONTINENT_DELETE, "&Delete");
 301                 }
 302                 // Under the continents == regions and sub-regions
 303                 else
 304                 {
 305                         if (!isFile (hItem))
 306                         {
 307                                 pMenu->AppendMenu (MF_STRING, ID_MENU_REGION_OPEN, "&Open");
 308                                 pMenu->AppendMenu (MF_STRING, ID_MENU_REGION_RENAME, "&Rename");
 309                                 pMenu->AppendMenu (MF_STRING, ID_MENU_REGION_NEW_SUBREGION, "New &SubRegion");
 310                                 pMenu->AppendMenu (MF_STRING, ID_MENU_REGION_NEW_GEORGES, "New &Form");
 311                                 pMenu->AppendMenu (MF_STRING, ID_MENU_REGION_NEW_PRIM, "New &Patatoid");
 312                                 pMenu->AppendMenu (MF_STRING, ID_MENU_REGION_DELETE, "&Delete");
 313                         }
 314                         else
 315                         {
 316                                 pMenu->AppendMenu (MF_STRING, ID_MENU_FILE_OPEN, "&Open");
 317                                 pMenu->AppendMenu (MF_STRING, ID_MENU_FILE_RENAME, "&Rename");
 318                                 pMenu->AppendMenu (MF_STRING, ID_MENU_FILE_DELETE, "&Delete");
 319                         }
 320                 }
 321         }
 322         pMenu->TrackPopupMenu (TPM_LEFTALIGN | TPM_LEFTBUTTON,
 323                                                         r.left+point.x, r.top+point.y, this);
 324 }
 325
 326 // ---------------------------------------------------------------------------
 327 void CMasterTree::OnMenuNewContinent ()
 328 {
 329         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 330         pDlg->continentNew ();
 331 }
 332
 333 // ---------------------------------------------------------------------------
 334 void CMasterTree::OnMenuContinentDelete ()
 335 {
 336         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 337         pDlg->continentDelete ((LPCSTR)GetItemText(GetSelectedItem()));
 338 }
 339
 340 // ---------------------------------------------------------------------------
 341 void CMasterTree::OnMenuContinentOpen ()
 342 {
 343         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent ();
 344         HTREEITEM hItem = GetSelectedItem ();
 345         HTREEITEM hParent = GetParentItem (hItem);
 346
 347         if (_LastActiveContinent != NULL)
 348                 SetItem (_LastActiveContinent, TVIF_STATE, NULL, 0, 0, 0, TVIS_BOLD, 0);
 349         SetItem (hItem, TVIF_STATE, NULL, 0, 0, TVIS_BOLD, TVIS_BOLD, 0);
 350         _LastActiveContinent = hItem;
 351         pDlg->continentOpen (string((LPCSTR)GetItemText(hItem)));
 352 }
 353
 354 // ---------------------------------------------------------------------------
 355 void CMasterTree::OnMenuContinentProperties ()
 356 {
 357         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 358         pDlg->continentProperties ((LPCSTR)GetItemText(GetSelectedItem()));
 359 }
 360
 361 // ---------------------------------------------------------------------------
 362 void CMasterTree::OnMenuContinentNewRegion ()
 363 {
 364         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 365         pDlg->continentNewRegion ((LPCSTR)GetItemText(GetSelectedItem()));
 366 }
 367
 368 // ---------------------------------------------------------------------------
 369 void CMasterTree::OnMenuRegionOpen ()
 370 {
 371         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 372         HTREEITEM ht = GetSelectedItem();
 373         pDlg->regionOpen (getPath(ht));
 374 }
 375
 376 // ---------------------------------------------------------------------------
 377 void CMasterTree::OnMenuRegionRename ()
 378 {
 379         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 380         HTREEITEM ht = GetSelectedItem();
 381         pDlg->regionRename (getPath(ht));
 382 }
 383
 384 // ---------------------------------------------------------------------------
 385 void CMasterTree::OnMenuRegionNewSubRegion ()
 386 {
 387         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 388         HTREEITEM ht = GetSelectedItem();
 389         pDlg->regionNewSubRegion (getPath(ht));
 390 }
 391
 392 // ---------------------------------------------------------------------------
 393 void CMasterTree::OnMenuRegionNewPrim ()
 394 {
 395         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 396         HTREEITEM ht = GetSelectedItem();
 397         pDlg->regionNewPrim (getPath(ht));
 398 }
 399
 400 // ---------------------------------------------------------------------------
 401 void CMasterTree::OnMenuRegionNewGeorges ()
 402 {
 403         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 404         HTREEITEM ht = GetSelectedItem();
 405         pDlg->regionNewGeorges (getPath(ht));
 406 }
 407
 408 // ---------------------------------------------------------------------------
 409 void CMasterTree::OnMenuRegionDelete ()
 410 {
 411         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 412         HTREEITEM ht = GetSelectedItem();
 413         pDlg->regionDelete (getPath(ht));
 414 }
 415
 416 // ---------------------------------------------------------------------------
 417 void CMasterTree::OnMenuFileOpen ()
 418 {
 419         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 420         HTREEITEM hItem = GetSelectedItem();
 421         bool bFile = isFile (hItem);
 422         if (!bFile) return;
 423         pDlg->fileOpen (getPath(hItem));
 424 }
 425
 426 // ---------------------------------------------------------------------------
 427 void CMasterTree::OnMenuFileRename ()
 428 {
 429         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 430         HTREEITEM hItem = GetSelectedItem();
 431         bool bFile = isFile (hItem);
 432         if (!bFile) return;
 433         pDlg->fileRename (getPath(hItem));
 434 }
 435
 436 // ---------------------------------------------------------------------------
 437 void CMasterTree::OnMenuFileDelete ()
 438 {
 439         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 440         HTREEITEM hItem = GetSelectedItem();
 441         bool bFile = isFile (hItem);
 442         if (!bFile) return;
 443         pDlg->fileDelete (getPath(hItem));
 444 }
 445
 446 // ---------------------------------------------------------------------------
 447 string CMasterTree::getCurrentPath ()
 448 {
 449         return getPath(GetSelectedItem());
 450 }
 451
 452 // TOOLS
 453
 454 // ---------------------------------------------------------------------------
 455 string CMasterTree::getPath (HTREEITEM ht)
 456 {
 457         string sTmp = "";
 458
 459         while (ht != NULL)
 460         {
 461                 sTmp = string("\\") + (LPCSTR)GetItemText(ht) + sTmp;
 462                 ht = GetParentItem(ht);
 463         }
 464
 465         return sTmp;
 466 }
 467
 468 // ---------------------------------------------------------------------------
 469 HTREEITEM CMasterTree::getContinent (HTREEITEM ht)
 470 {
 471         if (ht == NULL) return NULL;
 472         if (GetParentItem(ht) == NULL) return NULL;
 473         while (GetParentItem(GetParentItem(ht)) != NULL)
 474                 ht = GetParentItem(ht);
 475         if (isFile(ht)) return NULL;
 476         return ht;
 477 }
 478
 479 // ---------------------------------------------------------------------------
 480 HTREEITEM CMasterTree::getRegion (HTREEITEM ht)
 481 {
 482         if (ht == NULL) return NULL;
 483         if (GetParentItem(ht) == NULL) return NULL;
 484         if (GetParentItem(GetParentItem(ht)) == NULL) return NULL;
 485         while (GetParentItem(GetParentItem(GetParentItem(ht))) != NULL)
 486                 ht = GetParentItem(ht);
 487         if (isFile(ht)) return NULL;
 488         return ht;
 489 }
 490
 491 // ---------------------------------------------------------------------------
 492 bool CMasterTree::isFile (HTREEITEM ht)
 493 {
 494         CMasterTreeDlg *pDlg = (CMasterTreeDlg*)GetParent();
 495         map<HTREEITEM,string>::iterator it = pDlg->_Files.find (ht);
 496         if (it != pDlg->_Files.end())
 497                 return true;
 498         else
 499                 return false;
 500 }
 501
 502
 503 /////////////////////////////////////////////////////////////////////////////
 504 // CMasterTreeDlg dialog
 505 /////////////////////////////////////////////////////////////////////////////
 506
 507 BEGIN_MESSAGE_MAP(CMasterTreeDlg, CDialog)
 508         //{{AFX_MSG_MAP(CMasterTreeDlg)
 509         ON_WM_SIZE()
 510         ON_NOTIFY(TVN_ITEMEXPANDING, IDC_TREE, OnExpanding)
 511         //ON_NOTIFY(NM_DBLCLK, IDC_TREE, OnLDblClkTree)
 512         ON_WM_CREATE()
 513         ON_WM_CLOSE()
 514         //}}AFX_MSG_MAP
 515 END_MESSAGE_MAP()
 516
 517
 518
 519 // ---------------------------------------------------------------------------
 520 CMasterTreeDlg::CMasterTreeDlg ()
 521 {
 522         _Tree = NULL;
 523         ContinentSortBy = 1;    // 0/1 - by name
 524         TrashSortBy = 1;                // 2/3 - by date
 525         BackupSortBy = 2;
 526 }
 527
 528 // ---------------------------------------------------------------------------
 529 FILETIME getFileTime (const string &fname)
 530 {
 531         WIN32_FIND_DATA FindFileData;
 532         HANDLE hFind;
 533         FILETIME ret = { 0xFFFFFFFF, 0xFFFFFFFF };
 534
 535         hFind = FindFirstFile (fname.c_str(), &FindFileData);
 536
 537         if (hFind != INVALID_HANDLE_VALUE)
 538         {
 539                 ret = FindFileData.ftLastWriteTime;
 540                 FindClose (hFind);
 541         }
 542         return ret;
 543 }
 544
 545 // ---------------------------------------------------------------------------
 546 void CMasterTreeDlg::parseAdd (HTREEITEM itRoot, const string &path, char SortType, int DirDepth)
 547 {
 548         WIN32_FIND_DATA findData;
 549         HANDLE hFind;
 550         CTreeCtrl *pTree = (CTreeCtrl*)GetDlgItem(IDC_TREE);
 551         vector<string> SortTable;
 552         sint32 i, j;
 553
 554         char sCurDir[MAX_PATH];
 555         GetCurrentDirectory (MAX_PATH, sCurDir);
 556
 557         if (!SetCurrentDirectory (path.c_str()))
 558         {
 559                 SetCurrentDirectory (sCurDir);
 560                 return;
 561         }
 562
 563         hFind = FindFirstFile ("*.*", &findData);
 564         if (hFind != INVALID_HANDLE_VALUE)
 565         {
 566                 do
 567                 {
 568                         // Look if the name is a system directory
 569                         bool bFound = false;
 570                         for (uint32 i = 0; i < MAX_SYS_DIR; ++i)
 571                                 if (stricmp (findData.cFileName, gSysDir[i]) == 0)
 572                                 {
 573                                         bFound = true;
 574                                         break;
 575                                 }
 576                         if (!bFound) // No ok lets add it
 577                         {
 578                                 SortTable.push_back (findData.cFileName);
 579                         }
 580                 }
 581                 while (FindNextFile(hFind, &findData) != 0);
 582                 FindClose (hFind);
 583         }
 584
 585         if (SortTable.size() == 0)
 586         {
 587                 SetCurrentDirectory (sCurDir);
 588                 return;
 589         }
 590
 591         if (SortType == 0) // Sort By Name increasing (z-a)
 592         {
 593                 for (i = 0; i < (sint32)SortTable.size()-1; ++i)
 594                 for (j = i+1; j < (sint32)SortTable.size(); ++j)
 595                         if (strcmp(SortTable[i].c_str(), SortTable[j].c_str()) < 0)
 596                         {
 597                                 string tmp = SortTable[i];
 598                                 SortTable[i] = SortTable[j];
 599                                 SortTable[j] = tmp;
 600                         }
 601         }
 602         if (SortType == 1) // Sort By Name decreasing (a-z)
 603         {
 604                 for (i = 0; i < (sint32)SortTable.size()-1; ++i)
 605                 for (j = i+1; j < (sint32)SortTable.size(); ++j)
 606                         if (strcmp(SortTable[i].c_str(), SortTable[j].c_str()) > 0)
 607                         {
 608                                 string tmp = SortTable[i];
 609                                 SortTable[i] = SortTable[j];
 610                                 SortTable[j] = tmp;
 611                         }
 612         }
 613         if (SortType == 2) // Sort By Date increasing
 614         {
 615                 for (i = 0; i < (sint32)SortTable.size()-1; ++i)
 616                 {
 617                         FILETIME timeI = getFileTime (SortTable[i]);
 618                         for (j = i+1; j < (sint32)SortTable.size(); ++j)
 619                         {
 620                                 FILETIME timeJ = getFileTime (SortTable[j]);
 621                                 if ((timeI.dwHighDateTime < timeJ.dwHighDateTime) ||
 622                                         (
 623                                                 (timeI.dwHighDateTime == timeJ.dwHighDateTime) &&
 624                                                 (timeI.dwLowDateTime < timeJ.dwLowDateTime)
 625                                         ))
 626                                 {
 627                                         string tmp = SortTable[i];
 628                                         SortTable[i] = SortTable[j];
 629                                         SortTable[j] = tmp;
 630                                         timeI = timeJ;
 631                                 }
 632                         }
 633                 }
 634         }
 635
 636         if (SortType == 3) // Sort By Date decreasing
 637         {
 638                 for (i = 0; i < (sint32)SortTable.size()-1; ++i)
 639                 {
 640                         FILETIME timeI = getFileTime (SortTable[i]);
 641                         for (j = i+1; j < (sint32)SortTable.size(); ++j)
 642                         {
 643                                 FILETIME timeJ = getFileTime (SortTable[j]);
 644                                 if ((timeI.dwHighDateTime > timeJ.dwHighDateTime) ||
 645                                         (
 646                                                 (timeI.dwHighDateTime == timeJ.dwHighDateTime) &&
 647                                                 (timeI.dwLowDateTime > timeJ.dwLowDateTime)
 648                                         ))
 649                                 {
 650                                         string tmp = SortTable[i];
 651                                         SortTable[i] = SortTable[j];
 652                                         SortTable[j] = tmp;
 653                                         timeI = timeJ;
 654                                 }
 655                         }
 656                 }
 657         }
 658
 659         // Put directories first !
 660         vector<string> SortTable2;
 661         for (i = 0; i < (sint32)SortTable.size(); ++i)
 662         {
 663                 if (GetFileAttributes(SortTable[i].c_str())&FILE_ATTRIBUTE_DIRECTORY)
 664                         SortTable2.push_back(SortTable[i]);
 665         }
 666         for (i = 0; i < (sint32)SortTable.size(); ++i)
 667         {
 668                 if (!(GetFileAttributes(SortTable[i].c_str())&FILE_ATTRIBUTE_DIRECTORY))
 669                         SortTable2.push_back(SortTable[i]);
 670         }
 671         SortTable = SortTable2;
 672
 673         // Recurse
 674         for (i = 0; i < (sint32)SortTable.size(); ++i)
 675         {
 676                 if (GetFileAttributes(SortTable[i].c_str())&FILE_ATTRIBUTE_DIRECTORY)
 677                 {
 678                         HTREEITEM item;
 679
 680                         if (DirDepth == 0)
 681                                 item = pTree->InsertItem (SortTable[i].c_str(), 2, 2, itRoot);
 682                         else
 683                                 item = pTree->InsertItem (SortTable[i].c_str(), 0, 0, itRoot);
 684                         string newPath = path;
 685                         if (newPath[newPath.size()-1] != '\\')
 686                                 newPath += "\\";
 687                         newPath += SortTable[i].c_str();
 688                         parseAdd (item, newPath, SortType, DirDepth+1);
 689                 }
 690                 else
 691                 {
 692                         // Look if the name is a valid filename (look at the extension)
 693                         bool bFound = false;
 694                         for (uint32 j = 0; j < MAX_INVALID_EXT; ++j)
 695                                 if (strlen(SortTable[i].c_str()) > strlen(gInvalidExt[j]))
 696                                 if (stricmp(&SortTable[i].c_str()[strlen(SortTable[i].c_str())-strlen(gInvalidExt[j])], gInvalidExt[j]) == 0)
 697                                 {
 698                                         bFound = true;
 699                                         break;
 700                                 }
 701                         // If the extension is an invalid one -> Do not display file
 702                         if (!bFound)
 703                         {
 704                                 HTREEITEM item = pTree->InsertItem (SortTable[i].c_str(), 1, 1, itRoot);
 705                                 string sTemp = path;
 706                                 if (sTemp[sTemp.size()-1] != '\\')
 707                                         sTemp += "\\";
 708                                 sTemp += SortTable[i].c_str();
 709                                 _Files.insert(map<HTREEITEM,string>::value_type(item, sTemp));
 710                         }
 711
 712                 }
 713         }
 714         SetCurrentDirectory (sCurDir);
 715 }
 716
 717 // ---------------------------------------------------------------------------
 718 HTREEITEM CMasterTreeDlg::activate (const std::string &name, HTREEITEM parent)
 719 {
 720         // Extract the eltName
 721         string eltName;
 722         string resName;
 723         uint32 i = 0;
 724         if (name.size() == 0) return NULL;
 725         if (name[i] == '\\') ++i;
 726         for (; i < name.size(); ++i)
 727         {
 728                 if (name[i] == '\\') break;
 729                 eltName += name[i];
 730         }
 731         ++i;
 732         for (; i < name.size(); ++i)
 733         {
 734                 resName += name[i];
 735         }
 736
 737         CTreeCtrl *pTree = (CTreeCtrl*)GetDlgItem (IDC_TREE);
 738         HTREEITEM hChildItem = pTree->GetChildItem (parent);
 739         bool bFound = false;
 740         while (hChildItem != NULL)
 741         {
 742                 if (eltName == (LPCSTR)pTree->GetItemText(hChildItem))
 743                 {
 744                         pTree->SetItem (hChildItem, TVIF_STATE, NULL, 0, 0, TVIS_BOLD, TVIS_BOLD, 0);
 745                         pTree->Expand (hChildItem, TVE_EXPAND);
 746                         activate (resName, hChildItem);
 747                         bFound = true;
 748                         break;
 749                 }
 750
 751                 hChildItem = pTree->GetNextItem (hChildItem, TVGN_NEXT);
 752         }
 753         if (bFound)
 754                 return hChildItem;
 755         else
 756                 return NULL;
 757 }
 758
 759 // ---------------------------------------------------------------------------
 760 void CMasterTreeDlg::update (const std::string& ContinentsPath)
 761 {
 762         CMasterTree *pTree = (CMasterTree*)GetDlgItem (IDC_TREE);
 763         string sCurPath = pTree->getCurrentPath();
 764         _Files.clear();
 765         pTree->DeleteAllItems ();
 766         // Parse all the path
 767         char sCurDir[MAX_PATH];
 768         GetCurrentDirectory (MAX_PATH, sCurDir);
 769         parseAdd (TVI_ROOT, ContinentsPath, ContinentSortBy);
 770         SetCurrentDirectory (sCurDir);
 771         // Hilight active Continent
 772         CMainFrame *pMF = (CMainFrame *)GetParent ();
 773         activate (sCurPath, TVI_ROOT);
 774 }
 775
 776 // ---------------------------------------------------------------------------
 777 void CMasterTreeDlg::DoDataExchange (CDataExchange* pDX)
 778 {
 779         CDialog::DoDataExchange (pDX);
 780         //{{AFX_DATA_MAP(CMasterTreeDlg)
 781                 // NOTE: the ClassWizard will add DDX and DDV calls here
 782         //}}AFX_DATA_MAP
 783 }
 784
 785 // ---------------------------------------------------------------------------
 786 BOOL CMasterTreeDlg::OnInitDialog()
 787 {
 788         CDialog::OnInitDialog();
 789
 790         _Tree = new CMasterTree;
 791         RECT r;
 792         r.left = r.top = 10;
 793         r.right = r.bottom = 40;
 794         _Tree->Create (WS_VISIBLE|WS_BORDER, r, this, IDC_TREE);
 795         // Load image list
 796         CImageList *pImgList = new CImageList;
 797         pImgList->Create (16, 16, ILC_MASK, 0, 5);
 798         pImgList->Add (AfxGetApp()->LoadIcon(IDI_FOLDER));
 799         pImgList->Add (AfxGetApp()->LoadIcon(IDI_FILE));
 800         pImgList->Add (AfxGetApp()->LoadIcon(IDI_CONTINENTS));
 801         pImgList->Add (AfxGetApp()->LoadIcon(IDI_BACKUP));
 802         pImgList->Add (AfxGetApp()->LoadIcon(IDI_TRASH));
 803
 804         _Tree->SetImageList (pImgList, TVSIL_NORMAL);
 805         return true;
 806 }
 807
 808 // ---------------------------------------------------------------------------
 809 void CMasterTreeDlg::OnSize (UINT nType, int cx, int cy)
 810 {
 811         if (_Tree)
 812                 _Tree->SetWindowPos (&wndTop, 0, 0, cx-20, cy-20, SWP_NOMOVE);
 813 }
 814
 815 // ---------------------------------------------------------------------------
 816 void CMasterTreeDlg::OnExpanding (LPNMHDR pnmhdr, LRESULT *pLResult)
 817 {
 818         /*CTreeCtrl *pTree = (CTreeCtrl*)GetDlgItem (IDC_TREE);
 819         NMTREEVIEW *pnmtv = (LPNMTREEVIEW) pnmhdr;
 820
 821         if ((pnmtv->itemNew.state & TVIS_EXPANDED) != 0)
 822         {
 823                 // We want to collapse this item -> forbid it
 824                 *pLResult = true;
 825         }*/
 826 }
 827
 828 // ---------------------------------------------------------------------------
 829 void CMasterTreeDlg::openFile (const std::string &fname)
 830 {
 831         CMainFrame *pMF = (CMainFrame *)GetParent();
 832         pMF->openFile (fname.c_str());
 833 }
 834
 835 // ---------------------------------------------------------------------------
 836 void CMasterTreeDlg::openDir (const std::string &fname)
 837 {
 838         CMainFrame *pMF = (CMainFrame *)GetParent();
 839         pMF->openDir (fname.c_str());
 840 }
 841
 842 // ---------------------------------------------------------------------------
 843 void CMasterTreeDlg::continentNew ()
 844 {
 845         CMainFrame *pMF = (CMainFrame *)GetParent();
 846         pMF->continentNew ();
 847 }
 848
 849 // ---------------------------------------------------------------------------
 850 void CMasterTreeDlg::continentDelete (const string &contName)
 851 {
 852         CMainFrame *pMF = (CMainFrame*)GetParent();
 853         pMF->continentDelete (contName);
 854 }
 855
 856 // ---------------------------------------------------------------------------
 857 void CMasterTreeDlg::continentProperties (const string &contName)
 858 {
 859         CMainFrame *pMF = (CMainFrame *)GetParent();
 860         pMF->continentProperties (contName);
 861 }
 862
 863 // ---------------------------------------------------------------------------
 864 void CMasterTreeDlg::continentNewRegion (const string &contName)
 865 {
 866         CMainFrame *pMF = (CMainFrame *)GetParent();
 867         pMF->continentNewRegion (contName);
 868 }
 869
 870 // ---------------------------------------------------------------------------
 871 void CMasterTreeDlg::continentOpen (const string &contName)
 872 {
 873         CMainFrame *pMF = (CMainFrame *)GetParent();
 874         pMF->continentOpen (contName);
 875 }
 876
 877 // ---------------------------------------------------------------------------
 878 void CMasterTreeDlg::regionOpen (const string &path)
 879 {
 880         CMainFrame *pMF = (CMainFrame *)GetParent();
 881         pMF->regionOpen (path);
 882 }
 883
 884 // ---------------------------------------------------------------------------
 885 void CMasterTreeDlg::regionRename (const string &path)
 886 {
 887         CMainFrame *pMF = (CMainFrame *)GetParent();
 888         pMF->regionRename (path);
 889 }
 890
 891 // ---------------------------------------------------------------------------
 892 void CMasterTreeDlg::regionNewPrim (const string &path)
 893 {
 894         CMainFrame *pMF = (CMainFrame *)GetParent();
 895         pMF->regionNewPrim (path);
 896 }
 897
 898 // ---------------------------------------------------------------------------
 899 void CMasterTreeDlg::regionNewGeorges (const string &path)
 900 {
 901         CMainFrame *pMF = (CMainFrame *)GetParent();
 902         pMF->regionNewGeorges (path);
 903 }
 904
 905 // ---------------------------------------------------------------------------
 906 void CMasterTreeDlg::regionNewSubRegion (const std::string &path)
 907 {
 908         CMainFrame *pMF = (CMainFrame *)GetParent();
 909         pMF->regionNewSubRegion (path);
 910 }
 911
 912 // ---------------------------------------------------------------------------
 913 void CMasterTreeDlg::regionDelete (const std::string &path)
 914 {
 915         CMainFrame *pMF = (CMainFrame *)GetParent();
 916         pMF->regionDelete (path);
 917 }
 918
 919 // ---------------------------------------------------------------------------
 920 void CMasterTreeDlg::fileOpen (const std::string &sFileFullName)
 921 {
 922         CMainFrame *pMF = (CMainFrame *)GetParent();
 923         pMF->fileOpen (sFileFullName);
 924 }
 925
 926 // ---------------------------------------------------------------------------
 927 void CMasterTreeDlg::fileRename (const std::string &sFileFullName)
 928 {
 929         CMainFrame *pMF = (CMainFrame *)GetParent();
 930         pMF->fileRename (sFileFullName);
 931 }
 932
 933 // ---------------------------------------------------------------------------
 934 void CMasterTreeDlg::fileDelete (const std::string &sFileFullName)
 935 {
 936         CMainFrame *pMF = (CMainFrame *)GetParent();
 937         pMF->fileDelete (sFileFullName);
 938 }
 939
 940 // ---------------------------------------------------------------------------
 941 void CMasterTreeDlg::copy (const std::string &pathSrc, const std::string &pathDst)
 942 {
 943         CMainFrame *pMF = (CMainFrame *)GetParent();
 944         pMF->copy (pathSrc, pathDst);
 945 }
 946
 947 // ---------------------------------------------------------------------------
 948 /*
 949 void CMasterTreeDlg::OnLDblClkTree(NMHDR* pNMHDR, LRESULT* pResult)
 950 {
 951         CTreeCtrl *pTree = (CTreeCtrl*)GetDlgItem (IDC_TREE);
 952         NMTREEVIEW *pnmtv = (LPNMTREEVIEW) pNMHDR;
 953         HTREEITEM hItem = pTree->GetSelectedItem();
 954         HTREEITEM hParent = pTree->GetParentItem (hItem);
 955
 956         *pResult = 0;
 957         if (hItem != NULL)
 958         {
 959                 map<HTREEITEM,string>::iterator it = _Files.find (hItem);
 960
 961                 if (it != _Files.end())
 962                 {
 963                         // Double click on a file open the corresponding editor
 964                         openAnyFile (it->second.c_str());
 965                         return;
 966                 }
 967
 968                 if ((hParent != NULL) && (pTree->GetParentItem (hParent) == NULL))
 969                 {
 970                         // Double click on a Continent open all editors
 971                         // Parse all files and open them in the good editor
 972                         HTREEITEM hChildItem = pTree->GetChildItem (hItem);
 973
 974                         while (hChildItem != NULL)
 975                         {
 976                                 it = _Files.find (hChildItem);
 977                                 if (it != _Files.end())
 978                                 {
 979                                         openAnyFile (it->second.c_str());
 980                                 }
 981                                 hChildItem = pTree->GetNextItem (hChildItem, TVGN_NEXT);
 982                         }
 983                         return;
 984                 }
 985         }
 986
 987 }
 988 */
 989 // ---------------------------------------------------------------------------
 990 void CMasterTreeDlg::OnCancel ()
 991 {
 992 }
 993
 994 // ---------------------------------------------------------------------------
 995 void CMasterTreeDlg::OnOK ()
 996 {
 997 }
 998