rbutil/rbutil.cpp

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * Module: rbutil
   9  * File: rbutil.cpp
  10  *
  11  * Copyright (C) 2005 Christi Alice Scarborough
  12  *
  13  * All files in this archive are subject to the GNU General Public License.
  14  * See the file COPYING in the source tree root for full license agreement.
  15  *
  16  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  17  * KIND, either express or implied.
  18  *
  19  ****************************************************************************/
  20
  21 #include "rbutil.h"
  22 #include "installlog.h"
  23
  24 /* this function gets a Bitmap from embedded memory */
  25 wxBitmap wxGetBitmapFromMemory(const unsigned char *data,int length)
  26 {
  27     wxMemoryInputStream istream( data,length);
  28     return wxBitmap(wxImage(istream, wxBITMAP_TYPE_ANY, -1), -1);
  29 }
  30
  31 // This class allows us to return directories as well as files to
  32 // wxDir::Traverse
  33 class wxDirTraverserIncludeDirs : public wxDirTraverser
  34 {
  35 public:
  36     wxDirTraverserIncludeDirs(wxArrayString& files) : m_files(files) { }
  37
  38     virtual wxDirTraverseResult OnFile(const wxString& filename)
  39     {
  40         m_files.Add(filename);
  41         return wxDIR_CONTINUE;
  42     }
  43
  44     virtual wxDirTraverseResult OnDir(const wxString& dirname)
  45     {
  46         m_files.Add(dirname);
  47         return wxDIR_CONTINUE;
  48     }
  49
  50 private:
  51     wxArrayString& m_files;
  52 };
  53
  54 wxDEFINE_SCOPED_PTR_TYPE(wxZipEntry);
  55
  56 const wxChar* _rootmatch[] = {
  57     wxT("rockbox.*"),
  58     wxT("ajbrec.ajz"),
  59     wxT("archos.mod"),
  60     wxT(".scrobbler.*"),
  61     wxT("battery_bench.txt"),
  62     wxT("battery.dummy"),
  63 };
  64 const wxArrayString* rootmatch = new wxArrayString(
  65     (size_t) (sizeof(_rootmatch) / sizeof(wxChar*)), _rootmatch);
  66
  67 bool InstallTheme(wxString Themesrc)
  68 {
  69     wxString dest,src,err;
  70
  71     int pos = Themesrc.Find('/',true);
  72     wxString themename = Themesrc.SubString(pos+1,Themesrc.Length());
  73
  74     src = gv->themes_url + wxT("/") + Themesrc;
  75     dest = gv->stdpaths->GetUserDataDir()
  76            + wxT("" PATH_SEP "download" PATH_SEP) + themename;
  77     if( DownloadURL(src, dest) )
  78     {
  79         wxRemoveFile(dest);
  80         ERR_DIALOG(wxT("Unable to download ") + src, wxT("Install Theme"));
  81         return false;
  82     }
  83
  84     if(!checkZip(dest))
  85     {
  86         ERR_DIALOG(wxT("The Zip ") + dest
  87                    + wxT(" does not contain the correct dir structure"),
  88                    wxT("Install Theme"));
  89         return false;
  90     }
  91
  92     if(UnzipFile(dest,gv->curdestdir, true))
  93     {
  94         ERR_DIALOG(wxT("Unable to unzip ") + dest + wxT(" to ")
  95                    + gv->curdestdir, wxT("Install Theme"));
  96         return false;
  97     }
  98
  99     return true;
 100 }
 101
 102 bool checkZip(wxString zipname)
 103 {
 104     wxZipEntryPtr       entry;
 105
 106     wxFFileInputStream* in_file = new wxFFileInputStream(zipname);
 107     wxZipInputStream* in_zip = new wxZipInputStream(*in_file);
 108
 109     entry.reset(in_zip->GetNextEntry());
 110
 111     wxString name = entry->GetName();
 112     if(entry->IsDir())
 113     {
 114         if(name.Contains(wxT(".rockbox")))
 115         {
 116             return true;
 117         }
 118     }
 119     return false;
 120 }
 121
 122 int DownloadURL(wxString src, wxString dest)
 123 {
 124     int input, errnum = 0, success = false;
 125     wxString buf, errstr;
 126     wxLogVerbose(wxT("=== begin DownloadURL(%s,%s)"), src.c_str(),
 127         dest.c_str());
 128
 129     buf = wxT("Fetching ") + src;
 130     wxProgressDialog* progress = new wxProgressDialog(wxT("Downloading"),
 131                 buf, 100, NULL, wxPD_APP_MODAL |
 132                 wxPD_AUTO_HIDE | wxPD_SMOOTH | wxPD_ELAPSED_TIME |
 133                 wxPD_REMAINING_TIME | wxPD_CAN_ABORT);
 134     progress->SetSize(500,200);
 135     progress->Update(0);
 136
 137
 138     input = true;
 139     wxURL* in_http = new wxURL(src);
 140
 141     if(gv->proxy_url != wxT(""))
 142         in_http->SetProxy(gv->proxy_url);
 143
 144     if (in_http->GetError() == wxURL_NOERR)
 145     {
 146
 147     wxFFileOutputStream* os = new wxFFileOutputStream(dest);
 148     input = false;
 149     if (os->IsOk())
 150     {
 151         wxInputStream* is = in_http->GetInputStream();
 152         input = true;
 153         if (is)
 154         {
 155             size_t filesize = is->GetSize();
 156             input = true;
 157             if (is->IsOk())
 158             {
 159                 char buffer[FILE_BUFFER_SIZE + 1];
 160                 size_t current = 0;
 161
 162                 while (! is->Eof())
 163                 {
 164                     is->Read(buffer, FILE_BUFFER_SIZE);
 165                     input = true;
 166                     if (is->LastRead() )
 167                     {
 168                         os->Write(buffer, is->LastRead());
 169                         input = false;
 170                         if (os->IsOk())
 171                         {
 172                             current += os->LastWrite();
 173                             if (!progress->Update(current * 100 / filesize))
 174                             {
 175                                 errstr = wxT("Download aborted by user");
 176                                 errnum = 1000;
 177                                 break;
 178                             }
 179
 180                         } else
 181                         {
 182                             errnum = os->GetLastError();
 183                             errstr = wxT("Can't write to output stream (")
 184                                      + stream_err_str(errnum) + wxT(")");
 185
 186                             break;
 187                         }
 188
 189                     } else
 190                     {
 191                         errnum = is->GetLastError();
 192                         if (errnum == wxSTREAM_EOF)
 193                         {
 194                             errnum = 0;
 195                             break;
 196                         }
 197                         errstr = wxT("Can't read from input stream (")
 198                                  + stream_err_str(errnum) + wxT(")");
 199                     }
 200                 }
 201
 202                 os->Close();
 203                 if (! errnum)
 204                 {
 205                     errnum = os->GetLastError();
 206                     errstr = wxT("Can't close output file (")
 207                              + stream_err_str(errnum) + wxT(")");
 208
 209                     input = false;
 210                 }
 211
 212                 if (! errnum) success = true;
 213
 214                 } else
 215                 {
 216                     errnum = is->GetLastError();
 217                     errstr = wxT("Can't get input stream size (")
 218                              + stream_err_str(errnum) + wxT(")");
 219                 }
 220             } else
 221             {
 222                 errnum = in_http->GetError();
 223                 errstr.Printf(wxT("Can't get input stream (%d)"), errnum);
 224             }
 225             delete is;
 226         } else
 227         {
 228             errnum = os->GetLastError();
 229             errstr = wxT("Can't create output stream (")
 230                      + stream_err_str(errnum) + wxT(")");
 231         }
 232         delete os;
 233     } else
 234     {
 235         errstr.Printf(wxT("Can't open URL %s (%d)"), src.c_str(),
 236             in_http->GetError() );
 237         errnum = 100;
 238     }
 239
 240     delete in_http;
 241     delete progress;
 242
 243     if (!success)
 244     {
 245         if (errnum == 0) errnum = 999;
 246         if (input)
 247         {
 248             ERR_DIALOG(errstr + wxT(" reading\n") + src, wxT("Download URL"));
 249         } else
 250         {
 251             ERR_DIALOG(errstr + wxT("writing to download\n/") + dest,
 252                        wxT("Download URL"));
 253         }
 254
 255     }
 256
 257     wxLogVerbose(wxT("=== end DownloadURL"));
 258     return errnum;
 259 }
 260
 261 int UnzipFile(wxString src, wxString destdir, bool isInstall)
 262 {
 263     wxZipEntryPtr       entry;
 264     wxString            in_str, progress_msg, buf;
 265     int                 errnum = 0, curfile = 0, totalfiles = 0;
 266     InstallLog*         log = NULL;
 267
 268     wxLogVerbose(wxT("===begin UnzipFile(%s,%s,%i)"),
 269                src.c_str(), destdir.c_str(), isInstall);
 270
 271     wxFFileInputStream* in_file = new wxFFileInputStream(src);
 272     wxZipInputStream* in_zip = new wxZipInputStream(*in_file);
 273     if (in_file->Ok() )
 274     {
 275         if (! in_zip->IsOk() )
 276         {
 277             errnum = in_zip->GetLastError();
 278             ERR_DIALOG(wxT("Can't open ZIP stream ") + src
 279                        + wxT(" for reading (") + stream_err_str(errnum)
 280                        + wxT(")"), wxT("Unzip File") );
 281             delete in_zip;
 282             delete in_file;
 283             return true;
 284         }
 285
 286         totalfiles = in_zip->GetTotalEntries();
 287         if (! in_zip->IsOk() )
 288         {
 289             errnum = in_zip->GetLastError();
 290             ERR_DIALOG( wxT("Error Getting total ZIP entries for ")
 291                         + src + wxT(" (") + stream_err_str(errnum) + wxT(")"),
 292                         wxT("Unzip File") );
 293             delete in_zip;
 294             delete in_file;
 295             return true;
 296         }
 297     } else
 298     {
 299         errnum = in_file->GetLastError();
 300         ERR_DIALOG(wxT("Can't open ") + src + wxT(" (")
 301                    + stream_err_str(errnum) + wxT(")"), wxT("Unzip File") );
 302         delete in_zip;
 303         delete in_file;
 304         return true;
 305     }
 306
 307     wxProgressDialog* progress = new wxProgressDialog(wxT("Unpacking archive"),
 308                   wxT("Preparing to unpack the downloaded files to your audio"
 309                   "device"), totalfiles, NULL, wxPD_APP_MODAL |
 310                   wxPD_AUTO_HIDE | wxPD_SMOOTH | wxPD_ELAPSED_TIME |
 311                   wxPD_REMAINING_TIME | wxPD_CAN_ABORT);
 312     progress->Update(0);
 313
 314     // We're not overly worried if the logging fails
 315     if (isInstall)
 316     {
 317         log = new InstallLog(destdir + wxT("" PATH_SEP UNINSTALL_FILE));
 318     }
 319
 320     while (! errnum &&
 321            (entry.reset(in_zip->GetNextEntry()), entry.get() != NULL) )
 322     {
 323
 324         curfile++;
 325         wxString name = entry->GetName();
 326         progress_msg = wxT("Unpacking ") + name;
 327         if (! progress->Update(curfile, progress_msg) ) {
 328             MESG_DIALOG(wxT("Unpacking cancelled by user"));
 329             errnum = 1000;
 330             break;
 331         }
 332
 333         in_str = destdir + wxT("" PATH_SEP) + name;
 334
 335         if (entry->IsDir() ) {
 336             if (!wxDirExists(in_str) ) {
 337                 if (! wxMkdir(in_str, 0777) ) {
 338                     buf = wxT("Unable to create directory ") + in_str;
 339                     errnum = 100;
 340                     break;
 341                 }
 342             }
 343             log->WriteFile(name, true); // Directory
 344             continue;
 345         }
 346
 347         wxFFileOutputStream* out = new wxFFileOutputStream(in_str);
 348         if (! out->IsOk() )
 349         {
 350             buf = wxT("Can't open file ") + in_str + wxT(" for writing");
 351             delete out;
 352             return 100;
 353         } else if (isInstall)
 354         {
 355             log->WriteFile(name);
 356         }
 357
 358         in_zip->Read(*out);
 359         if (! out->IsOk()) {
 360             buf.Printf(wxT("Can't write to %s (%d)"), in_str.c_str(),
 361                         errnum = out->GetLastError() );
 362         }
 363
 364         if (!in_zip->IsOk() && ! in_file->GetLastError() == wxSTREAM_EOF)
 365         {
 366             buf.Printf(wxT("Can't read from %s (%d)"), src.c_str(),
 367             errnum = in_file->GetLastError() );
 368         }
 369
 370         if (! out->Close() && errnum == 0)
 371         {
 372             buf.Printf(wxT("Unable to close %s (%d)"), in_str.c_str(),
 373                 errnum = out->GetLastError() );
 374
 375         }
 376
 377         delete out;
 378
 379     }
 380
 381     delete in_zip; delete in_file; delete progress;
 382
 383     if (errnum)
 384     {
 385         ERR_DIALOG(buf, wxT("Unzip File"));
 386     }
 387
 388     if (log) delete log;
 389     wxLogVerbose(wxT("=== end UnzipFile"));
 390     return(errnum);
 391 }
 392
 393 int Uninstall(const wxString dir, bool isFullUninstall) {
 394     wxString buf, uninst;
 395     unsigned int i;
 396     bool errflag = false;
 397     InstallLog *log = NULL;
 398     wxArrayString* FilesToRemove = NULL;
 399
 400     wxLogVerbose(wxT("=== begin Uninstall(%s,%i)"), dir.c_str(), isFullUninstall);
 401
 402     wxProgressDialog* progress = new wxProgressDialog(wxT("Uninstalling"),
 403                 wxT("Reading uninstall data from jukebox"), 100, NULL,
 404                 wxPD_APP_MODAL | wxPD_AUTO_HIDE | wxPD_SMOOTH |
 405                 wxPD_ELAPSED_TIME | wxPD_REMAINING_TIME | wxPD_CAN_ABORT);
 406     progress->Update(0);
 407
 408     if (! isFullUninstall)
 409     {
 410
 411         buf = dir + wxT("" PATH_SEP UNINSTALL_FILE);
 412         log = new InstallLog(buf, false); // Don't create the log
 413         FilesToRemove = log->GetInstalledFiles();
 414         if (log) delete log;
 415
 416         if (FilesToRemove == NULL || FilesToRemove->GetCount() < 1) {
 417             wxLogNull lognull;
 418             if ( wxMessageDialog(NULL,
 419                 wxT("Rockbox Utility can't find any uninstall data on this "
 420                 "jukebox.\n"
 421                 "Would you like to attempt a full uninstall?\n"
 422                 "(WARNING: A full uninstall removes all files in your Rockbox "
 423                 "folder)"),
 424                 wxT("Standard uninstall not possible"),
 425                 wxICON_EXCLAMATION | wxYES_NO | wxNO_DEFAULT).ShowModal()
 426                 == wxID_YES)
 427             {
 428                 isFullUninstall = true;
 429             }
 430             else {
 431                 MESG_DIALOG(wxT("Uninstall cancelled by user"));
 432                 delete progress;
 433                 return 1000;
 434             }
 435         }
 436     }
 437
 438     if (isFullUninstall )
 439     {
 440         buf = dir + wxT("" PATH_SEP ".rockbox");
 441         if (rm_rf(buf) )
 442         {
 443             WARN_DIALOG(wxT("Unable to completely remove Rockbox directory"),
 444             wxT("Full uninstall") );
 445             errflag = true;
 446         }
 447
 448         wxDir* root = new wxDir(dir);
 449         wxArrayString* special = new wxArrayString();
 450         // Search for files for deletion in the jukebox root
 451         for (i = 0; i < rootmatch->GetCount(); i++)
 452         {
 453             const wxString match = (*rootmatch)[i];
 454             root->GetAllFiles(dir, special, match, wxDIR_FILES);
 455         }
 456         delete root;
 457
 458         // Sort in reverse order so we get directories last
 459         special->Sort(true);
 460
 461         for (i = 0; i < special->GetCount(); i++)
 462         {
 463
 464             if (wxDirExists((*special)[i]) )
 465             {
 466                 // We don't check the return code since we don't want non
 467                 // empty dirs disappearing.
 468                 wxRmdir((*special)[i]);
 469
 470             } else if (wxFileExists((*special)[i]) )
 471             {
 472                 if (! wxRemoveFile((*special)[i]) )
 473                 {
 474                     WARN_DIALOG(wxT("Can't delete ") + (*special)[i],
 475                                 wxT("Full uninstall"));
 476                     errflag = true;
 477                 }
 478             }
 479             // Otherwise there isn't anything there, so we don't have to worry.
 480         }
 481         delete special;
 482     } else
 483     {
 484         wxString instplat, this_path_sep;
 485         unsigned int totalfiles, rc;
 486         totalfiles = FilesToRemove->GetCount();
 487         FilesToRemove->Sort(true); // Reverse alphabetical ie dirs after files
 488
 489         for (i = 0; i < totalfiles; i++)
 490         {
 491             // If we're running on the device, let's not delete our own
 492             // installation, eh?
 493             if (gv->portable &&
 494                 FilesToRemove->Item(i).StartsWith(PATH_SEP
 495                     wxT("RockboxUtility")) )
 496             {
 497                 continue;
 498             }
 499
 500             wxString* buf2 = new wxString;
 501             buf = dir + FilesToRemove->Item(i);
 502             buf2->Format(wxT("Deleting %s"), buf.c_str());
 503
 504             if (! progress->Update((i + 1) * 100 / totalfiles, *buf2) )
 505             {
 506                 WARN_DIALOG(wxT("Cancelled by user"), wxT("Normal Uninstall"));
 507                 delete progress;
 508                 return true;
 509             }
 510
 511             if (wxDirExists(buf) )
 512             {
 513                 // If we're about to attempt to remove .rockbox. delete
 514                 // install data first
 515                 *buf2 = dir + wxT("" PATH_SEP ".rockbox");
 516                 if ( buf.IsSameAs(buf2->c_str()) )
 517                 {
 518                     *buf2 = dir +wxT("" PATH_SEP UNINSTALL_FILE);
 519                     wxRemoveFile(*buf2);
 520                 }
 521
 522                 if ( (rc = ! wxRmdir(buf)) )
 523                 {
 524                     buf = buf.Format(wxT("Can't remove directory %s"),
 525                         buf.c_str());
 526                     errflag = true;
 527                     WARN_DIALOG(buf.c_str(), wxT("Standard uninstall"));
 528                 }
 529             } else if (wxFileExists(buf) )
 530             {
 531                 if ( (rc = ! wxRemoveFile(buf)) )
 532                 {
 533                     buf = buf.Format(wxT("Can't delete file %s"),
 534                         buf.c_str());
 535                     errflag = true;
 536                     WARN_DIALOG(buf.c_str(), wxT("Standard uninstall"));
 537                 }
 538             } else
 539             {
 540                 errflag = true;
 541                 buf = buf.Format(wxT("Can't find file or directory %s"),
 542                     buf.c_str() );
 543                 WARN_DIALOG(buf.c_str(), wxT("Standard uninstall") );
 544             }
 545
 546             uninst = uninst.AfterFirst('\n');
 547         }
 548         if (errflag)
 549         {
 550             ERR_DIALOG(wxT("Unable to remove some files"),
 551                 wxT("Standard uninstall"))    ;
 552         }
 553
 554         if (FilesToRemove != NULL) delete FilesToRemove;
 555     }
 556
 557     delete progress;
 558     wxLogVerbose(wxT("=== end Uninstall"));
 559     return errflag;
 560 }
 561
 562
 563 wxString stream_err_str(int errnum)
 564 {
 565     wxString out;
 566
 567     switch (errnum) {
 568     case wxSTREAM_NO_ERROR:
 569         out = wxT("wxSTREAM_NO_ERROR");
 570         break;
 571     case wxSTREAM_EOF:
 572         out = wxT("wxSTREAM_EOF");
 573         break;
 574     case wxSTREAM_WRITE_ERROR:
 575         out = wxT("wxSTREAM_WRITE_ERROR");
 576         break;
 577     case wxSTREAM_READ_ERROR:
 578         out = wxT("wxSTREAM_READ_ERROR");
 579         break;
 580     default:
 581         out = wxT("UNKNOWN");
 582         break;
 583     }
 584     return out;
 585 }
 586
 587 bool InstallRbutil(wxString dest)
 588 {
 589     wxArrayString   filestocopy;
 590     wxString        str, buf, dstr, localpath, destdir;
 591     unsigned int    i;
 592     wxDir           dir;
 593     bool            copied_exe = false, made_rbdir = false;
 594     InstallLog*     log;
 595
 596     buf = dest + wxT("" PATH_SEP ".rockbox");
 597
 598     if (! wxDirExists(buf) )
 599     {
 600         wxMkdir(buf);
 601         made_rbdir = true;
 602     }
 603
 604     buf = dest + wxT("" PATH_SEP UNINSTALL_FILE);
 605     log = new InstallLog(buf);
 606     if (made_rbdir) log->WriteFile(wxT(".rockbox"), true);
 607
 608     destdir = dest + wxT("" PATH_SEP "RockboxUtility");
 609     if (! wxDirExists(destdir) )
 610     {
 611         if (! wxMkdir(destdir, 0777) )
 612         {
 613             WARN_DIALOG( wxT("Unable to create directory for installer (")
 614                          + destdir + wxT(")"), wxT("Portable install") );
 615             return false;
 616         }
 617         log->WriteFile(wxT("RockboxUtility"), true);
 618     }
 619
 620     dir.GetAllFiles(gv->ResourceDir, &filestocopy, wxT("*"),
 621         wxDIR_FILES);
 622     if (filestocopy.GetCount() < 1)
 623     {
 624         WARN_DIALOG(wxT("No files to copy"), wxT("Portable install") );
 625         return false;
 626     }
 627
 628     // Copy the contents of the program directory
 629     for (i = 0; i < filestocopy.GetCount(); i++)
 630     {
 631         if (filestocopy[i].AfterLast(PATH_SEP_CHR) == EXE_NAME)
 632         {
 633             copied_exe = true;
 634         }
 635
 636         dstr = destdir + wxT("" PATH_SEP)
 637                + filestocopy[i].AfterLast(PATH_SEP_CHR);
 638         if (! wxCopyFile(filestocopy[i], dstr) )
 639         {
 640             WARN_DIALOG( wxT("Error copying file (")
 641                          + filestocopy[i].c_str() + wxT(" -> ")
 642                          + dstr + wxT(")"), wxT("Portable Install") );
 643             return false;
 644         }
 645         buf = dstr;
 646         buf.Replace(dest, wxEmptyString, false);
 647         log->WriteFile(buf);
 648     }
 649
 650     if (! copied_exe)
 651     {
 652         str = gv->AppDir + wxT("" PATH_SEP EXE_NAME);
 653         dstr = destdir + wxT("" PATH_SEP EXE_NAME);
 654         if (! wxCopyFile(str, dstr) )
 655         {
 656             WARN_DIALOG(wxT("Can't copy program binary ")
 657                         + str + wxT(" -> ") + dstr, wxT("Portable Install") );
 658             return false;
 659         }
 660         buf = dstr;
 661         buf.Replace(dest, wxEmptyString, false);
 662         log->WriteFile(buf);
 663     }
 664
 665     // Copy the local ini file so that it knows that it's a portable copy
 666     gv->UserConfig->Flush();
 667     dstr = destdir + wxT("" PATH_SEP "RockboxUtility.cfg");
 668     if (! wxCopyFile(gv->UserConfigFile, dstr) )
 669     {
 670         WARN_DIALOG(wxT("Unable to install user config file (")
 671                     + gv->UserConfigFile + wxT(" -> ") + dstr + wxT(")"),
 672                     wxT("Portable Install") );
 673         return false;
 674     }
 675     buf = dstr;
 676     buf.Replace(dest, wxEmptyString, false);
 677     log->WriteFile(buf);
 678
 679     delete log;
 680     return true;
 681 }
 682
 683 bool rm_rf(wxString file)
 684 {
 685     wxLogVerbose(wxT("=== begin rm-rf(%s)"), file.c_str() );
 686
 687     wxString buf;
 688     wxArrayString selected;
 689     wxDirTraverserIncludeDirs wxdtid(selected);
 690     unsigned int rc = 0, i;
 691     bool errflag = false;
 692
 693     if (wxFileExists(file) )
 694     {
 695         rc = ! wxRemoveFile(file);
 696     } else if (wxDirExists(file) )
 697     {
 698         wxDir* dir = new wxDir(file);;
 699         dir->Traverse(wxdtid);
 700         delete dir;
 701         // Sort into reverse alphabetical order for deletion in correct order
 702         // (directories after files)
 703         selected.Sort(true);
 704         selected.Add(file);
 705
 706         wxProgressDialog* progress = new wxProgressDialog(wxT("Removing files"),
 707                 wxT("Deleting files"), selected.GetCount(), NULL,
 708                 wxPD_APP_MODAL | wxPD_AUTO_HIDE | wxPD_SMOOTH |
 709                 wxPD_ELAPSED_TIME | wxPD_REMAINING_TIME | wxPD_CAN_ABORT);
 710
 711         for (i = 0; i < selected.GetCount(); i++)
 712         {
 713             wxLogVerbose(selected[i]);
 714             if (progress != NULL)
 715             {
 716                 buf = wxT("Deleting ") + selected[i];
 717                 if (! progress->Update(i, buf))
 718                 {
 719                     WARN_DIALOG(wxT("Cancelled by user"), wxT("Erase Files"));
 720                     delete progress;
 721                     return true;
 722                 }
 723             }
 724
 725             if (wxDirExists(selected[i]) )
 726             {
 727                 if ((rc = ! wxRmdir(selected[i])) )
 728                 {
 729                     errflag = true;
 730                     WARN_DIALOG(wxT("Can't remove directory ") + selected[i],
 731                                 wxT("Erase files"));
 732                 }
 733             } else if ((rc = ! wxRemoveFile(selected[i])) )
 734             {
 735                 errflag = true;
 736                 WARN_DIALOG(wxT("Error deleting file ") + selected[i],
 737                             wxT("Erase files"));
 738             }
 739         }
 740         delete progress;
 741     } else
 742     {
 743         WARN_DIALOG(wxT("Can't find expected file ") + file,
 744                     wxT("Erase files"));
 745         return true;
 746     }
 747
 748     wxLogVerbose(wxT("=== end rm-rf"));
 749     return rc ? true : false;
 750 }
 751
 752