diff -r 96907930389d -r 12af337248b1 clock/clockui/clocksettingsview/src/clocksettingsview.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/clock/clockui/clocksettingsview/src/clocksettingsview.cpp Tue Aug 31 15:13:43 2010 +0300 @@ -0,0 +1,589 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* Implementation file for class ClockSettingsView. +* +*/ + +// System includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// User includes +#include "clocksettingsview.h" +#include "clocksettingsdefines.h" +#include "clocksettingsdocloader.h" +#include "settingsutility.h" +#include "timezoneclient.h" +#include "settingsdatatypes.h" +#include "settingscustomitem.h" +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "clocksettingsviewTraces.h" +#endif + + +/*! + \class ClockSettingsView + + This implements the clock settings which allows user to set the + date, time, location and other related parameters. + */ + +/*! + Constructor. + + \param parent The parent of type QGraphicsWidget. + */ +ClockSettingsView::ClockSettingsView(QObject *parent, HbTranslator *translator, bool launchedByClock) +:QObject(parent), mTranslator(0), mLaunchedByClock(launchedByClock) +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_CLOCKSETTINGSVIEW_ENTRY ); + + // Load the translation file and install the editor specific translator + if(!translator) { + mTranslator = new HbTranslator("clocksettingsview"); + mTranslator->loadCommon(); + } + + // Construct the settings utility. + mSettingsUtility = new SettingsUtility(); + + // Construct the timezone client. + mTimezoneClient = TimezoneClient::getInstance(); + connect( + mTimezoneClient, SIGNAL(timechanged()), + this, SLOT(updatePlaceItem())); + connect( + mTimezoneClient, SIGNAL(timechanged()), + this, SLOT(updateDateItem())); + connect( + mTimezoneClient, SIGNAL(timechanged()), + this, SLOT(updateTimeItem())); + connect( + mTimezoneClient, SIGNAL(autoTimeUpdateChanged(int)), + this, SLOT(handleAutoTimeUpdateChange(int))); + connect( + mTimezoneClient, SIGNAL(cityUpdated()), + this, SLOT(updatePlaceItem())); + + // Start a timer. For updating the remaining alarm time. + mTickTimer = new QTimer(this); + connect( + mTickTimer, SIGNAL(timeout()), + this, SLOT(updateTimeItem())); + + // Create the settings manager. + mSettingsManager = new XQSettingsManager(this); + + // Create the key for alarm snooze time. + mAlarmSnoozeTimeKey = new XQSettingsKey( + XQSettingsKey::TargetCentralRepository, + KCRUidClockApp, + KClockAppSnoozeTime); + + // Start the monitoring for the alarm snooze time key. + mSettingsManager->startMonitoring(*mAlarmSnoozeTimeKey); + + // Listen to the key value changes. + connect( + mSettingsManager, SIGNAL(valueChanged(XQSettingsKey, QVariant)), + this, SLOT(eventMonitor(XQSettingsKey, QVariant))); + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_CLOCKSETTINGSVIEW_EXIT ); +} + +/*! + Destructor. + */ +ClockSettingsView::~ClockSettingsView() +{ + OstTraceFunctionEntry0( DUP1_CLOCKSETTINGSVIEW_CLOCKSETTINGSVIEW_ENTRY ); + if (mDocLoader) { + delete mDocLoader; + } + + // Remove the translator + if (mTranslator) { + delete mTranslator; + mTranslator = 0; + } + if(mSettingsUtility){ + delete mSettingsUtility; + } + + if(mSettingsModel){ + delete mSettingsModel; + } + + + OstTraceFunctionExit0( DUP1_CLOCKSETTINGSVIEW_CLOCKSETTINGSVIEW_EXIT ); +} + +/*! + Loads the settings view from the docml. + */ +void ClockSettingsView::loadSettingsView() +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_LOADSETTINGSVIEW_ENTRY ); + bool loadSuccess; + + // Construct the document loader instance + mDocLoader = new ClockSettingsDocLoader(); + + // Load the application xml. + mDocLoader->load(CLOCK_SETTINGS_VIEW_DOCML, &loadSuccess); + + // Load the correct section based on orientation. + HbMainWindow *window = hbInstance->allMainWindows().first(); + Qt::Orientation currentOrientation = window->orientation(); + + if (Qt::Vertical == currentOrientation) { + // Load portrait section. + mDocLoader->load( + CLOCK_SETTINGS_VIEW_DOCML, + CLOCK_SETTINGS_VIEW_PORTRAIT_SECTION, + &loadSuccess); + } else { + // Load landscape section. + mDocLoader->load( + CLOCK_SETTINGS_VIEW_DOCML, + CLOCK_SETTINGS_VIEW_LANDSCAPE_SECTION, + &loadSuccess); + } + + // Connect the required signals. + connect( + window, SIGNAL(orientationChanged(Qt::Orientation)), + this, SLOT(handleOrientationChanged(Qt::Orientation))); + + // Find the main view. + mSettingsView = static_cast ( + mDocLoader->findWidget(CLOCK_SETTINGS_VIEW)); + + // Setup the view. + setupView(); + + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_LOADSETTINGSVIEW_EXIT ); +} + +/*! + Slot to handle the back action of the view. + */ +void ClockSettingsView::handleBackAction() +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_HANDLEBACKACTION_ENTRY ); + HbMainWindow *window = hbInstance->allMainWindows().first(); + window->removeView(mSettingsView); + deleteLater(); + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_HANDLEBACKACTION_EXIT ); +} + +/*! + Updates the zone info in the place item field. + */ +void ClockSettingsView::updatePlaceItem() +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_UPDATEPLACEITEM_ENTRY ); + // Get the current zone info. + LocationInfo currentZoneInfo = mTimezoneClient->getCurrentZoneInfoL(); + + if (mTimezoneClient->timeUpdateOn()) { + mPlaceDataFormItem->setContentWidgetData( + "text", currentZoneInfo.countryName); + } else { + QString placeInfo = currentZoneInfo.cityName + + tr(", ") + currentZoneInfo.countryName; + mPlaceDataFormItem->setContentWidgetData("text", placeInfo); + } + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_UPDATEPLACEITEM_EXIT ); +} + +/*! + Slot to update the display of the date settings item field. + */ +void ClockSettingsView::updateDateItem() +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_UPDATEDATEITEM_ENTRY ); + mDateDataFormItem->setContentWidgetData("text", mSettingsUtility->date()); + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_UPDATEDATEITEM_EXIT ); +} + +/*! + Slot to update the display of the time settings item field. + */ +void ClockSettingsView::updateTimeItem() +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_UPDATETIMEITEM_ENTRY ); + if (!mTickTimer->isActive()) { + mTickTimer->stop(); + } + mTimeDataFormItem->setContentWidgetData("text", mSettingsUtility->time()); + + // Start the timer again. + mTickTimer->start(60000 - 1000 * QTime::currentTime().second()); + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_UPDATETIMEITEM_EXIT ); +} + +/*! + This slot is called whenever orientattion of the view changes. + */ +void ClockSettingsView::handleOrientationChanged(Qt::Orientation orientation) +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_HANDLEORIENTATIONCHANGED_ENTRY ); + bool success; + // If horizontal, load the landscape section. + if (Qt::Horizontal == orientation) { + mDocLoader->load( + CLOCK_SETTINGS_VIEW_DOCML, + CLOCK_SETTINGS_VIEW_LANDSCAPE_SECTION, + &success); + } else if (Qt::Vertical == orientation) { + mDocLoader->load( + CLOCK_SETTINGS_VIEW_DOCML, + CLOCK_SETTINGS_VIEW_PORTRAIT_SECTION, + &success); + } + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_HANDLEORIENTATIONCHANGED_EXIT ); +} + +void ClockSettingsView::handleNetworkTimeStateChange(int state) +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_HANDLENETWORKTIMESTATECHANGE_ENTRY ); + bool cenrepValue = mTimezoneClient->timeUpdateOn(); + if ((Qt::Checked == state && !cenrepValue) + || (Qt::Unchecked == state && cenrepValue)) { + if (Qt::Checked == state) { + // Update the cenrep value. + mTimezoneClient->setTimeUpdateOn(true); + + } else if (Qt::Unchecked == state) { + // Update the cenrep value. + mTimezoneClient->setTimeUpdateOn(false); + } + } + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_HANDLENETWORKTIMESTATECHANGE_EXIT ); +} + +/*! + Called after loading the view from the docml. + The initializaion/setup of the view is done here. + + \param docLoader Pointer to ClockSettingsDocLoader object. + */ +void ClockSettingsView::setupView() +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_SETUPVIEW_ENTRY ); + + if(!mLaunchedByClock) { + mSettingsView->setTitle(hbTrId("txt_clock_title_control_panel")); + } + + HbMainWindow *window = hbInstance->allMainWindows().first(); + window->addView(mSettingsView); + window->setCurrentView(mSettingsView); + + // Add the back softkey. + mBackAction = new HbAction(Hb::BackNaviAction); + mSettingsView->setNavigationAction(mBackAction); + connect( + mBackAction, SIGNAL(triggered()), + this, SLOT(handleBackAction())); + + // Get the data form. + mSettingsForm = static_cast ( + mDocLoader->findWidget(CLOCK_SETTINGS_DATA_FORM)); + + // Create the custom prototype. + QList prototypes = mSettingsForm->itemPrototypes(); + SettingsCustomItem *customPrototype = new SettingsCustomItem(mSettingsForm, mLaunchedByClock); + prototypes.append(customPrototype); + mSettingsForm->setItemPrototypes(prototypes); + + // Create the model. + createModel(); + updatePlaceItem(); + + mTickTimer->start(60000 - 1000 * QTime::currentTime().second()); + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_SETUPVIEW_EXIT ); +} + +/*! + Creates the model for the settings form. + */ +void ClockSettingsView::createModel() +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_CREATEMODEL_ENTRY ); + // Remove the model. + if (mSettingsForm->model()) { + delete mSettingsForm->model(); + mSettingsForm->setModel(0); + } + + // Create a model and set it. + mSettingsModel = new HbDataFormModel(); + // Add the items to the view. + populateModel(); + mSettingsForm->setModel(mSettingsModel); + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_CREATEMODEL_EXIT ); +} + +/*! + Poplulates the item in the model. + */ +void ClockSettingsView::populateModel() +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_POPULATEMODEL_ENTRY ); + if (!mSettingsModel) { + createModel(); + } + + // Add the network time update item. + mNetworkTimeItem = mSettingsModel->appendDataFormItem( + HbDataFormModelItem::CheckBoxItem, ""); + bool networkTime = mTimezoneClient->timeUpdateOn(); + Qt::CheckState state = Qt::Unchecked; + if (networkTime) { + state = Qt::Checked; + } + mNetworkTimeItem->setContentWidgetData( + "checkState", state); + mNetworkTimeItem->setContentWidgetData( + "text", QString(hbTrId("txt_clk_setlabel_use_network_date_time"))); + mNetworkTimeItem->setContentWidgetData("objectName", "networkTime"); + mSettingsForm->addConnection( + mNetworkTimeItem, SIGNAL(stateChanged(int)), + this, SLOT(handleNetworkTimeStateChange(int))); + + // Add the time item. + // Custom data type for adding a time button to the data form. + HbDataFormModelItem::DataItemType timeItemType = + static_cast + (HbDataFormModelItem::CustomItemBase + TimeItem); + mTimeDataFormItem = mSettingsModel->appendDataFormItem( + timeItemType, QString(hbTrId("txt_clock_setlabel_time"))); + mTimeDataFormItem->setContentWidgetData("text", mSettingsUtility->time()); + mTimeDataFormItem->setContentWidgetData("objectName", "timeItem"); + + // Add the date item. + // Custom data type for adding a time button to the data form. + HbDataFormModelItem::DataItemType dateItemType = + static_cast + (HbDataFormModelItem::CustomItemBase + DateItem); + mDateDataFormItem = mSettingsModel->appendDataFormItem( + dateItemType, QString(hbTrId("txt_clock_setlabel_date"))); + mDateDataFormItem->setContentWidgetData("text", mSettingsUtility->date()); + mDateDataFormItem->setContentWidgetData("objectName", "dateItem"); + + // Add the place item. + HbDataFormModelItem::DataItemType placeItemType = + static_cast + (HbDataFormModelItem::CustomItemBase + PlaceItem); + mPlaceDataFormItem = mSettingsModel->appendDataFormItem( + placeItemType, QString(hbTrId("txt_clock_formlabel_place"))); + + LocationInfo currentZoneInfo = mTimezoneClient->getCurrentZoneInfoL(); + QString placeItemText(""); + if (Qt::Unchecked == state) { + placeItemText.append(currentZoneInfo.cityName); + placeItemText+= tr(", "); + } + placeItemText.append(currentZoneInfo.countryName); + mPlaceDataFormItem->setContentWidgetData("text", placeItemText); + mPlaceDataFormItem->setContentWidgetData("objectName", "placeItem"); + + if (networkTime) { + mTimeDataFormItem->setEnabled(false); + mDateDataFormItem->setEnabled(false); + mPlaceDataFormItem->setEnabled(false); + } else { + mTimeDataFormItem->setEnabled(true); + mDateDataFormItem->setEnabled(true); + mPlaceDataFormItem->setEnabled(true); + } + + // Add the regional settings item. + HbDataFormModelItem::DataItemType regionalSettingsItem = + static_cast + (HbDataFormModelItem::CustomItemBase + RegionalSettingsItem); + mRegionalDataFormItem = mSettingsModel->appendDataFormItem( + regionalSettingsItem); + mRegionalDataFormItem->setContentWidgetData( + "text", hbTrId("txt_clock_button_regional_date_time_settings")); + mRegionalDataFormItem->setContentWidgetData( + "objectName", "regionalSettings"); + + // Add the clock type item. + HbDataFormModelItem::DataItemType clockTypeSettingsItem = + static_cast + (HbDataFormModelItem::ToggleValueItem); + mClockTypeItem = mSettingsModel->appendDataFormItem( + clockTypeSettingsItem,hbTrId("txt_clock_setlabel_clock_type")); + QStringList clockTypeList; + int clockType = mSettingsUtility->clockType(clockTypeList); + int zeroIndex(0); + if( zeroIndex == clockType ){ + mClockTypeItem->setContentWidgetData("text", clockTypeList[0]); + mClockTypeItem->setContentWidgetData("additionalText", clockTypeList[1]); + } else { + mClockTypeItem->setContentWidgetData("text", clockTypeList[1]); + mClockTypeItem->setContentWidgetData("additionalText", clockTypeList[0]); + } + mClockTypeItem->setContentWidgetData("objectName", "clockType"); + mSettingsForm->addConnection( + mClockTypeItem, SIGNAL(clicked()), + this, SLOT(handleClockTypeChanged())); + + // Add the alarm snooze time item. + mAlarmSnoozeItem = mSettingsModel->appendDataFormItem( + HbDataFormModelItem::ComboBoxItem, + hbTrId("txt_clock_setlabel_alarm_snooze_time")); + QStringList alramSnoozeTimes; + alramSnoozeTimes << hbTrId("txt_clock_setlabel_ln_mins", 5) + << hbTrId("txt_clock_setlabel_ln_mins", 10) + << hbTrId("txt_clock_setlabel_ln_mins", 15) + << hbTrId("txt_clock_setlabel_ln_mins", 30); + + // Build the hash map for the reminder. + mAlarmSnoozeTimeHash[0] = 5; + mAlarmSnoozeTimeHash[1] = 10; + mAlarmSnoozeTimeHash[2] = 15; + mAlarmSnoozeTimeHash[3] = 30; + + mAlarmSnoozeItem->setContentWidgetData("items", alramSnoozeTimes); + QVariant value = mSettingsManager->readItemValue(*mAlarmSnoozeTimeKey); + bool success; + int index; + int alarmSnoozeTime = value.toInt(&success); + if (success) { + index = mAlarmSnoozeTimeHash.key(alarmSnoozeTime); + } else { + index = mAlarmSnoozeTimeHash.key(15); + } + mAlarmSnoozeItem->setContentWidgetData("currentIndex", index); + mAlarmSnoozeItem->setContentWidgetData("objectName", "alarmSnooze"); + mSettingsForm->addConnection( + mAlarmSnoozeItem, SIGNAL(currentIndexChanged(int)), + this, SLOT(handleAlarmSnoozeTimeChanged(int))); + + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_POPULATEMODEL_EXIT ); +} + +/*! + Slot which handles the auto time update value changes in cenrep. + + /param value New value of the auto time update. + */ +void ClockSettingsView::handleAutoTimeUpdateChange(int value) +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_HANDLEAUTOTIMEUPDATECHANGE_ENTRY ); + int state = (mNetworkTimeItem->contentWidgetData("checkState")).toInt(); + + if (value) { + // Disable the time, date and place item. + if (mTimeDataFormItem) { + mTimeDataFormItem->setEnabled(false); + } + if (mDateDataFormItem) { + mDateDataFormItem->setEnabled(false); + } + if (mPlaceDataFormItem) { + mPlaceDataFormItem->setEnabled(false); + } + if (Qt::Unchecked == state) { + mNetworkTimeItem->setContentWidgetData( + "checkState", Qt::Checked); + } + } else { + // Enable the time, date and place item. + if (mTimeDataFormItem) { + mTimeDataFormItem->setEnabled(true); + } + if (mDateDataFormItem) { + mDateDataFormItem->setEnabled(true); + } + if (mPlaceDataFormItem) { + mPlaceDataFormItem->setEnabled(true); + } + if (Qt::Checked == state) { + mNetworkTimeItem->setContentWidgetData( + "checkState", Qt::Unchecked); + } + } + updatePlaceItem(); + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_HANDLEAUTOTIMEUPDATECHANGE_EXIT ); +} + +/*! + Slot which handles the alarm snooze time changes. + + /param value New index of the alarm snooze time. + */ +void ClockSettingsView::handleAlarmSnoozeTimeChanged(int index) +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_HANDLEALARMSNOOZETIMECHANGED_ENTRY ); + if (mAlarmSnoozeTimeHash.value(index)) { + mSettingsManager->writeItemValue( + *mAlarmSnoozeTimeKey, mAlarmSnoozeTimeHash.value(index)); + } + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_HANDLEALARMSNOOZETIMECHANGED_EXIT ); +} + +/*! + Slot which handles the clock type change.. + */ +void ClockSettingsView::handleClockTypeChanged() +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_HANDLECLOCKTYPECHANGED_ENTRY ); + mSettingsUtility->setClockType( + mClockTypeItem->contentWidgetData("text").toString()); + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_HANDLECLOCKTYPECHANGED_EXIT ); +} + +/*! + Slot which is called when the value changes in cenrep. + + \param key The key which got changed in cenrep. + \param value The new value of that key. + */ +void ClockSettingsView::eventMonitor( + const XQSettingsKey& key, const QVariant& value) +{ + OstTraceFunctionEntry0( CLOCKSETTINGSVIEW_EVENTMONITOR_ENTRY ); + if (key.uid() == KCRUidClockApp && key.key() == KClockAppSnoozeTime) { + if (mSettingsManager->error() == XQSettingsManager::NoError) { + + bool success; + int alarmSnoozeTime = value.toInt(&success); + + if (success) { + mAlarmSnoozeItem->setContentWidgetData( + "currentIndex", mAlarmSnoozeTimeHash.key( + alarmSnoozeTime)); + } + } + } + OstTraceFunctionExit0( CLOCKSETTINGSVIEW_EVENTMONITOR_EXIT ); +} + +// End of file --Don't remove this.