13 * |
13 * |
14 * Description: VideoListDataModelPrivate class implementation |
14 * Description: VideoListDataModelPrivate class implementation |
15 * |
15 * |
16 */ |
16 */ |
17 |
17 |
18 // Version : %version: 38.1.1 % |
18 // Version : %version: 38.1.6 % |
19 |
19 |
20 // INCLUDE FILES |
20 // INCLUDE FILES |
21 #include <hbglobal.h> |
21 #include <hbglobal.h> |
22 #include <mpxmediageneraldefs.h> |
22 #include <mpxmediageneraldefs.h> |
23 #include <mpxmediavideodefs.h> |
23 #include <mpxmediavideodefs.h> |
24 #include <thumbnailmanager_qt.h> |
24 #include <thumbnailmanager_qt.h> |
25 #include <mpxmediaarray.h> |
25 #include <mpxmediaarray.h> |
26 #include <mpxmedia.h> |
26 #include <mpxmedia.h> |
27 #include <qvariant.h> |
27 #include <qvariant.h> |
28 #include <hbextendedlocale.h> |
28 #include <hbextendedlocale.h> |
|
29 #include <qfileinfo.h> |
29 |
30 |
30 #include "videolistdatamodel.h" |
31 #include "videolistdatamodel.h" |
31 #include "videocollectionclient.h" |
32 #include "videocollectionclient.h" |
32 #include "videodeleteworker.h" |
33 #include "videodeleteworker.h" |
33 #include "videolistdatamodel_p.h" |
34 #include "videolistdatamodel_p.h" |
89 if(mInitialized) |
90 if(mInitialized) |
90 { |
91 { |
91 return 0; |
92 return 0; |
92 } |
93 } |
93 mVideoThumbnailData = &(VideoThumbnailData::instance()); |
94 mVideoThumbnailData = &(VideoThumbnailData::instance()); |
94 if(!connect( mVideoThumbnailData, SIGNAL(thumbnailsFetched( QList<TMPXItemId> )), |
95 if(!connect( mVideoThumbnailData, SIGNAL(thumbnailsFetched( QList<TMPXItemId>& )), |
95 this, SLOT(thumbnailsFetchedSlot( QList<TMPXItemId> )))) |
96 this, SLOT(thumbnailsFetchedSlot( QList<TMPXItemId>& )))) |
96 { |
97 { |
97 return -1; |
98 return -1; |
98 } |
99 } |
99 |
100 |
100 mInitialized = true; |
101 mInitialized = true; |
112 |
113 |
113 // ----------------------------------------------------------------------------- |
114 // ----------------------------------------------------------------------------- |
114 // getMediaIdFromIndex |
115 // getMediaIdFromIndex |
115 // ----------------------------------------------------------------------------- |
116 // ----------------------------------------------------------------------------- |
116 // |
117 // |
117 TMPXItemId VideoListDataModelPrivate::getMediaIdFromIndex( int index ) const |
118 const TMPXItemId& VideoListDataModelPrivate::getMediaIdFromIndex(const int &index ) const |
118 { |
119 { |
119 return mMediaData.idFromIndex(index); |
120 return mMediaData.idFromIndex(index); |
120 } |
121 } |
121 |
122 |
122 // ----------------------------------------------------------------------------- |
123 // ----------------------------------------------------------------------------- |
123 // getVideoNameFromIndex |
124 // getVideoNameFromIndex |
124 // ----------------------------------------------------------------------------- |
125 // ----------------------------------------------------------------------------- |
125 // |
126 // |
126 const QString VideoListDataModelPrivate::getVideoNameFromIndex( int index ) const |
127 const QString VideoListDataModelPrivate::getVideoNameFromIndex(const int &index ) const |
127 { |
128 { |
128 QString txt; |
129 QString txt; |
129 CMPXMedia* media = mMediaData.fromIndex(index); |
130 CMPXMedia* media = mMediaData.fromIndex(index); |
130 VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralTitle, txt ); |
131 VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralTitle, txt ); |
131 return txt; |
132 return txt; |
133 |
134 |
134 // ----------------------------------------------------------------------------- |
135 // ----------------------------------------------------------------------------- |
135 // getVideoThumbnailFromIndex |
136 // getVideoThumbnailFromIndex |
136 // ----------------------------------------------------------------------------- |
137 // ----------------------------------------------------------------------------- |
137 // |
138 // |
138 const QIcon* VideoListDataModelPrivate::getVideoThumbnailFromIndex( int index ) const |
139 const QIcon* VideoListDataModelPrivate::getVideoThumbnailFromIndex(const int &index ) const |
139 { |
140 { |
140 if(mVideoThumbnailData) |
141 if(mVideoThumbnailData) |
141 { |
142 { |
142 return mVideoThumbnailData->getThumbnail( mMediaData.idFromIndex(index) ); |
143 return mVideoThumbnailData->getThumbnail( mMediaData.idFromIndex(index) ); |
143 } |
144 } |
146 |
147 |
147 // ----------------------------------------------------------------------------- |
148 // ----------------------------------------------------------------------------- |
148 // getCategoryVideoCountFromIndex |
149 // getCategoryVideoCountFromIndex |
149 // ----------------------------------------------------------------------------- |
150 // ----------------------------------------------------------------------------- |
150 // |
151 // |
151 quint32 VideoListDataModelPrivate::getCategoryVideoCountFromIndex( int index ) const |
152 quint32 VideoListDataModelPrivate::getCategoryVideoCountFromIndex(const int &index ) const |
152 { |
153 { |
153 quint32 count(0); |
154 quint32 count(0); |
154 CMPXMedia *media = mMediaData.fromIndex(index); |
155 CMPXMedia *media = mMediaData.fromIndex(index); |
155 VideoCollectionUtils::instance().mediaValue<quint32>(media, KVcxMediaMyVideosCategoryItemCount, count ); |
156 VideoCollectionUtils::instance().mediaValue<quint32>(media, KVcxMediaMyVideosCategoryItemCount, count ); |
156 return count; |
157 return count; |
158 |
159 |
159 // ----------------------------------------------------------------------------- |
160 // ----------------------------------------------------------------------------- |
160 // getVideoSizeFromIndex |
161 // getVideoSizeFromIndex |
161 // ----------------------------------------------------------------------------- |
162 // ----------------------------------------------------------------------------- |
162 // |
163 // |
163 quint32 VideoListDataModelPrivate::getVideoSizeFromIndex( int index ) const |
164 quint32 VideoListDataModelPrivate::getVideoSizeFromIndex(const int &index ) const |
164 { |
165 { |
165 quint32 size(0); |
166 quint32 size(0); |
166 CMPXMedia *media = mMediaData.fromIndex(index); |
167 CMPXMedia *media = mMediaData.fromIndex(index); |
167 VideoCollectionUtils::instance().mediaValue<quint32>(media, KMPXMediaGeneralSize, size ); |
168 VideoCollectionUtils::instance().mediaValue<quint32>(media, KMPXMediaGeneralSize, size ); |
168 return size; |
169 return size; |
170 |
171 |
171 // ----------------------------------------------------------------------------- |
172 // ----------------------------------------------------------------------------- |
172 // getVideoAgeProfileFromIndex |
173 // getVideoAgeProfileFromIndex |
173 // --------------------------------------------------------------------------- |
174 // --------------------------------------------------------------------------- |
174 // |
175 // |
175 quint32 VideoListDataModelPrivate::getVideoAgeProfileFromIndex( int index ) const |
176 quint32 VideoListDataModelPrivate::getVideoAgeProfileFromIndex(const int &index ) const |
176 { |
177 { |
177 quint32 ageProfile(0); |
178 quint32 ageProfile(0); |
178 CMPXMedia *media = mMediaData.fromIndex(index); |
179 CMPXMedia *media = mMediaData.fromIndex(index); |
179 VideoCollectionUtils::instance().mediaValue<quint32>(media, KVcxMediaMyVideosAgeProfile, ageProfile ); |
180 VideoCollectionUtils::instance().mediaValue<quint32>(media, KVcxMediaMyVideosAgeProfile, ageProfile ); |
180 return ageProfile; |
181 return ageProfile; |
182 |
183 |
183 // ----------------------------------------------------------------------------- |
184 // ----------------------------------------------------------------------------- |
184 // getVideodurationFromIndex |
185 // getVideodurationFromIndex |
185 // ----------------------------------------------------------------------------- |
186 // ----------------------------------------------------------------------------- |
186 // |
187 // |
187 quint32 VideoListDataModelPrivate::getVideodurationFromIndex( int index ) const |
188 quint32 VideoListDataModelPrivate::getVideodurationFromIndex(const int &index ) const |
188 { |
189 { |
189 CMPXMedia *media = mMediaData.fromIndex(index); |
190 CMPXMedia *media = mMediaData.fromIndex(index); |
190 return getVideoDuration(media); |
191 return getVideoDuration(media); |
191 } |
192 } |
192 |
193 |
205 |
206 |
206 // ----------------------------------------------------------------------------- |
207 // ----------------------------------------------------------------------------- |
207 // getVideoDateFromIndex |
208 // getVideoDateFromIndex |
208 // ----------------------------------------------------------------------------- |
209 // ----------------------------------------------------------------------------- |
209 // |
210 // |
210 QDateTime VideoListDataModelPrivate::getVideoDateFromIndex( int index ) const |
211 QDateTime VideoListDataModelPrivate::getVideoDateFromIndex(const int &index ) const |
211 { |
212 { |
212 return getVideoDate(mMediaData.fromIndex(index)); |
213 return getVideoDate(mMediaData.fromIndex(index)); |
213 } |
214 } |
214 |
215 |
215 // ----------------------------------------------------------------------------- |
216 // ----------------------------------------------------------------------------- |
232 |
233 |
233 // ----------------------------------------------------------------------------- |
234 // ----------------------------------------------------------------------------- |
234 // markVideosRemoved |
235 // markVideosRemoved |
235 // ----------------------------------------------------------------------------- |
236 // ----------------------------------------------------------------------------- |
236 // |
237 // |
237 TMPXItemId VideoListDataModelPrivate::markVideoRemoved(const QModelIndex &itemIndex) |
238 const TMPXItemId VideoListDataModelPrivate::markVideoRemoved(const QModelIndex &itemIndex) |
238 { |
239 { |
239 return mMediaData.markItemRemoved(itemIndex.row()); |
240 return mMediaData.markItemRemoved(itemIndex.row()); |
240 } |
241 } |
241 |
242 |
242 // ----------------------------------------------------------------------------- |
243 // ----------------------------------------------------------------------------- |
257 |
258 |
258 // ----------------------------------------------------------------------------- |
259 // ----------------------------------------------------------------------------- |
259 // getFilePathFromIndex |
260 // getFilePathFromIndex |
260 // ----------------------------------------------------------------------------- |
261 // ----------------------------------------------------------------------------- |
261 // |
262 // |
262 const QString VideoListDataModelPrivate::getFilePathFromIndex(int index) const |
263 const QString VideoListDataModelPrivate::getFilePathFromIndex(const int &index) const |
263 { |
264 { |
264 QString filePath; |
265 QString filePath; |
265 VideoCollectionUtils::instance().mediaValue<QString>(mMediaData.fromIndex(index), |
266 VideoCollectionUtils::instance().mediaValue<QString>(mMediaData.fromIndex(index), |
266 KMPXMediaGeneralUri, filePath ); |
267 KMPXMediaGeneralUri, filePath ); |
267 return filePath; |
268 return filePath; |
269 |
270 |
270 // ----------------------------------------------------------------------------- |
271 // ----------------------------------------------------------------------------- |
271 // getFilePathForId |
272 // getFilePathForId |
272 // ----------------------------------------------------------------------------- |
273 // ----------------------------------------------------------------------------- |
273 // |
274 // |
274 const QString VideoListDataModelPrivate::getFilePathForId(TMPXItemId mediaId) const |
275 const QString VideoListDataModelPrivate::getFilePathForId(const TMPXItemId &mediaId) |
275 { |
276 { |
276 QString filePath; |
277 QString filePath; |
277 int index = mMediaData.indexOfId(mediaId); |
278 int index = mMediaData.indexOfId(mediaId); |
278 VideoCollectionUtils::instance().mediaValue<QString>(mMediaData.fromIndex(index), |
279 VideoCollectionUtils::instance().mediaValue<QString>(mMediaData.fromIndex(index), |
279 KMPXMediaGeneralUri, filePath ); |
280 KMPXMediaGeneralUri, filePath ); |
306 |
307 |
307 // ----------------------------------------------------------------------------- |
308 // ----------------------------------------------------------------------------- |
308 // setAlbumInUse |
309 // setAlbumInUse |
309 // ----------------------------------------------------------------------------- |
310 // ----------------------------------------------------------------------------- |
310 // |
311 // |
311 void VideoListDataModelPrivate::setAlbumInUse(TMPXItemId albumId) |
312 void VideoListDataModelPrivate::setAlbumInUse(const TMPXItemId &albumId) |
312 { |
313 { |
313 FUNC_LOG; |
314 FUNC_LOG; |
314 mCurrentAlbum = albumId; |
315 mCurrentAlbum = albumId; |
315 } |
316 } |
316 |
317 |
317 // ----------------------------------------------------------------------------- |
318 // ----------------------------------------------------------------------------- |
318 // removeItemsFromAlbum |
319 // removeItemsFromAlbum |
319 // ----------------------------------------------------------------------------- |
320 // ----------------------------------------------------------------------------- |
320 // |
321 // |
321 int VideoListDataModelPrivate::removeItemsFromAlbum(TMPXItemId &albumId, |
322 int VideoListDataModelPrivate::removeItemsFromAlbum(const TMPXItemId &albumId, |
322 const QList<TMPXItemId> &items) |
323 const QList<TMPXItemId> &items) |
323 { |
324 { |
324 FUNC_LOG; |
325 FUNC_LOG; |
325 QHash<TMPXItemId, QSet<TMPXItemId> >::iterator iter = mAlbumData.find(albumId); |
326 QHash<TMPXItemId, QSet<TMPXItemId> >::iterator iter = mAlbumData.find(albumId); |
326 if(iter == mAlbumData.end()) |
327 if(iter == mAlbumData.end()) |
420 |
421 |
421 // ----------------------------------------------------------------------------- |
422 // ----------------------------------------------------------------------------- |
422 // albumDataChangedL |
423 // albumDataChangedL |
423 // ----------------------------------------------------------------------------- |
424 // ----------------------------------------------------------------------------- |
424 // |
425 // |
425 void VideoListDataModelPrivate::albumDataChangedL(TMPXItemId albumId, |
426 void VideoListDataModelPrivate::albumDataChangedL(TMPXItemId &albumId, |
426 CMPXMediaArray *videoArray) |
427 CMPXMediaArray *videoArray) |
427 { |
428 { |
428 FUNC_LOG; |
429 FUNC_LOG; |
429 if (!videoArray || albumId == TMPXItemId::InvalidId()) |
430 if (!videoArray || albumId == TMPXItemId::InvalidId()) |
430 { |
431 { |
431 return; |
432 return; |
432 } |
433 } |
433 QSet<TMPXItemId> items; |
434 QSet<TMPXItemId> items; |
434 |
435 |
|
436 int oldCount = mAlbumData[albumId].count(); |
|
437 |
435 // remove existing |
438 // remove existing |
436 mAlbumData.remove(albumId); |
439 mAlbumData.remove(albumId); |
437 |
440 |
438 int videoCount = videoArray->Count(); |
441 int videoCount = videoArray->Count(); |
439 CMPXMedia *media = 0; |
442 CMPXMedia *media = 0; |
448 } |
451 } |
449 } |
452 } |
450 |
453 |
451 mAlbumData[albumId] = items; |
454 mAlbumData[albumId] = items; |
452 |
455 |
453 // signal that album has been updated |
456 if(oldCount != items.count()) |
454 emit q_ptr->albumChanged(); |
457 { |
455 |
458 // signal that album has been updated |
456 // signal that model has changed. |
459 emit q_ptr->albumChanged(); |
457 emit q_ptr->modelChanged(); |
460 |
|
461 // signal that model has changed. |
|
462 emit q_ptr->modelChanged(); |
|
463 } |
458 } |
464 } |
459 |
465 |
460 |
466 |
461 // ----------------------------------------------------------------------------- |
467 // ----------------------------------------------------------------------------- |
462 // thumbnailsFetchedSlot |
468 // thumbnailsFetchedSlot |
463 // ----------------------------------------------------------------------------- |
469 // ----------------------------------------------------------------------------- |
464 // |
470 // |
465 void VideoListDataModelPrivate::thumbnailsFetchedSlot(QList<TMPXItemId> mediaIds) |
471 void VideoListDataModelPrivate::thumbnailsFetchedSlot(QList<TMPXItemId> &mediaIds) |
466 { |
472 { |
467 TMPXItemId id; |
473 TMPXItemId id; |
468 QModelIndex rowIndex; |
474 QModelIndex rowIndex; |
469 |
475 |
470 while(!mediaIds.isEmpty()) |
476 while(!mediaIds.isEmpty()) |
471 { |
477 { |
472 id = mediaIds.takeFirst(); |
478 id = mediaIds.takeFirst(); |
473 rowIndex = q_ptr->index(mMediaData.indexOfId(id), 0); |
479 rowIndex = q_ptr->index(mMediaData.indexOfId(id), 0); |
474 if(rowIndex.isValid()) |
480 if(rowIndex.isValid()) |
475 { |
481 { |
476 emit dataChanged( rowIndex, rowIndex); |
482 emit q_ptr->dataChanged( rowIndex, rowIndex); |
477 } |
483 } |
478 } |
484 } |
479 } |
485 } |
480 |
486 |
481 // ----------------------------------------------------------------------------- |
487 // ----------------------------------------------------------------------------- |
593 |
599 |
594 // ----------------------------------------------------------------------------- |
600 // ----------------------------------------------------------------------------- |
595 // albumRemoved |
601 // albumRemoved |
596 // ----------------------------------------------------------------------------- |
602 // ----------------------------------------------------------------------------- |
597 // |
603 // |
598 void VideoListDataModelPrivate::albumRemoved(TMPXItemId albumId) |
604 void VideoListDataModelPrivate::albumRemoved(TMPXItemId &albumId) |
599 { |
605 { |
600 FUNC_LOG; |
606 FUNC_LOG; |
601 if (albumId == TMPXItemId::InvalidId() || albumId.iId2 != KVcxMvcMediaTypeAlbum) |
607 if (albumId == TMPXItemId::InvalidId() || albumId.iId2 != KVcxMvcMediaTypeAlbum) |
602 { |
608 { |
603 return; |
609 return; |
686 int status(VideoCollectionCommon::statusDeleteSucceed); |
692 int status(VideoCollectionCommon::statusDeleteSucceed); |
687 QVariant data; |
693 QVariant data; |
688 if(failedMediaIds->count() > 0) |
694 if(failedMediaIds->count() > 0) |
689 { |
695 { |
690 QString nameOfFirstFailed(""); |
696 QString nameOfFirstFailed(""); |
691 CMPXMedia *media = mMediaData.getRemovedMedia( TMPXItemId(failedMediaIds->at(0))); |
697 CMPXMedia *media = mMediaData.getRemovedMedia(failedMediaIds->first()); |
692 VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralTitle, nameOfFirstFailed ); |
698 VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralTitle, nameOfFirstFailed ); |
693 if(failedMediaIds->count() == 1) |
699 if(failedMediaIds->count() == 1) |
694 { |
700 { |
695 status = VideoCollectionCommon::statusSingleDeleteFail; |
701 status = VideoCollectionCommon::statusSingleDeleteFail; |
696 data = nameOfFirstFailed; |
702 data = nameOfFirstFailed; |
720 int status(VideoCollectionCommon::statusRemoveSucceed); |
726 int status(VideoCollectionCommon::statusRemoveSucceed); |
721 QVariant data; |
727 QVariant data; |
722 if(failedMediaIds->count() > 0) |
728 if(failedMediaIds->count() > 0) |
723 { |
729 { |
724 QString nameOfFirstFailed(""); |
730 QString nameOfFirstFailed(""); |
725 CMPXMedia *media = mMediaData.getRemovedMedia( TMPXItemId(failedMediaIds->at(0))); |
731 CMPXMedia *media = mMediaData.getRemovedMedia(failedMediaIds->first()); |
726 VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralTitle, nameOfFirstFailed ); |
732 VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralTitle, nameOfFirstFailed ); |
727 if(failedMediaIds->count() == 1) |
733 if(failedMediaIds->count() == 1) |
728 { |
734 { |
729 status = VideoCollectionCommon::statusSingleRemoveFail; |
735 status = VideoCollectionCommon::statusSingleRemoveFail; |
730 data = nameOfFirstFailed; |
736 data = nameOfFirstFailed; |
854 QString format; |
860 QString format; |
855 if(VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralMimeType, format)) { |
861 if(VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralMimeType, format)) { |
856 map[MetaKeyFormat] = format; |
862 map[MetaKeyFormat] = format; |
857 } |
863 } |
858 |
864 |
|
865 // MetaKeyFileName and MetaKeyFilePath |
|
866 QString fileName; |
|
867 if(VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralUri, fileName)) { |
|
868 |
|
869 QFileInfo fInfo(fileName); |
|
870 if(fInfo.isFile()) |
|
871 { |
|
872 map[MetaKeyFileName] = fInfo.fileName(); |
|
873 map[MetaKeyFilePath] = fInfo.absolutePath(); |
|
874 } |
|
875 } |
|
876 |
|
877 // Metakey video title |
|
878 QString videoTitle; |
|
879 if(VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralTitle, videoTitle)) { |
|
880 map[MetaKeyVideoTitle] = videoTitle; |
|
881 } |
|
882 |
|
883 |
859 QVariant variant = QVariant(map); |
884 QVariant variant = QVariant(map); |
860 emit videoDetailsReady(variant); |
885 emit q_ptr->fullVideoDetailsReady(variant); |
861 } |
886 } |
862 |
887 |
863 // ----------------------------------------------------------------------------- |
888 // ----------------------------------------------------------------------------- |
864 // albumListAvailableSlot |
889 // albumListAvailableSlot |
865 // ----------------------------------------------------------------------------- |
890 // ----------------------------------------------------------------------------- |
866 // |
891 // |
867 void VideoListDataModelPrivate::albumListAvailableSlot(TMPXItemId albumId, |
892 void VideoListDataModelPrivate::albumListAvailableSlot(TMPXItemId &albumId, |
868 CMPXMediaArray *albumItems) |
893 CMPXMediaArray *albumItems) |
869 { |
894 { |
870 FUNC_LOG; |
895 FUNC_LOG; |
871 // currently only one album is kept in memory |
896 // currently only one album is kept in memory |
872 TRAP_IGNORE(albumDataChangedL(albumId, albumItems)); |
897 TRAP_IGNORE(albumDataChangedL(albumId, albumItems)); |
882 int index = mMediaData.indexOfId(itemId); |
907 int index = mMediaData.indexOfId(itemId); |
883 if(index != -1) |
908 if(index != -1) |
884 { |
909 { |
885 QModelIndex rowIndex = q_ptr->index(index, 0); |
910 QModelIndex rowIndex = q_ptr->index(index, 0); |
886 if(rowIndex.isValid()) |
911 if(rowIndex.isValid()) |
887 { |
912 { |
888 emit dataChanged(rowIndex, rowIndex); |
913 emit q_ptr->dataChanged(rowIndex, rowIndex); |
889 emit q_ptr->itemModified(itemId); |
914 emit q_ptr->modelChanged(); |
890 } |
915 } |
891 } |
916 } |
892 } |
917 } |
893 |
918 |
894 // ----------------------------------------------------------------------------- |
919 // ----------------------------------------------------------------------------- |
895 // listCompleteSlot |
920 // videoListCompleteSlot |
896 // ----------------------------------------------------------------------------- |
921 // ----------------------------------------------------------------------------- |
897 // |
922 // |
898 void VideoListDataModelPrivate::listCompleteSlot() |
923 void VideoListDataModelPrivate::videoListCompleteSlot() |
899 { |
924 { |
900 emit q_ptr->modelReady(); |
925 emit q_ptr->modelReady(); |
901 } |
926 } |
902 |
927 |
|
928 // ----------------------------------------------------------------------------- |
|
929 // albumListCompleteSlot |
|
930 // ----------------------------------------------------------------------------- |
|
931 // |
|
932 void VideoListDataModelPrivate::albumListCompleteSlot() |
|
933 { |
|
934 emit q_ptr->albumListReady(); |
|
935 } |
|
936 |
903 // End of file |
937 // End of file |