precords.cpp

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

      deleteSong (song, record);

      relSongs.unrelate (record, song);
      songs.getModel ()->erase (iter);
   }
}

//-----------------------------------------------------------------------------
/// Exports the contents of the page to HTML
/// \param fd: File-descriptor for exporting
//-----------------------------------------------------------------------------
void PRecords::export2HTML (unsigned int fd, const std::string&) {
   std::sort (interprets.begin (), interprets.end (), &Interpret::compByName);

   // Write record-information
   for (std::vector<HInterpret>::const_iterator i (interprets.begin ());
	i != interprets.end (); ++i)
      if (relRecords.isRelated (*i)) {
	 std::stringstream output;
	 output << 'I' << **i;

	 const std::vector<HRecord>& records (relRecords.getObjects (*i));
	 Check3 (records.size ());
	 for (std::vector<HRecord>::const_iterator r (records.begin ());
	      r != records.end (); ++r)
	    output << "R" << **r;

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

//-----------------------------------------------------------------------------
/// Adds a song to the list (creating record/interpret/song, if necessary)
/// \param artist: Name of artist
/// \param record: Name of record
/// \param song: Name of song
/// \param track: Number of track
//-----------------------------------------------------------------------------
void PRecords::addEntry (const Glib::ustring&artist, const Glib::ustring& record,
			 const Glib::ustring& song, unsigned int track) {
   HInterpret interpret;
   Gtk::TreeIter i (records.getOwner (artist));
   if (i == records.getModel ()->children ().end ()) {
      TRACE9 ("PRecords::addEntry (3x const Glib::ustring&, unsigned int) - Adding band " << artist);
      interpret.define ();
      interpret->setName (artist);
      i = addInterpret (interpret);
   }
   else
      interpret = records.getInterpretAt (i);

   HRecord rec;
   Gtk::TreeIter r (records.getObject (i, record));
   if (r == i->children ().end ()) {
      TRACE9 ("PRecords::addEntry (3x const Glib::ustring&, unsigned int) - Adding record " << record);
      rec.define ();
      rec->setSongsLoaded ();
      rec->setName (record);
      addRecord (i, rec);
   }
   else {
      rec = records.getRecordAt (r);
      records.selectRow (r);
   }

   HSong hSong;
   Gtk::TreeIter s (songs.getSong (song));
   if (s == songs.getModel ()->children ().end ()) {
      TRACE9 ("PRecords::addEntry (3x const Glib::ustring&, unsigned int) - Adding song " << hSong);
      hSong.define ();
      hSong->setName (song);
      if (track)
	 hSong->setTrack (track);
      addSong (hSong);
   }
   else {
      hSong = songs.getSongAt (s);
      songs.scroll_to_row (songs.getModel ()->get_path (s), 0.80);
      Glib::RefPtr<Gtk::TreeSelection> songSel (songs.get_selection ());
      songSel->select (s);
      if (track) {
	 hSong->setTrack (track);
	 Gtk::TreeRow row (*s);
	 songs.updateTrack (row, hSong->getTrack ());
      }
   }
}

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

   Undo last (aUndo.top ());
   switch (last.what ()) {
   case SONG:
      undoSong (last);
      break;

   case RECORD:
      undoRecord (last);
      break;

   case INTERPRET:
      undoInterpret (last);
      break;

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

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

//-----------------------------------------------------------------------------
/// Undoes the last changes to a record
/// \param last: Undo-information
//-----------------------------------------------------------------------------
void PRecords::undoRecord (const Undo& last) {
   TRACE6 ("PRecords::undoRecord (const Undo&)");

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

   Check3 (typeid (*last.getEntity ()) == typeid (Record));
   HRecord record (HRecord::cast (last.getEntity ()));
   TRACE9 ("PRecords::undoRecord (const Undo&) - " << last.how () << ": " << record->getName ());

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

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

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

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

   case Undo::INSERT:
      Check3 (iter->parent ());
      Check3 (relRecords.isRelated (record));
      relRecords.unrelate (records.getInterpretAt (iter->parent ()), record);
      records.getModel ()->erase (iter);
      iter = records.getModel ()->children ().end ();
      break;

   case Undo::DELETE: {
      std::map<YGP::HEntity, YGP::HEntity>::iterator delRel
	 (delRelation.find (last.getEntity ()));
      Check3 (typeid (*delRel->second) == typeid (Interpret));
      HInterpret interpret (HInterpret::cast (delRel->second));
      Gtk::TreeRow rowInterpret (*records.getOwner (interpret));

      iter = records.append (record, rowInterpret);
      path = records.getModel ()->get_path (iter);

      relRecords.relate (interpret, record);
      delRelation.erase (delRel);
      break; }

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

   if (iter) {
      Gtk::TreeRow row (*iter);
      records.update (row);
   }
   records.set_cursor (path);
   records.scroll_to_row (path, 0.8);
   // records.get_selection ()->select (p);
}

//-----------------------------------------------------------------------------
/// Undoes the last changes to an interpret
/// \param last: Undo-information
//-----------------------------------------------------------------------------
void PRecords::undoInterpret (const Undo& last) {
   TRACE6 ("PRecords::undoInterpret (const Undo&)");

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

   Check3 (typeid (*last.getEntity ()) == typeid (Interpret));
   HInterpret interpret (HInterpret::cast (last.getEntity ()));
   TRACE9 ("PRecords::undoInterpret (const Undo&) - " << last.how () << ": " << interpret->getName ());

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

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

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

   case Undo::INSERT:
      Check3 (!relRecords.isRelated (interpret));
      records.getModel ()->erase (iter);
      iter = records.getModel ()->children ().end ();
      break;

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

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

   if (iter) {
      Gtk::TreeRow row (*iter);
      records.update (row);
   }
   records.set_cursor (path);
   records.scroll_to_row (path, 0.8);
   // records.get_selection ()->select (p);
}

//-----------------------------------------------------------------------------
/// Undoes the last changes to a song
/// \param last: Undo-information
//-----------------------------------------------------------------------------
void PRecords::undoSong (const Undo& last) {
   TRACE6 ("PRecords::undoSong (const Undo&) - " << last.column ());

   Gtk::TreePath path (last.getPath ());
   Gtk::TreeIter iter (records.getModel ()->get_iter (path));
   Glib::RefPtr<Gtk::TreeSelection> sel (records.get_selection ());
   sel->unselect_all ();
   sel->select (iter);

   Check3 (typeid (*last.getEntity ()) == typeid (Song));
   HSong song (HSong::cast (last.getEntity ()));
   TRACE9 ("PRecords::undoSong (const Undo&) - " << last.how () << ": " << song->getName ());
   iter = songs.getSong (song); Check3 (iter);

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

      case 1:
	 song->setName (last.getValue ());
	 break;

      case 2:
	 song->setDuration (last.getValue ());
	 break;

      case 3:
	 Check3 (last.getValue ().size () == 1);
	 song->setGenre ((unsigned int)last.getValue ()[0]);
	 break;

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

   case Undo::INSERT:
      relSongs.unrelate (relSongs.getParent (song), song);
      songs.getModel ()->erase (iter);
      iter = songs.getModel ()->children ().end ();
      break;

   case Undo::DELETE: {
      iter = songs.insert (song, iter);

      std::map<YGP::HEntity, YGP::HEntity>::iterator delRel (delRelation.find (last.getEntity ()));
      Check3 (typeid (*delRel->second) == typeid (Record));
      relSongs.relate (HRecord::cast (delRel->second), song);

      delRelation.erase (delRel);
      break; }

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

   if (iter) {
      Gtk::TreeRow row (*iter);
      songs.update (row);
      path = songs.getModel ()->get_path (iter);
   }
   songs.set_cursor (path);
   songs.scroll_to_row (path, 0.8);
   // songs.get_selection ()->select (p);
}

//-----------------------------------------------------------------------------
/// Sets the focus to the record-list
//-----------------------------------------------------------------------------
void PRecords::getFocus () {
   records.grab_focus ();
}

//-----------------------------------------------------------------------------
/// Removes all information from the page
//-----------------------------------------------------------------------------
void PRecords::clear () {
   TRACE9 ("PRecords::clear ()");
   relSongs.unrelateAll ();
   relRecords.unrelateAll ();
   interprets.clear ();

   songs.getModel ()->clear ();
   records.getModel ()->clear ();
   NBPage::clear ();
}