precords.cpp

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

	    Gtk::TreeModel::Children list (model->children ()); Check3 (list.size ());
	    for (Gtk::TreeIter i (list.begin ()); i != list.end (); ++i)
	       songs.setGenre (i, genre);
	 }
      }
   }

   apMenus[UNDO]->set_sensitive ();
   enableSave ();
}

//-----------------------------------------------------------------------------
/// Setting the page-specific menu
/// \param ui: User-interface string holding menus
/// \param grpActions: Added actions
//-----------------------------------------------------------------------------
void PRecords::addMenu (Glib::ustring& ui, Glib::RefPtr<Gtk::ActionGroup> grpAction) {
   TRACE7 ("PRecords::addMenu");

   ui += ("<menuitem action='RUndo'/>"
	  "<separator/>"
	  "<menuitem action='NInterpret'/>"
	  "<menuitem action='NRecord'/>"
	  "<menuitem action='NSong'/>"
	  "<separator/>"
	  "<menuitem action='RDelete'/>"
	  "</placeholder></menu>");

   grpAction->add (apMenus[UNDO] = Gtk::Action::create ("RUndo", Gtk::Stock::UNDO),
		   Gtk::AccelKey (_("<ctl>Z")),
		   mem_fun (*this, &PRecords::undo));
   grpAction->add (apMenus[NEW1] = Gtk::Action::create ("NInterpret", Gtk::Stock::NEW,
							_("New _interpret")),
		   Gtk::AccelKey (_("<ctl>N")),
		   mem_fun (*this, &PRecords::newInterpret));
   grpAction->add (apMenus[NEW2] = Gtk::Action::create ("NRecord", _("_New record")),
		   Gtk::AccelKey (_("<ctl><alt>N")),
		   mem_fun (*this, &PRecords::newRecord));
   grpAction->add (apMenus[NEW3] = Gtk::Action::create ("NSong", _("New _song")),
		   Gtk::AccelKey (_("<ctl><shft>N")),
		   mem_fun (*this, &PRecords::newSong));
   grpAction->add (apMenus[DELETE] = Gtk::Action::create ("RDelete", Gtk::Stock::DELETE, _("_Delete")),
		   Gtk::AccelKey (_("<ctl>Delete")),
		   mem_fun (*this, &PRecords::deleteSelection));

   apMenus[UNDO]->set_sensitive (false);
   recordSelected ();
}

//-----------------------------------------------------------------------------
/// Adds an interpret to the record listbox
/// \param interpret: Handle to the new interpret
/// \returns Gtk::TreeIter: Iterator to new added interpret
//-----------------------------------------------------------------------------
Gtk::TreeIter PRecords::addInterpret (const HInterpret& interpret) {
   interprets.push_back (interpret);

   Gtk::TreeModel::iterator i (records.append (interpret));
   Gtk::TreePath path (records.getModel ()->get_path (i));
   records.set_cursor (path);

   aUndo.push (Undo (Undo::INSERT, INTERPRET, 0, YGP::HEntity::cast (interpret), path, ""));
   apMenus[UNDO]->set_sensitive ();
   enableSave ();
   return i;
}

//-----------------------------------------------------------------------------
/// Adds a record to the record listbox
/// \param parent: Iterator to the interpret of the record
/// \param record: Handle to the new record
/// \returns Gtk::TreeIter: Iterator to new added record
//-----------------------------------------------------------------------------
Gtk::TreeIter PRecords::addRecord (Gtk::TreeIter& parent, HRecord& record) {
   Gtk::TreeIter i (records.append (record, *parent));
   Glib::RefPtr<Gtk::TreeStore> model (records.getModel ());
   records.expand_row (model->get_path (parent), false);
   Gtk::TreePath path (records.getModel ()->get_path (i));
   records.set_cursor (path);

   HInterpret interpret;
   interpret = records.getInterpretAt (parent);
   relRecords.relate (interpret, record);

   aUndo.push (Undo (Undo::INSERT, RECORD, 0, YGP::HEntity::cast (record), path, ""));
   apMenus[UNDO]->set_sensitive ();
   enableSave ();
   return i;
}

//-----------------------------------------------------------------------------
/// Adds a song to the song listbox
/// \param song: Handle to the new song
/// \returns Gtk::TreeIter: Iterator to new added song
//-----------------------------------------------------------------------------
Gtk::TreeIter PRecords::addSong (HSong& song) {
   Glib::RefPtr<Gtk::TreeSelection> recordSel (records.get_selection ());
   Gtk::TreeSelection::ListHandle_Path list (recordSel->get_selected_rows ());
   Check3 (list.size ());
   Gtk::TreeIter p (records.getModel ()->get_iter (*list.begin ())); Check3 (p);

   HRecord record (records.getRecordAt (p)); Check3 (record.isDefined ());
   relSongs.relate (record, song);
   Gtk::TreeIter iterSong (songs.append (song));
   Gtk::TreePath pathSong (songs.getModel ()->get_path (iterSong));
   songs.set_cursor (pathSong);

   Gtk::TreePath path (*list.begin ());
   aUndo.push (Undo (Undo::INSERT, SONG, 0, YGP::HEntity::cast (song), path, ""));

   apMenus[UNDO]->set_sensitive ();
   enableSave ();
   return p;
}

//-----------------------------------------------------------------------------
/// Saves the changed information
/// \throw std::exception: In case of error
//-----------------------------------------------------------------------------
void PRecords::saveData () throw (std::exception) {
   TRACE5 ("PRecords::saveData () - " << aUndo.size ());

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

   while (aUndo.size ()) {
      Undo last (aUndo.top ());
      TRACE7 ("PRecords::saveData () - What: " << last.what () << '/' << last.how ());

      posSaved = lower_bound (aSaved.begin (), aSaved.end (), last.getEntity ());
      if ((posSaved == aSaved.end ()) || (*posSaved != last.getEntity ())) {
	 switch (last.what ()) {
	 case SONG: {
	    Check3 (typeid (*last.getEntity ()) == typeid (Song));
	    HSong song (HSong::cast (last.getEntity ()));
	    if (last.how () == Undo::DELETE) {
	       if (song->getId ()) {
		  Check3 (song->getId () == last.column ());
		  StorageRecord::deleteSong (song->getId ());
	       }

	       std::map<YGP::HEntity, YGP::HEntity>::iterator delRel
		  (delRelation.find (last.getEntity ()));
	       Check3 (delRel != delRelation.end ());
	       Check3 (typeid (*delRel->second) == typeid (Record));
	       delRelation.erase (delRel);
	    }
	    else {
	       HRecord hRec (relSongs.getParent (song));
	       if (!hRec->getId ()) {
		  Check3 (std::find (aSaved.begin (), aSaved.end (), YGP::HEntity::cast (hRec)) == aSaved.end ());
		  Check3 (delRelation.find (YGP::HEntity::cast (hRec)) == delRelation.end ());

		  HInterpret interpret  (relRecords.getParent (hRec));
		  if (!interpret->getId ()) {
		     Check3 (std::find (aSaved.begin (), aSaved.end (), YGP::HEntity::cast (interpret)) == aSaved.end ());
		     Check3 (delRelation.find (YGP::HEntity::cast (interpret)) == delRelation.end ());

		     SaveCelebrity::store (interpret, "Interprets", *getWindow ());
		     aSaved.insert (lower_bound (aSaved.begin (), aSaved.end (), YGP::HEntity::cast (interpret)),
				    YGP::HEntity::cast (interpret));
		  }
		  StorageRecord::saveRecord (hRec, relRecords.getParent (hRec)->getId ());
		  aSaved.insert (lower_bound (aSaved.begin (), aSaved.end (), YGP::HEntity::cast (hRec)),
				 YGP::HEntity::cast (hRec));
		  posSaved = lower_bound (aSaved.begin (), aSaved.end (), last.getEntity ());
	       }
	       StorageRecord::saveSong (song, hRec->getId ());
	    }
	    break; }

	 case RECORD: {
	    Check3 (typeid (*last.getEntity ()) == typeid (Record));
	    HRecord rec (HRecord::cast (last.getEntity ()));
	    if (last.how () == Undo::DELETE) {
	       if (rec->getId ()) {
		  Check3 (rec->getId () == last.column ());
		  StorageRecord::deleteRecord (rec->getId ());
	       }

	       std::map<YGP::HEntity, YGP::HEntity>::iterator delRel
		  (delRelation.find (last.getEntity ()));
	       Check3 (delRel != delRelation.end ());
	       Check3 (typeid (*delRel->second) == typeid (Interpret));
	       delRelation.erase (delRel);
	    }
	    else {
	       HInterpret interpret  (relRecords.getParent (rec));
	       if (!interpret->getId ()) {
		  Check3 (std::find (aSaved.begin (), aSaved.end (), YGP::HEntity::cast (interpret)) == aSaved.end ());
		  Check3 (delRelation.find (YGP::HEntity::cast (interpret)) == delRelation.end ());

		  SaveCelebrity::store (interpret, "Interprets", *getWindow ());
		  aSaved.insert (lower_bound (aSaved.begin (), aSaved.end (), YGP::HEntity::cast (interpret)),
				 YGP::HEntity::cast (interpret));
		  posSaved = lower_bound (aSaved.begin (), aSaved.end (), last.getEntity ());
	       }
	       StorageRecord::saveRecord (rec, interpret->getId ());
	    }
	    break; }

	 case INTERPRET: {
	    Check3 (typeid (*last.getEntity ()) == typeid (Interpret));
	    HInterpret interpret (HInterpret::cast (last.getEntity ()));
	    if (last.how () == Undo::DELETE) {
	       if (interpret->getId ()) {
		  Check3 (interpret->getId () == last.column ());
		  StorageRecord::deleteInterpret (interpret->getId ());
	       }
	    }
	    else
	       SaveCelebrity::store (interpret, "Interprets", *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 PRecords::deleteSelection () {
   if (records.has_focus ())
      deleteSelectedRecords ();
   else if (songs.has_focus ())
      deleteSelectedSongs ();

   apMenus[UNDO]->set_sensitive ();
   enableSave ();
}

//-----------------------------------------------------------------------------
/// Removes the selected records or artists from the listbox. Depending objects
/// (records or songs) are deleted too.
//-----------------------------------------------------------------------------
void PRecords::deleteSelectedRecords () {
   TRACE9 ("PRecords::deleteSelectedRecords ()");

   Glib::RefPtr<Gtk::TreeSelection> selection (records.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 (records.get_model ()->get_iter (*i)); Check3 (iter);
      if ((*iter)->parent ())                // A record is going to be deleted
	 deleteRecord (iter);
      else {                             // An interpret is going to be deleted
	 TRACE9 ("PRecords::deleteSelectedRecords () - Deleting " <<
		 iter->children ().size () << " children");
	 HInterpret interpret (records.getInterpretAt (iter)); Check3 (interpret.isDefined ());
	 while (iter->children ().size ()) {
	    Gtk::TreeIter child (iter->children ().begin ());
	    HRecord hRecord (records.getRecordAt (child));
	    if (hRecord->needsLoading () && hRecord->getId ())
	       loadSongs (hRecord);
	    deleteRecord (child);
	 }
	 Gtk::TreePath path (records.getModel ()->get_path (iter));
	 aUndo.push (Undo (Undo::DELETE, INTERPRET, interpret->getId (), YGP::HEntity::cast (interpret), path, ""));
	 records.getModel ()->erase (iter);
      }
   }
}

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

   HRecord hRec (records.getRecordAt (record));
   TRACE9 ("PRecords::deleteRecord (const Gtk::TreeIter&) - Deleting record "
	   << hRec->getName ());
   Check3 (relRecords.isRelated (hRec));
   HInterpret hInterpret (relRecords.getParent (hRec)); Check3 (hInterpret.isDefined ());

   // Remove related songs
   TRACE3 ("PRecords::deleteRecord (const Gtk::TreeIter&) - Remove Songs");
   if (relSongs.isRelated (hRec)) {
      const std::vector<HSong>& as (relSongs.getObjects (hRec));
      for (std::vector<HSong>::const_iterator s (as.begin ()); s != as.end (); ++s)
	 deleteSong ((HSong&)(*s), hRec);
      relSongs.unrelateAll (hRec);
   }

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

   Gtk::TreePath path (records.getModel ()->get_path (records.getOwner (hInterpret)));
   aUndo.push (Undo (Undo::DELETE, RECORD, hRec->getId (), YGP::HEntity::cast (hRec), path, ""));
   delRelation[YGP::HEntity::cast (hRec)] = YGP::HEntity::cast (hInterpret);
   relRecords.unrelate (hInterpret, hRec);

   records.getModel ()->erase (record);
}

//-----------------------------------------------------------------------------
/// Removes the passed songs from the model (but not from the relations).
/// \param song: Song to delete
/// \param record: Record of song
//-----------------------------------------------------------------------------
void PRecords::deleteSong (const HSong& song, const HRecord& record) {
   TRACE9 ("PRecords::deleteSong (const HSong& song, const HRecord& record)");
   Check1 (song.isDefined ()); Check1 (record.isDefined ());
   Check3 (delRelation.find (YGP::HEntity::cast (song)) == delRelation.end ());

   Gtk::TreePath path (records.getModel ()->get_path (records.getObject (HEntity::cast (record))));
   aUndo.push (Undo (Undo::DELETE, SONG, song->getId (), YGP::HEntity::cast (song), path, ""));
   delRelation[YGP::HEntity::cast (song)] = YGP::HEntity::cast (record);
}

//-----------------------------------------------------------------------------
/// Removes the selected songs from the listbox.
//-----------------------------------------------------------------------------
void PRecords::deleteSelectedSongs () {
   TRACE9 ("PRecords::deleteSelectedSongs ()");

   Glib::RefPtr<Gtk::TreeSelection> selection (songs.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 (songs.get_model ()->get_iter (*i)); Check3 (iter);
      HSong song (songs.getSongAt (iter)); Check3 (song.isDefined ());
      Check3 (relSongs.isRelated (song));
      HRecord record (relSongs.getParent (song));
      Check3 (record.isDefined ());