pactors.cpp

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

   return PMovies::findMovie (movies.getDirectors (), movies.getRelMovies (), id);
}

//-----------------------------------------------------------------------------
/// Setting the page-specific menu
/// \param ui: User-interface string holding menus
/// \param grpActions: Added actions
//-----------------------------------------------------------------------------
void PActors::addMenu (Glib::ustring& ui, Glib::RefPtr<Gtk::ActionGroup> grpAction) {
   ui += ("<menuitem action='AUndo'/>"
	  "<separator/>"
	  "<menuitem action='NActor'/>"
	  "<menuitem action='AddMovie'/>"
	  "<separator/>"
	  "<menuitem action='ADelete'/>"
	  "</placeholder></menu>"
	  "<placeholder name='Other'><menu action='View'>"
	  "<menuitem action='ByActor'/>"
	  "<menuitem action='ByMovie'/>"
	  "</menu></placeholder>");

   // Add edit-menu
   grpAction->add (apMenus[UNDO] = Gtk::Action::create ("AUndo", Gtk::Stock::UNDO),
		   Gtk::AccelKey (_("<ctl>Z")),
		   mem_fun (*this, &PActors::undo));
   grpAction->add (apMenus[NEW1] = Gtk::Action::create ("NActor", Gtk::Stock::NEW,
							_("New _actor")),
		   Gtk::AccelKey (_("<ctl>N")),
		   mem_fun (*this, &PActors::newActor));
   grpAction->add (apMenus[NEW2] = Gtk::Action::create ("AddMovie", _("_Plays in movie...")),
		   Gtk::AccelKey (_("<ctl><alt>N")),
		   mem_fun (*this, &PActors::actorPlaysInMovie));
   grpAction->add (apMenus[DELETE] = Gtk::Action::create ("ADelete", Gtk::Stock::DELETE, _("_Delete")),
		   Gtk::AccelKey (_("<ctl>Delete")),
		   mem_fun (*this, &PActors::deleteSelection));

   apMenus[UNDO]->set_sensitive (false);

   // Add view-menu
   grpAction->add (Gtk::Action::create ("View", _("_View")));
   Gtk::RadioButtonGroup grpOrder;
   grpAction->add (menuView[0] = Gtk::RadioAction::create (grpOrder, "ByActor", _("By _actor")),
		   Gtk::AccelKey ("<ctl>1"), mem_fun (*this, &PActors::viewByActor));
   grpAction->add (menuView[1] = Gtk::RadioAction::create (grpOrder, "ByMovie", _("By _movie")),
		   Gtk::AccelKey ("<ctl>2"), mem_fun (*this, &PActors::viewByMovie));

   Check2 (actView < (sizeof (menuView) / sizeof (*menuView)));
   menuView[actView]->set_active ();

   actView ? viewByMovie () : viewByActor ();
}

//-----------------------------------------------------------------------------
/// Removes the selected actor from the listbox. Depending movies are disconnected.
//-----------------------------------------------------------------------------
void PActors::deleteSelection () {
   TRACE9 ("PActors::deleteSelection ()");

   Glib::RefPtr<Gtk::TreeSelection> selection (actors.get_selection ());
   Gtk::TreeIter selRow (selection->get_selected ());
   Glib::RefPtr<Gtk::TreeStore> model (actors.getModel ());
   Gtk::TreePath path (model->get_path (selRow));

   if (selRow) {
      Check3 (!selRow->parent ());
      HActor actor (HActor::cast (actors.getEntityAt (selRow))); Check3 (actor.isDefined ());
      TRACE9 ("PActors::deleteSelectedActor () - Deleting " << actor->getName ());

      YGP::Handle<RelUndo> hOldRel; hOldRel.define ();
      if (relActors.isRelated (actor)) {
	 hOldRel->setRelatedMovies (relActors.getObjects (actor));
	 relActors.unrelateAll (actor);

	 while (selRow->children ().size ())
	    model->erase (selRow->children ().begin ());
      }

      delRelation[YGP::HEntity::cast (hOldRel)] = YGP::HEntity::cast (actor);
      aUndo.push (Undo (Undo::DELETE, MOVIES, actor->getId (), YGP::HEntity::cast (hOldRel), path, ""));

      Gtk::TreePath path (model->get_path (selRow));
      aUndo.push (Undo (Undo::DELETE, ACTOR, actor->getId (), YGP::HEntity::cast (actor), path, ""));
      model->erase (selRow);
   }
   apMenus[UNDO]->set_sensitive ();
   enableSave ();
}

//-----------------------------------------------------------------------------
/// Undoes the changes on the page
//-----------------------------------------------------------------------------
void PActors::undo () {
   TRACE4 ("PActors::undo () - " << aUndo.size ());
   Check3 (aUndo.size ());

   Undo last (aUndo.top ());
   TRACE9 ("PActors::undo () - Undoing " << last.what () << ": " << last.how ());
   switch (last.what ()) {
   case ACTOR:
      undoActor (last);
      break;

   case MOVIES: {
      Check3 ((last.how () == Undo::CHANGED) || (last.how () == Undo::DELETE));
      Check3 (typeid (*last.getEntity ()) == typeid (RelUndo));
      YGP::Handle<RelUndo> relActor (YGP::Handle<RelUndo>::cast (last.getEntity ()));

      std::map<YGP::HEntity, YGP::HEntity>::iterator delRel (delRelation.find (last.getEntity ()));
      Check3 (typeid (*delRel->second) == typeid (Actor));
      HActor actor (HActor::cast (delRel->second));
      Glib::RefPtr<Gtk::TreeStore> model (actors.getModel ());

      showMovies (actor, relActor->getRelatedMovies ());
      delRelation.erase (delRel);
      break; }

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

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

//-----------------------------------------------------------------------------
/// Undoes the last changes to an actor
/// \param last: Undo-information
//-----------------------------------------------------------------------------
void PActors::undoActor (const Undo& last) {
   TRACE7 ("PActors::undoActor (const Undo&)");

   Glib::RefPtr<Gtk::TreeStore> model (actors.getModel ());
   Gtk::TreePath path (last.getPath ());
   Gtk::TreeIter iter (model->get_iter (path));

   Check3 (typeid (*last.getEntity ()) == typeid (Actor));
   HActor actor (HActor::cast (last.getEntity ()));
   TRACE9 ("PActors::undoActor (const Undo&) - " << last.how () << ": " << actor->getName ());

   switch (last.how ()) {
   case Undo::CHANGED:
      switch (last.column ()) {
      case 0:
	 actor->setName (last.getValue ());
	 if (actView)
	    changeAllEntries (YGP::HEntity::cast (actor),
			      model->children ().begin (), model->children ().end ());
	 break;

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

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

   case Undo::INSERT:
      Check3 (!relActors.isRelated (actor));
      model->erase (iter);
      iter = model->children ().end ();
      break;

   case Undo::DELETE:
      iter = actors.insert (YGP::HEntity::cast (actor), iter);
      path = model->get_path (iter);
      break;

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

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

//-----------------------------------------------------------------------------
/// Removes all information from the page
//-----------------------------------------------------------------------------
void PActors::clear () {
   aActors.clear ();
   actors.clear ();
   actors.getModel ()->clear ();
   relActors.unrelateAll ();
   NBPage::clear ();
   actView = 0;
}

//-----------------------------------------------------------------------------
/// Saves the changed information
/// \throw std::exception: In case of error
//-----------------------------------------------------------------------------
void PActors::saveData () throw (std::exception) {
   TRACE9 ("PActors::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 MOVIES:
	 case ACTOR: {
	    HActor actor (HActor::cast ((last.what () == ACTOR)
					? last.getEntity ()
					: delRelation[last.getEntity ()]));
	    if (last.how () == Undo::DELETE) {
	       if (actor->getId ()) {
		  Check3 (actor->getId () == last.column ());
		  StorageActor::deleteActor (actor->getId ());
	       }
	    }
	    else {
	       SaveCelebrity::store (actor, "Actors", *getWindow ());

	       // Check if the related movies have been changed
	       YGP::HEntity entityActor (YGP::HEntity::cast (actor));
	       for (std::map<YGP::HEntity, YGP::HEntity>::iterator i (delRelation.begin ());
		    i != delRelation.end (); ++i)
		  if (i->second == entityActor) {
		     saveRelatedMovies (actor);
		     delRelation.erase (i);
		  }
	    }
	    break; }

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

   delRelation.clear ();
}

//-----------------------------------------------------------------------------
/// Saves the related movies
/// \param actor: Actor whose movies shall be stored
/// \throw std::exception in case of an error
//-----------------------------------------------------------------------------
void PActors::saveRelatedMovies (const HActor& actor) throw (std::exception) {
   TRACE9 ("PActors::saveRelatedMovies (const HActor&)");
   StorageActor::startTransaction ();
   StorageActor::deleteActorMovies (actor->getId ());

   try {
      for (std::vector<HMovie>::const_iterator m (relActors.getObjects (actor).begin ());
	   m != relActors.getObjects (actor).end (); ++m)
	 StorageActor::saveActorMovie (actor->getId (), (*m)->getId ());
      StorageActor::commitTransaction ();
   }
   catch (std::exception& e) {
      StorageActor::abortTransaction ();
      throw e;
   }
}

//-----------------------------------------------------------------------------
/// Views the list sorted by actor
//-----------------------------------------------------------------------------
void PActors::viewByActor () {
   if (menuView[0]->get_active ()) {
      TRACE9 ("PActors::viewByActor () - Actors: " << aActors.size ());
      actView = 0;

      Check3 (actors.get_column (0));
      actors.get_column (0)->set_title (_("Actors/Movies"));

      // Fill list sorted by actors with their movies as child
      actors.clear ();
      for (std::vector<HActor>::const_iterator a (aActors.begin ()); a != aActors.end (); ++a) {
	 Gtk::TreeModel::Row actor (actors.append (YGP::HEntity::cast (*a)));

	 if (relActors.isRelated (*a)) {
	    const std::vector<HMovie>& am (relActors.getObjects (*a));
	    for (std::vector<HMovie>::const_iterator m (am.begin ()); m != am.end (); ++m)
	       actors.append (YGP::HEntity::cast (*m), actor);
	 }
      }
      actors.expand_all ();
      actorSelected ();
   }
}

//-----------------------------------------------------------------------------
/// Views the list sorted by movie
//-----------------------------------------------------------------------------
void PActors::viewByMovie () {
   if (menuView[1]->get_active ()) {
      actView = 1;

      Check3 (actors.get_column (0));
      actors.get_column (0)->set_title (_("Movies/Actors"));

      std::vector<HMovie> aMovies;
      for (std::vector<HActor>::const_iterator a (aActors.begin ()); a != aActors.end (); ++a)
	 if (relActors.isRelated (*a)) {
	    const std::vector<HMovie>& am (relActors.getObjects (*a));
	    for (std::vector<HMovie>::const_iterator m (am.begin ()); m != am.end (); ++m) {
	       std::vector<HMovie>::iterator pos (lower_bound (aMovies.begin (), aMovies.end (), YGP::HEntity::cast (*m)));
	       if ((pos == aMovies.end ()) || (*pos != *m))
		  aMovies.insert (pos, *m);
	    }
	 }
      std::sort (aMovies.begin (), aMovies.end (), &Movie::compByName);

      // Fill list sorted by actors with their movies as child
      actors.clear ();
      for (std::vector<HMovie>::const_iterator m (aMovies.begin ()); m != aMovies.end (); ++m) {
	 Gtk::TreeModel::Row movie (actors.append (YGP::HEntity::cast (*m)));

	 if (relActors.isRelated (*m)) {
	    const std::vector<HActor>& aa (relActors.getParents (*m));
	    for (std::vector<HActor>::const_iterator a (aa.begin ()); a != aa.end (); ++a)
	       actors.append (YGP::HEntity::cast (*a), movie);
	 }
      }
      actors.expand_all ();
      actorSelected ();
   }
}

//-----------------------------------------------------------------------------
/// Updates all entries showing the passed entry
/// \param entry: Entry to find
/// \param begin: Start object
/// \param end: End object
//-----------------------------------------------------------------------------
void PActors::changeAllEntries (const YGP::HEntity& entry, Gtk::TreeIter begin, Gtk::TreeIter end) {
   Check1 (entry.isDefined ());

   while (begin != end) {
      Gtk::TreeModel::Row row (*begin);
      if (entry == actors.getEntityAt (row))
	 actors.update (row);

      if (begin->children ().size ())
	 changeAllEntries (entry, begin->children ().begin (), begin->children ().end ());
      ++begin;
   } // end-while
}