FCL/sf/app/radio: comparison radioapp/radiouiengine/src/radiostationmodel.cpp

equal deleted inserted replaced

-:6bcf277166c1
+:451b2e1545b2
 */
 // System includes
 #include <QStringList>
+// User includes
 #include "radiostationmodel.h"
 #include "radiostationmodel_p.h"
 #include "radiopresetstorage.h"
 #include "radioenginewrapper.h"
 #include "radiouiengine.h"
 /*!
 *
 */
 RadioStationModel::~RadioStationModel()
 {
-delete d_ptr;
 }
 /*!
 *
 */
 return list;
 }
 return firstLine;
-} else if ( role == RadioStationModel::RadioStationRole ) {
+} else if ( role == RadioRole::RadioStationRole ) {
 QVariant variant;
 variant.setValue( stationAt( index.row() ) );
 return variant;
 } else if ( role == Qt::DecorationRole &&
 d->mDetailLevel.testFlag( RadioStationModel::ShowIcons ) ) {
 }
 if ( currentStation().frequency() == station.frequency() && !d->mNowPlayingIcon.isNull() ) {
 list.append( d->mNowPlayingIcon );
 }
 return list;
+} else if ( role == RadioRole::IsFavoriteRole ) {
+QVariant variant;
+variant.setValue( stationAt( index.row() ).isFavorite() );
+return variant;
 }
 return QVariant();
 }
 */
 bool RadioStationModel::setData( const QModelIndex& index, const QVariant& value, int role )
 {
 Q_UNUSED( index );
-if ( role == RadioStationModel::ToggleFavoriteRole ) {
+if ( role == RadioRole::ToggleFavoriteRole ) {
 const uint frequency = value.toUInt();
 RadioStation station;
 if ( findFrequency( frequency, station ) ) {
 setFavoriteByPreset( station.presetIndex(), !station.isFavorite() );
 } else {
 void RadioStationModel::initialize( RadioPresetStorage* storage, RadioEngineWrapper* wrapper )
 {
 Q_D( RadioStationModel );
 d->mPresetStorage = storage;
 d->mWrapper = wrapper;
-const int presetCount = d->mPresetStorage->presetCount();
 int index = d->mPresetStorage->firstPreset();
-LOG_FORMAT( "RadioStationModelPrivate::initialize: presetCount: %d, firstIndex: %d", presetCount, index );
+LOG_FORMAT( "RadioStationModel::initialize: presetCount: %d, firstIndex: %d",
+d->mPresetStorage->presetCount(), index );
-#ifdef COMPILE_WITH_NEW_PRESET_UTILITY
 while ( index >= 0 ) {
-#else
-index = 0;
-while ( index < presetCount ) {
-#endif // COMPILE_WITH_NEW_PRESET_UTILITY
 RadioStation station;
-station.detach();
+RadioStationIf* stationInterface = static_cast<RadioStationIf*>( station.data_ptr() );
-RadioStationIf* preset = static_cast<RadioStationIf*>( station.data_ptr() );
+if ( d->mPresetStorage->readPreset( index, *stationInterface ) ) {
-if ( d->mPresetStorage->readPreset( index, *preset ) ) {
+if ( station.isValid() && d->mWrapper->isFrequencyValid( station.frequency() ) ) {
-if ( station.isValid() ) {
 d->mStations.insert( station.frequency(), station );
 } else {
-LOG( "RadioStationModelPrivate::initialize: Invalid station!" );
+LOG( "RadioStationModel::initialize: Invalid station!" );
+LOG_FORMAT( "Invalid station freq: %d", station.frequency() );
 }
 }
-#ifdef COMPILE_WITH_NEW_PRESET_UTILITY
 index = d->mPresetStorage->nextPreset( index );
-#endif
 }
 d->setCurrentStation( d->mWrapper->currentFrequency() );
 wrapper->addObserver( d );
 RadioStation RadioStationModel::stationAt( int index ) const
 {
 // Get the value from the keys list instead of directly accessing the values list
 // because QMap may have added a default-constructed value to the values list
 Q_D( const RadioStationModel );
-if ( index < d->mStations.keys().count() ) {
+if ( index >= 0 && index < d->mStations.keys().count() ) {
 uint frequency = d->mStations.keys().at( index );
 return d->mStations.value( frequency );
 }
 return RadioStation();
 }
 /*!
 * Finds a station by frequency
 */
-bool RadioStationModel::findFrequency( uint frequency, RadioStation& station )
+bool RadioStationModel::findFrequency( uint frequency, RadioStation& station, FindCriteria::Criteria criteria ) const
 {
-Q_D( RadioStationModel );
+Q_D( const RadioStationModel );
+if ( criteria == FindCriteria::IncludeManualStation && d->mCurrentStation->frequency() == frequency ) {
+station = *d->mCurrentStation;
+return true;
+}
 if ( d->mStations.contains( frequency ) ) {
 station = d->mStations.value( frequency );
 return true;
 }
 return false;
+}
+/*!
+* Convenience function to find a radio station.
+*/
+RadioStation RadioStationModel::findStation( uint frequency, FindCriteria::Criteria criteria ) const
+{
+RadioStation station;
+findFrequency( frequency, station, criteria ); // Return value ignored
+return station;
 }
 /*!
 * Finds a station by preset index
 */
 {
 Q_D( RadioStationModel );
 const bool findFavorite = mode == StationSkip::PreviousFavorite || mode == StationSkip::NextFavorite;
 const bool findNext = mode == StationSkip::Next || mode == StationSkip::NextFavorite;
 QList<RadioStation> list = findFavorite ? d->favorites() : d->mStations.values();
+if ( list.isEmpty() ) {
+return RadioStation();
+}
 // Find the previous and next station from current frequency
 RadioStation previous;
 RadioStation next;
 foreach( const RadioStation& station, list ) {
 return findNext ? next : previous;
 }
 /*!
+* Checks if the model contains the given frequency
+*/
+bool RadioStationModel::contains( const uint frequency ) const
+{
+RadioStation unused;
+return findFrequency( frequency, unused );
+}
+/*!
 * Removes a station by frequency
 */
 void RadioStationModel::removeByFrequency( uint frequency )
 {
 RadioStation station;
 }
 // Copy the station to a temporary variable that can be used as signal parameter
 RadioStation tempStation = station;
-const int row = modelIndexFromFrequency( tempStation.frequency() ).row();
+const int row = indexFromFrequency( tempStation.frequency() );
 beginRemoveRows( QModelIndex(), row, row );
 d->mPresetStorage->deletePreset( tempStation.presetIndex() );
 d->mStations.remove( frequency );
 saveStation( newStation );
 }
 }
 }
 }
-reset(); // TODO: Remove. this is a workaround to HbGridView update problem
 }
 /*!
 * Adds a new station to the list
 */
 void RadioStationModel::addStation( const RadioStation& station )
 {
 Q_D( RadioStationModel );
 const int newIndex = findUnusedPresetIndex();
-LOG_FORMAT( "RadioStationModelPrivate::addStation: Adding station to index %d", newIndex );
+LOG_FORMAT( "RadioStationModel::addStation: Adding station to index %d", newIndex );
 RadioStation newStation = station;
 newStation.setPresetIndex( newIndex );
-newStation.unsetType( RadioStation::Temporary );
+newStation.unsetType( RadioStation::ManualStation );
 // We have to call beginInsertRows() BEFORE the addition is actually done so we must figure out where
 // the new station will go in the sorted frequency order
 int row = 0;
 const int count = rowCount();
 if ( station.frequency() > existingFreq ) {
 row = 1;
 }
 }
-//    emit layoutAboutToBeChanged();
 beginInsertRows( QModelIndex(), row, row );
 d->doSaveStation( newStation );
 d->setCurrentStation( d->mWrapper->currentFrequency() );
 endInsertRows();
-//    emit layoutChanged();
+// Not all UI components listen to rowsInserted() signal so emit the favorite signal
+if ( newStation.isFavorite() ) {
+emit favoriteChanged( *d->mCurrentStation );
+}
 }
 /*!
 * Saves the given station. It is expected to already exist in the list
 */
 Q_D( RadioStationModel );
 const bool stationHasChanged = station.hasChanged();
 RadioStation::Change changeFlags = station.changeFlags();
 station.resetChangeFlags();
-if ( station.isType( RadioStation::Temporary ) ) {
+if ( station.isType( RadioStation::ManualStation ) ) {
+d->mManualStation = station;
 emitChangeSignals( station, changeFlags );
 } else if ( station.isValid() && stationHasChanged && d->mStations.contains( station.frequency() )) {
 d->doSaveStation( station, changeFlags.testFlag( RadioStation::PersistentDataChanged ) );
 */
 void RadioStationModel::setFavoriteByFrequency( uint frequency, bool favorite )
 {
 Q_D( RadioStationModel );
 if ( d->mWrapper->isFrequencyValid( frequency ) ) {
-LOG_FORMAT( "RadioStationModelPrivate::setFavoriteByFrequency, frequency: %d", frequency );
+LOG_FORMAT( "RadioStationModel::setFavoriteByFrequency, frequency: %d", frequency );
 RadioStation station;
 if ( findFrequency( frequency, station ) ) { // Update existing preset
 if ( station.isFavorite() != favorite ) {
 station.setFavorite( favorite );
 saveStation( station );
 newStation.setFrequency( frequency );
 }
 newStation.setType( RadioStation::LocalStation | RadioStation::Favorite );
-// If PI code has been received, it is a local station
-if ( newStation.hasPiCode() ) {
-newStation.setType( RadioStation::LocalStation );
-}
 // Emit the signals only after adding the preset and reinitializing the current station
 // because the UI will probably query the current station in its slots that get called.
 addStation( newStation );
 }
 }
 /*!
 * Changes the favorite status of a station by its preset index
 */
 void RadioStationModel::setFavoriteByPreset( int presetIndex, bool favorite )
 {
-LOG_FORMAT( "RadioStationModelPrivate::setFavoriteByPreset, presetIndex: %d", presetIndex );
+LOG_FORMAT( "RadioStationModel::setFavoriteByPreset, presetIndex: %d", presetIndex );
 RadioStation station;
 if ( findPresetIndex( presetIndex, station ) != RadioStation::NotFound ) {
 station.setFavorite( favorite );
 saveStation( station );
 }
 /*!
 * Renames a station by its preset index
 */
 void RadioStationModel::renameStation( int presetIndex, const QString& name )
 {
-LOG_FORMAT( "RadioStationModelPrivate::renameStation, presetIndex: %d, name: %s", presetIndex, GETSTRING(name) );
+LOG_FORMAT( "RadioStationModel::renameStation, presetIndex: %d, name: %s", presetIndex, GETSTRING(name) );
 RadioStation station;
 if ( findPresetIndex( presetIndex, station ) != RadioStation::NotFound ) {
 station.setUserDefinedName( name );
 saveStation( station );
 }
 }
 /*!
 * Returns the model index corresponding to the given frequency
 */
-QModelIndex RadioStationModel::modelIndexFromFrequency( uint frequency )
+int RadioStationModel::indexFromFrequency( uint frequency )
 {
 RadioStation station;
 if ( findFrequency( frequency, station ) ) {
-return index( findPresetIndex( station.presetIndex() ), 0 );
+return findPresetIndex( station.presetIndex() );
 }
-return QModelIndex();
+return -1;
 }
 /*!
 * Private slot
 * Timer timeout slot to indicate that the dynamic PS check has ended
 int index = 0;
 for ( ; indexes.contains( index ); ++index ) {
 // Nothing to do here
 }
-LOG_FORMAT( "RadioStationModelPrivate::findUnusedPresetIndex, index: %d", index );
+LOG_FORMAT( "RadioStationModel::findUnusedPresetIndex, index: %d", index );
 return index;
 }
-/*!
-* Used by the RDS data setters to find the correct station where the data is set
-*/
-RadioStation RadioStationModel::findCurrentStation( uint frequency )
-{
-Q_D( RadioStationModel );
-RadioStation station = *d->mCurrentStation;
-if ( station.frequency() != frequency ) {
-if ( !findFrequency( frequency, station ) ) {
-return RadioStation();
-}
-}
-return station;
-}

branch	GCC_SURGE
changeset 37	451b2e1545b2
parent 19	afea38384506
parent 33	11b6825f0862