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

equal deleted inserted replaced

-:579cc610882e
+:ef813d54df51
 #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;
 	mCalenAgendaView = NULL;
 	mCalenMonthView = NULL;
 	mCalenAgendaViewAlt = NULL;
 	mSettingsView = NULL;
 	mCalenDayView = NULL;
+	mInstanceViewCreated = false;
 	// Connect to instance view and entry view creation signals from agenda
 	// 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>)));
+connect(mController.agendaInterface(), SIGNAL(entryUpdated(ulong)),
+this, SLOT(handleEntryUpdation(ulong)));
+connect(mController.agendaInterface(), SIGNAL(entryAdded(ulong)),
+this, SLOT(handleEntryUpdation(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
 		loadAgendaView();
 		ActivateDefaultViewL(ECalenAgendaView);
 		// Add agenda view to mainwindow.
 		mController.MainWindow().addView(mCalenAgendaView);
 		mController.MainWindow().setCurrentView(mCalenAgendaView);
-	}
+		mController.MainWindow().addView(mCalenAgendaViewAlt);
-	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::loadDayView
+// Loads day view from the docml
+// ----------------------------------------------------------------------------
+void CalenViewManager::loadDayView()
+{
+bool loadSuccess = false;
+// Create the docloader object
+CalenDocLoader *docLoader = new CalenDocLoader(mController);
+if (docLoader) {
+docLoader->load(CALEN_DAYVIEW_DOCML, &loadSuccess);
+if (!loadSuccess) {
+qFatal("calenviewmanager.cpp : Unable to load day view XML");
+}
+// Get the CalenDayView object from the loader
+mCalenDayView = static_cast<CalenDayView *>
+(docLoader->findWidget(CALEN_DAYVIEW));
+if (!mCalenDayView) {
+qFatal("calenviewmanager.cpp : Unable to find day view");
+}
+// Set up the day view - day view takes the ownership
+mCalenDayView->setupView(docLoader);
+}
 }
 // ----------------------------------------------------------------------------
 // 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) {
+if (mCalenMonthView) {
 		mCalenMonthView->doLazyLoading();
+		if (mInstanceViewCreated) {
+			// populate entries for the month view if the month view is launched
+			// from the service APIs. Otherwise the month view is not populated with
+			// the entries as CalenViewManager::handleInstanceViewCreation is called
+			// before the month view creation so the model array is not populated.
+			mCalenMonthView->fetchEntriesAndUpdateModel();
+		}
 	}
 	// Construct other views
 	constructOtherViews();
 	//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
 		{
 		// Load all other views
 		loadAgendaView();
 		if (!mCalenDayView) {
-			mCalenDayView = new CalenDayView(mController.Services());
+		    loadDayView();
 		}
 	}
 	else //agenda view was launched as first view
 	    {
 		// No implementation yet. UI specs not clear
 // 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
 			mCurrentViewId = ECalenAgendaView;
 			activateCurrentView();
 			break;
 		case ECalenDayView:
 {
-// First add new view and use QueuedConnection to assure that
+// First add new view
-// view is ready before setting it as the current view
 			mController.MainWindow().addView(mCalenDayView);
-			QMetaObject::invokeMethod(this, "handleDayViewReady",
-			    Qt::QueuedConnection);
+			// 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();
 			}
 			break;
 		case ECalenEventView:
 			launchEventView();
 			break;
 		    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 ECalenNotifySystemTimeChanged:
-		    {
+		case ECalenNotifySystemLanguageChanged: {
-		    activateCurrentView();
-		    }
+			if (notification == ECalenNotifySystemTimeChanged) {
+				MCalenContext &context = mController.context();
+				QDateTime defaultTime = context.defaultCalTimeForViewsL();
+				context.setFocusDateAndTime(defaultTime);
+			}
+			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)
 {
+	Q_UNUSED(date);
+	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEVIEWINGCOMPLETED_ENTRY );
 	// Cleanup.
 	mCalenEventViewer->deleteLater();
 	if (!date.isNull() && date.isValid()) {
-	mController.Services().Context().setFocusDate(QDateTime(date));
+	    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);
+	// This flag is needed if mCalenMonthView and mCalenAgendaview is not created
+	// and before that this slot is getting called.
+	// if we launch views through services then this slot is getting called
+	// before the view construction.
+	mInstanceViewCreated = true;
 	// 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
 	// solution for the month view implements the construction in two phases so
 		mCalenMonthView->fetchEntriesAndUpdateModel();
 	}
 	else if (mCalenAgendaView) {
 		mCalenAgendaView->doPopulation();
 	}
+	// Calls the emitAppReady function of CalenController. Need to emit this
+	// signal after the view is fully constructed & populated
+	// with actual data and ready to be used. So entry view & instance view
+	// needs to be created so that a new entry can also be created. Finally
+	// NotesApplication object needs to emit applicationReady Signal.
+	mController.emitAppReady();
+	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
+// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+// CalenViewManager::handleEntriesChanged
-//
+// this function will be called when someone else has changed the database
-void CalenViewManager::handleDayViewReady()
+// ----------------------------------------------------------------------------
-{
+//
-// Removes current view
+void CalenViewManager::handleEntriesChanged(QList<ulong> ids)
-// Notice: removing view should be done after new view is set as current to
+{
-// avoid situation that there is no current view in application
+	Q_UNUSED(ids);
-removePreviousView();
+	HbView *currentview = mController.MainWindow().currentView();
+	if((mCalenMonthView == currentview)||(mCalenDayView == currentview)||
-// Sets and activates day view
+(mCalenAgendaView == currentview ))
-mCurrentViewId = ECalenDayView;
+	    {
 activateCurrentView();
+	    }
+}
+// ----------------------------------------------------------------------------
+// CalenViewManager::handleEntryUpdation
+// this function will be called when any entry is updated or added into database
+// Here we need to set the context to the entry updated or added.
+// ----------------------------------------------------------------------------
+//
+void CalenViewManager::handleEntryUpdation(ulong id)
+{
+AgendaEntry updatedEntry = mController.agendaInterface()->fetchById(id);
+// Agenda entry is not null then refresh the view else close event viewer
+if (!updatedEntry.isNull()) {
+if (AgendaEntry::TypeTodo != updatedEntry.type()) {
+QDate date = updatedEntry.startTime().date();
+if (!date.isNull() && date.isValid()) {
+mController.Services().Context().setFocusDate(QDateTime(date));
+}
+}
+}
 }
 // ----------------------------------------------------------------------------
 // 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 58	ef813d54df51
parent 50	579cc610882e
child 68	a5a1242fd2e8