MythTV: videofilter.cpp Source File

00001 /*
00002     videofilter.cpp
00003     (c) 2003 Thor Sigvaldason, Isaac Richards, and ?? ??
00004     Part of the mythTV project
00005 */
00006 
00007 #include <mythtv/mythcontext.h>
00008 #include <mythtv/uitypes.h>
00009 
00010 #include "globals.h"
00011 #include "videofilter.h"
00012 #include "videolist.h"
00013 #include "dbaccess.h"
00014 #include "metadata.h"
00015 #include "metadatalistmanager.h"
00016 #include "videoutils.h"
00017 
00018 #include <set>
00019 
00020 enum GenreFilter {
00021     kGenreFilterAll = -1,
00022     kGenreFilterUnknown = 0
00023 };
00024 
00025 enum CountryFilter {
00026     kCountryFilterAll = -1,
00027     kCountryFilterUnknown = 0
00028 };
00029 
00030 enum CastFilter {
00031     kCastFilterAll = -1,
00032     kCastFilterUnknown = 0
00033 };
00034 
00035 enum CategoryFilter {
00036     kCategoryFilterAll = -1,
00037     kCategoryFilterUnknown = 0
00038 };
00039 
00040 enum YearFilter {
00041     kYearFilterAll = -1,
00042     kYearFilterUnknown = 0
00043 };
00044 
00045 enum RuntimeFilter {
00046     kRuntimeFilterAll = -2,
00047     kRuntimeFilterUnknown = -1
00048 };
00049 
00050 enum UserRatingFilter {
00051     kUserRatingFilterAll = -1
00052 };
00053 
00054 enum BrowseFilter {
00055     kBrowseFilterAll = -1
00056 };
00057 
00058 enum InetRefFilter {
00059     kInetRefFilterAll = -1,
00060     kInetRefFilterUnknown = 0
00061 };
00062 
00063 enum CoverFileFilter {
00064     kCoverFileFilterAll = -1,
00065     kCoverFileFilterNone = 0
00066 };
00067 
00068 const unsigned int VideoFilterSettings::FILTER_MASK;
00069 const unsigned int VideoFilterSettings::SORT_MASK;
00070 
00071 VideoFilterSettings::VideoFilterSettings(bool loaddefaultsettings,
00072                                          const QString& _prefix) :
00073     category(kCategoryFilterAll), genre(kGenreFilterAll),
00074     country(kCountryFilterAll), cast(kCastFilterAll),
00075     year(kYearFilterAll), runtime(kRuntimeFilterAll), 
00076     userrating(kUserRatingFilterAll), browse(kBrowseFilterAll), 
00077     m_inetref(kInetRefFilterAll), m_coverfile(kCoverFileFilterAll), 
00078     orderby(kOrderByTitle), m_parental_level(ParentalLevel::plNone), 
00079     m_changed_state(0)
00080 {
00081     if (!_prefix)
00082         prefix = "VideoDefault";
00083     else
00084         prefix = _prefix + "Default";
00085 
00086     // do nothing yet
00087     if (loaddefaultsettings)
00088     {
00089         category = gContext->GetNumSetting(QString("%1Category").arg(prefix),
00090                                            kCategoryFilterAll);
00091         genre = gContext->GetNumSetting(QString("%1Genre").arg(prefix),
00092                                         kGenreFilterAll);
00093         country = gContext->GetNumSetting(QString("%1Country").arg(prefix),
00094                                           kCountryFilterAll);
00095         cast = gContext->GetNumSetting(QString("%1Cast").arg(prefix),
00096                                         kCastFilterAll);
00097         year = gContext->GetNumSetting(QString("%1Year").arg(prefix),
00098                                        kYearFilterAll);
00099         runtime = gContext->GetNumSetting(QString("%1Runtime").arg(prefix),
00100                                           kRuntimeFilterAll);
00101         userrating =
00102                 gContext->GetNumSetting(QString("%1Userrating").arg(prefix),
00103                                         kUserRatingFilterAll);
00104         browse = gContext->GetNumSetting(QString("%1Browse").arg(prefix),
00105                                          kBrowseFilterAll);
00106         m_inetref = gContext->GetNumSetting(QString("%1InetRef").arg(prefix),
00107                 kInetRefFilterAll);
00108         m_coverfile = gContext->GetNumSetting(QString("%1CoverFile")
00109                 .arg(prefix), kCoverFileFilterAll);
00110         orderby = (ordering)gContext->GetNumSetting(QString("%1Orderby")
00111                                                     .arg(prefix),
00112                                                     kOrderByTitle);
00113     }
00114 }
00115 
00116 VideoFilterSettings::VideoFilterSettings(const VideoFilterSettings &rhs) :
00117     m_changed_state(0)
00118 {
00119     *this = rhs;
00120 }
00121 
00122 VideoFilterSettings &
00123 VideoFilterSettings::operator=(const VideoFilterSettings &rhs)
00124 {
00125     prefix = rhs.prefix;
00126 
00127     if (category != rhs.category)
00128     {
00129         m_changed_state |= kFilterCategoryChanged;
00130         category = rhs.category;
00131     }
00132 
00133     if (genre != rhs.genre)
00134     {
00135         m_changed_state |= kFilterGenreChanged;
00136         genre = rhs.genre;
00137     }
00138 
00139     if (country != rhs.country)
00140     {
00141         m_changed_state |= kFilterCountryChanged;
00142         country = rhs.country;
00143     }
00144 
00145     if (cast != rhs.cast)
00146     {
00147         m_changed_state |= kFilterCastChanged;
00148         cast = rhs.cast;
00149     }
00150 
00151     if (year != rhs.year)
00152     {
00153         m_changed_state |= kFilterYearChanged;
00154         year = rhs.year;
00155     }
00156 
00157     if (runtime != rhs.runtime)
00158     {
00159         m_changed_state |= kFilterRuntimeChanged;
00160         runtime = rhs.runtime;
00161     }
00162 
00163     if (userrating != rhs.userrating)
00164     {
00165         m_changed_state |= kFilterUserRatingChanged;
00166         userrating = rhs.userrating;
00167     }
00168 
00169     if (browse != rhs.browse)
00170     {
00171         m_changed_state |= kFilterBrowseChanged;
00172         browse = rhs.browse;
00173     }
00174 
00175     if (m_inetref != rhs.m_inetref)
00176     {
00177         m_changed_state |= kFilterInetRefChanged;
00178         m_inetref = rhs.m_inetref;
00179     }
00180 
00181     if (m_coverfile != rhs.m_coverfile)
00182     {
00183         m_changed_state |= kFilterCoverFileChanged;
00184         m_coverfile = rhs.m_coverfile;
00185     }
00186 
00187     if (orderby != rhs.orderby)
00188     {
00189         m_changed_state |= kSortOrderChanged;
00190         orderby = rhs.orderby;
00191     }
00192 
00193     if (m_parental_level != rhs.m_parental_level)
00194     {
00195         m_changed_state |= kFilterParentalLevelChanged;
00196         m_parental_level = rhs.m_parental_level;
00197     }
00198 
00199     return *this;
00200 }
00201 
00202 void VideoFilterSettings::saveAsDefault()
00203 {
00204     gContext->SaveSetting(QString("%1Category").arg(prefix), category);
00205     gContext->SaveSetting(QString("%1Genre").arg(prefix), genre);
00206     gContext->SaveSetting(QString("%1Cast").arg(prefix), cast);
00207     gContext->SaveSetting(QString("%1Country").arg(prefix), country);
00208     gContext->SaveSetting(QString("%1Year").arg(prefix), year);
00209     gContext->SaveSetting(QString("%1Runtime").arg(prefix), runtime);
00210     gContext->SaveSetting(QString("%1Userrating").arg(prefix), userrating);
00211     gContext->SaveSetting(QString("%1Browse").arg(prefix), browse);
00212     gContext->SaveSetting(QString("%1InetRef").arg(prefix), m_inetref);
00213     gContext->SaveSetting(QString("%1CoverFile").arg(prefix), m_coverfile);
00214     gContext->SaveSetting(QString("%1Orderby").arg(prefix), orderby);
00215 }
00216 
00217 bool VideoFilterSettings::matches_filter(const Metadata &mdata) const
00218 {
00219     bool matches = true;
00220 
00221     if (genre != kGenreFilterAll)
00222     {
00223         matches = false;
00224 
00225         const Metadata::genre_list &gl = mdata.Genres();
00226         for (Metadata::genre_list::const_iterator p = gl.begin();
00227              p != gl.end(); ++p)
00228         {
00229             if ((matches = p->first == genre))
00230             {
00231                 break;
00232             }
00233         }
00234     }
00235 
00236     if (matches && country != kCountryFilterAll)
00237     {
00238         matches = false;
00239 
00240         const Metadata::country_list &cl = mdata.Countries();
00241         for (Metadata::country_list::const_iterator p = cl.begin();
00242              p != cl.end(); ++p)
00243         {
00244             if ((matches = p->first == country))
00245             {
00246                 break;
00247             }
00248         }
00249     }
00250 
00251     if (matches && cast != kCastFilterAll)
00252     {
00253         const Metadata::cast_list &cl = mdata.getCast();
00254 
00255         if (cast == kCastFilterUnknown && cl.size() == 0)
00256         {
00257             matches = true;
00258         }
00259         else
00260         {
00261             matches = false;
00262 
00263             for (Metadata::cast_list::const_iterator p = cl.begin();
00264                  p != cl.end(); ++p)
00265             {
00266                 if ((matches = p->first == cast))
00267                 {
00268                     break;
00269                 }
00270             }
00271         }
00272     }
00273 
00274     if (matches && category != kCategoryFilterAll)
00275     {
00276         matches = category == mdata.getCategoryID();
00277     }
00278 
00279     if (matches && year != kYearFilterAll)
00280     {
00281         if (year == kYearFilterUnknown)
00282         {
00283             matches = (mdata.Year() == 0) ||
00284                     (mdata.Year() == VIDEO_YEAR_DEFAULT);
00285         }
00286         else
00287         {
00288             matches = year == mdata.Year();
00289         }
00290     }
00291 
00292     if (matches && runtime != kRuntimeFilterAll)
00293     {
00294         if (runtime == kRuntimeFilterUnknown)
00295         {
00296             matches = mdata.Length() == 0;
00297         }
00298         else
00299         {
00300             matches = runtime == (mdata.Length() / 30);
00301         }
00302     }
00303 
00304     if (matches && userrating != kUserRatingFilterAll)
00305     {
00306         matches = mdata.UserRating() >= userrating;
00307     }
00308 
00309     if (matches && browse != kBrowseFilterAll)
00310     {
00311         matches = mdata.Browse() == browse;
00312     }
00313 
00314     if (matches && m_inetref != kInetRefFilterAll)
00315     {
00316         matches = mdata.InetRef() == VIDEO_INETREF_DEFAULT;
00317     }
00318 
00319     if (matches && m_coverfile != kCoverFileFilterAll)
00320     {
00321         matches = isDefaultCoverFile(mdata.CoverFile());
00322     }
00323 
00324     if (matches && m_parental_level)
00325     {
00326         matches = (mdata.ShowLevel() != ParentalLevel::plNone) &&
00327                 (mdata.ShowLevel() <= m_parental_level);
00328     }
00329 
00330     return matches;
00331 }
00332 
00334 bool VideoFilterSettings::meta_less_than(const Metadata &lhs,
00335                                          const Metadata &rhs,
00336                                          bool sort_ignores_case) const
00337 {
00338     bool ret = false;
00339     switch (orderby)
00340     {
00341         case kOrderByTitle:
00342         {
00343             Metadata::SortKey lhs_key;
00344             Metadata::SortKey rhs_key;
00345             if (lhs.hasSortKey() && rhs.hasSortKey())
00346             {
00347                 lhs_key = lhs.getSortKey();
00348                 rhs_key = rhs.getSortKey();
00349             }
00350             else
00351             {
00352                 lhs_key = Metadata::GenerateDefaultSortKey(lhs,
00353                                                            sort_ignores_case);
00354                 rhs_key = Metadata::GenerateDefaultSortKey(rhs,
00355                                                            sort_ignores_case);
00356             }
00357             ret = lhs_key < rhs_key;
00358             break;
00359         }
00360         case kOrderByYearDescending:
00361         {
00362             ret = lhs.Year() > rhs.Year();
00363             break;
00364         }
00365         case kOrderByUserRatingDescending:
00366         {
00367             ret = lhs.UserRating() > rhs.UserRating();
00368             break;
00369         }
00370         case kOrderByLength:
00371         {
00372             ret = lhs.Length() < rhs.Length();
00373             break;
00374         }
00375         case kOrderByFilename:
00376         {
00377             QString lhsfn(sort_ignores_case ?
00378                           lhs.Filename().lower() : lhs.Filename());
00379             QString rhsfn(sort_ignores_case ?
00380                           rhs.Filename().lower() : rhs.Filename());
00381             ret = QString::localeAwareCompare(lhsfn, rhsfn) < 0;
00382             break;
00383         }
00384         case kOrderByID:
00385         {
00386             ret = lhs.ID() < rhs.ID();
00387             break;
00388         }
00389         default:
00390         {
00391             VERBOSE(VB_IMPORTANT, QString("Error: unknown sort type %1")
00392                     .arg(orderby));
00393         }
00394     }
00395 
00396     return ret;
00397 }
00398 
00400 // VideoFilterDialog
00402 VideoFilterDialog::VideoFilterDialog(FilterSettingsProxy *fsp,
00403                                  MythMainWindow *parent_,
00404                                  QString window_name,
00405                                  QString theme_filename,
00406                                  const VideoList &video_list,
00407                                  const char *name_) :
00408     MythThemedDialog(parent_, window_name, theme_filename, name_),
00409     browse_select(0), orderby_select(0), year_select(0), userrating_select(0),
00410     category_select(0), country_select(0), genre_select(0), cast_select(0), 
00411     runtime_select(0), save_button(0), done_button(0), numvideos_text(0), 
00412     m_intetref_select(0), m_coverfile_select(0), m_fsp(fsp), 
00413     m_video_list(video_list)
00414 {
00415     //
00416     //  The only thing this screen does is let the
00417     //  user set (some) metadata information. It only
00418     //  works on a single metadata entry.
00419     //
00420 
00421     m_settings = m_fsp->getSettings();
00422 
00423     wireUpTheme();
00424     fillWidgets();
00425     update_numvideo();
00426     assignFirstFocus();
00427 }
00428 
00429 void VideoFilterDialog::update_numvideo()
00430 {
00431     if (numvideos_text)
00432     {
00433         int video_count = m_video_list.test_filter(m_settings);
00434 
00435         if (video_count > 0)
00436         {
00437             numvideos_text->SetText(
00438                     QString(tr("Result of this filter : %1 video(s)"))
00439                     .arg(video_count));
00440         }
00441         else
00442         {
00443             numvideos_text->SetText(
00444                     QString(tr("Result of this filter : No Videos")));
00445         }
00446     }
00447 }
00448 
00449 void VideoFilterDialog::fillWidgets()
00450 {
00451     bool have_unknown_year = false;
00452     bool have_unknown_runtime = false;
00453 
00454     typedef std::set<int> int_list;
00455     int_list years;
00456     int_list runtimes;
00457     int_list user_ratings;
00458 
00459     const MetadataListManager::metadata_list &mdl =
00460             m_video_list.getListCache().getList();
00461     for (MetadataListManager::metadata_list::const_iterator p = mdl.begin();
00462          p != mdl.end(); ++p)
00463     {
00464         int year = (*p)->Year();
00465         if ((year == 0) || (year == VIDEO_YEAR_DEFAULT))
00466             have_unknown_year = true;
00467         else
00468             years.insert(year);
00469 
00470         int runtime = (*p)->Length();
00471         if (runtime == 0)
00472             have_unknown_runtime = true;
00473         else
00474             runtimes.insert(runtime / 30);
00475 
00476         user_ratings.insert(static_cast<int>((*p)->UserRating()));
00477     }
00478 
00479     if (category_select)
00480     {
00481         category_select->addItem(kCategoryFilterAll, QObject::tr("All"));
00482 
00483         const VideoCategory::entry_list &vcl =
00484                 VideoCategory::getCategory().getList();
00485         for (VideoCategory::entry_list::const_iterator p = vcl.begin();
00486              p != vcl.end(); ++p)
00487         {
00488             category_select->addItem(p->first, p->second);
00489         }
00490 
00491         category_select->addItem(kCategoryFilterUnknown,
00492                                  VIDEO_CATEGORY_UNKNOWN);
00493         category_select->setToItem(m_settings.getCategory());
00494     }
00495 
00496     if (genre_select)
00497     {
00498         genre_select->addItem(kGenreFilterAll, QObject::tr("All"));
00499 
00500         const VideoGenre::entry_list &gl = VideoGenre::getGenre().getList();
00501         for (VideoGenre::entry_list::const_iterator p = gl.begin();
00502              p != gl.end(); ++p)
00503         {
00504             genre_select->addItem(p->first, p->second);
00505         }
00506 
00507         genre_select->addItem(kGenreFilterUnknown, VIDEO_GENRE_UNKNOWN);
00508         genre_select->setToItem(m_settings.getGenre());
00509     }
00510 
00511     if (cast_select)
00512     {
00513         cast_select->addItem(kCastFilterAll, QObject::tr("All"));
00514 
00515         const VideoCast::entry_list &cl = VideoCast::getCast().getList();
00516         for (VideoCast::entry_list::const_iterator p = cl.begin();
00517              p != cl.end(); ++p)
00518         {
00519             cast_select->addItem(p->first, p->second);
00520         }
00521 
00522         cast_select->addItem(kCastFilterUnknown, VIDEO_CAST_UNKNOWN);
00523         cast_select->setToItem(m_settings.getCast());
00524     }
00525 
00526     if (country_select)
00527     {
00528         country_select->addItem(kCountryFilterAll, QObject::tr("All"));
00529 
00530         const VideoCountry::entry_list &cl =
00531                 VideoCountry::getCountry().getList();
00532         for (VideoCountry::entry_list::const_iterator p = cl.begin();
00533              p != cl.end(); ++p)
00534         {
00535             country_select->addItem(p->first, p->second);
00536         }
00537 
00538         country_select->addItem(kCountryFilterUnknown, VIDEO_COUNTRY_UNKNOWN);
00539         country_select->setToItem(m_settings.getCountry());
00540     }
00541 
00542     if (year_select)
00543     {
00544         year_select->addItem(kYearFilterAll, QObject::tr("All"));
00545 
00546         for (int_list::const_reverse_iterator p = years.rbegin();
00547              p != years.rend(); ++p)
00548         {
00549             year_select->addItem(*p, QString::number(*p));
00550         }
00551 
00552         if (have_unknown_year)
00553         {
00554             year_select->addItem(kYearFilterUnknown, VIDEO_YEAR_UNKNOWN);
00555         }
00556 
00557         year_select->setToItem(m_settings.getYear());
00558     }
00559 
00560     if (runtime_select)
00561     {
00562         runtime_select->addItem(kRuntimeFilterAll, QObject::tr("All"));
00563 
00564         if (have_unknown_runtime)
00565         {
00566             runtime_select->addItem(kRuntimeFilterUnknown,
00567                                     VIDEO_RUNTIME_UNKNOWN);
00568         }
00569 
00570         for (int_list::const_iterator p = runtimes.begin();
00571              p != runtimes.end(); ++p)
00572         {
00573             QString s = QString("%1 %2 ~ %3 %4").arg(*p * 30).arg(tr("minutes"))
00574                     .arg((*p + 1) * 30).arg(tr("minutes"));
00575             runtime_select->addItem(*p, s);
00576         }
00577 
00578         runtime_select->setToItem(m_settings.getRuntime());
00579     }
00580 
00581     if (userrating_select)
00582     {
00583         userrating_select->addItem(kUserRatingFilterAll, QObject::tr("All"));
00584 
00585         for (int_list::const_reverse_iterator p = user_ratings.rbegin();
00586              p != user_ratings.rend(); ++p)
00587         {
00588             userrating_select->addItem(*p, QString(">= %1")
00589                                        .arg(QString::number(*p)));
00590         }
00591 
00592         userrating_select->setToItem(m_settings.getUserrating());
00593     }
00594 
00595     if (browse_select)
00596     {
00597         browse_select->addItem(kBrowseFilterAll, QObject::tr("All"));
00598         browse_select->addItem(1, QObject::tr("Yes"));
00599         browse_select->addItem(0, QObject::tr("No"));
00600         browse_select->setToItem(m_settings.getBrowse());
00601     }
00602 
00603     if (m_intetref_select)
00604     {
00605         m_intetref_select->addItem(kInetRefFilterAll, QObject::tr("All"));
00606         m_intetref_select->addItem(kInetRefFilterUnknown,
00607                 QObject::tr("Unknown"));
00608         m_intetref_select->setToItem(m_settings.getInteRef());
00609     }
00610 
00611     if (m_coverfile_select)
00612     {
00613         m_coverfile_select->addItem(kCoverFileFilterAll, QObject::tr("All"));
00614         m_coverfile_select->addItem(kCoverFileFilterNone,
00615                 QObject::tr("None"));
00616         m_coverfile_select->setToItem(m_settings.getCoverFile());
00617     }
00618 
00619     if (orderby_select)
00620     {
00621         orderby_select->addItem(VideoFilterSettings::kOrderByTitle,
00622                                 QObject::tr("Title"));
00623         orderby_select->addItem(VideoFilterSettings::kOrderByYearDescending,
00624                                 QObject::tr("Year"));
00625         orderby_select->addItem(
00626                 VideoFilterSettings::kOrderByUserRatingDescending,
00627                 QObject::tr("User Rating"));
00628         orderby_select->addItem(VideoFilterSettings::kOrderByLength,
00629                                 QObject::tr("Runtime"));
00630         orderby_select->addItem(VideoFilterSettings::kOrderByFilename,
00631                                 QObject::tr("Filename"));
00632         orderby_select->addItem(VideoFilterSettings::kOrderByID,
00633                                 QObject::tr("Video ID"));
00634         orderby_select->setToItem(m_settings.getOrderby());
00635     }
00636 }
00637 
00638 namespace
00639 {
00640     void widget_testset(UISelectorType *&ret, UIType *current,
00641             UISelectorType *sel)
00642     {
00643         if (sel && current == sel) ret = sel;
00644     }
00645 }
00646 
00647 void VideoFilterDialog::keyPressEvent(QKeyEvent *e)
00648 {
00649     bool handled = false;
00650     bool something_pushed = false;
00651 
00652     QStringList actions;
00653     gContext->GetMainWindow()->TranslateKeyPress("Video", e, actions);
00654 
00655     for (unsigned int i = 0; i < actions.size() && !handled; i++)
00656     {
00657         QString action = actions[i];
00658         handled = true;
00659 
00660         if (action == "UP")
00661             nextPrevWidgetFocus(false);
00662         else if (action == "DOWN")
00663             nextPrevWidgetFocus(true);
00664         else if ((action == "LEFT") || (action == "RIGHT"))
00665         {
00666             something_pushed = false;
00667 
00668             UISelectorType *currentSelector = NULL;
00669             UIType *focused = getCurrentFocusWidget();
00670             widget_testset(currentSelector, focused, category_select);
00671             widget_testset(currentSelector, focused, genre_select);
00672             widget_testset(currentSelector, focused, country_select);
00673             widget_testset(currentSelector, focused, cast_select);
00674             widget_testset(currentSelector, focused, year_select);
00675             widget_testset(currentSelector, focused, runtime_select);
00676             widget_testset(currentSelector, focused, userrating_select);
00677             widget_testset(currentSelector, focused, browse_select);
00678             widget_testset(currentSelector, focused, m_intetref_select);
00679             widget_testset(currentSelector, focused, m_coverfile_select);
00680             widget_testset(currentSelector, focused, orderby_select);
00681 
00682             if (currentSelector)
00683             {
00684                 currentSelector->push(action == "RIGHT");
00685                 something_pushed = true;
00686             }
00687 
00688             if (!something_pushed)
00689             {
00690                 activateCurrent();
00691             }
00692         }
00693         else if (action == "SELECT")
00694             activateCurrent();
00695         else if (action == "0")
00696         {
00697             if (done_button)
00698                 done_button->push();
00699         }
00700         else
00701             handled = false;
00702     }
00703 
00704     if (!handled)
00705         MythThemedDialog::keyPressEvent(e);
00706 }
00707 
00708 void VideoFilterDialog::takeFocusAwayFromEditor(bool up_or_down)
00709 {
00710     nextPrevWidgetFocus(up_or_down);
00711 
00712     MythRemoteLineEdit *which_editor = (MythRemoteLineEdit *)sender();
00713 
00714     if (which_editor)
00715     {
00716         which_editor->clearFocus();
00717     }
00718 }
00719 
00720 void VideoFilterDialog::saveAsDefault()
00721 {
00722      m_settings.saveAsDefault();
00723      this->saveAndExit();
00724 }
00725 
00726 void VideoFilterDialog::saveAndExit()
00727 {
00728     m_fsp->setSettings(m_settings);
00729     reject();
00730 }
00731 
00732 void VideoFilterDialog::setYear(int new_year)
00733 {
00734         m_settings.setYear(new_year);
00735         update_numvideo();
00736 }
00737 
00738 void VideoFilterDialog::setUserRating(int new_userrating)
00739 {
00740         m_settings.setUserrating(new_userrating);
00741         update_numvideo();
00742 }
00743 
00744 void VideoFilterDialog::setCategory(int new_category)
00745 {
00746         m_settings.setCategory(new_category);
00747         update_numvideo();
00748 }
00749 
00750 void VideoFilterDialog::setCountry(int new_country)
00751 {
00752         m_settings.setCountry(new_country);
00753         update_numvideo();
00754 }
00755 
00756 void VideoFilterDialog::setGenre(int new_genre)
00757 {
00758         m_settings.setGenre(new_genre);
00759         update_numvideo();
00760 }
00761 
00762 void VideoFilterDialog::setCast(int new_cast)
00763 {
00764         m_settings.setCast(new_cast);
00765         update_numvideo();
00766 }
00767 
00768 void VideoFilterDialog::setRunTime(int new_runtime)
00769 {
00770         m_settings.setRuntime(new_runtime);
00771         update_numvideo();
00772 }
00773 
00774 void VideoFilterDialog::setBrowse(int new_browse)
00775 {
00776         m_settings.setBrowse(new_browse);
00777         update_numvideo();
00778 }
00779 
00780 void VideoFilterDialog::setInetRef(int new_inetref)
00781 {
00782     m_settings.setInetRef(new_inetref);
00783     update_numvideo();
00784 }
00785 
00786 void VideoFilterDialog::setCoverFile(int new_coverfile)
00787 {
00788     m_settings.setCoverFile(new_coverfile);
00789     update_numvideo();
00790 }
00791 
00792 void VideoFilterDialog::setOrderby(int new_orderby)
00793 {
00794         m_settings.setOrderby(
00795                 (VideoFilterSettings::ordering)new_orderby);
00796         update_numvideo();
00797 }
00798 
00799 void VideoFilterDialog::wireUpTheme()
00800 {
00801     year_select = getUISelectorType("year_select");
00802     if (year_select)
00803         connect(year_select, SIGNAL(pushed(int)),
00804                 this, SLOT(setYear(int)));
00805 
00806     userrating_select = getUISelectorType("userrating_select");
00807     if (userrating_select)
00808         connect(userrating_select, SIGNAL(pushed(int)),
00809                 this, SLOT(setUserRating(int)));
00810 
00811     category_select = getUISelectorType("category_select");
00812     if (category_select)
00813         connect(category_select, SIGNAL(pushed(int)),
00814                 this, SLOT(setCategory(int)));
00815 
00816     country_select = getUISelectorType("country_select");
00817     if (country_select)
00818         connect(country_select, SIGNAL(pushed(int)),
00819                 this, SLOT(setCountry(int)));
00820 
00821     genre_select = getUISelectorType("genre_select");
00822     if (genre_select)
00823         connect(genre_select,SIGNAL(pushed(int)),
00824                 this, SLOT(setGenre(int)));
00825 
00826     cast_select = getUISelectorType("cast_select");
00827     if (cast_select)
00828         connect(cast_select,SIGNAL(pushed(int)),
00829                 this, SLOT(setCast(int)));
00830 
00831     runtime_select = getUISelectorType("runtime_select");
00832     if (runtime_select)
00833         connect(runtime_select, SIGNAL(pushed(int)),
00834                 this, SLOT(setRunTime(int)));
00835 
00836     browse_select = getUISelectorType("browse_select");
00837     if (browse_select)
00838         connect(browse_select, SIGNAL(pushed(int)),
00839                 this, SLOT(setBrowse(int)));
00840 
00841     m_intetref_select = getUISelectorType("inetref_select");
00842     if (m_intetref_select)
00843         connect(m_intetref_select, SIGNAL(pushed(int)),
00844                 this, SLOT(setInetRef(int)));
00845 
00846     m_coverfile_select = getUISelectorType("coverfile_select");
00847     if (m_coverfile_select)
00848         connect(m_coverfile_select, SIGNAL(pushed(int)),
00849                 this, SLOT(setCoverFile(int)));
00850 
00851     orderby_select = getUISelectorType("orderby_select");
00852     if (orderby_select)
00853         connect(orderby_select, SIGNAL(pushed(int)),
00854                 this, SLOT(setOrderby(int)));
00855 
00856     save_button = getUITextButtonType("save_button");
00857 
00858     if (save_button)
00859     {
00860         save_button->setText(tr("Save as default"));
00861         connect(save_button, SIGNAL(pushed()), this, SLOT(saveAsDefault()));
00862     }
00863 
00864     done_button = getUITextButtonType("done_button");
00865     if (done_button)
00866     {
00867         done_button->setText(tr("Done"));
00868         connect(done_button, SIGNAL(pushed()), this, SLOT(saveAndExit()));
00869     }
00870 
00871     numvideos_text = getUITextType("numvideos_text");
00872     buildFocusList();
00873 }
00874 
00875 VideoFilterDialog::~VideoFilterDialog()
00876 {
00877 }