--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/widgetmodel/alfwidgetmodel/src/alfflowlayoutpreferencesimpl.cpp Thu Dec 17 08:56:02 2009 +0200
@@ -0,0 +1,246 @@
+/*
+* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: layoutpreferences implementation for flowlayoutmanager.
+*
+*/
+
+
+#include <assert.h>
+#include <alf/ialfwidgetcontrol.h>
+#include "alf/alfwidget.h"
+#include <alf/alfexceptions.h>
+#include <alf/ialflayoutpreferences.h>
+#include <alf/alfflowlayoutmanager.h>
+#include <alf/ialfflowlayoutpolicy.h>
+#include <osn/osnnew.h>
+
+//stl
+#include <algorithm> //for min & max
+#include "alfflowlayoutpreferencesimpl.h"
+
+using namespace Alf;
+
+namespace Alf
+ {
+// ======== MEMBER FUNCTIONS ========
+
+AlfFlowLayoutPreferencesImpl::AlfFlowLayoutPreferencesImpl(
+ AlfFlowLayoutManager& aFlowLayoutManager) :
+ mFlowLayoutManager(aFlowLayoutManager), mPreferredSize(TAlfMetric(0))
+ {
+ }
+// ---------------------------------------------------------------------------
+// from IAlfLayoutPreferences
+// Returns the minimum area that this layout manager can occupy by observing
+// the minimum sizes of the child UI elements in the layout
+// ---------------------------------------------------------------------------
+//
+bool AlfFlowLayoutPreferencesImpl::getMinimumSize(TAlfXYMetric& aMinSize) const
+ {
+ return calculateChildSizes(aMinSize,
+ flowLayoutPolicy().flowDirection(), ESizeMin);
+ }
+
+// ---------------------------------------------------------------------------
+// from IAlfLayoutPreferences
+// Returns the maximum area that this layout manager can occupy by observing
+// the maximum sizes of the child UI elements in the layout
+// ---------------------------------------------------------------------------
+//
+bool AlfFlowLayoutPreferencesImpl::getMaximumSize(TAlfXYMetric& aMaxSize) const
+ {
+ return calculateChildSizes(aMaxSize,
+ flowLayoutPolicy().flowDirection(), ESizeMax);
+ }
+
+// ---------------------------------------------------------------------------
+// Combines and returns the preferred sizes of all child UI elements according
+// to the layouting rules.
+// ---------------------------------------------------------------------------
+//
+bool AlfFlowLayoutPreferencesImpl::getPreferredSize(TAlfXYMetric& aPreferredSize) const
+ {
+ bool b = false;
+ bool manualSet = (mPreferredSize.iX.iMagnitude > 0 &&
+ mPreferredSize.iY.iMagnitude > 0);
+
+ if (manualSet)
+ {
+ aPreferredSize = mPreferredSize;
+ b = true;
+ }
+ else
+ {
+ b = calculateChildSizes(aPreferredSize,
+ flowLayoutPolicy().flowDirection(), ESizePreferred);
+ }
+ return b;
+ }
+
+// ---------------------------------------------------------------------------
+// from IAlfLayoutPreferences
+// At the moment doesn't do anything since preferred size is being queried
+// from the child UI elements added to this layout manager.
+// ---------------------------------------------------------------------------
+//
+void AlfFlowLayoutPreferencesImpl::setPreferredSize(
+ const TAlfXYMetric& aPreferredSize )
+ {
+ mPreferredSize = aPreferredSize;
+ mFlowLayoutManager.owner().updateParentLayout();
+ }
+
+// ---------------------------------------------------------------------------
+// From class IAlfInterfaceBase.
+// Getter for interfaces provided by the element.
+// ---------------------------------------------------------------------------
+//
+IAlfInterfaceBase* AlfFlowLayoutPreferencesImpl::makeInterface(
+ const IfId& aType)
+ {
+ UString param(aType.mImplementationId);
+ IAlfInterfaceBase* ret = 0;
+ if (param == IAlfLayoutPreferences::type().mImplementationId)
+ {
+ ret = static_cast<IAlfLayoutPreferences*>(this);
+ }
+
+ return ret;
+ }
+
+// ---------------------------------------------------------------------------
+// calculate the min-, preferred-, or max- sizes from the children.
+// ---------------------------------------------------------------------------
+//
+bool AlfFlowLayoutPreferencesImpl::calculateChildSizes(
+ TAlfXYMetric& aSize,
+ enum IAlfFlowLayoutPolicy::flowDirection aFlowDirection,
+ enum AlfFlowLayoutPreferencesImpl::sizeType aSizeType) const
+ {
+ bool ret = false;
+ TAlfXYMetric resultSize(TAlfMetric(0), TAlfMetric(0));
+
+ // Iterate through all the child controls, and get their
+ // preferred sizes.
+ int childCount = mFlowLayoutManager.count();
+ for (int i = 0; i < childCount; i++)
+ {
+ CAlfWidgetControl* childWidgetControl = mFlowLayoutManager.getControl(i);
+
+ TAlfXYMetric size;
+ if (getSize(childWidgetControl, size, aSizeType))
+ {
+ TAlfRealSize pixelSize = sizeInPixels(size);
+
+ if (aFlowDirection == IAlfFlowLayoutPolicy::EFlowVertical)
+ {
+ //total width = max preferred width of child widgets.
+ //total height = sum of the preferred heights of child widgets.
+ if(pixelSize.iWidth > resultSize.iX.iMagnitude)
+ {
+ resultSize.iX.iMagnitude = pixelSize.iWidth;
+ }
+ resultSize.iY.iMagnitude += pixelSize.iHeight;
+ ret = true;
+ }
+ else
+ {
+ //horizontal flow direction
+ //total height = max preferred height of child widgets.
+ //total width = sum of the preferred widths of child widgets.
+ if(pixelSize.iHeight > resultSize.iY.iMagnitude)
+ {
+ resultSize.iY.iMagnitude = pixelSize.iHeight;
+ }
+ resultSize.iX.iMagnitude += pixelSize.iWidth;
+ ret = true;
+ }
+ }
+ }
+
+ aSize = resultSize;
+ return ret;
+ }
+
+// ---------------------------------------------------------------------------
+// fetches the size from the IAlfLayoutPreferences-interface of the aControl.
+// ---------------------------------------------------------------------------
+//
+bool AlfFlowLayoutPreferencesImpl::getSize(
+ CAlfWidgetControl* aControl,
+ TAlfXYMetric& aSize,
+ enum AlfFlowLayoutPreferencesImpl::sizeType aSizeType) const
+ {
+ bool ret = false;
+
+ if (aControl)
+ {
+ const IAlfLayoutPreferences* layoutPrefs =
+ mFlowLayoutManager.getLayoutPreferences(aControl);
+
+ if (layoutPrefs)
+ {
+ switch(aSizeType)
+ {
+ case AlfFlowLayoutPreferencesImpl::ESizePreferred:
+ ret = layoutPrefs->getPreferredSize(aSize);
+ break;
+ case AlfFlowLayoutPreferencesImpl::ESizeMin:
+ ret = layoutPrefs->getMinimumSize(aSize);
+ break;
+ case AlfFlowLayoutPreferencesImpl::ESizeMax:
+ ret = layoutPrefs->getMaximumSize(aSize);
+ break;
+ }
+ }
+ }
+
+ return ret;
+ }
+
+// ---------------------------------------------------------------------------
+// get the flowlayoutpolicy-interface.
+// ---------------------------------------------------------------------------
+//
+const IAlfFlowLayoutPolicy& AlfFlowLayoutPreferencesImpl::flowLayoutPolicy() const
+ {
+ AlfFlowLayoutManager* man =
+ const_cast<AlfFlowLayoutManager*>(&mFlowLayoutManager);
+ IAlfFlowLayoutPolicy* policy =
+ IAlfInterfaceBase::makeInterface<IAlfFlowLayoutPolicy>(man);
+ assert(policy);
+ return *policy;
+ }
+// ---------------------------------------------------------------------------
+// converts size in metrics to size in pixels.
+// implementation missing!
+// ---------------------------------------------------------------------------
+//
+TAlfRealSize AlfFlowLayoutPreferencesImpl::sizeInPixels(
+ const TAlfXYMetric& aSize)
+ {
+ TAlfRealSize s;
+
+ if(aSize.iX.iUnit == EAlfUnitPixel)
+ {
+ s.iWidth = aSize.iX.iMagnitude;
+ }
+ if(aSize.iY.iUnit == EAlfUnitPixel)
+ {
+ s.iHeight = aSize.iY.iMagnitude;
+ }
+
+ return s;
+ }
+} // Alf