pmovies.cpp

来自「磁盘管理工具,主要管理光盘信息和内容希望大家喜欢」· C++ 代码 · 共 767 行 · 第 1/2 页

      movies.expand_all ();

      Glib::ustring msg (Glib::locale_to_utf8 (ngettext ("Loaded %1 movie", "Loaded %1 movies", cMovies)));
      msg.replace (msg.find ("%1"), 2, YGP::ANumeric::toString (cMovies));
      showStatus (msg);

      loaded = true;

      if (stat.getType () > YGP::StatusObject::UNDEFINED) {
	 stat.generalize (_("Warnings loading movies"));
	 XGP::MessageDlg::create (stat);
      }
   }
   catch (std::exception& err) {
      Glib::ustring msg (_("Can't query available movies!\n\nReason: %1"));
      msg.replace (msg.find ("%1"), 2, err.what ());
      Gtk::MessageDialog dlg (msg, Gtk::MESSAGE_ERROR);
      dlg.run ();
   }
}

//-----------------------------------------------------------------------------
/// Loads the movies from the database for a certain language.
///
/// According to the available information the page of the notebook
/// is created.
/// \param lang: Language for movies to load
//-----------------------------------------------------------------------------
void PMovies::loadData (const std::string& lang) {
   TRACE5 ("PMovies::loadMovies (const std::string&) - Language: " << lang);
   try {
      StorageMovie::loadNames (directors, relMovies, lang);
      loadedLangs[lang] = true;
   }
   catch (std::exception& err) {
      Glib::ustring msg (_("Can't query available movies!\n\nReason: %1"));
      msg.replace (msg.find ("%1"), 2, err.what ());
      Gtk::MessageDialog dlg (msg, Gtk::MESSAGE_ERROR);
      dlg.run ();
   }
}

//-----------------------------------------------------------------------------
/// Saves the changed information
/// \throw std::exception: In case of error
//-----------------------------------------------------------------------------
void PMovies::saveData () throw (std::exception) {
   TRACE9 ("PMovies::saveData ()");

   std::vector<YGP::HEntity> aSaved;
   std::vector<YGP::HEntity>::iterator posSaved (aSaved.end ());

   while (aUndo.size ()) {
      Undo last (aUndo.top ());

      posSaved = lower_bound (aSaved.begin (), aSaved.end (), last.getEntity ());
      if ((posSaved == aSaved.end ()) || (*posSaved != last.getEntity ())) {
	 switch (last.what ()) {
	 case MOVIE: {
	    Check3 (typeid (*last.getEntity ()) == typeid (Movie));
	    HMovie movie (HMovie::cast (last.getEntity ()));
	    if (last.how () == Undo::DELETE) {
	       if (movie->getId ()) {
		  Check3 (movie->getId () == last.column ());
		  StorageMovie::deleteMovie (movie->getId ());
	       }

	       std::map<YGP::HEntity, YGP::HEntity>::iterator delRel
		  (delRelation.find (last.getEntity ()));
	       Check3 (delRel != delRelation.end ());
	       Check3 (typeid (*delRel->second) == typeid (Director));
	       delRelation.erase (delRel);
	    }
	    else {
	       HDirector director  (relMovies.getParent (movie));
	       if (!director->getId ()) {
		  Check3 (std::find (aSaved.begin (), aSaved.end (), YGP::HEntity::cast (director)) == aSaved.end ());
		  Check3 (delRelation.find (YGP::HEntity::cast (director)) == delRelation.end ());

		  SaveCelebrity::store (director, "Directors", *getWindow ());
		  aSaved.insert (lower_bound (aSaved.begin (), aSaved.end (), YGP::HEntity::cast (director)),
				 YGP::HEntity::cast (director));
		  posSaved = lower_bound (aSaved.begin (), aSaved.end (), last.getEntity ());
	       }
	       StorageMovie::saveMovie (movie, relMovies.getParent (movie)->getId ());
	    }
	    break; }

	 case DIRECTOR: {
	    Check3 (typeid (*last.getEntity ()) == typeid (Director));
	    HDirector director (HDirector::cast (last.getEntity ()));
	    if (last.how () == Undo::DELETE) {
	       if (director->getId ()) {
		  Check3 (director->getId () == last.column ());
		  StorageMovie::deleteDirector (director->getId ());
	       }
	    }
	    else
	       SaveCelebrity::store (director, "Directors", *getWindow ());
	    break; }

	 default:
	    Check1 (0);
	 } // end-switch
	 aSaved.insert (posSaved, last.getEntity ());
	 }
      aUndo.pop ();
   } // end-while
   Check3 (apMenus[UNDO]);
   apMenus[UNDO]->set_sensitive (false);

   Check3 (delRelation.empty ());
}

//-----------------------------------------------------------------------------
/// Removes the selected movies or directors from the listbox. Depending movies
/// are deleted too.
//-----------------------------------------------------------------------------
void PMovies::deleteSelection () {
   TRACE9 ("PMovies::deleteSelection ()");

   Glib::RefPtr<Gtk::TreeSelection> selection (movies.get_selection ());
   while (selection->get_selected_rows ().size ()) {
      Gtk::TreeSelection::ListHandle_Path list (selection->get_selected_rows ());
      Check3 (list.size ());
      Gtk::TreeSelection::ListHandle_Path::iterator i (list.begin ());

      Gtk::TreeIter iter (movies.get_model ()->get_iter (*i)); Check3 (iter);
      if ((*iter)->parent ())                 // A movie is going to be deleted
	 deleteMovie (iter);
      else {                               // A director is going to be deleted
	 TRACE9 ("PMovies::deleteSelection () - Deleting " << iter->children ().size () << " children");
	 HDirector director (movies.getDirectorAt (iter)); Check3 (director.isDefined ());
	 while (iter->children ().size ()) {
	    Gtk::TreeIter child (iter->children ().begin ());
	    deleteMovie (child);
	 }

	 Gtk::TreePath path (movies.getModel ()->get_path (iter));
	 aUndo.push (Undo (Undo::DELETE, DIRECTOR, director->getId (), YGP::HEntity::cast (director), path, ""));
	 movies.getModel ()->erase (iter);
      }
   }
   apMenus[UNDO]->set_sensitive ();
   enableSave ();
}

//-----------------------------------------------------------------------------
/// Deletes the passed movie
/// \param movie: Iterator to movie to delete
//-----------------------------------------------------------------------------
void PMovies::deleteMovie (const Gtk::TreeIter& movie) {
   Check2 (movie->children ().empty ());

   HMovie hMovie (movies.getMovieAt (movie));
   TRACE9 ("PMovies::deleteMovie (const Gtk::TreeIter&) - Deleting movie "
	   << hMovie->getName ());
   Check3 (relMovies.isRelated (hMovie));
   HDirector hDirector (relMovies.getParent (hMovie)); Check3 (hDirector.isDefined ());

   Check3 (delRelation.find (YGP::HEntity::cast (hMovie)) == delRelation.end ());

   Glib::RefPtr<Gtk::TreeStore> model (movies.getModel ());
   Gtk::TreePath path (model->get_path (movies.getOwner (hDirector)));
   aUndo.push (Undo (Undo::DELETE, MOVIE, hMovie->getId (), YGP::HEntity::cast (hMovie), path, ""));
   delRelation[YGP::HEntity::cast (hMovie)] = YGP::HEntity::cast (hDirector);

   relMovies.unrelate (hDirector, hMovie);
   model->erase (movie);
}

//-----------------------------------------------------------------------------
/// Exports the contents of the page to HTML
/// \param fd: File-descriptor for exporting
/// \param lang: Language, in which to export
//-----------------------------------------------------------------------------
void PMovies::export2HTML (unsigned int fd, const std::string& lang) {
   std::string oldLang (Movie::currLang);
   Movie::currLang = lang;

   // Load the names of the movies in the actual language
   if (!loadedLangs[Movie::currLang])
      loadData (Movie::currLang);
   Check3 (loadedLangs[Movie::currLang]);

   std::sort (directors.begin (), directors.end (), &Director::compByName);

   // Write movie-information
   for (std::vector<HDirector>::const_iterator i (directors.begin ());
	i != directors.end (); ++i)
      if (relMovies.isRelated (*i)) {
	 std::stringstream output;
	 output << 'D' << **i;

	 const std::vector<HMovie>& dirMovies (relMovies.getObjects (*i));
	 Check3 (dirMovies.size ());
	 for (std::vector<HMovie>::const_iterator m (dirMovies.begin ());
	      m != dirMovies.end (); ++m)
	    output << "M" << **m;

	 TRACE9 ("PMovies::export2HTML (unsinged int) - Writing: " << output.str ());
	 ::write (fd, output.str ().data (), output.str ().size ());
      }

   Movie::currLang = oldLang;
}

//-----------------------------------------------------------------------------
/// Undoes the changes on the page
//-----------------------------------------------------------------------------
void PMovies::undo () {
   TRACE1 ("PMovies::undo ()");
   Check3 (aUndo.size ());

   Undo last (aUndo.top ());
   switch (last.what ()) {
   case MOVIE:
      undoMovie (last);
      break;

   case DIRECTOR:
      undoDirector (last);
      break;

   default:
      Check1 (0);
   } // end-switch

   aUndo.pop ();
   if (aUndo.empty ()) {
      enableSave (false);
      apMenus[UNDO]->set_sensitive (false);
   }
}

//-----------------------------------------------------------------------------
/// Undoes the last changes to a movie
/// \param last: Undo-information
//-----------------------------------------------------------------------------
void PMovies::undoMovie (const Undo& last) {
   TRACE5 ("PMovies::undoMovie (const Undo&)");

   Gtk::TreePath path (last.getPath ());
   Gtk::TreeIter iter (movies.getModel ()->get_iter (path));

   Check3 (typeid (*last.getEntity ()) == typeid (Movie));
   HMovie movie (HMovie::cast (last.getEntity ()));
   TRACE9 ("PMovies::undoMovie (const Undo&) - " << last.how () << ": " << movie->getName ());

   switch (last.how ()) {
   case Undo::CHANGED:
      Check3 (iter->parent ());

      switch (last.column ()) {
      case 0:
	 movie->setName (last.getValue ());
	 break;

      case 1:
	 movie->setYear (last.getValue ());
	 break;

      case 2:
	 movie->setGenre ((unsigned int)last.getValue ()[0]);
	 break;

      case 3:
	 movie->setType (last.getValue ());
	 break;

      case 4:
	 movie->setLanguage (last.getValue ());
	 break;

      case 5:
	 movie->setTitles (last.getValue ());
	 break;

      default:
	 Check1 (0);
      } // end-switch
      break;

   case Undo::INSERT:
      Check3 (iter->parent ());
      Check3 (relMovies.isRelated (movie));
      relMovies.unrelate (movies.getDirectorAt (iter->parent ()), movie);
      movies.getModel ()->erase (iter);
      iter = movies.getModel ()->children ().end ();
      break;

   case Undo::DELETE: {
      std::map<YGP::HEntity, YGP::HEntity>::iterator delRel
	 (delRelation.find (last.getEntity ()));
      Check3 (typeid (*delRel->second) == typeid (Director));
      HDirector director (HDirector::cast (delRel->second));
      Gtk::TreeRow rowDirector (*movies.getOwner (director));

      iter = movies.append (movie, rowDirector);
      path = movies.getModel ()->get_path (iter);

      relMovies.relate (director, movie);

      delRelation.erase (delRel);
      break; }

   default:
      Check1 (0);
   } // end-switch

   if (iter) {
      Gtk::TreeRow row (*iter);
      movies.update (row);
   }
   movies.set_cursor (path);
   movies.scroll_to_row (path, 0.8);
}

//-----------------------------------------------------------------------------
/// Undoes the last changes to a director
/// \param last: Undo-information
//-----------------------------------------------------------------------------
void PMovies::undoDirector (const Undo& last) {
   TRACE5 ("PMovies::undoDirector (const Undo&)");

   Gtk::TreePath path (last.getPath ());
   Gtk::TreeIter iter (movies.getModel ()->get_iter (path)); Check3 (!iter->parent ());

   Check3 (typeid (*last.getEntity ()) == typeid (Director));
   HDirector director (HDirector::cast (last.getEntity ()));
   TRACE9 ("PMovies::undoDirector (const Undo&) - " << last.how () << ": " << director->getName ());

   switch (last.how ()) {
   case Undo::CHANGED:
      switch (last.column ()) {
      case 0:
	 director->setName (last.getValue ());
	 break;

      case 1:
	 director->setLifespan (last.getValue ());
	 break;

      default:
	 Check1 (0);
      } // end-switch
      break;

   case Undo::INSERT:
      Check3 (!relMovies.isRelated (director));
      movies.getModel ()->erase (iter);
      iter = movies.getModel ()->children ().end ();
      break;

   case Undo::DELETE:
      iter = movies.insert (director, iter);
      path = movies.getModel ()->get_path (iter);
      break;

   default:
      Check1 (0);
   } // end-switch

   if (iter) {
      Gtk::TreeRow row (*iter);
      movies.update (row);
   }
   movies.set_cursor (path);
   movies.scroll_to_row (path, 0.8);
}

//-----------------------------------------------------------------------------
/// Removes all information from the page
//-----------------------------------------------------------------------------
void PMovies::clear () {
   relMovies.unrelateAll ();
   directors.clear ();
   movies.clear ();
   movies.getModel ()->clear ();
   NBPage::clear ();
   loadedLangs.clear ();
}