/[svn]/gigedit/trunk/src/gigedit/mainwindow.cpp
ViewVC logotype

Diff of /gigedit/trunk/src/gigedit/mainwindow.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3469 by persson, Tue Feb 12 18:54:58 2019 UTC revision 3471 by persson, Sat Feb 16 19:13:37 2019 UTC
# Line 1892  void MainWindow::on_sel_change() Line 1892  void MainWindow::on_sel_change()
1892      }      }
1893  }  }
1894    
1895    
1896    LoaderSaverBase::LoaderSaverBase(const Glib::ustring filename, gig::File* gig) :
1897        filename(filename), gig(gig), thread(0), progress(0.f)
1898    {
1899    }
1900    
1901  void loader_progress_callback(gig::progress_t* progress)  void loader_progress_callback(gig::progress_t* progress)
1902  {  {
1903      Loader* loader = static_cast<Loader*>(progress->custom);      LoaderSaverBase* loader = static_cast<LoaderSaverBase*>(progress->custom);
1904      loader->progress_callback(progress->factor);      loader->progress_callback(progress->factor);
1905  }  }
1906    
1907  void Loader::progress_callback(float fraction)  void LoaderSaverBase::progress_callback(float fraction)
1908  {  {
1909      {      {
1910          Glib::Threads::Mutex::Lock lock(progressMutex);          Glib::Threads::Mutex::Lock lock(progressMutex);
# Line 1911  void Loader::progress_callback(float fra Line 1917  void Loader::progress_callback(float fra
1917  // make sure stack is 16-byte aligned for SSE instructions  // make sure stack is 16-byte aligned for SSE instructions
1918  __attribute__((force_align_arg_pointer))  __attribute__((force_align_arg_pointer))
1919  #endif  #endif
1920  void Loader::thread_function()  void LoaderSaverBase::thread_function()
1921  {  {
1922      printf("thread_function self=%p\n",      printf("thread_function self=%p\n",
1923             static_cast<void*>(Glib::Threads::Thread::self()));             static_cast<void*>(Glib::Threads::Thread::self()));
1924      printf("Start %s\n", filename.c_str());      printf("Start %s\n", filename.c_str());
1925      try {      try {
         RIFF::File* riff = new RIFF::File(filename);  
         gig = new gig::File(riff);  
1926          gig::progress_t progress;          gig::progress_t progress;
1927          progress.callback = loader_progress_callback;          progress.callback = loader_progress_callback;
1928          progress.custom = this;          progress.custom = this;
1929    
1930          gig->GetInstrument(0, &progress);          thread_function_sub(progress);
1931          printf("End\n");          printf("End\n");
1932          finished_dispatcher();          finished_dispatcher();
1933      } catch (RIFF::Exception e) {      } catch (RIFF::Exception e) {
# Line 1935  void Loader::thread_function() Line 1939  void Loader::thread_function()
1939      }      }
1940  }  }
1941    
1942  Loader::Loader(const char* filename)  void LoaderSaverBase::launch()
     : filename(filename), gig(0), thread(0), progress(0.f)  
 {  
 }  
   
 void Loader::launch()  
1943  {  {
1944  #ifdef OLD_THREADS  #ifdef OLD_THREADS
1945      thread = Glib::Thread::create(sigc::mem_fun(*this, &Loader::thread_function), true);      thread = Glib::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function), true);
1946  #else  #else
1947      thread = Glib::Threads::Thread::create(sigc::mem_fun(*this, &Loader::thread_function));      thread = Glib::Threads::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function));
1948  #endif  #endif
1949      printf("launch thread=%p\n", static_cast<void*>(thread));      printf("launch thread=%p\n", static_cast<void*>(thread));
1950  }  }
1951    
1952  float Loader::get_progress()  float LoaderSaverBase::get_progress()
1953  {  {
1954      float res;      Glib::Threads::Mutex::Lock lock(progressMutex);
1955      {      return progress;
         Glib::Threads::Mutex::Lock lock(progressMutex);  
         res = progress;  
     }  
     return res;  
1956  }  }
1957    
1958  Glib::Dispatcher& Loader::signal_progress()  Glib::Dispatcher& LoaderSaverBase::signal_progress()
1959  {  {
1960      return progress_dispatcher;      return progress_dispatcher;
1961  }  }
1962    
1963  Glib::Dispatcher& Loader::signal_finished()  Glib::Dispatcher& LoaderSaverBase::signal_finished()
1964  {  {
1965      return finished_dispatcher;      return finished_dispatcher;
1966  }  }
1967    
1968  Glib::Dispatcher& Loader::signal_error()  Glib::Dispatcher& LoaderSaverBase::signal_error()
1969  {  {
1970      return error_dispatcher;      return error_dispatcher;
1971  }  }
1972    
1973  void saver_progress_callback(gig::progress_t* progress)  void LoaderSaverBase::join() {
1974  {      thread->join();
     Saver* saver = static_cast<Saver*>(progress->custom);  
     saver->progress_callback(progress->factor);  
1975  }  }
1976    
1977  void Saver::progress_callback(float fraction)  
1978    Loader::Loader(const char* filename) :
1979        LoaderSaverBase(filename, 0)
1980  {  {
     {  
         Glib::Threads::Mutex::Lock lock(progressMutex);  
         progress = fraction;  
     }  
     progress_dispatcher.emit();  
1981  }  }
1982    
1983  #if defined(WIN32) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))  void Loader::thread_function_sub(gig::progress_t& progress)
 // make sure stack is 16-byte aligned for SSE instructions  
 __attribute__((force_align_arg_pointer))  
 #endif  
 void Saver::thread_function()  
1984  {  {
1985      printf("thread_function self=%p\n",      RIFF::File* riff = new RIFF::File(filename);
1986             static_cast<void*>(Glib::Threads::Thread::self()));      gig = new gig::File(riff);
     printf("Start %s\n", filename.c_str());  
     try {  
         gig::progress_t progress;  
         progress.callback = saver_progress_callback;  
         progress.custom = this;  
   
         // if no filename was provided, that means "save", if filename was provided means "save as"  
         if (filename.empty()) {  
             if (!Settings::singleton()->saveWithTemporaryFile) {  
                 // save directly over the existing .gig file  
                 // (requires less disk space than solution below  
                 // but may be slower)  
                 gig->Save(&progress);  
             } else {  
                 // save the file as separate temporary file first,  
                 // then move the saved file over the old file  
                 // (may result in performance speedup during save)  
                 gig::String tmpname = filename + ".TMP";  
                 gig->Save(tmpname, &progress);  
                 #if defined(WIN32)  
                 if (!DeleteFile(filename.c_str())) {  
                     throw RIFF::Exception("Could not replace original file with temporary file (unable to remove original file).");  
                 }  
                 #else // POSIX ...  
                 if (unlink(filename.c_str())) {  
                     throw RIFF::Exception("Could not replace original file with temporary file (unable to remove original file): " + gig::String(strerror(errno)));  
                 }  
                 #endif  
                 if (rename(tmpname.c_str(), filename.c_str())) {  
                     #if defined(WIN32)  
                     throw RIFF::Exception("Could not replace original file with temporary file (unable to rename temp file).");  
                     #else  
                     throw RIFF::Exception("Could not replace original file with temporary file (unable to rename temp file): " + gig::String(strerror(errno)));  
                     #endif  
                 }  
             }  
         } else {  
             gig->Save(filename, &progress);  
         }  
1987    
1988          printf("End\n");      gig->GetInstrument(0, &progress);
         finished_dispatcher.emit();  
     } catch (RIFF::Exception e) {  
         error_message = e.Message;  
         error_dispatcher.emit();  
     } catch (...) {  
         error_message = _("Unknown exception occurred");  
         error_dispatcher.emit();  
     }  
1989  }  }
1990    
1991  Saver::Saver(gig::File* file, Glib::ustring filename)  
1992      : gig(file), filename(filename), thread(0), progress(0.f)  Saver::Saver(gig::File* file, Glib::ustring filename) :
1993        LoaderSaverBase(filename, file)
1994  {  {
1995  }  }
1996    
1997  void Saver::launch()  void Saver::thread_function_sub(gig::progress_t& progress)
1998  {  {
1999  #ifdef OLD_THREADS      // if no filename was provided, that means "save", if filename was provided means "save as"
2000      thread = Glib::Thread::create(sigc::mem_fun(*this, &Saver::thread_function), true);      if (filename.empty()) {
2001            if (!Settings::singleton()->saveWithTemporaryFile) {
2002                // save directly over the existing .gig file
2003                // (requires less disk space than solution below
2004                // but may be slower)
2005                gig->Save(&progress);
2006            } else {
2007                // save the file as separate temporary file first,
2008                // then move the saved file over the old file
2009                // (may result in performance speedup during save)
2010                gig::String tmpname = filename + ".TMP";
2011                gig->Save(tmpname, &progress);
2012    #if defined(WIN32)
2013                if (!DeleteFile(filename.c_str())) {
2014                    throw RIFF::Exception("Could not replace original file with temporary file (unable to remove original file).");
2015                }
2016    #else // POSIX ...
2017                if (unlink(filename.c_str())) {
2018                    throw RIFF::Exception("Could not replace original file with temporary file (unable to remove original file): " + gig::String(strerror(errno)));
2019                }
2020    #endif
2021                if (rename(tmpname.c_str(), filename.c_str())) {
2022    #if defined(WIN32)
2023                    throw RIFF::Exception("Could not replace original file with temporary file (unable to rename temp file).");
2024  #else  #else
2025      thread = Glib::Threads::Thread::create(sigc::mem_fun(*this, &Saver::thread_function));                  throw RIFF::Exception("Could not replace original file with temporary file (unable to rename temp file): " + gig::String(strerror(errno)));
2026  #endif  #endif
2027      printf("launch thread=%p\n", static_cast<void*>(thread));              }
2028  }          }
2029        } else {
2030  float Saver::get_progress()          gig->Save(filename, &progress);
 {  
     float res;  
     {  
         Glib::Threads::Mutex::Lock lock(progressMutex);  
         res = progress;  
2031      }      }
     return res;  
 }  
   
 Glib::Dispatcher& Saver::signal_progress()  
 {  
     return progress_dispatcher;  
2032  }  }
2033    
 Glib::Dispatcher& Saver::signal_finished()  
 {  
     return finished_dispatcher;  
 }  
   
 Glib::Dispatcher& Saver::signal_error()  
 {  
     return error_dispatcher;  
 }  
2034    
2035  ProgressDialog::ProgressDialog(const Glib::ustring& title, Gtk::Window& parent)  ProgressDialog::ProgressDialog(const Glib::ustring& title, Gtk::Window& parent)
2036      : Gtk::Dialog(title, parent, true)      : Gtk::Dialog(title, parent, true)
# Line 2319  void MainWindow::on_loader_progress() Line 2262  void MainWindow::on_loader_progress()
2262    
2263  void MainWindow::on_loader_finished()  void MainWindow::on_loader_finished()
2264  {  {
2265        loader->join();
2266      printf("Loader finished!\n");      printf("Loader finished!\n");
2267      printf("on_loader_finished self=%p\n",      printf("on_loader_finished self=%p\n",
2268             static_cast<void*>(Glib::Threads::Thread::self()));             static_cast<void*>(Glib::Threads::Thread::self()));
# Line 2328  void MainWindow::on_loader_finished() Line 2272  void MainWindow::on_loader_finished()
2272    
2273  void MainWindow::on_loader_error()  void MainWindow::on_loader_error()
2274  {  {
2275        loader->join();
2276      Glib::ustring txt = _("Could not load file: ") + loader->error_message;      Glib::ustring txt = _("Could not load file: ") + loader->error_message;
2277      Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);      Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2278      msg.run();      msg.run();
# Line 2398  void MainWindow::on_saver_progress() Line 2343  void MainWindow::on_saver_progress()
2343    
2344  void MainWindow::on_saver_error()  void MainWindow::on_saver_error()
2345  {  {
2346        saver->join();
2347      file_structure_changed_signal.emit(this->file);      file_structure_changed_signal.emit(this->file);
2348      Glib::ustring txt = _("Could not save file: ") + saver->error_message;      Glib::ustring txt = _("Could not save file: ") + saver->error_message;
2349      Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);      Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
# Line 2406  void MainWindow::on_saver_error() Line 2352  void MainWindow::on_saver_error()
2352    
2353  void MainWindow::on_saver_finished()  void MainWindow::on_saver_finished()
2354  {  {
2355        saver->join();
2356      this->file = saver->gig;      this->file = saver->gig;
2357      this->filename = saver->filename;      this->filename = saver->filename;
2358      current_gig_dir = Glib::path_get_dirname(filename);      current_gig_dir = Glib::path_get_dirname(filename);
Legend:
Removed from v.3469  
changed lines
  Added in v.3471
  ViewVC Help
Powered by ViewVC