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

equal deleted inserted replaced

-:5de72ea7a065
+:579cc610882e
 *
 */
 //system includes
-#include <QDebug>
 #include <hbmainwindow.h>
 #include <hbinstance.h>
 #include <hbapplication.h> // hbapplication
 #include <xqserviceutil.h> // service utils
 #include "calenviewmanager.h"
 #include "calencontroller.h"
 #include "hb_calencommands.hrh"
 #include "calenservicesimpl.h"
 #include "calenmonthview.h"
-#include "calendayview.h"
+#include "calenagendaview.h"
 #include "calenmonthview.h"
 #include "agendaeventviewer.h"
 #include "calennotificationhandler.h"
 #include "CalenUid.h"
 #include "calenactionuiutils.h"
 #include "calensettingsview.h"
 #include "calendocloader.h"
 #include "calendarui_debug.h"
 #include "calencommon.h"
+#include "calendayview.h"
 // ----------------------------------------------------------------------------
 // CalenViewManager::CalenViewManager
 // 2nd phase of construction.
 // (other items were commented in a header).
 	TRACE_ENTRY_POINT;
 	// Following block intializes member variables
 	mCalenEventViewer = NULL;
 	mMonthViewDocLoader = NULL;
-	mDayViewDocLoader = NULL;
+	mAgendaViewDocLoader = NULL;
-	mDayViewAltDocLoader = NULL;
+	mAgendaViewAltDocLoader = NULL;
+	mCalenAgendaView = NULL;
+	mCalenMonthView = NULL;
+	mCalenAgendaViewAlt = NULL;
+	mSettingsView = NULL;
 	mCalenDayView = NULL;
-	mCalenMonthView = NULL;
-	mCalenDayViewAlt = NULL;
-	mSettingsView = NULL;
 	// Connect to instance view and entry view creation signals from agenda
 	// interface
 	connect(mController.agendaInterface(), SIGNAL(instanceViewCreationCompleted(int)),
 	        this, SLOT(handleInstanceViewCreation(int)));
 mFirstView = viewId;
 if (ECalenMonthView == viewId) // Check if Activity was stored for month view
 {
 loadMonthView(); // Load month view
 }
-else if (ECalenDayView == viewId) // Check if Activity was stored for day view
+else if (ECalenAgendaView == viewId) // Check if Activity was stored for agenda view
 {
-loadDayView(); // Load day view
+	loadAgendaView(); // Load agenda view
 }
 ActivateDefaultViewL(viewId);
 // Connect to the view ready signal so that we can construct other views
 // once this view is ready
 if (ECalenMonthView == viewId) // Check if Activity was stored for month view
 {
 mController.MainWindow().addView(mCalenMonthView); // Add month view to main window
 mController.MainWindow().setCurrentView(mCalenMonthView); // Set month view as current view
 }
-else if (ECalenDayView == viewId) // Check if Activity was stored for day view
+else if (ECalenAgendaView == viewId) // Check if Activity was stored for agenda view
 {
-mController.MainWindow().addView(mCalenDayView); // Add day view to main window
+mController.MainWindow().addView(mCalenAgendaView); // Add agenda view to main window
-mController.MainWindow().setCurrentView(mCalenDayView); // Set day view as current view
+mController.MainWindow().setCurrentView(mCalenAgendaView); // Set agenda view as current view
 }
 } else if (isFromServiceFrmWrk/*Hb::ActivationReasonService == activityReason*/) {
 // Dont load any views until our remote slot gets called in
 // calenserviceprovider.cpp
 // Just have an empty mainwindow
 	if (mSettingsView) {
 		delete mSettingsView;
 		mSettingsView = 0;
 	}
-	if (mDayViewDocLoader) {
+	if (mAgendaViewDocLoader) {
-		delete mDayViewDocLoader;
+		delete mAgendaViewDocLoader;
-		mDayViewDocLoader = 0;
+		mAgendaViewDocLoader = 0;
 	}
-	if (mDayViewAltDocLoader) {
+	if (mAgendaViewAltDocLoader) {
-		delete mDayViewAltDocLoader;
+		delete mAgendaViewAltDocLoader;
-		mDayViewAltDocLoader = 0;
+		mAgendaViewAltDocLoader = 0;
 	}
 	if (mMonthViewDocLoader) {
 		delete mMonthViewDocLoader;
 		mMonthViewDocLoader = 0;
 	}
 		loadMonthView();
 		ActivateDefaultViewL(ECalenMonthView);
 		// Add month view to mainwindow.
 		mController.MainWindow().addView(mCalenMonthView);
 		mController.MainWindow().setCurrentView(mCalenMonthView);
-	} else if (view == ECalenDayView) {
+	} else if (view == ECalenAgendaView) {
-		mFirstView = ECalenDayView;
+		mFirstView = ECalenAgendaView;
-		loadDayView();
+		loadAgendaView();
-		ActivateDefaultViewL(ECalenDayView);
+		ActivateDefaultViewL(ECalenAgendaView);
-		// Add day view to mainwindow.
+		// Add agenda view to mainwindow.
-		mController.MainWindow().addView(mCalenDayView);
+		mController.MainWindow().addView(mCalenAgendaView);
-		mController.MainWindow().setCurrentView(mCalenDayView);
+		mController.MainWindow().setCurrentView(mCalenAgendaView);
 	}
 	TRACE_EXIT_POINT;
 }
 // ----------------------------------------------------------------------------
 	// Setup the month view.
 	mCalenMonthView->setupView(mMonthViewDocLoader);
 }
 // ----------------------------------------------------------------------------
-// CalenViewManager::loadDayView
+// CalenViewManager::loadAgendaView
-// Loads the day view frm the docml
+// Loads the agenda view frm the docml
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
-void CalenViewManager::loadDayView()
+void CalenViewManager::loadAgendaView()
 {
 	bool loadSuccess = false;
-	// Create the day view docloader object.
+	// Create the agenda view docloader object.
-	mDayViewDocLoader = new CalenDocLoader(mController);
+	mAgendaViewDocLoader = new CalenDocLoader(mController);
 	// Load default section
-	mDayViewDocLoader->load(CALEN_DAYVIEW_XML_FILE, &loadSuccess);
+	mAgendaViewDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, &loadSuccess);
 	if (!loadSuccess) {
 		qFatal("calenviewmanager.cpp : Unable to load XML");
 	}
-	// Get the calenday view from the loader
+	// Get the calenagenda view from the loader
-	mCalenDayView = static_cast<CalenDayView *> (mDayViewDocLoader->findWidget(CALEN_DAYVIEW));
+	mCalenAgendaView = static_cast<CalenAgendaView *> (mAgendaViewDocLoader->findWidget(CALEN_AGENDAVIEW));
-	if (!mCalenDayView) {
+	if (!mCalenAgendaView) {
-		qFatal("calenviewmanager.cpp : Unable to find day view");
+		qFatal("calenviewmanager.cpp : Unable to find agenda view");
 	}
-	// Setup the day view
+	// Setup the agenda view
-	mCalenDayView->setupView(mDayViewDocLoader);
+	mCalenAgendaView->setupView(mAgendaViewDocLoader);
 	// The following code is done to provide swipe support
-	// in day view. Idea is to create two views and keep
+	// 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
-	loadAlternateDayView();
+	loadAlternateAgendaView();
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleMainViewReady
 // Slot to handle viewReady() signal from mainwindow
 	}
 	// Construct other views
 	constructOtherViews();
+// Install the event filter for the controller once the view is ready
+// so that system language/locale changes can be handled
+	//hbInstance->allMainWindows().first()->installEventFilter(&mController);
 	// disconnect the view ready signal as we dont need it anymore
 	disconnect(&mController.MainWindow(), SIGNAL(viewReady()),
 			   this, SLOT(handleMainViewReady()));
 }
 void CalenViewManager::constructOtherViews()
 {
 	// Load all other views except mFirstView
 	// NOTE: Right now, since Calendar has only two views, month view
-	// and day view, when client launches day view, then there is no need
+	// 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
-	// come after day view, then we need to construct those views if they are
+	// come after agenda view, then we need to construct those views if they are
 	// native views. Right now, there is a event viewer but its not a native
-	// view. Hence, if day view is launched, dont construct month view
+	// view. Hence, if agenda view is launched, dont construct month view
-	if (mFirstView != ECalenDayView) // check if day view is not already loaded
+	if (mFirstView != ECalenAgendaView) // check if agenda view is not already loaded
 		{
 		// Load all other views
-		loadDayView();
+		loadAgendaView();
-	}
-	else //day view was launched as first view
+		if (!mCalenDayView) {
+			mCalenDayView = new CalenDayView(mController.Services());
+		}
+	}
+	else //agenda view was launched as first view
 	    {
 		// No implementation yet. UI specs not clear
 		// to be commented in with some more code once UI specs is frozen
-		// for day view launching as first view after it was saved as activity
+		// for agenda view launching as first view after it was saved as activity
 		// when it was launched from month view
 // loadMonthView();
 // mCalenMonthView->doLazyLoading();
 	    }
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::showNextDay()
 {
 // Set the context for the next day
-QDateTime currentDay = mController.Services().Context().focusDateAndTimeL();
+QDateTime currentDay = mController.Services().Context().focusDateAndTime();
 currentDay = currentDay.addDays(1);
-mController.Services().Context().setFocusDateL(currentDay, ECalenDayView);
+mController.Services().Context().setFocusDate(currentDay);
-mCurrentViewId = ECalenDayView;
+mCurrentViewId = ECalenAgendaView;
 // Check which is the currently activated view
-if (mController.MainWindow().currentView() == mCalenDayView) {
+if (mController.MainWindow().currentView() == mCalenAgendaView) {
-mCalenDayView->disconnectAboutToQuitEvent(); // disconnect mCalenDayView to get aboutToQuit Events
+mCalenAgendaView->disconnectAboutToQuitEvent(); // disconnect mCalenAgendaView to get aboutToQuit Events
-HbEffect::add(mCalenDayView,
+HbEffect::add(mCalenAgendaView,
 ":/fxml/view_hide",
 "hide");
-HbEffect::add(mCalenDayViewAlt,
+HbEffect::add(mCalenAgendaViewAlt,
 ":/fxml/view_show",
 "show");
-// Set the other day view as the current view
+// Set the other agenda view as the current view
 // and animate to provide illusion of swipe
 		// It would also connect for aboutToQuit events
-mCalenDayViewAlt->doPopulation();
+mCalenAgendaViewAlt->doPopulation();
-mController.MainWindow().setCurrentView(mCalenDayViewAlt, true, Hb::ViewSwitchUseNormalAnim);
+mController.MainWindow().setCurrentView(mCalenAgendaViewAlt, true, Hb::ViewSwitchUseNormalAnim);
 } else {
-mCalenDayViewAlt->disconnectAboutToQuitEvent(); // disconnect mCalenDayViewAlt to get aboutToQuit Events
+mCalenAgendaViewAlt->disconnectAboutToQuitEvent(); // disconnect mCalenAgendaViewAlt to get aboutToQuit Events
-HbEffect::add(mCalenDayViewAlt,
+HbEffect::add(mCalenAgendaViewAlt,
 ":/fxml/view_hide",
 "hide");
-HbEffect::add(mCalenDayView,
+HbEffect::add(mCalenAgendaView,
 ":/fxml/view_show",
 "show");
 		// It would also connect for aboutToQuit events
-mCalenDayView->doPopulation();
+mCalenAgendaView->doPopulation();
-mController.MainWindow().setCurrentView(mCalenDayView, true, Hb::ViewSwitchUseNormalAnim);
+mController.MainWindow().setCurrentView(mCalenAgendaView, true, Hb::ViewSwitchUseNormalAnim);
 }
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::showPrevDay
 // other items were commented in a header
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::showPrevDay()
 {
-QDateTime currentDay = mController.Services().Context().focusDateAndTimeL();
+QDateTime currentDay = mController.Services().Context().focusDateAndTime();
 currentDay = currentDay.addDays(-1);
-mController.Services().Context().setFocusDateL(currentDay, ECalenDayView);
+mController.Services().Context().setFocusDate(currentDay);
-mCurrentViewId = ECalenDayView;
+mCurrentViewId = ECalenAgendaView;
-if (mController.MainWindow().currentView() == mCalenDayView) {
+if (mController.MainWindow().currentView() == mCalenAgendaView) {
-mCalenDayView->disconnectAboutToQuitEvent(); // disconnect mCalenDayView to get aboutToQuit Events
+mCalenAgendaView->disconnectAboutToQuitEvent(); // disconnect mCalenAgendaView to get aboutToQuit Events
-HbEffect::add(mCalenDayView,
+HbEffect::add(mCalenAgendaView,
 ":/fxml/view_hide_back",
 "hide");
-HbEffect::add(mCalenDayViewAlt,
+HbEffect::add(mCalenAgendaViewAlt,
 ":/fxml/view_show_back",
 "show");
 		// It would also connect for aboutToQuit events
-mCalenDayViewAlt->doPopulation();
+mCalenAgendaViewAlt->doPopulation();
-mController.MainWindow().setCurrentView(mCalenDayViewAlt, true, Hb::ViewSwitchUseNormalAnim);
+mController.MainWindow().setCurrentView(mCalenAgendaViewAlt, true, Hb::ViewSwitchUseNormalAnim);
 } else {
-mCalenDayViewAlt->disconnectAboutToQuitEvent(); // disconnect mCalenDayViewAlt to get aboutToQuit Events
+mCalenAgendaViewAlt->disconnectAboutToQuitEvent(); // disconnect mCalenAgendaViewAlt to get aboutToQuit Events
-HbEffect::add(mCalenDayViewAlt,
+HbEffect::add(mCalenAgendaViewAlt,
 ":/fxml/view_hide_back",
 "hide");
-HbEffect::add(mCalenDayView,
+HbEffect::add(mCalenAgendaView,
 ":/fxml/view_show_back",
 "show");
 		// It would also connect for aboutToQuit events
-mCalenDayView->doPopulation();
+mCalenAgendaView->doPopulation();
-mController.MainWindow().setCurrentView(mCalenDayView, true, Hb::ViewSwitchUseNormalAnim);
+mController.MainWindow().setCurrentView(mCalenAgendaView, true, Hb::ViewSwitchUseNormalAnim);
 }
 }
 // ----------------------------------------------------------------------------
-// CalenViewManager::removeDayViews
+// CalenViewManager::removePreviousView
-// other items were commented in a header
+// Remove the previous view from main window
 // ----------------------------------------------------------------------------
 //
-void CalenViewManager::removeDayViews()
+void CalenViewManager::removePreviousView()
 {
-mCalenDayView->clearListModel();
+	if (ECalenAgendaView == mCurrentViewId) {
-mCalenDayViewAlt->clearListModel();
+		mCalenAgendaView->clearListModel();
-mController.MainWindow().removeView(mCalenDayView);
+		mCalenAgendaViewAlt->clearListModel();
-mController.MainWindow().removeView(mCalenDayViewAlt);
+		mController.MainWindow().removeView(mCalenAgendaView);
+		mController.MainWindow().removeView(mCalenAgendaViewAlt);
+	} else if (ECalenDayView == mCurrentViewId) {
+		mController.MainWindow().removeView(mCalenDayView);
+	} else {
+		if (ECalenMonthView == mCurrentViewId) {
+			mController.MainWindow().removeView(mCalenMonthView);
+		}
+	}
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::~ActivateDefaultViewL
 //  Activates the default view, as retrieved from settings.
 {
 	TRACE_ENTRY_POINT;
 	mCurrentViewId = defaultView;
 	if (ECalenMonthView == defaultView) {
 		mCalenMonthView->doPopulation();
-	} else if (ECalenDayView == defaultView) {
+	} else if (ECalenAgendaView == defaultView) {
-		mCalenDayView->doPopulation();
+		mCalenAgendaView->doPopulation();
 	}
 	TRACE_EXIT_POINT;
 }
 // ----------------------------------------------------------------------------
 	switch (mCurrentViewId) {
 		case ECalenMonthView:
 		    mCalenMonthView->doPopulation();
 		    mController.MainWindow().setCurrentView(mCalenMonthView);
 			break;
-		case ECalenDayView:
+		case ECalenAgendaView:
-		    if (mController.MainWindow().currentView() == mCalenDayView) {
+		    if (mController.MainWindow().currentView() == mCalenAgendaView) {
 		        // This happens when settings view or event viewer is opened
 		        // from the agenda view. Simply repopulate the view
-		    	if (mCalenDayView) {
+		    	if (mCalenAgendaView) {
-		    		// Remove month view from mainwindow.
+		    		mCalenAgendaView->doPopulation();
-		    		mController.MainWindow().removeView(mCalenMonthView); // what if month view is never loaded
+					mController.MainWindow().setCurrentView(mCalenAgendaView);
-					mCalenDayView->doPopulation();
-					mController.MainWindow().setCurrentView(mCalenDayView);
 		    	}
-		    } else if (mController.MainWindow().currentView() == mCalenDayViewAlt){
+		    } else if (mController.MainWindow().currentView() == mCalenAgendaViewAlt){
 		        // This happens when settings view or event viewer is opened
 		        // from the agenda view. Simply repopulate the view
-		    	if (mCalenDayViewAlt) {
+		    	if (mCalenAgendaViewAlt) {
-					mCalenDayViewAlt->doPopulation();
+		    		mCalenAgendaViewAlt->doPopulation();
-					mController.MainWindow().setCurrentView(mCalenDayViewAlt);
+		    		mController.MainWindow().setCurrentView(mCalenAgendaViewAlt);
 		    	}
 		    } else {
-		        // This is called whenever the day view is opened from the month
+		        // This is called whenever the agenda view is opened from the month
-		        // view. Since the day view is not added to the mainwindow,
+		        // view. Since the agenda view is not added to the mainwindow,
-		        // add the day views to mainwindow and set any one of them as
+		        // add the agenda views to mainwindow and set any one of them as
 		        // current view
-		    	if (mCalenDayView) {
+		    	if (mCalenAgendaView) {
-		    		mCalenDayView->doPopulation();
+		    		mCalenAgendaView->doPopulation();
-					mController.MainWindow().addView(mCalenDayView);
+		    		mController.MainWindow().addView(mCalenAgendaView);
-					mController.MainWindow().setCurrentView(mCalenDayView);
+		    		mController.MainWindow().setCurrentView(mCalenAgendaView);
-					mController.MainWindow().addView(mCalenDayViewAlt);
+		    		mController.MainWindow().addView(mCalenAgendaViewAlt);
 		    	}
 		    }
 			break;
 		case ECalenShowSettings:
-		    {
 		    mSettingsView->refreshView();
-		    }
+			break;
-			break;
+		case ECalenDayView:
-		case ECalenLandscapeDayView:
+			mCalenDayView->doPopulation();
-			// For later implementation
+			mController.MainWindow().setCurrentView(mCalenDayView);
 			break;
 	}
 	TRACE_EXIT_POINT;
 }
 {
 // capture cureent view in case app closed/quits from AgendaEventViewer
 if (mCalenMonthView) {
 mCalenMonthView->captureScreenshot(true);
 }
-else if (mCalenDayView) {
+else if (mCalenAgendaView) {
-mCalenDayView->captureScreenshot(true);
+	mCalenAgendaView->captureScreenshot(true);
 }
 	MCalenContext& context = mController.Services().Context();
 	AgendaEntry viewEntry= mController.Services().agendaInterface()->fetchById(
 			context.instanceId().mEntryLocalUid );
 	if (viewEntry.isRepeating()
 			&& viewEntry.type() != AgendaEntry::TypeTodo) {
-		QDateTime startDateTime = context.focusDateAndTimeL();
+		QDateTime startDateTime = context.focusDateAndTime();
 		viewEntry.setStartAndEndTime(startDateTime,
 		                     startDateTime.addSecs(viewEntry.durationInSecs()));
 	}
 	mCalenEventViewer = new AgendaEventViewer(
 			mController.Services().agendaInterface(), this);
 	// Launch agenda event viewer
 	mCalenEventViewer->view(viewEntry, AgendaEventViewer::ActionEditDelete);
 }
 // ----------------------------------------------------------------------------
-// CalenViewManager::loadAlternateDayView
+// CalenViewManager::loadAlternateAgendaView
 // other items were commented in a header
 // ----------------------------------------------------------------------------
 //
-void CalenViewManager::loadAlternateDayView()
+void CalenViewManager::loadAlternateAgendaView()
 {
 bool loadSuccess = false;
-// Create the day view docloader object.
+// Create the agenda view docloader object.
-mDayViewAltDocLoader = new CalenDocLoader(mController);
+mAgendaViewAltDocLoader = new CalenDocLoader(mController);
 // Load default section
-mDayViewAltDocLoader->load(CALEN_DAYVIEW_XML_FILE, &loadSuccess);
+mAgendaViewAltDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, &loadSuccess);
 if (!loadSuccess) {
 qFatal("calenviewmanager.cpp : Unable to load XML");
 }
-// Get the calenday view from the loader
+// Get the calenagenda view from the loader
-mCalenDayViewAlt = static_cast<CalenDayView *> (mDayViewAltDocLoader->findWidget(CALEN_DAYVIEW));
+mCalenAgendaViewAlt = static_cast<CalenAgendaView *> (mAgendaViewAltDocLoader->findWidget(CALEN_AGENDAVIEW));
-if (!mCalenDayViewAlt) {
+if (!mCalenAgendaViewAlt) {
-qFatal("calenviewmanager.cpp : Unable to find alternate day view");
+qFatal("calenviewmanager.cpp : Unable to find alternate agenda view");
 }
-// Setup the day view
+// Setup the agenda view
-mCalenDayViewAlt->setupView(mDayViewAltDocLoader);
+mCalenAgendaViewAlt->setupView(mAgendaViewAltDocLoader);
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::HandleCommandL
 // Handles view manager commands.
 	TRACE_ENTRY_POINT;
 	TBool commandUsed(EFalse);
 	switch (command.Command()) {
 		case ECalenMonthView:
-		    removeDayViews();
+			// First remove the previous native view before
-		    // Add month view to mainwindow.
+			// we set the mCurrentViewId with the current view
+			removePreviousView();
+			// Add month view to mainwindow.
 			mController.MainWindow().addView(mCalenMonthView);
 			mCurrentViewId = ECalenMonthView;
 			activateCurrentView();
 			break;
+		case ECalenAgendaView:
+			// First remove the previous native view before
+			// we set the mCurrentViewId with the current view
+			removePreviousView();
+			mCurrentViewId = ECalenAgendaView;
+			activateCurrentView();
+			break;
 		case ECalenDayView:
-			mCurrentViewId = ECalenDayView;
+{
-			activateCurrentView();
+// First add new view and use QueuedConnection to assure that
+// view is ready before setting it as the current view
+			mController.MainWindow().addView(mCalenDayView);
+			QMetaObject::invokeMethod(this, "handleDayViewReady",
+			    Qt::QueuedConnection);
+			}
 			break;
 		case ECalenEventView:
 			launchEventView();
-			break;
-		case ECalenLandscapeDayView:
-			mCurrentViewId = ECalenLandscapeDayView;
-			activateCurrentView();
 			break;
 		case ECalenStartActiveStep:
 			activateCurrentView();
 			break;
 		case ECalenShowNextDay:
 		    {
 		    //when setting view closed , switch to the previous view
 		    mCurrentViewId = mPreviousViewsId ;
 			mController.Services().IssueCommandL(ECalenStartActiveStep);
-			 // invalidate captured screenshots as either day view is activated now
+			 // invalidate captured screenshots as either agenda view is activated now
 			if (mCalenMonthView) {
 			mCalenMonthView->captureScreenshot();
-			} else if (mCalenDayView) {
+			} else if (mCalenAgendaView) {
-			mCalenDayView->captureScreenshot();
+				mCalenAgendaView->captureScreenshot();
 			}
 		    }
 			break;
 		default:
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleViewingCompleted(const QDate date)
 {
-	qDebug() <<"calendar: CalenViewManager::handleEditingCompleted -->";
 	// Cleanup.
 	mCalenEventViewer->deleteLater();
 	if (!date.isNull() && date.isValid()) {
-	mController.Services().Context().setFocusDateL(QDateTime(date),
+	mController.Services().Context().setFocusDate(QDateTime(date));
-	                                               ECalenDayView);
 	}
 	mController.Services().IssueNotificationL(ECalenNotifyEntryClosed);
-	// invalidate captured screenshots as either day view is activated now
+	// invalidate captured screenshots as either agenda view is activated now
 	if (mCalenMonthView) {
 	mCalenMonthView->captureScreenshot();
-	} else if (mCalenDayView) {
+	} else if (mCalenAgendaView) {
-	mCalenDayView->captureScreenshot();
+		mCalenAgendaView->captureScreenshot();
 	}
-	qDebug() <<"calendar: CalenViewManager::handleEditingCompleted <--";
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleEditingStarted
 //  Slot to handle signal editingStarted by the agenda event viewer
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleEditingStarted()
 {
-	qDebug() <<"calendar: CalenViewManager::handleEditingStarted -->";
 	mController.IssueCommandL(ECalenEditEntryFromViewer);
-	qDebug() <<"calendar: CalenViewManager::handleEditingStarted <--";
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleEditingCompleted
 //  Slot to handle signal editingCompleted by the agenda event viewer
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleEditingCompleted()
 {
-	qDebug() <<"calendar: CalenViewManager::handleEditingStarted -->";
 	mController.Services().IssueNotificationL(ECalenNotifyEditorClosedFromViewer);
-	qDebug() <<"calendar: CalenViewManager::handleEditingStarted <--";
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleDeletingStarted
 //  Slot to handle signal deletingStarted by the agenda event viewer
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleDeletingStarted()
 {
-	qDebug() <<"calendar: CalenViewManager::handleEditingStarted -->";
 	mController.IssueCommandL(ECalenDeleteEntryFromViewer);
-	qDebug() <<"calendar: CalenViewManager::handleEditingStarted <--";
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleDeletingCompleted
 //  Slot to handle signal deletingCompleted by the agenda event viewer
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::handleDeletingCompleted()
 {
-	qDebug() <<"calendar: CalenViewManager::handleEditingStarted -->";
 	mController.Services().IssueNotificationL(ECalenNotifyEntryDeleted);
-	// invalidate captured screenshots as either month view or day view is activated now
+	// invalidate captured screenshots as either month view or agenda view is activated now
 if (mCalenMonthView) {
 mCalenMonthView->captureScreenshot();
-} else if (mCalenDayView) {
+} else if (mCalenAgendaView) {
-mCalenDayView->captureScreenshot();
+	mCalenAgendaView->captureScreenshot();
 }
-	qDebug() <<"calendar: CalenViewManager::handleEditingStarted <--";
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleInstanceViewCreation
 //  Slot to handle completion of instance view creation
 	// it needs to be refactored and a common solution needs to be put here. So
 	// that code doesn't break if another view is added tomorow
 	if (mCalenMonthView) {
 		mCalenMonthView->fetchEntriesAndUpdateModel();
 	}
-	else if (mCalenDayView) {
+	else if (mCalenAgendaView) {
-	mCalenDayView->doPopulation();
+		mCalenAgendaView->doPopulation();
 	}
 }
 // ----------------------------------------------------------------------------
 // CalenViewManager::handleDeletingCompleted
 void CalenViewManager::handleEntryViewCreation(int status)
 {
 	// Nothing Yet
 	Q_UNUSED(status);
 }
+// ----------------------------------------------------------------------------
+// CalenViewManager::handleDayViewReady
+// Launches day view when it is added to MainWindow and ready to be displayed
+// ----------------------------------------------------------------------------
+//
+void CalenViewManager::handleDayViewReady()
+{
+// 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();
+}
 // ----------------------------------------------------------------------------
 // CalenViewManager::launchSettingsView
 // Launches settings view
 // (other items were commented in a header).
 // ----------------------------------------------------------------------------
 //
 void CalenViewManager::launchSettingsView()
 {
 mPreviousViewsId = mCurrentViewId ;
 mCurrentViewId = ECalenShowSettings;
 mSettingsView->initializeForm();
 mController.Services().MainWindow().setCurrentView(mSettingsView);
 // capture cureent view in case app closed/quits from settings view
 if (mCalenMonthView){
 mCalenMonthView->captureScreenshot(true);
-} else if(mCalenDayView){
+} else if(mCalenAgendaView){
-mCalenDayView->captureScreenshot(true);
+	mCalenAgendaView->captureScreenshot(true);
 }
-	}
+}
 // End of file	--Don't remove this.

changeset 50	579cc610882e
parent 49	5de72ea7a065
child 58	ef813d54df51