FCL/sf/app/organizer: comparison calendarui/controller/src/calenviewmanager.cpp

equal deleted inserted replaced

-:ecd7b9840282
+:0b38fc5b94c6
 #include "calensettingsview.h"
 #include "calendocloader.h"
 #include "calendarui_debug.h"
 #include "calencommon.h"
 #include "calendayview.h"
+#include "agendautil.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "calenviewmanagerTraces.h"
+#endif
 // ----------------------------------------------------------------------------
 // CalenViewManager::CalenViewManager
 // 2nd phase of construction.
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 CalenViewManager::CalenViewManager( CCalenController& aController)
 : mController(aController)
 {
-	TRACE_ENTRY_POINT;
+	OstTraceFunctionEntry0( CALENVIEWMANAGER_CALENVIEWMANAGER_ENTRY );
 	// Following block intializes member variables
 	mCalenEventViewer = NULL;
 	mMonthViewDocLoader = NULL;
 	mAgendaViewDocLoader = NULL;
 	// interface
 	connect(mController.agendaInterface(), SIGNAL(instanceViewCreationCompleted(int)),
 	        this, SLOT(handleInstanceViewCreation(int)));
 	connect(mController.agendaInterface(), SIGNAL(entryViewCreationCompleted(int)),
 		        this, SLOT(handleEntryViewCreation(int)));
+	connect(mController.agendaInterface(), SIGNAL(entriesChanged(QList<ulong>)),
-	TRACE_EXIT_POINT;
+								this, SLOT(handleEntriesChanged(QList<ulong>)));
+	OstTraceFunctionExit0( CALENVIEWMANAGER_CALENVIEWMANAGER_EXIT );
 }
 void CalenViewManager::SecondPhaseConstruction()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_SECONDPHASECONSTRUCTION_ENTRY );
-TRACE_ENTRY_POINT;
 // Check the Application Startup reason from Activity Manager
 int activityReason = qobject_cast<HbApplication*>(qApp)->activateReason();
 // Check if calendar is launched thru XQService framework
 mController.MainWindow().addView(mCalenMonthView);
 mController.MainWindow().setCurrentView(mCalenMonthView);
 }
-TRACE_EXIT_POINT;
+OstTraceFunctionExit0( CALENVIEWMANAGER_SECONDPHASECONSTRUCTION_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::~CalenViewManager
 // Destructor.
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 CalenViewManager::~CalenViewManager()
 {
-	TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( DUP1_CALENVIEWMANAGER_CALENVIEWMANAGER_ENTRY );
 	if (mSettingsView) {
 		delete mSettingsView;
 		mSettingsView = 0;
 	}
 	if (mAgendaViewDocLoader) {
 	}
 	if (mMonthViewDocLoader) {
 		delete mMonthViewDocLoader;
 		mMonthViewDocLoader = 0;
 	}
-	TRACE_EXIT_POINT;
+	OstTraceFunctionExit0( DUP1_CALENVIEWMANAGER_CALENVIEWMANAGER_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::constructAndActivateView
 // Constructs and activates the requested view
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::constructAndActivateView(int view)
 {
-	TRACE_ENTRY_POINT;
+	OstTraceFunctionEntry0( CALENVIEWMANAGER_CONSTRUCTANDACTIVATEVIEW_ENTRY );
-	// We are here because, some other application is launching calendar with
+// We are here because, some other application is launching calendar with
 	// the view, hence connect to viewReady() signal to do any lazy loading
 	// in the slot
 	// Connect to the view ready signal so that we construct other view
 	// once this view is shown
 		ActivateDefaultViewL(ECalenAgendaView);
 		// Add agenda view to mainwindow.
 		mController.MainWindow().addView(mCalenAgendaView);
 		mController.MainWindow().setCurrentView(mCalenAgendaView);
 	}
-	TRACE_EXIT_POINT;
+	OstTraceFunctionExit0( CALENVIEWMANAGER_CONSTRUCTANDACTIVATEVIEW_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::loadMonthView
 // Loads month view frm the docml
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::loadMonthView()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_LOADMONTHVIEW_ENTRY );
 	bool loadSuccess = false;
 	Qt::Orientation currentOrienation = mController.MainWindow().orientation();
 	// Create the month view docloader object.
 	mMonthViewDocLoader = new CalenDocLoader(mController);
 	mMonthViewDocLoader->load(CALEN_MONTHVIEW_XML_FILE, &loadSuccess);
 	Q_ASSERT_X(mCalenMonthView, "calenviewmanager.cpp",
 											"Unable to load calenMonth view");
 	// Setup the month view.
 	mCalenMonthView->setupView(mMonthViewDocLoader);
+	OstTraceFunctionExit0( CALENVIEWMANAGER_LOADMONTHVIEW_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::loadAgendaView
 // Loads the agenda view frm the docml
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::loadAgendaView()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_LOADAGENDAVIEW_ENTRY );
 	bool loadSuccess = false;
 	// Create the agenda view docloader object.
 	mAgendaViewDocLoader = new CalenDocLoader(mController);
 	// Load default section
 	// in agenda view. Idea is to create two views and keep
 	// switiching between these two using view switch effects
 	// to provide an illusion of flow to the user
 	loadAlternateAgendaView();
+	OstTraceFunctionExit0( CALENVIEWMANAGER_LOADAGENDAVIEW_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleMainViewReady
 // Slot to handle viewReady() signal from mainwindow
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleMainViewReady()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEMAINVIEWREADY_ENTRY );
 	// Construct the month view part that is kept for lazy loading
 	if (mCalenMonthView) {
 		mCalenMonthView->doLazyLoading();
 	}
 	//hbInstance->allMainWindows().first()->installEventFilter(&mController);
 	// disconnect the view ready signal as we dont need it anymore
 	disconnect(&mController.MainWindow(), SIGNAL(viewReady()),
 			   this, SLOT(handleMainViewReady()));
+	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEMAINVIEWREADY_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::constructOtherViews
 // Constructs the other views apart frm firstview and adds them to main window
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::constructOtherViews()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_CONSTRUCTOTHERVIEWS_ENTRY );
 	// Load all other views except mFirstView
 	// NOTE: Right now, since Calendar has only two views, month view
 	// and agenda view, when client launches agenda view, then there is no need
 	// to construct the month view as per UI REQ., but tomorrow if new views
 // mCalenMonthView->doLazyLoading();
 	    }
 	// Setup the settings view
 	mSettingsView = new CalenSettingsView(mController.Services());
+	OstTraceFunctionExit0( CALENVIEWMANAGER_CONSTRUCTOTHERVIEWS_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::getFirstView
 // Returns the first view
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 int CalenViewManager::getFirstView()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_GETFIRSTVIEW_ENTRY );
+	OstTraceFunctionExit0( CALENVIEWMANAGER_GETFIRSTVIEW_EXIT );
 	return mFirstView;
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::showNextDay
 // other items were commented in a header
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::showNextDay()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_SHOWNEXTDAY_ENTRY );
 // Set the context for the next day
 QDateTime currentDay = mController.Services().Context().focusDateAndTime();
 currentDay = currentDay.addDays(1);
 mController.Services().Context().setFocusDate(currentDay);
 mCurrentViewId = ECalenAgendaView;
 "show");
 		// It would also connect for aboutToQuit events
 mCalenAgendaView->doPopulation();
 mController.MainWindow().setCurrentView(mCalenAgendaView, true, Hb::ViewSwitchUseNormalAnim);
 }
+OstTraceFunctionExit0( CALENVIEWMANAGER_SHOWNEXTDAY_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::showPrevDay
 // other items were commented in a header
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::showPrevDay()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_SHOWPREVDAY_ENTRY );
 QDateTime currentDay = mController.Services().Context().focusDateAndTime();
 currentDay = currentDay.addDays(-1);
 mController.Services().Context().setFocusDate(currentDay);
 mCurrentViewId = ECalenAgendaView;
 if (mController.MainWindow().currentView() == mCalenAgendaView) {
 "show");
 		// It would also connect for aboutToQuit events
 mCalenAgendaView->doPopulation();
 mController.MainWindow().setCurrentView(mCalenAgendaView, true, Hb::ViewSwitchUseNormalAnim);
 }
+OstTraceFunctionExit0( CALENVIEWMANAGER_SHOWPREVDAY_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::removePreviousView
 // Remove the previous view from main window
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::removePreviousView()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_REMOVEPREVIOUSVIEW_ENTRY );
 	if (ECalenAgendaView == mCurrentViewId) {
 		mCalenAgendaView->clearListModel();
 		mCalenAgendaViewAlt->clearListModel();
 		mController.MainWindow().removeView(mCalenAgendaView);
 		mController.MainWindow().removeView(mCalenAgendaViewAlt);
 		if (ECalenMonthView == mCurrentViewId) {
 			mController.MainWindow().removeView(mCalenMonthView);
 		}
 	}
+	OstTraceFunctionExit0( CALENVIEWMANAGER_REMOVEPREVIOUSVIEW_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::~ActivateDefaultViewL
 //  Activates the default view, as retrieved from settings.
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::ActivateDefaultViewL(int defaultView)
 {
-	TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENVIEWMANAGER_ACTIVATEDEFAULTVIEWL_ENTRY );
 	mCurrentViewId = defaultView;
 	if (ECalenMonthView == defaultView) {
 		mCalenMonthView->doPopulation();
 	} else if (ECalenAgendaView == defaultView) {
 		mCalenAgendaView->doPopulation();
 	}
-	TRACE_EXIT_POINT;
+	OstTraceFunctionExit0( CALENVIEWMANAGER_ACTIVATEDEFAULTVIEWL_EXIT );
 }
 // ----------------------------------------------------------------------------
 // Refresh current view.
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 void CalenViewManager::refreshCurrentViewL()
 {
-	TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENVIEWMANAGER_REFRESHCURRENTVIEWL_ENTRY );
 	activateCurrentView();
-	TRACE_EXIT_POINT;
+	OstTraceFunctionExit0( CALENVIEWMANAGER_REFRESHCURRENTVIEWL_EXIT );
 }
 // ----------------------------------------------------------------------------
 // Activate current view.
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 void CalenViewManager::activateCurrentView()
 {
-	TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENVIEWMANAGER_ACTIVATECURRENTVIEW_ENTRY );
 	switch (mCurrentViewId) {
 		case ECalenMonthView:
 		    mCalenMonthView->doPopulation();
 		    mController.MainWindow().setCurrentView(mCalenMonthView);
 			break;
 		case ECalenDayView:
 			mCalenDayView->doPopulation();
 			mController.MainWindow().setCurrentView(mCalenDayView);
 			break;
 	}
-	TRACE_EXIT_POINT;
+	OstTraceFunctionExit0( CALENVIEWMANAGER_ACTIVATECURRENTVIEW_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::launchEventView
 // Launch event view.
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::launchEventView()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_LAUNCHEVENTVIEW_ENTRY );
 // capture cureent view in case app closed/quits from AgendaEventViewer
 if (mCalenMonthView) {
 mCalenMonthView->captureScreenshot(true);
 }
 else if (mCalenAgendaView) {
 			        this, SLOT(handleDeletingCompleted()));
 	// Launch agenda event viewer
 	mCalenEventViewer->view(viewEntry, AgendaEventViewer::ActionEditDelete);
+	OstTraceFunctionExit0( CALENVIEWMANAGER_LAUNCHEVENTVIEW_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::loadAlternateAgendaView
 // other items were commented in a header
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::loadAlternateAgendaView()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_LOADALTERNATEAGENDAVIEW_ENTRY );
 bool loadSuccess = false;
 // Create the agenda view docloader object.
 mAgendaViewAltDocLoader = new CalenDocLoader(mController);
 // Load default section
 qFatal("calenviewmanager.cpp : Unable to find alternate agenda view");
 }
 // Setup the agenda view
 mCalenAgendaViewAlt->setupView(mAgendaViewAltDocLoader);
+OstTraceFunctionExit0( CALENVIEWMANAGER_LOADALTERNATEAGENDAVIEW_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::HandleCommandL
 // Handles view manager commands.
 // @return ETrue if command is handled, EFalse otherwise
 // ----------------------------------------------------------------------------
 //
 TBool CalenViewManager::HandleCommandL(const TCalenCommand& command)
 {
-	TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLECOMMANDL_ENTRY );
 	TBool commandUsed(EFalse);
 	switch (command.Command()) {
 		case ECalenMonthView:
 			// First remove the previous native view before
 		    break;
 		case ECalenShowPrevDay:
 showPrevDay();
 		    break;
 	}
-	TRACE_EXIT_POINT;
+	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLECOMMANDL_EXIT );
 	return commandUsed;
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::HandleNotification
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::HandleNotification(
 const TCalenNotification notification)
 {
-	TRACE_ENTRY_POINT;
+OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLENOTIFICATION_ENTRY );
 	switch (notification) {
 		case ECalenNotifyExternalDatabaseChanged:
 		case ECalenNotifyDialogClosed:
 		case ECalenNotifyMultipleEntriesDeleted:
 		case ECalenNotifyEntrySaved:
 		case ECalenNotifyEntryDeleted:
 		case ECalenNotifyInstanceDeleted:
 		case ECalenNotifyEntryClosed:
 		case ECalenNotifySystemLocaleChanged:
-		case ECalenNotifySystemLanguageChanged:
+		case ECalenNotifySystemLanguageChanged: {
-		    {
+activateCurrentView();
-		    activateCurrentView();
+if (mCalenMonthView) {
-		    }
+mCalenMonthView->captureScreenshot();
+} else if (mCalenAgendaView) {
+mCalenAgendaView->captureScreenshot();
+}
+		}
 		    break;
-		case ECalenNotifySettingsClosed:
+		case ECalenNotifySettingsClosed: {
-		    {
 		    //when setting view closed , switch to the previous view
 		    mCurrentViewId = mPreviousViewsId ;
 			mController.Services().IssueCommandL(ECalenStartActiveStep);
 			 // invalidate captured screenshots as either agenda view is activated now
 		    }
 			break;
 		default:
 			break;
 	}
-	TRACE_EXIT_POINT;
+	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLENOTIFICATION_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::settingsView
 //  Returns the settings view
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 CalenSettingsView* CalenViewManager::settingsView()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_SETTINGSVIEW_ENTRY );
+	OstTraceFunctionExit0( CALENVIEWMANAGER_SETTINGSVIEW_EXIT );
 	return mSettingsView;
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleViewingCompleted
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleViewingCompleted(const QDate date)
 {
+	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEVIEWINGCOMPLETED_ENTRY );
 	// Cleanup.
 	mCalenEventViewer->deleteLater();
-	if (!date.isNull() && date.isValid()) {
-	mController.Services().Context().setFocusDate(QDateTime(date));
-	}
 	mController.Services().IssueNotificationL(ECalenNotifyEntryClosed);
 	// invalidate captured screenshots as either agenda view is activated now
 	if (mCalenMonthView) {
 	mCalenMonthView->captureScreenshot();
 	} else if (mCalenAgendaView) {
 		mCalenAgendaView->captureScreenshot();
 	}
+	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEVIEWINGCOMPLETED_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleEditingStarted
 //  Slot to handle signal editingStarted by the agenda event viewer
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleEditingStarted()
 {
+	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEEDITINGSTARTED_ENTRY );
 	mController.IssueCommandL(ECalenEditEntryFromViewer);
+	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEEDITINGSTARTED_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleEditingCompleted
 //  Slot to handle signal editingCompleted by the agenda event viewer
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleEditingCompleted()
 {
+	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEEDITINGCOMPLETED_ENTRY );
 	mController.Services().IssueNotificationL(ECalenNotifyEditorClosedFromViewer);
+	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEEDITINGCOMPLETED_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleDeletingStarted
 //  Slot to handle signal deletingStarted by the agenda event viewer
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleDeletingStarted()
 {
+	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEDELETINGSTARTED_ENTRY );
 	mController.IssueCommandL(ECalenDeleteEntryFromViewer);
+	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEDELETINGSTARTED_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleDeletingCompleted
 //  Slot to handle signal deletingCompleted by the agenda event viewer
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleDeletingCompleted()
 {
+	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEDELETINGCOMPLETED_ENTRY );
 	mController.Services().IssueNotificationL(ECalenNotifyEntryDeleted);
 	// invalidate captured screenshots as either month view or agenda view is activated now
 if (mCalenMonthView) {
 mCalenMonthView->captureScreenshot();
 } else if (mCalenAgendaView) {
 	mCalenAgendaView->captureScreenshot();
 }
+OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEDELETINGCOMPLETED_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleInstanceViewCreation
 //  Slot to handle completion of instance view creation
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleInstanceViewCreation(int status)
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEINSTANCEVIEWCREATION_ENTRY );
 	Q_UNUSED(status);
 	// handleInstanceViewCreation function is called only once. Now that the instance
 	// view creation is successfull. Events need to be populated on screen
 	// Ideal colution should be to call a uniform function, e.g. PopulateEvents
 	// where PopulateEvents should be implemeted by all views. Since the current
 		mCalenMonthView->fetchEntriesAndUpdateModel();
 	}
 	else if (mCalenAgendaView) {
 		mCalenAgendaView->doPopulation();
 	}
+	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEINSTANCEVIEWCREATION_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleDeletingCompleted
 //  Slot to handle completion of entry view creation
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleEntryViewCreation(int status)
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEENTRYVIEWCREATION_ENTRY );
 	// Nothing Yet
 	Q_UNUSED(status);
+	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEENTRYVIEWCREATION_EXIT );
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleDayViewReady
 // Launches day view when it is added to MainWindow and ready to be displayed
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleDayViewReady()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEDAYVIEWREADY_ENTRY );
 // Removes current view
 // Notice: removing view should be done after new view is set as current to
 // avoid situation that there is no current view in application
 removePreviousView();
 // Sets and activates day view
 mCurrentViewId = ECalenDayView;
 activateCurrentView();
+	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEDAYVIEWREADY_EXIT );
+}
+// ----------------------------------------------------------------------------
+// CalenViewManager::handleEntriesChanged
+// this function will be called when someone else has changed the database
+// ----------------------------------------------------------------------------
+//
+void CalenViewManager::handleEntriesChanged(QList<ulong> ids)
+{
+	// Update and refresh the view.
+	activateCurrentView();
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::launchSettingsView
 // Launches settings view
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::launchSettingsView()
 {
+OstTraceFunctionEntry0( CALENVIEWMANAGER_LAUNCHSETTINGSVIEW_ENTRY );
 mPreviousViewsId = mCurrentViewId ;
 mCurrentViewId = ECalenShowSettings;
 mSettingsView->initializeForm();
 mController.Services().MainWindow().setCurrentView(mSettingsView);
 if (mCalenMonthView){
 mCalenMonthView->captureScreenshot(true);
 } else if(mCalenAgendaView){
 	mCalenAgendaView->captureScreenshot(true);
 }
+OstTraceFunctionExit0( CALENVIEWMANAGER_LAUNCHSETTINGSVIEW_EXIT );
 }
 // End of file	--Don't remove this.

changeset 51	0b38fc5b94c6
parent 45	b6db4fd4947b
child 55	2c54b51f39c4