FCL/sf/app/organizer: comparison calendarui/views/src/calenmonthgrid.cpp

equal deleted inserted replaced

-:ecd7b9840282
+:0b38fc5b94c6
 #include <hbabstractviewitem.h>
 #include <hbstyleloader.h>
 #include <hbcolorscheme.h>
 #include <hbpangesture.h>
 #include <hbswipegesture.h>
+#include <hbtapgesture.h>
 #include <hbdeviceprofile.h>
 // User includes
 #include "calenmonthgrid.h"
 #include "calengriditemprototype.h"
 #include "calenmonthdata.h"
 #include "calenmonthview.h"
 #include "calendateutils.h"
 #include "calencommon.h"
 #include "calenconstants.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "calenmonthgridTraces.h"
+#endif
 // Constants
 #define SCROLL_SPEEED 3000
 #define GRIDLINE_WIDTH 0.075 //units
 #define MAX_PAN_DIRECTION_THRESHOLD 50
 	mCurrentRow(-100),
 	mIsNonActiveDayFocused(false),
 	mIgnoreItemActivated(false),
 	mGridBorderColor(Qt::gray)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_CALENMONTHGRID_ENTRY );
 	setScrollDirections(Qt::Vertical);
 	setRowCount(KNumOfVisibleRows);
 	setColumnCount(KCalenDaysInWeek);
 	setLongPressEnabled(false);
 	setItemRecycling(false);
 	}
 	// Connect to scrolling finished signal
 	connect(this, SIGNAL(scrollingEnded()), this,
 			SLOT(scrollingFinished()));
+	OstTraceFunctionExit0( CALENMONTHGRID_CALENMONTHGRID_EXIT );
 }
 /*!
 Destructor
 */
 CalenMonthGrid::~CalenMonthGrid()
 {
+OstTraceFunctionEntry0( DUP1_CALENMONTHGRID_CALENMONTHGRID_ENTRY );
 	// Nothing Yet
+OstTraceFunctionExit0( DUP1_CALENMONTHGRID_CALENMONTHGRID_EXIT );
 }
 /*!
 Stores the view pointer
 */
 void CalenMonthGrid::setView(CalenMonthView *view)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_SETVIEW_ENTRY );
 	mView = view;
+	OstTraceFunctionExit0( CALENMONTHGRID_SETVIEW_EXIT );
 }
 /*!
 Updates the model with the proper dates and sets the required user roles
 */
 void CalenMonthGrid::updateMonthGridModel(QList<CalenMonthData> &monthDataArray,
 int indexToBeScrolled, bool isFirstTime)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_UPDATEMONTHGRIDMODEL_ENTRY );
 	int loopStart = 0;
 	int loopEnd = monthDataArray.count();
 	if (isFirstTime) {
 		// Create the model with only 42 items as visible to the user
 		mModel = new QStandardItemModel(KCalenDaysInWeek * KNumOfVisibleRows,
 		// Calculate the last visible item in the grid
 		QModelIndex lastVisibleIndex = mModel->index(indexToBeScrolled, 0);
 		scrollTo(lastVisibleIndex);
 	}
 	mMonthDataArray = monthDataArray;
+	OstTraceFunctionExit0( CALENMONTHGRID_UPDATEMONTHGRIDMODEL_EXIT );
 }
 /*!
 	Updates the view with jprevious month dates when calendar is opened for the
 	first time to improve the opening time
 */
 void CalenMonthGrid::updateMonthGridWithInActiveMonths(
 										QList<CalenMonthData> &monthDataArray)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_UPDATEMONTHGRIDWITHINACTIVEMONTHS_ENTRY );
 	mMonthDataArray = monthDataArray;
 	// Prepend the required rows
 	handlePrependingRows(monthDataArray);
 	// Now connect to the signal which gets emitted when any item on the grid
 	// is tapped.
 	connect(this, SIGNAL(activated(const QModelIndex &)), this,
 						SLOT(itemActivated(const QModelIndex &)));
+	OstTraceFunctionExit0( CALENMONTHGRID_UPDATEMONTHGRIDWITHINACTIVEMONTHS_EXIT );
 }
 /*!
 	Updates the view with just event indicators
 */
 void CalenMonthGrid::updateMonthGridWithEventIndicators(
 										QList<CalenMonthData> &monthDataArray)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_UPDATEMONTHGRIDWITHEVENTINDICATORS_ENTRY );
 	mMonthDataArray = monthDataArray;
-	for(int i = 0; i < monthDataArray.count(); i++) {
+	int count(monthDataArray.count());
+	for(int i = 0; i < count; i++) {
 		// Check if the day has events
 		if (monthDataArray[i].HasEvents()) {
 			QModelIndex itemIndex = mModel->index(i,0);
 			QVariant itemData = itemIndex.data(Qt::UserRole + 1);
 			QVariantList list = itemData.toList();
 			list.replace(CalendarNamespace::CalendarMonthEventRole, true);
 			mModel->itemFromIndex(itemIndex)->setData(list);
 		}
 	}
+	OstTraceFunctionExit0( CALENMONTHGRID_UPDATEMONTHGRIDWITHEVENTINDICATORS_EXIT );
 }
 /*!
 Scrolls the content dowmwards
 */
 void CalenMonthGrid::downGesture()
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_DOWNGESTURE_ENTRY );
 // Make sure that content widget is properly placed
 if (mIsNonActiveDayFocused) {
 mIsAtomicScroll = true;
 int itemToBeScrolled = mView->rowsInPrevMonth() * KCalenDaysInWeek;
 QModelIndex indexToBeScrolled  = mModel->index(itemToBeScrolled, 0);
 mDirection = down;
 mIsAtomicScroll = false;
 setAttribute(Hb::InteractionDisabled);
 QPointF targetPos(0.0, 0.0);
 scrollContentsTo(targetPos,500);
+OstTraceFunctionExit0( CALENMONTHGRID_DOWNGESTURE_EXIT );
 }
 /*!
 Scrolls the content upwards
 */
 void CalenMonthGrid::upGesture()
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_UPGESTURE_ENTRY );
 // Make sure that content widget is properly placed
 if (mIsNonActiveDayFocused) {
 mIsAtomicScroll = true;
 int itemToBeScrolled = mView->rowsInPrevMonth() * KCalenDaysInWeek;
 itemToBeScrolled += KNumOfVisibleRows * KCalenDaysInWeek;
 mIsAtomicScroll = false;
 setAttribute(Hb::InteractionDisabled);
 QPointF targetPos(0.0, mStartPos.y() - size().height());
 scrollContentsTo(-targetPos,500);
+OstTraceFunctionExit0( CALENMONTHGRID_UPGESTURE_EXIT );
 }
 /*!
 Function to listen mouse press events
 */
 void CalenMonthGrid::mousePressEvent(QGraphicsSceneMouseEvent* event)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_MOUSEPRESSEVENT_ENTRY );
 	// Pass it to parent
 	HbGridView::mousePressEvent(event);
+	OstTraceFunctionExit0( CALENMONTHGRID_MOUSEPRESSEVENT_EXIT );
 }
 /*!
 Function to listen mouse release events
 */
 void CalenMonthGrid::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_MOUSERELEASEEVENT_ENTRY );
 	// Pass it grid view if pan gesture is not in progress else pass it to
 	// scrollarea. Problem here is, if we pass to gridview when panning, then
 	// its emitting item activated signal simply becasue of which focus item
 	// is getting changed when you finish the pan / shake
 	if (!mIsPanGesture) {
 		HbGridView::mouseReleaseEvent(event);
 	} else {
 		HbScrollArea::mouseReleaseEvent(event);
 	}
+	OstTraceFunctionExit0( CALENMONTHGRID_MOUSERELEASEEVENT_EXIT );
 }
 /*!
 Function to list for all the gesture events
 */
 void CalenMonthGrid::gestureEvent(QGestureEvent *event)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_GESTUREEVENT_ENTRY );
 if(HbPanGesture *gesture = qobject_cast<HbPanGesture *>(event->gesture(Qt::PanGesture))) {
 if (gesture->state() == Qt::GestureStarted) {
 setAttribute(Hb::InteractionDisabled);
 mIsAtomicScroll = false;
 if (!mIsPanGesture) {
 mIsPanGesture = true;
 mIgnoreItemActivated = true;
 mDirection = up;
 } else {
 event->accept(Qt::PanGesture);
+OstTraceFunctionExit0( CALENMONTHGRID_GESTUREEVENT_EXIT );
 return;
 }
 } else if (abs(delta.x()) < MAX_PAN_DIRECTION_THRESHOLD) {
 if (delta.y() > MIN_PAN_DIRECTION_THRESHOLD) {
 mIsPanGesture = true;
 mIsPanGesture = true;
 mIgnoreItemActivated = true;
 mDirection = up;
 }else {
 event->accept(Qt::PanGesture);
+OstTraceFunctionExit0( DUP1_CALENMONTHGRID_GESTUREEVENT_EXIT );
 return;
 }
 }
 }
 }
 mDirection = down;
 } else if (gesture->sceneVerticalDirection() == QSwipeGesture::Up) {
 mDirection = up;
 } else {
 event->accept(Qt::SwipeGesture);
+OstTraceFunctionExit0( DUP2_CALENMONTHGRID_GESTUREEVENT_EXIT );
 return;
+}
+}
+} else if (HbTapGesture *gesture = qobject_cast<HbTapGesture *>(event->gesture(Qt::TapGesture))) {
+if(gesture->state() == Qt::GestureFinished) {
+// Check if scrolling is in progress
+if (mDirection != invalid) {
+// Set the pan flag to true so that grid adjusts to nearest
+// month after tapping
+mIsPanGesture = true;
+handlePanGestureFinished();
 }
 }
 }
 if (mDirection!= invalid) {
 // Call the parent class to perform the pan gesture
 // When scrolling finished, month grid will adjust to show the proper month
 HbScrollArea::gestureEvent(event);
 }
+OstTraceFunctionExit0( DUP3_CALENMONTHGRID_GESTUREEVENT_EXIT );
 }
 /*!
 Gets called when scrolling finishes to update the model
 */
 void CalenMonthGrid::scrollingFinished()
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_SCROLLINGFINISHED_ENTRY );
 	if (mIsPanGesture) {
 		handlePanGestureFinished();
 	} else if(!mIsAtomicScroll) {
 		QDateTime activeDate = mView->getActiveDay();
 		if(mDirection == down) { // down gesture
 mIsAtomicScroll = false;
 mDirection = invalid;
 	}
 	mIgnoreItemActivated = false;
 	setAttribute(Hb::InteractionDisabled, false);
+	OstTraceFunctionExit0( CALENMONTHGRID_SCROLLINGFINISHED_EXIT );
 }
 /*!
 Function to handle completion of pan gesture
 */
 void CalenMonthGrid::handlePanGestureFinished()
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_HANDLEPANGESTUREFINISHED_ENTRY );
 	mIsPanGesture = false;
 	// Get the first item that is visible
 	QList<HbAbstractViewItem *> list = visibleItems();
 	HbAbstractViewItem* item = list[0];
 	QModelIndex modelIndex = item->modelIndex();
 	} else if (month == nextMonth.addMonths(1).date().month()) {
 		// first visible date belongs to next to next month
 		// hence, scroll up to show the next month
 		upGesture();
 	}
+	OstTraceFunctionExit0( CALENMONTHGRID_HANDLEPANGESTUREFINISHED_EXIT );
 }
 /*!
 Called when down gesture is performed. Adds the new previous month details
 to the model
 */
 void CalenMonthGrid::prependRows()
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_PREPENDROWS_ENTRY );
 	// Before we do anything, set the focus to proper date
 	// Set it only when non active day was focussed. When inactive day
 	// was focussed, we need to focus the same day
 	if (!mIsNonActiveDayFocused) {
 		setFocusToProperDay();
 	// Update the mCurrentRow
 	mCurrentRow += countToBeAdded;
 	// Update the sart position of the content widget
 	mStartPos = mContentWidget->pos();
+	OstTraceFunctionExit0( CALENMONTHGRID_PREPENDROWS_EXIT );
 }
 /*!
 	Helper function that prepends the required rows to the model
 */
 void CalenMonthGrid::handlePrependingRows(QList<CalenMonthData > &monthDataList)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_HANDLEPREPENDINGROWS_ENTRY );
 	QDateTime currDate = mView->getCurrentDay();
 	QDateTime currDateTime = CalenDateUtils::beginningOfDay( currDate );
 	int rowsInPrevMonth = mView->rowsInPrevMonth();
 	// Add the new days
 	int countToBeAdded = rowsInPrevMonth * KCalenDaysInWeek;
 		itemData << false;
 		// Set the data to model
 		mModel->itemFromIndex(currentIndex)->setData(itemData);
 	}
+	OstTraceFunctionExit0( CALENMONTHGRID_HANDLEPREPENDINGROWS_EXIT );
 }
 /*!
 Called when Up gwsture is performed. Adds the new future month details
 to the model
 */
 void CalenMonthGrid::appendRows()
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_APPENDROWS_ENTRY );
 	// Before we do anything, set the focus to proper date
 	// Set it only when non active day was focussed. When inactive day
 	// was focussed, we need to focus the same day
 	if (!mIsNonActiveDayFocused) {
 		setFocusToProperDay();
 	mIsAtomicScroll = true;
 	scrollTo(indexToBeScrolled);
 	// Update the sart position of the content widget
 mStartPos = mContentWidget->pos();
+OstTraceFunctionExit0( CALENMONTHGRID_APPENDROWS_EXIT );
 }
 /*!
 	Helper function that appends the required rows to the model
 */
 void CalenMonthGrid::handleAppendingRows(QList<CalenMonthData > &monthDataList)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_HANDLEAPPENDINGROWS_ENTRY );
 	QDateTime currDate = mView->getCurrentDay();
 	QDateTime currDateTime = CalenDateUtils::beginningOfDay( currDate );
 	int rowsInFutMonth = mView->rowsInFutMonth();
 	int countToBeAdded = rowsInFutMonth * KCalenDaysInWeek;
 	int lastVisibleIndex = monthDataList.count() - countToBeAdded;
 		itemData << false;
 		// Set the data to model
 		mModel->itemFromIndex(currentIndex)->setData(itemData);
 	}
+	OstTraceFunctionExit0( CALENMONTHGRID_HANDLEAPPENDINGROWS_EXIT );
 }
 /*!
 Slot to handle when a particular grid item is tapped
 */
 void CalenMonthGrid::itemActivated(const QModelIndex &index)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_ITEMACTIVATED_ENTRY );
 	if (mIgnoreItemActivated) {
 		mIgnoreItemActivated = false;
+		OstTraceFunctionExit0( CALENMONTHGRID_ITEMACTIVATED_EXIT );
 		return;
 	}
 	mIsNonActiveDayFocused = false;
 	// Check if the same item has been tapped twice
 	if (mCurrentRow == index.row()) {
 	} else {
 		// Reset the focus attribute to this item
 		QModelIndex itemIndex = mModel->index(mCurrentRow,0);
 		if(itemIndex.row() < 0 || itemIndex.row() >= mModel->rowCount() ||
 				itemIndex.column() < 0 || itemIndex.column() > mModel->columnCount()) {
+			OstTraceFunctionExit0( DUP1_CALENMONTHGRID_ITEMACTIVATED_EXIT );
 			return;
 		}
 		QVariant itemData = itemIndex.data(Qt::UserRole + 1);
 		QVariantList list = itemData.toList();
 		list.replace(CalendarNamespace::CalendarMonthFocusRole, false);
 				setActiveDates(activeMonth.addMonths(-2).date());
 			}
 		}
 		mView->setContextForActiveDay(index.row());
 	}
+	OstTraceFunctionExit0( DUP2_CALENMONTHGRID_ITEMACTIVATED_EXIT );
 }
 /*!
 Sets the focus to proper day after the flick scrollng
 */
 void CalenMonthGrid::setFocusToProperDay()
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_SETFOCUSTOPROPERDAY_ENTRY );
 	// Calculate the new item to be focussed
 	QDateTime oldFocussedDate = mView->getActiveDay();
 	QList<CalenMonthData> monthDataList = mView->monthDataList();
 	int listCount = monthDataList.count();
 	int rowsInPrevMonth = mView->rowsInPrevMonth();
 			mCurrentRow = i;
 			mView->setContextForActiveDay(i);
 			break;
 		}
 	}
+	OstTraceFunctionExit0( CALENMONTHGRID_SETFOCUSTOPROPERDAY_EXIT );
 }
 /*!
 Sets the appropriate text color depending upon the active dates
 */
 void CalenMonthGrid::setActiveDates(QDate activeDate)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_SETACTIVEDATES_ENTRY );
 	// By default, text color will be set as inactive date color
 	// set active date color only for the dates that fall in current month
 	// So, in the whole data array, start from where the current month starts
 	// and stop the loop where it the current month ends
 	}
 	// Now set the inactive text color to those which were active before the swipe
 	if (mDirection == invalid) {
 		// no need to do anything as other dates will be in inactive dates color
+		OstTraceFunctionExit0( CALENMONTHGRID_SETACTIVEDATES_EXIT );
 		return;
 	}
 	if (mDirection == up) {
 		// Came here as user did up gesture
 		QVariant itemData = index.data(Qt::UserRole + 1);
 		QVariantList list = itemData.toList();
 		list.replace(CalendarNamespace::CalendarMonthTextColorRole, false);
 		mModel->itemFromIndex(index)->setData(list);
 	}
+	OstTraceFunctionExit0( DUP1_CALENMONTHGRID_SETACTIVEDATES_EXIT );
 }
 /*!
 To get current foucsed index of monthGrid
 */
 int CalenMonthGrid::getCurrentIndex()
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_GETCURRENTINDEX_ENTRY );
+	OstTraceFunctionExit0( CALENMONTHGRID_GETCURRENTINDEX_EXIT );
 	return mCurrentRow;
 }
 /*!
 To set the focus to Index
 */
 void CalenMonthGrid::setCurrentIdex(int index)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_SETCURRENTIDEX_ENTRY );
 	itemActivated(mModel->index(index, 0));
+	OstTraceFunctionExit0( CALENMONTHGRID_SETCURRENTIDEX_EXIT );
 }
 /*!
 Function to override the default behavior of hbgridview on orientation change
 */
 void CalenMonthGrid::orientationChanged(Qt::Orientation newOrientation)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_ORIENTATIONCHANGED_ENTRY );
 Q_UNUSED(newOrientation)
 	// We are overriding this function to avoid the default behavior of
 	// hbgridview on orientation change as it swaps the row and column counts
 	// Calculate the proper index to be scrolled to
 	int rowsInPrevMonth;
 				KCalenDaysInWeek) - 1;
 		indexToBeScrolled = mModel->index(itemToBeScrolled, 0);
 		mIsAtomicScroll = true;
 		scrollTo(indexToBeScrolled);
 	}
+	OstTraceFunctionExit0( CALENMONTHGRID_ORIENTATIONCHANGED_EXIT );
 }
 /*!
 Paint function to draw grid lines
 */
 void CalenMonthGrid::paint(QPainter* painter,
 const QStyleOptionGraphicsItem* option,
 QWidget* widget)
 {
+OstTraceFunctionEntry0( CALENMONTHGRID_PAINT_ENTRY );
 	Q_UNUSED(option);
 	Q_UNUSED(widget);
 	painter->setRenderHint(QPainter::NonCosmeticDefaultPen);
 	// Set the required attributes to the pen
 	if (mGridLineColor.isValid()) {
 		pen.setBrush(mGridLineColor);
 	} else {
 		pen.setBrush(mGridBorderColor);
 	}
-	//store the old pen first
+	// Store the old pen
-QPen oldPen = painter->pen();
+	QPen oldPen = painter->pen();
 	// Set the new pen to the painter
 	painter->setPen(pen);
 	// Get the sizes of content widget
 	qreal contentHeight = mContentWidget->size().height();
 		pointList.append(QPointF(endPoint.x() + (i * colWidth), endPoint.y()));
 	}
 	// Draw the lines for the points in the vector list
 	painter->drawLines(pointList);
 	// Set the old pen back
 	painter->setPen(oldPen);
+	OstTraceFunctionExit0( CALENMONTHGRID_PAINT_EXIT );
 }
 // End of File

changeset 51	0b38fc5b94c6
parent 45	b6db4fd4947b
child 55	2c54b51f39c4