| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the QtGui module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qs60style.h" |
| #include "qs60style_p.h" |
| #include "qpainter.h" |
| #include "qstyleoption.h" |
| #include "qstyle.h" |
| #include "private/qapplication_p.h" |
| #include "private/qt_s60_p.h" |
| #include "private/qpixmap_raster_symbian_p.h" |
| #include "private/qcore_symbian_p.h" |
| #include "private/qvolatileimage_p.h" |
| #include "qapplication.h" |
| #include "qsettings.h" |
| |
| #include <w32std.h> |
| #include <AknsConstants.h> |
| #include <aknconsts.h> |
| #include <AknsItemID.h> |
| #include <AknsUtils.h> |
| #include <AknsDrawUtils.h> |
| #include <AknsSkinInstance.h> |
| #include <AknsBasicBackgroundControlContext.h> |
| #include <avkon.mbg> |
| #include <AknFontAccess.h> |
| #include <AknLayoutFont.h> |
| #include <AknUtils.h> |
| #include <aknnavi.h> |
| #include <gulicon.h> |
| #include <AknBitmapAnimation.h> |
| #include <centralrepository.h> |
| |
| #if !defined(QT_NO_STYLE_S60) || defined(QT_PLUGIN) |
| |
| QT_BEGIN_NAMESPACE |
| |
| enum TDrawType { |
| EDrawIcon, |
| EDrawGulIcon, |
| EDrawBackground, |
| EDrawAnimation, |
| ENoDraw |
| }; |
| |
| const TUid personalisationUID = { 0x101F876F }; |
| |
| enum TSupportRelease { |
| ES60_None = 0x0000, //indicates that the commonstyle should draw the graphics |
| ES60_3_1 = 0x0001, |
| ES60_3_2 = 0x0002, |
| ES60_5_0 = 0x0004, |
| ES60_5_1 = 0x0008, |
| ES60_5_2 = 0x0010, |
| ES60_5_3 = 0x0020, |
| ES60_3_X = ES60_3_1 | ES60_3_2, |
| // Releases before Symbian Foundation |
| ES60_PreSF = ES60_3_1 | ES60_3_2 | ES60_5_0, |
| // Releases before the S60 5.2 |
| ES60_Pre52 = ES60_3_1 | ES60_3_2 | ES60_5_0 | ES60_5_1, |
| // Releases before S60 5.3 |
| ES60_Pre53 = ES60_3_1 | ES60_3_2 | ES60_5_0 | ES60_5_1 | ES60_5_2, |
| // Add all new releases here |
| ES60_All = ES60_3_1 | ES60_3_2 | ES60_5_0 | ES60_5_1 | ES60_5_2 | ES60_5_3 |
| }; |
| |
| typedef struct { |
| const TAknsItemID &skinID; // Determines default theme graphics ID. |
| TDrawType drawType; // Determines which native drawing routine is used to draw this item. |
| int supportInfo; // Defines the S60 versions that use the default graphics. |
| // These two, define new graphics that are used in releases other than partMapEntry.supportInfo defined releases. |
| // In general, these are given in numeric form to allow style compilation in earlier |
| // native releases that do not contain the new graphics. |
| int newMajorSkinId; |
| int newMinorSkinId; |
| } partMapEntry; |
| |
| AnimationData::AnimationData(const QS60StyleEnums::SkinParts part, int frames, int interval) : m_id(part), |
| m_frames(frames), m_interval(interval), m_mode(QS60StyleEnums::AM_Looping) |
| { |
| } |
| |
| AnimationDataV2::AnimationDataV2(const AnimationData &data) : AnimationData(data.m_id, data.m_frames, data.m_interval), |
| m_animation(0), m_currentFrame(0), m_resourceBased(false), m_timerId(0) |
| { |
| } |
| AnimationDataV2::~AnimationDataV2() |
| { |
| delete m_animation; |
| } |
| |
| QS60StyleAnimation::QS60StyleAnimation(const QS60StyleEnums::SkinParts part, int frames, int interval) |
| { |
| QT_TRAP_THROWING(m_defaultData = new (ELeave) AnimationData(part, frames, interval)); |
| QT_TRAP_THROWING(m_currentData = new (ELeave) AnimationDataV2(*m_defaultData)); |
| } |
| |
| QS60StyleAnimation::~QS60StyleAnimation() |
| { |
| delete m_currentData; |
| delete m_defaultData; |
| } |
| |
| void QS60StyleAnimation::setAnimationObject(CAknBitmapAnimation* animation) |
| { |
| Q_ASSERT(animation); |
| if (m_currentData->m_animation) |
| delete m_currentData->m_animation; |
| m_currentData->m_animation = animation; |
| } |
| |
| void QS60StyleAnimation::resetToDefaults() |
| { |
| delete m_currentData; |
| m_currentData = 0; |
| QT_TRAP_THROWING(m_currentData = new (ELeave) AnimationDataV2(*m_defaultData)); |
| } |
| |
| class QS60StyleModeSpecifics |
| { |
| public: |
| static QPixmap skinnedGraphics(QS60StyleEnums::SkinParts stylepart, |
| const QSize &size, QS60StylePrivate::SkinElementFlags flags); |
| static QPixmap skinnedGraphics(QS60StylePrivate::SkinFrameElements frameElement, const QSize &size, QS60StylePrivate::SkinElementFlags flags); |
| static QPixmap colorSkinnedGraphics(const QS60StyleEnums::SkinParts &stylepart, |
| const QSize &size, QPainter *painter, QS60StylePrivate::SkinElementFlags flags); |
| static QColor colorValue(const TAknsItemID &colorGroup, int colorIndex); |
| static QPixmap fromFbsBitmap(CFbsBitmap *icon, CFbsBitmap *mask, QS60StylePrivate::SkinElementFlags flags, const TSize& targetSize); |
| static bool disabledPartGraphic(QS60StyleEnums::SkinParts &part); |
| static bool disabledFrameGraphic(QS60StylePrivate::SkinFrameElements &frame); |
| static QPixmap generateMissingThemeGraphic(QS60StyleEnums::SkinParts &part, const QSize &size, QS60StylePrivate::SkinElementFlags flags); |
| static TAknsItemID partSpecificThemeId(int part); |
| |
| static QVariant themeDefinition(QS60StyleEnums::ThemeDefinitions definition, QS60StyleEnums::SkinParts part); |
| |
| private: |
| static QPixmap createSkinnedGraphicsLX(QS60StyleEnums::SkinParts part, |
| const QSize &size, QS60StylePrivate::SkinElementFlags flags); |
| static QPixmap createSkinnedGraphicsLX(QS60StylePrivate::SkinFrameElements frameElement, const QSize &size, QS60StylePrivate::SkinElementFlags flags); |
| static QPixmap colorSkinnedGraphicsLX(const QS60StyleEnums::SkinParts &stylepart, |
| const QSize &size, QPainter *painter, QS60StylePrivate::SkinElementFlags flags); |
| static void frameIdAndCenterId(QS60StylePrivate::SkinFrameElements frameElement, TAknsItemID &frameId, TAknsItemID ¢erId); |
| static TRect innerRectFromElement(QS60StylePrivate::SkinFrameElements frameElement, const TRect &outerRect); |
| static void fallbackInfo(const QS60StyleEnums::SkinParts &stylePart, TInt &fallbackIndex); |
| static bool checkSupport(const int supportedRelease); |
| // Array to match the skin ID, fallback graphics and Qt widget graphics. |
| static const partMapEntry m_partMap[]; |
| }; |
| |
| const partMapEntry QS60StyleModeSpecifics::m_partMap[] = { |
| /* SP_QgnGrafBarWaitAnim */ {KAknsIIDQgnGrafBarWaitAnim, EDrawAnimation, ES60_All, -1,-1}, |
| /* SP_QgnGrafBarFrameCenter */ {KAknsIIDQgnGrafBarFrameCenter, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnGrafBarFrameSideL */ {KAknsIIDQgnGrafBarFrameSideL, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnGrafBarFrameSideR */ {KAknsIIDQgnGrafBarFrameSideR, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnGrafBarProgress */ {KAknsIIDQgnGrafBarProgress, EDrawIcon, ES60_All, -1,-1}, |
| // No drop area for 3.x non-touch devices |
| /* SP_QgnGrafOrgBgGrid */ {KAknsIIDNone, EDrawIcon, ES60_3_X, EAknsMajorGeneric ,0x1eba}, //KAknsIIDQgnGrafOrgBgGrid |
| /* SP_QgnGrafScrollArrowDown */ {KAknsIIDQgnGrafScrollArrowDown, EDrawGulIcon, ES60_All, -1,-1}, |
| /* SP_QgnGrafScrollArrowLeft */ {KAknsIIDQgnGrafScrollArrowLeft, EDrawGulIcon, ES60_All, -1,-1}, |
| /* SP_QgnGrafScrollArrowRight */ {KAknsIIDQgnGrafScrollArrowRight, EDrawGulIcon, ES60_All, -1,-1}, |
| /* SP_QgnGrafScrollArrowUp */ {KAknsIIDQgnGrafScrollArrowUp, EDrawGulIcon, ES60_All, -1,-1}, |
| |
| // In S60 5.3 there is a new tab graphic |
| /* SP_QgnGrafTabActiveL */ {KAknsIIDQgnGrafTabActiveL, EDrawIcon, ES60_Pre53, EAknsMajorSkin, 0x2219}, //KAknsIIDQtgFrTabActiveNormalL |
| /* SP_QgnGrafTabActiveM */ {KAknsIIDQgnGrafTabActiveM, EDrawIcon, ES60_Pre53, EAknsMajorSkin, 0x221b}, //KAknsIIDQtgFrTabActiveNormalC |
| /* SP_QgnGrafTabActiveR */ {KAknsIIDQgnGrafTabActiveR, EDrawIcon, ES60_Pre53, EAknsMajorSkin, 0x221a}, //KAknsIIDQtgFrTabActiveNormalR |
| /* SP_QgnGrafTabPassiveL */ {KAknsIIDQgnGrafTabPassiveL, EDrawIcon, ES60_Pre53, EAknsMajorSkin, 0x2221}, //KAknsIIDQtgFrTabPassiveNormalL |
| /* SP_QgnGrafTabPassiveM */ {KAknsIIDQgnGrafTabPassiveM, EDrawIcon, ES60_Pre53, EAknsMajorSkin, 0x2223}, //KAknsIIDQtgFrTabPassiveNormalC |
| /* SP_QgnGrafTabPassiveR */ {KAknsIIDQgnGrafTabPassiveR, EDrawIcon, ES60_Pre53, EAknsMajorSkin, 0x2222}, //KAknsIIDQtgFrTabPassiveNormalR |
| |
| // In 3.1 there is no slider groove. |
| /* SP_QgnGrafNsliderEndLeft */ {KAknsIIDNone, EDrawIcon, ES60_3_1, EAknsMajorGeneric, 0x19cf /* KAknsIIDQgnGrafNsliderEndLeft */}, |
| /* SP_QgnGrafNsliderEndRight */ {KAknsIIDNone, EDrawIcon, ES60_3_1, EAknsMajorGeneric, 0x19d0 /* KAknsIIDQgnGrafNsliderEndRight */}, |
| /* SP_QgnGrafNsliderMiddle */ {KAknsIIDNone, EDrawIcon, ES60_3_1, EAknsMajorGeneric, 0x19d2 /* KAknsIIDQgnGrafNsliderMiddle */}, |
| /* SP_QgnIndiCheckboxOff */ {KAknsIIDQgnIndiCheckboxOff, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnIndiCheckboxOn */ {KAknsIIDQgnIndiCheckboxOn, EDrawIcon, ES60_All, -1,-1}, |
| |
| // Following 5 items (SP_QgnIndiHlColSuper - SP_QgnIndiHlLineStraight) are available starting from S60 release 3.2. |
| // In 3.1 CommonStyle drawing is used for these QTreeView elements, since no similar icons in AVKON UI. |
| /* SP_QgnIndiHlColSuper */ {KAknsIIDNone, EDrawIcon, ES60_3_1, EAknsMajorGeneric, 0x17d5 /* KAknsIIDQgnIndiHlColSuper */}, |
| /* SP_QgnIndiHlExpSuper */ {KAknsIIDNone, EDrawIcon, ES60_3_1, EAknsMajorGeneric, 0x17d6 /* KAknsIIDQgnIndiHlExpSuper */}, |
| /* SP_QgnIndiHlLineBranch */ {KAknsIIDNone, EDrawIcon, ES60_3_1, EAknsMajorGeneric, 0x17d7 /* KAknsIIDQgnIndiHlLineBranch */}, |
| /* SP_QgnIndiHlLineEnd */ {KAknsIIDNone, EDrawIcon, ES60_3_1, EAknsMajorGeneric, 0x17d8 /* KAknsIIDQgnIndiHlLineEnd */}, |
| /* SP_QgnIndiHlLineStraight */ {KAknsIIDNone, EDrawIcon, ES60_3_1, EAknsMajorGeneric, 0x17d9 /* KAknsIIDQgnIndiHlLineStraight */}, |
| /* SP_QgnIndiMarkedAdd */ {KAknsIIDQgnIndiMarkedAdd, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnIndiNaviArrowLeft */ {KAknsIIDQgnIndiNaviArrowLeft, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnIndiNaviArrowRight */ {KAknsIIDQgnIndiNaviArrowRight, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnIndiRadiobuttOff */ {KAknsIIDQgnIndiRadiobuttOff, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnIndiRadiobuttOn */ {KAknsIIDQgnIndiRadiobuttOn, EDrawIcon, ES60_All, -1,-1}, |
| |
| // In 3.1 there different slider graphic and no pressed state. |
| /* SP_QgnGrafNsliderMarker */ {KAknsIIDQgnIndiSliderEdit, EDrawIcon, ES60_3_1, EAknsMajorGeneric, 0x19d1 /* KAknsIIDQgnGrafNsliderMarker */}, |
| /* SP_QgnGrafNsliderMarkerSelected */ {KAknsIIDQgnIndiSliderEdit, EDrawIcon, ES60_3_1, EAknsMajorGeneric, 0x1a4a /* KAknsIIDQgnGrafNsliderMarkerSelected */}, |
| /* SP_QgnIndiSubmenu */ {KAknsIIDQgnIndiSubmenu, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnNoteErased */ {KAknsIIDQgnNoteErased, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnNoteError */ {KAknsIIDQgnNoteError, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnNoteInfo */ {KAknsIIDQgnNoteInfo, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnNoteOk */ {KAknsIIDQgnNoteOk, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnNoteQuery */ {KAknsIIDQgnNoteQuery, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnNoteWarning */ {KAknsIIDQgnNoteWarning, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnPropFileSmall */ {KAknsIIDQgnPropFileSmall, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnPropFolderCurrent */ {KAknsIIDQgnPropFolderCurrent, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnPropFolderSmall */ {KAknsIIDQgnPropFolderSmall, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnPropFolderSmallNew */ {KAknsIIDQgnPropFolderSmallNew, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QgnPropPhoneMemcLarge */ {KAknsIIDQgnPropPhoneMemcLarge, EDrawIcon, ES60_All, -1,-1}, |
| |
| // Toolbar graphics is different in 3.1/3.2 vs. 5.0 |
| /* SP_QgnFrSctrlButtonCornerTl */ {KAknsIIDQsnFrButtonTbCornerTl, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2301}, /* KAknsIIDQgnFrSctrlButtonCornerTl*/ |
| /* SP_QgnFrSctrlButtonCornerTr */ {KAknsIIDQsnFrButtonTbCornerTr, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2302}, |
| /* SP_QgnFrSctrlButtonCornerBl */ {KAknsIIDQsnFrButtonTbCornerBl, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2303}, |
| /* SP_QgnFrSctrlButtonCornerBr */ {KAknsIIDQsnFrButtonTbCornerBr, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2304}, |
| /* SP_QgnFrSctrlButtonSideT */ {KAknsIIDQsnFrButtonTbSideT, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2305}, |
| /* SP_QgnFrSctrlButtonSideB */ {KAknsIIDQsnFrButtonTbSideB, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2306}, |
| /* SP_QgnFrSctrlButtonSideL */ {KAknsIIDQsnFrButtonTbSideL, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2307}, |
| /* SP_QgnFrSctrlButtonSideR */ {KAknsIIDQsnFrButtonTbSideR, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2308}, |
| /* SP_QgnFrSctrlButtonCenter */ {KAknsIIDQsnFrButtonTbCenter, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2309}, /*KAknsIIDQgnFrSctrlButtonCenter*/ |
| |
| // No pressed state for toolbar button in 3.1/3.2. |
| /* SP_QgnFrSctrlButtonCornerTlPressed */ {KAknsIIDQsnFrButtonTbCornerTl, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2621}, /*KAknsIIDQgnFrSctrlButtonCornerTlPressed*/ |
| /* SP_QgnFrSctrlButtonCornerTrPressed */ {KAknsIIDQsnFrButtonTbCornerTr, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2622}, |
| /* SP_QgnFrSctrlButtonCornerBlPressed */ {KAknsIIDQsnFrButtonTbCornerBl, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2623}, |
| /* SP_QgnFrSctrlButtonCornerBrPressed */ {KAknsIIDQsnFrButtonTbCornerBr, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2624}, |
| /* SP_QgnFrSctrlButtonSideTPressed */ {KAknsIIDQsnFrButtonTbSideT, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2625}, |
| /* SP_QgnFrSctrlButtonSideBPressed */ {KAknsIIDQsnFrButtonTbSideB, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2626}, |
| /* SP_QgnFrSctrlButtonSideLPressed */ {KAknsIIDQsnFrButtonTbSideL, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2627}, |
| /* SP_QgnFrSctrlButtonSideRPressed */ {KAknsIIDQsnFrButtonTbSideR, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2628}, |
| /* SP_QgnFrSctrlButtonCenterPressed */ {KAknsIIDQsnFrButtonTbCenter, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2629}, |
| |
| // 3.1 & 3.2 do not have pressed state for scrollbar, so use normal scrollbar graphics instead. |
| /* SP_QsnCpScrollHandleBottomPressed*/ {KAknsIIDQsnCpScrollHandleBottom, EDrawIcon, ES60_3_X, EAknsMajorGeneric, 0x20f8}, /*KAknsIIDQsnCpScrollHandleBottomPressed*/ |
| /* SP_QsnCpScrollHandleMiddlePressed*/ {KAknsIIDQsnCpScrollHandleMiddle, EDrawIcon, ES60_3_X, EAknsMajorGeneric, 0x20f9}, /*KAknsIIDQsnCpScrollHandleMiddlePressed*/ |
| /* SP_QsnCpScrollHandleTopPressed*/ {KAknsIIDQsnCpScrollHandleTop, EDrawIcon, ES60_3_X, EAknsMajorGeneric, 0x20fa}, /*KAknsIIDQsnCpScrollHandleTopPressed*/ |
| |
| /* SP_QsnBgScreen */ {KAknsIIDQsnBgScreen, EDrawBackground, ES60_All, -1,-1}, |
| |
| /* SP_QsnCpScrollBgBottom */ {KAknsIIDQsnCpScrollBgBottom, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QsnCpScrollBgMiddle */ {KAknsIIDQsnCpScrollBgMiddle, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QsnCpScrollBgTop */ {KAknsIIDQsnCpScrollBgTop, EDrawIcon, ES60_All, -1,-1}, |
| |
| /* SP_QsnCpScrollHandleBottom */ {KAknsIIDQsnCpScrollHandleBottom, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QsnCpScrollHandleMiddle */ {KAknsIIDQsnCpScrollHandleMiddle, EDrawIcon, ES60_All, -1,-1}, |
| /* SP_QsnCpScrollHandleTop */ {KAknsIIDQsnCpScrollHandleTop, EDrawIcon, ES60_All, -1,-1}, |
| |
| /* SP_QsnFrButtonTbCornerTl */ {KAknsIIDQsnFrButtonTbCornerTl, ENoDraw, ES60_All, -1, -1}, |
| /* SP_QsnFrButtonTbCornerTr */ {KAknsIIDQsnFrButtonTbCornerTr, ENoDraw, ES60_All, -1, -1}, |
| /* SP_QsnFrButtonTbCornerBl */ {KAknsIIDQsnFrButtonTbCornerBl, ENoDraw, ES60_All, -1, -1}, |
| /* SP_QsnFrButtonTbCornerBr */ {KAknsIIDQsnFrButtonTbCornerBr, ENoDraw, ES60_All, -1, -1}, |
| /* SP_QsnFrButtonTbSideT */ {KAknsIIDQsnFrButtonTbSideT, ENoDraw, ES60_All, -1, -1}, |
| /* SP_QsnFrButtonTbSideB */ {KAknsIIDQsnFrButtonTbSideB, ENoDraw, ES60_All, -1, -1}, |
| /* SP_QsnFrButtonTbSideL */ {KAknsIIDQsnFrButtonTbSideL, ENoDraw, ES60_All, -1, -1}, |
| /* SP_QsnFrButtonTbSideR */ {KAknsIIDQsnFrButtonTbSideR, ENoDraw, ES60_All, -1, -1}, |
| /* SP_QsnFrButtonTbCenter */ {KAknsIIDQsnFrButtonTbCenter, EDrawIcon, ES60_All, -1, -1}, |
| |
| /* SP_QsnFrButtonTbCornerTlPressed */{KAknsIIDQsnFrButtonTbCornerTlPressed, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrButtonTbCornerTrPressed */{KAknsIIDQsnFrButtonTbCornerTrPressed, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrButtonTbCornerBlPressed */{KAknsIIDQsnFrButtonTbCornerBlPressed, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrButtonTbCornerBrPressed */{KAknsIIDQsnFrButtonTbCornerBrPressed, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrButtonTbSideTPressed */ {KAknsIIDQsnFrButtonTbSideTPressed, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrButtonTbSideBPressed */ {KAknsIIDQsnFrButtonTbSideBPressed, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrButtonTbSideLPressed */ {KAknsIIDQsnFrButtonTbSideLPressed, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrButtonTbSideRPressed */ {KAknsIIDQsnFrButtonTbSideRPressed, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrButtonTbCenterPressed */ {KAknsIIDQsnFrButtonTbCenterPressed, EDrawIcon, ES60_All, -1,-1}, |
| |
| /* SP_QsnFrCaleCornerTl */ {KAknsIIDQsnFrCaleCornerTl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleCornerTr */ {KAknsIIDQsnFrCaleCornerTr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleCornerBl */ {KAknsIIDQsnFrCaleCornerBl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleCornerBr */ {KAknsIIDQsnFrCaleCornerBr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleSideT */ {KAknsIIDQsnFrCaleSideT, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleSideB */ {KAknsIIDQsnFrCaleSideB, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleSideL */ {KAknsIIDQsnFrCaleSideL, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleSideR */ {KAknsIIDQsnFrCaleSideR, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleCenter */ {KAknsIIDQsnFrCaleCenter, ENoDraw, ES60_All, -1,-1}, |
| |
| /* SP_QsnFrCaleHeadingCornerTl */ {KAknsIIDQsnFrCaleHeadingCornerTl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleHeadingCornerTr */ {KAknsIIDQsnFrCaleHeadingCornerTr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleHeadingCornerBl */ {KAknsIIDQsnFrCaleHeadingCornerBl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleHeadingCornerBr */ {KAknsIIDQsnFrCaleHeadingCornerBr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleHeadingSideT */ {KAknsIIDQsnFrCaleHeadingSideT, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleHeadingSideB */ {KAknsIIDQsnFrCaleHeadingSideB, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleHeadingSideL */ {KAknsIIDQsnFrCaleHeadingSideL, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleHeadingSideR */ {KAknsIIDQsnFrCaleHeadingSideR, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrCaleHeadingCenter */ {KAknsIIDQsnFrCaleHeadingCenter, ENoDraw, ES60_All, -1,-1}, |
| |
| /* SP_QsnFrInputCornerTl */ {KAknsIIDQsnFrInputCornerTl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrInputCornerTr */ {KAknsIIDQsnFrInputCornerTr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrInputCornerBl */ {KAknsIIDQsnFrInputCornerBl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrInputCornerBr */ {KAknsIIDQsnFrInputCornerBr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrInputSideT */ {KAknsIIDQsnFrInputSideT, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrInputSideB */ {KAknsIIDQsnFrInputSideB, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrInputSideL */ {KAknsIIDQsnFrInputSideL, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrInputSideR */ {KAknsIIDQsnFrInputSideR, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrInputCenter */ {KAknsIIDQsnFrInputCenter, ENoDraw, ES60_All, -1,-1}, |
| |
| /* SP_QsnFrListCornerTl */ {KAknsIIDQsnFrListCornerTl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrListCornerTr */ {KAknsIIDQsnFrListCornerTr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrListCornerBl */ {KAknsIIDQsnFrListCornerBl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrListCornerBr */ {KAknsIIDQsnFrListCornerBr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrListSideT */ {KAknsIIDQsnFrListSideT, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrListSideB */ {KAknsIIDQsnFrListSideB, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrListSideL */ {KAknsIIDQsnFrListSideL, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrListSideR */ {KAknsIIDQsnFrListSideR, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrListCenter */ {KAknsIIDQsnFrListCenter, ENoDraw, ES60_All, -1,-1}, |
| |
| /* SP_QsnFrPopupCornerTl */ {KAknsIIDQsnFrPopupCornerTl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrPopupCornerTr */ {KAknsIIDQsnFrPopupCornerTr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrPopupCornerBl */ {KAknsIIDQsnFrPopupCornerBl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrPopupCornerBr */ {KAknsIIDQsnFrPopupCornerBr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrPopupSideT */ {KAknsIIDQsnFrPopupSideT, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrPopupSideB */ {KAknsIIDQsnFrPopupSideB, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrPopupSideL */ {KAknsIIDQsnFrPopupSideL, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrPopupSideR */ {KAknsIIDQsnFrPopupSideR, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrPopupCenter */ {KAknsIIDQsnFrPopupCenterSubmenu, ENoDraw, ES60_All, -1,-1}, |
| |
| // ToolTip graphics different in 3.1 vs. 3.2+. |
| /* SP_QsnFrPopupPreviewCornerTl */ {KAknsIIDQsnFrPopupCornerTl, ENoDraw, ES60_3_1, EAknsMajorSkin, 0x19c5}, /* KAknsIIDQsnFrPopupPreviewCornerTl */ |
| /* SP_QsnFrPopupPreviewCornerTr */ {KAknsIIDQsnFrPopupCornerTr, ENoDraw, ES60_3_1, EAknsMajorSkin, 0x19c6}, |
| /* SP_QsnFrPopupPreviewCornerBl */ {KAknsIIDQsnFrPopupCornerBl, ENoDraw, ES60_3_1, EAknsMajorSkin, 0x19c3}, |
| /* SP_QsnFrPopupPreviewCornerBr */ {KAknsIIDQsnFrPopupCornerBr, ENoDraw, ES60_3_1, EAknsMajorSkin, 0x19c4}, |
| /* SP_QsnFrPopupPreviewSideT */ {KAknsIIDQsnFrPopupSideT, ENoDraw, ES60_3_1, EAknsMajorSkin, 0x19ca}, |
| /* SP_QsnFrPopupPreviewSideB */ {KAknsIIDQsnFrPopupSideB, ENoDraw, ES60_3_1, EAknsMajorSkin, 0x19c7}, |
| /* SP_QsnFrPopupPreviewSideL */ {KAknsIIDQsnFrPopupSideL, ENoDraw, ES60_3_1, EAknsMajorSkin, 0x19c8}, |
| /* SP_QsnFrPopupPreviewSideR */ {KAknsIIDQsnFrPopupSideR, ENoDraw, ES60_3_1, EAknsMajorSkin, 0x19c9}, |
| /* SP_QsnFrPopupPreviewCenter */ {KAknsIIDQsnFrPopupCenter, ENoDraw, ES60_3_1, EAknsMajorSkin, 0x19c2}, |
| |
| /* SP_QsnFrSetOptCornerTl */ {KAknsIIDQsnFrSetOptCornerTl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrSetOptCornerTr */ {KAknsIIDQsnFrSetOptCornerTr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrSetOptCornerBl */ {KAknsIIDQsnFrSetOptCornerBl, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrSetOptCornerBr */ {KAknsIIDQsnFrSetOptCornerBr, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrSetOptSideT */ {KAknsIIDQsnFrSetOptSideT, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrSetOptSideB */ {KAknsIIDQsnFrSetOptSideB, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrSetOptSideL */ {KAknsIIDQsnFrSetOptSideL, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrSetOptSideR */ {KAknsIIDQsnFrSetOptSideR, ENoDraw, ES60_All, -1,-1}, |
| /* SP_QsnFrSetOptCenter */ {KAknsIIDQsnFrSetOptCenter, ENoDraw, ES60_All, -1,-1}, |
| |
| // No toolbar frame for 5.0+ releases. |
| /* SP_QsnFrPopupSubCornerTl */ {KAknsIIDQsnFrPopupSubCornerTl, ENoDraw, ES60_3_X, -1,-1}, |
| /* SP_QsnFrPopupSubCornerTr */ {KAknsIIDQsnFrPopupSubCornerTr, ENoDraw, ES60_3_X, -1,-1}, |
| /* SP_QsnFrPopupSubCornerBl */ {KAknsIIDQsnFrPopupSubCornerBl, ENoDraw, ES60_3_X, -1,-1}, |
| /* SP_QsnFrPopupSubCornerBr */ {KAknsIIDQsnFrPopupSubCornerBr, ENoDraw, ES60_3_X, -1,-1}, |
| /* SP_QsnFrPopupSubSideT */ {KAknsIIDQsnFrPopupSubSideT, ENoDraw, ES60_3_X, -1,-1}, |
| /* SP_QsnFrPopupSubSideB */ {KAknsIIDQsnFrPopupSubSideB, ENoDraw, ES60_3_X, -1,-1}, |
| /* SP_QsnFrPopupSubSideL */ {KAknsIIDQsnFrPopupSubSideL, ENoDraw, ES60_3_X, -1,-1}, |
| /* SP_QsnFrPopupSubSideR */ {KAknsIIDQsnFrPopupSubSideR, ENoDraw, ES60_3_X, -1,-1}, |
| /* SP_QsnFrPopupSubCenter */ {KAknsIIDQsnFrPopupCenterSubmenu, ENoDraw, ES60_3_X, -1,-1}, |
| |
| // No inactive button graphics in 3.1/3.2 |
| /* SP_QsnFrButtonCornerTlInactive */ {KAknsIIDQsnFrButtonTbCornerTl, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x21b1}, /*KAknsIIDQsnFrButtonCornerTlInactive*/ |
| /* SP_QsnFrButtonCornerTrInactive */ {KAknsIIDQsnFrButtonTbCornerTr, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x21b2}, |
| /* SP_QsnFrButtonCornerBlInactive */ {KAknsIIDQsnFrButtonTbCornerBl, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x21b3}, |
| /* SP_QsnFrButtonCornerTrInactive */ {KAknsIIDQsnFrButtonTbCornerBr, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x21b4}, |
| /* SP_QsnFrButtonSideTInactive */ {KAknsIIDQsnFrButtonTbSideT, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x21b5}, |
| /* SP_QsnFrButtonSideBInactive */ {KAknsIIDQsnFrButtonTbSideB, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x21b6}, |
| /* SP_QsnFrButtonSideLInactive */ {KAknsIIDQsnFrButtonTbSideL, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x21b7}, |
| /* SP_QsnFrButtonSideRInactive */ {KAknsIIDQsnFrButtonTbSideR, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x21b8}, |
| /* SP_QsnFrButtonCenterInactive */ {KAknsIIDQsnFrButtonTbCenter, EDrawIcon, ES60_3_X, EAknsMajorSkin, 0x21b9}, |
| |
| // No pressed down grid in 3.1/3.2 |
| /* SP_QsnFrGridCornerTlPressed */ {KAknsIIDQsnFrGridCornerTl, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2681}, /*KAknsIIDQsnFrGridCornerTlPressed*/ |
| /* SP_QsnFrGridCornerTrPressed */ {KAknsIIDQsnFrGridCornerTr, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2682}, |
| /* SP_QsnFrGridCornerBlPressed */ {KAknsIIDQsnFrGridCornerBl, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2683}, |
| /* SP_QsnFrGridCornerBrPressed */ {KAknsIIDQsnFrGridCornerBr, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2684}, |
| /* SP_QsnFrGridSideTPressed */ {KAknsIIDQsnFrGridSideT, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2685}, |
| /* SP_QsnFrGridSideBPressed */ {KAknsIIDQsnFrGridSideB, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2686}, |
| /* SP_QsnFrGridSideLPressed */ {KAknsIIDQsnFrGridSideL, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2687}, |
| /* SP_QsnFrGridSideRPressed */ {KAknsIIDQsnFrGridSideR, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2688}, |
| /* SP_QsnFrGridCenterPressed */ {KAknsIIDQsnFrGridCenter, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2689}, |
| |
| // No pressed down list in 3.1/3.2 |
| /* SP_QsnFrListCornerTlPressed */ {KAknsIIDQsnFrListCornerTl, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x268b}, /*KAknsIIDQsnFrListCornerTlPressed*/ |
| /* SP_QsnFrListCornerTrPressed */ {KAknsIIDQsnFrListCornerTr, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x268c}, |
| /* SP_QsnFrListCornerBlPressed */ {KAknsIIDQsnFrListCornerBl, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x268d}, |
| /* SP_QsnFrListCornerBrPressed */ {KAknsIIDQsnFrListCornerBr, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x268e}, |
| /* SP_QsnFrListSideTPressed */ {KAknsIIDQsnFrListSideT, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x268f}, |
| /* SP_QsnFrListSideBPressed */ {KAknsIIDQsnFrListSideB, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2690}, |
| /* SP_QsnFrListSideLPressed */ {KAknsIIDQsnFrListSideL, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2691}, |
| /* SP_QsnFrListSideRPressed */ {KAknsIIDQsnFrListSideR, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2692}, |
| /* SP_QsnFrListCenterPressed */ {KAknsIIDQsnFrListCenter, ENoDraw, ES60_3_X, EAknsMajorSkin, 0x2693}, |
| |
| /* SP_QtgToolBarAdd */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x27c0}, //KAknsIIDQtgToolbarAdd |
| /* SP_QtgToolBarAddDetail */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2778}, //KAknsIIDQtgToolbarAddDetail |
| /* SP_QtgToolbarAgain */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x271a}, //KAknsIIDQtgToolbarAgain |
| /* SP_QtgToolBarAgenda */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x281a}, //KAknsIIDQtgToolbarAgenda |
| /* SP_QtgToolBarAudioOff */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2751}, //KAknsIIDQtgToolbarAudioOff |
| /* SP_QtgToolBarAudioOn */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2752}, //KAknsIIDQtgToolbarAudioOn |
| /* SP_CustomToolBarBack */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x271b}, //KAknsIIDQtgToolbarBack |
| /* SP_QtgToolBarBluetoothOff */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2753}, //KAknsIIDQtgToolbarBluetoothOff |
| /* SP_QtgToolBarBluetoothOn */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2754}, //KAknsIIDQtgToolbarBluetoothOn |
| /* SP_QtgToolBarCancel */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2895}, //KAknsIIDQtgToolbarCancel |
| /* SP_QtgToolBarDelete */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2755}, //KAknsIIDQtgToolbarDelete |
| /* SP_QtgToolBarDetails */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x271e}, //KAknsIIDQtgToolbarDetails |
| /* SP_QtgToolBarDone */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x271f}, //KAknsIIDQtgToolbarDone |
| /* SP_QtgToolBarEdit */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2720}, //KAknsIIDQtgToolbarEdit |
| /* SP_QtgToolBarEditDisabled */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2946}, //KAknsIIDQtgToolbarEditDisabled |
| /* SP_QtgToolBarEmailSend */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x292f}, //KAknsIIDQtgToolbarEmailSend |
| /* SP_QtgToolBarEmergencyCall */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2721}, //KAknsIIDQtgToolbarEmergencyCall |
| /* SP_QtgToolBarFavouriteAdd */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x28ed}, //KAknsIIDQtgToolbarFavouriteAdd |
| /* SP_QtgToolBarFavouriteRemove */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x28ee}, //KAknsIIDQtgToolbarFavouriteRemove |
| /* SP_QtgToolBarFavourites */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x28b8}, //KAknsIIDQtgToolbarFavourites |
| /* SP_QtgToolBarForward */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x281b}, //KAknsIIDQtgToolbarForward |
| /* SP_QtgToolBarGo */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2930}, //KAknsIIDQtgToolbarGo |
| /* SP_QtgToolBarHome */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2722}, //KAknsIIDQtgToolbarHome |
| /* SP_QtgToolBarImageTools */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2947}, //KAknsIIDQtgToolbarImageTools |
| /* SP_QtgToolBarList */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x28b9}, //KAknsIIDQtgToolbarList |
| /* SP_QtgToolBarLock */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2723}, //KAknsIIDQtgToolbarLock |
| /* SP_QtgToolBarLogs */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x281c}, //KAknsIIDQtgToolbarLogs |
| /* SP_QtgToolBarMenu */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2724}, //KAknsIIDQtgToolbarMenu |
| /* SP_QtgToolBarNewContact */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2779}, //KAknsIIDQtgToolbarNewContact |
| /* SP_QtgToolBarNewGroup */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x277a}, //KAknsIIDQtgToolbarNewGroup |
| /* SP_QtgToolBarNext */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x281d}, //KAknsIIDQtgToolbarNext |
| /* SP_QtgToolBarNextFrame */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2981}, //KAknsIIDQtgToolbarNextFrame |
| /* SP_QtgToolBarNowPlay */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x28ef}, //KAknsIIDQtgToolbarNowplay |
| /* SP_QtgToolBarOptions */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2725}, //KAknsIIDQtgToolbarOptions |
| /* SP_QtgToolBarOther */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2726}, //KAknsIIDQtgToolbarOther |
| /* SP_QtgToolBarOvi */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2931}, //KAknsIIDQtgToolbarOvi |
| /* SP_QtgToolBarPause */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2727}, //KAknsIIDQtgToolbarPause |
| /* SP_QtgToolBarPlay */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2728}, //KAknsIIDQtgToolbarPlay |
| /* SP_QtgToolBarPrevious */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x281e}, //KAknsIIDQtgToolbarPrevious |
| /* SP_QtgToolBarPreviousFrame */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2982}, //KAknsIIDQtgToolbarPreviousFrame |
| /* SP_QtgToolBarRead */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2729}, //KAknsIIDQtgToolbarRead |
| /* SP_QtgToolBarRedo */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2948}, //KAknsIIDQtgToolbarRedo |
| /* SP_QtgToolBarRedoDisabled */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2949}, //KAknsIIDQtgToolbarRedoDisabled |
| /* SP_QtgToolBarRefresh */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2932}, //KAknsIIDQtgToolbarRefresh |
| /* SP_QtgToolBarRemoveDetail */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x277b}, //KAknsIIDQtgToolbarRemoveDetail |
| /* SP_QtgToolBarRemoveDisabled */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x294a}, //KAknsIIDQtgToolbarRemoveDisabled |
| /* SP_QtgToolBarRepeat */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x281f}, //KAknsIIDQtgToolbarRepeat |
| /* SP_QtgToolBarRepeatOff */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2820}, //KAknsIIDQtgToolbarRepeatOff |
| /* SP_QtgToolBarRepeatOne */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2821}, //KAknsIIDQtgToolbarRepeatOne |
| /* SP_QtgToolBarRewind */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2822}, //KAknsIIDQtgToolbarRewind |
| /* SP_QtgToolBarSearch */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x272a}, //KAknsIIDQtgToolbarSearch |
| /* SP_QtgToolBarSearchDisabled */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x294b}, //KAknsIIDQtgToolbarSearchDisabled |
| /* SP_QtgToolBarSelectContent */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x294c}, //KAknsIIDQtgToolbarSelectContent |
| /* SP_QtgToolBarSelfTimer */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2756}, //KAknsIIDQtgToolbarSelfTimer |
| /* SP_QtgToolBarSend */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x272b}, //KAknsIIDQtgToolbarSend |
| /* SP_QtgToolBarSendDimmed */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x29b0}, //KAknsIIDQtgToolbarSendDimmed |
| /* SP_QtgToolBarShare */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2823}, //KAknsIIDQtgToolbarShare |
| /* SP_QtgToolBarShift */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x272c}, //KAknsIIDQtgToolbarShift |
| /* SP_QtgToolBarShuffle */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2824}, //KAknsIIDQtgToolbarShuffle |
| /* SP_QtgToolBarShuffleOff */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2825}, //KAknsIIDQtgToolbarShuffleOff |
| /* SP_QtgToolBarSignalOff */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2757}, //KAknsIIDQtgToolbarSignalOff |
| /* SP_QtgToolBarSignalOn */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2758}, //KAknsIIDQtgToolbarSignalOn |
| /* SP_QtgToolBarStop */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x272d}, //KAknsIIDQtgToolbarStop |
| /* SP_QtgToolBarSync */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2894}, //KAknsIIDQtgToolbarSync |
| /* SP_QtgToolBarTools */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2983}, //KAknsIIDQtgToolbarTools |
| /* SP_QtgToolBarTrim */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2954}, //KAknsIIDQtgToolbarTrim |
| /* SP_QtgToolBarUnlock */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x272e}, //KAknsIIDQtgToolbarUnlock |
| /* SP_QtgToolBarUnmark */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x272f}, //KAknsIIDQtgToolbarUnmark |
| /* SP_QtgToolBarView */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2730}, //KAknsIIDQtgToolbarView |
| /* SP_QtgToolBarWlanOff */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2759}, //KAknsIIDQtgToolbarWlanOff |
| /* SP_QtgToolBarWlanOn */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x275a}, //KAknsIIDQtgToolbarWlanOn |
| |
| /* SP_QtgGrafCameraButtonCaptureNormal */ {KAknsIIDNone, EDrawIcon, ES60_Pre52, EAknsMajorGeneric, 0x2743}, //KAknsIIDQtgGrafCameraButtonCaptureNormal (already in 9.2) |
| /* SP_QtgGrafCameraButtonCapturePressed */ {KAknsIIDNone, EDrawIcon, ES60_Pre52, EAknsMajorGeneric, 0x2744}, //KAknsIIDQtgGrafCameraButtonCapturePressed |
| /* SP_QtgGrafCameraButtonPauseNormal */ {KAknsIIDNone, EDrawIcon, ES60_Pre52, EAknsMajorGeneric, 0x2745}, //KAknsIIDQtgGrafCameraButtonPauseNormal |
| /* SP_QtgGrafCameraButtonPausePressed */ {KAknsIIDNone, EDrawIcon, ES60_Pre52, EAknsMajorGeneric, 0x2746}, //KAknsIIDQtgGrafCameraButtonPausePressed |
| /* SP_QtgGrafCameraButtonPlayNormal */ {KAknsIIDNone, EDrawIcon, ES60_Pre52, EAknsMajorGeneric, 0x2747}, //KAknsIIDQtgGrafCameraButtonPlayNormal |
| /* SP_QtgGrafCameraButtonPlayPressed */ {KAknsIIDNone, EDrawIcon, ES60_Pre52, EAknsMajorGeneric, 0x2748}, //KAknsIIDQtgGrafCameraButtonPlayPressed |
| /* SP_QtgGrafCameraButtonRecNormal */ {KAknsIIDNone, EDrawIcon, ES60_Pre52, EAknsMajorGeneric, 0x2749}, //KAknsIIDQtgGrafCameraButtonRecNormal |
| /* SP_QtgGrafCameraButtonRecPressed */ {KAknsIIDNone, EDrawIcon, ES60_Pre52, EAknsMajorGeneric, 0x274a}, //KAknsIIDQtgGrafCameraButtonRecPressed |
| /* SP_QtgGrafCameraButtonStopNormal */ {KAknsIIDNone, EDrawIcon, ES60_Pre52, EAknsMajorGeneric, 0x274b}, //KAknsIIDQtgGrafCameraButtonStopNormal |
| /* SP_QtgGrafCameraButtonStopPressed */ {KAknsIIDNone, EDrawIcon, ES60_Pre52, EAknsMajorGeneric, 0x274c}, //KAknsIIDQtgGrafCameraButtonStopPressed |
| |
| /* SP_QtgTabAll */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2851}, //KAknsIIDQtgTabAll |
| /* SP_QtgTabArtist */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x288f}, //KAknsIIDQtgTabArtist |
| /* SP_QtgTabFavourite */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x28eb}, //KAknsIIDQtgTabFavourite |
| /* SP_QtgTabGenre */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2890}, //KAknsIIDQtgTabGenre |
| /* SP_QtgTabLanguage */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x28ec}, //KAknsIIDQtgTabLanguage |
| /* SP_QtgTabMusicAlbum */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2891}, //KAknsIIDQtgTabMusicAlbum |
| /* SP_QtgTabPhotosAlbum */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2818}, //KAknsIIDQtgTabPhotosAlbum |
| /* SP_QtgTabPhotosAll */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2819}, //KAknsIIDQtgTabPhotosAll |
| /* SP_QtgTabPlaylist */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2892}, //KAknsIIDQtgTabPlaylist |
| /* SP_QtgTabServices */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x274f}, //KAknsIIDQtgTabServices |
| /* SP_QtgTabSongs */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2893}, //KAknsIIDQtgTabSongs |
| /* SP_QtgTabVideos */ {KAknsIIDNone, EDrawIcon, ES60_Pre53, EAknsMajorGeneric, 0x2750}, //KAknsIIDQtgTabVideos |
| |
| /* SP_QgnIndiBrowserTbReload */ {KAknsIIDQgnIndiBrowserTbReload, EDrawIcon, ES60_All, -1, -1}, |
| /* SP_QgnIndiBrowserTbHome */ {KAknsIIDQgnIndiBrowserTbHome, EDrawIcon, ES60_All, -1, -1}, |
| /* SP_QgnIndiBrowserTbStop */ {KAknsIIDQgnIndiBrowserTbStop, EDrawIcon, ES60_All, -1, -1}, |
| }; |
| |
| QPixmap QS60StyleModeSpecifics::skinnedGraphics( |
| QS60StyleEnums::SkinParts stylepart, const QSize &size, |
| QS60StylePrivate::SkinElementFlags flags) |
| { |
| QPixmap themedImage; |
| TRAPD( error, QT_TRYCATCH_LEAVING({ |
| const QPixmap skinnedImage = createSkinnedGraphicsLX(stylepart, size, flags); |
| themedImage = skinnedImage; |
| })); |
| if (error) |
| return themedImage = QPixmap(); |
| return themedImage; |
| } |
| |
| QPixmap QS60StyleModeSpecifics::skinnedGraphics( |
| QS60StylePrivate::SkinFrameElements frame, const QSize &size, QS60StylePrivate::SkinElementFlags flags) |
| { |
| QPixmap themedImage; |
| TRAPD( error, QT_TRYCATCH_LEAVING({ |
| const QPixmap skinnedImage = createSkinnedGraphicsLX(frame, size, flags); |
| themedImage = skinnedImage; |
| })); |
| if (error) |
| return themedImage = QPixmap(); |
| return themedImage; |
| } |
| |
| QPixmap QS60StyleModeSpecifics::colorSkinnedGraphics( |
| const QS60StyleEnums::SkinParts &stylepart, const QSize &size, QPainter *painter, |
| QS60StylePrivate::SkinElementFlags flags) |
| { |
| QPixmap colorGraphics; |
| TRAPD(error, QT_TRYCATCH_LEAVING(colorGraphics = colorSkinnedGraphicsLX(stylepart, size, painter, flags))); |
| return error ? QPixmap() : colorGraphics; |
| } |
| |
| void QS60StyleModeSpecifics::fallbackInfo(const QS60StyleEnums::SkinParts &stylePart, TInt &fallbackIndex) |
| { |
| switch(stylePart) { |
| case QS60StyleEnums::SP_QgnGrafBarWaitAnim: |
| fallbackIndex = EMbmAvkonQgn_graf_bar_wait_1; |
| break; |
| case QS60StyleEnums::SP_QgnGrafBarFrameCenter: |
| fallbackIndex = EMbmAvkonQgn_graf_bar_frame_center; |
| break; |
| case QS60StyleEnums::SP_QgnGrafBarFrameSideL: |
| fallbackIndex = EMbmAvkonQgn_graf_bar_frame_side_l; |
| break; |
| case QS60StyleEnums::SP_QgnGrafBarFrameSideR: |
| fallbackIndex = EMbmAvkonQgn_graf_bar_frame_side_r; |
| break; |
| case QS60StyleEnums::SP_QgnGrafBarProgress: |
| fallbackIndex = EMbmAvkonQgn_graf_bar_progress; |
| break; |
| case QS60StyleEnums::SP_QgnGrafTabActiveL: |
| fallbackIndex = EMbmAvkonQgn_graf_tab_active_l; |
| break; |
| case QS60StyleEnums::SP_QgnGrafTabActiveM: |
| fallbackIndex = EMbmAvkonQgn_graf_tab_active_m; |
| break; |
| case QS60StyleEnums::SP_QgnGrafTabActiveR: |
| fallbackIndex = EMbmAvkonQgn_graf_tab_active_r; |
| break; |
| case QS60StyleEnums::SP_QgnGrafTabPassiveL: |
| fallbackIndex = EMbmAvkonQgn_graf_tab_passive_l; |
| break; |
| case QS60StyleEnums::SP_QgnGrafTabPassiveM: |
| fallbackIndex = EMbmAvkonQgn_graf_tab_passive_m; |
| break; |
| case QS60StyleEnums::SP_QgnGrafTabPassiveR: |
| fallbackIndex = EMbmAvkonQgn_graf_tab_passive_r; |
| break; |
| case QS60StyleEnums::SP_QgnIndiCheckboxOff: |
| fallbackIndex = EMbmAvkonQgn_indi_checkbox_off; |
| break; |
| case QS60StyleEnums::SP_QgnIndiCheckboxOn: |
| fallbackIndex = EMbmAvkonQgn_indi_checkbox_on; |
| break; |
| case QS60StyleEnums::SP_QgnIndiHlColSuper: |
| fallbackIndex = 0x4456; /* EMbmAvkonQgn_indi_hl_col_super */ |
| break; |
| case QS60StyleEnums::SP_QgnIndiHlExpSuper: |
| fallbackIndex = 0x4458; /* EMbmAvkonQgn_indi_hl_exp_super */ |
| break; |
| case QS60StyleEnums::SP_QgnIndiHlLineBranch: |
| fallbackIndex = 0x445A; /* EMbmAvkonQgn_indi_hl_line_branch */ |
| break; |
| case QS60StyleEnums::SP_QgnIndiHlLineEnd: |
| fallbackIndex = 0x445C; /* EMbmAvkonQgn_indi_hl_line_end */ |
| break; |
| case QS60StyleEnums::SP_QgnIndiHlLineStraight: |
| fallbackIndex = 0x445E; /* EMbmAvkonQgn_indi_hl_line_straight */ |
| break; |
| case QS60StyleEnums::SP_QgnIndiMarkedAdd: |
| fallbackIndex = EMbmAvkonQgn_indi_marked_add; |
| break; |
| case QS60StyleEnums::SP_QgnIndiNaviArrowLeft: |
| fallbackIndex = EMbmAvkonQgn_indi_navi_arrow_left; |
| break; |
| case QS60StyleEnums::SP_QgnIndiNaviArrowRight: |
| fallbackIndex = EMbmAvkonQgn_indi_navi_arrow_right; |
| break; |
| case QS60StyleEnums::SP_QgnIndiRadiobuttOff: |
| fallbackIndex = EMbmAvkonQgn_indi_radiobutt_off; |
| break; |
| case QS60StyleEnums::SP_QgnIndiRadiobuttOn: |
| fallbackIndex = EMbmAvkonQgn_indi_radiobutt_on; |
| break; |
| case QS60StyleEnums::SP_QgnGrafNsliderMarker: |
| fallbackIndex = 17572; /* EMbmAvkonQgn_graf_nslider_marker */ |
| break; |
| case QS60StyleEnums::SP_QgnGrafNsliderMarkerSelected: |
| fallbackIndex = 17574; /* EMbmAvkonQgn_graf_nslider_marker_selected */ |
| break; |
| case QS60StyleEnums::SP_QgnIndiSubmenu: |
| fallbackIndex = EMbmAvkonQgn_indi_submenu; |
| break; |
| case QS60StyleEnums::SP_QgnNoteErased: |
| fallbackIndex = EMbmAvkonQgn_note_erased; |
| break; |
| case QS60StyleEnums::SP_QgnNoteError: |
| fallbackIndex = EMbmAvkonQgn_note_error; |
| break; |
| case QS60StyleEnums::SP_QgnNoteInfo: |
| fallbackIndex = EMbmAvkonQgn_note_info; |
| break; |
| case QS60StyleEnums::SP_QgnNoteOk: |
| fallbackIndex = EMbmAvkonQgn_note_ok; |
| break; |
| case QS60StyleEnums::SP_QgnNoteQuery: |
| fallbackIndex = EMbmAvkonQgn_note_query; |
| break; |
| case QS60StyleEnums::SP_QgnNoteWarning: |
| fallbackIndex = EMbmAvkonQgn_note_warning; |
| break; |
| case QS60StyleEnums::SP_QgnPropFileSmall: |
| fallbackIndex = EMbmAvkonQgn_prop_file_small; |
| break; |
| case QS60StyleEnums::SP_QgnPropFolderCurrent: |
| fallbackIndex = EMbmAvkonQgn_prop_folder_current; |
| break; |
| case QS60StyleEnums::SP_QgnPropFolderSmall: |
| fallbackIndex = EMbmAvkonQgn_prop_folder_small; |
| break; |
| case QS60StyleEnums::SP_QgnPropFolderSmallNew: |
| fallbackIndex = EMbmAvkonQgn_prop_folder_small_new; |
| break; |
| case QS60StyleEnums::SP_QgnPropPhoneMemcLarge: |
| fallbackIndex = EMbmAvkonQgn_prop_phone_memc_large; |
| break; |
| default: |
| fallbackIndex = -1; |
| break; |
| } |
| } |
| |
| QPixmap QS60StyleModeSpecifics::colorSkinnedGraphicsLX( |
| const QS60StyleEnums::SkinParts &stylepart, |
| const QSize &size, QPainter *painter, QS60StylePrivate::SkinElementFlags flags) |
| { |
| // this function can throw both exceptions and leaves. There are no cleanup dependencies between Qt and Symbian parts. |
| const int stylepartIndex = (int)stylepart; |
| const TAknsItemID skinId = m_partMap[stylepartIndex].skinID; |
| |
| TInt fallbackGraphicID = -1; |
| HBufC* iconFile = HBufC::NewLC( KMaxFileName ); |
| fallbackInfo(stylepart, fallbackGraphicID); |
| |
| TAknsItemID colorGroup = KAknsIIDQsnIconColors; |
| TRgb defaultColor = KRgbBlack; |
| int colorIndex = -1; //set a bogus value to color index to ensure that painter color is used |
| //to color the icon |
| if (painter) { |
| QRgb widgetColor = painter->pen().color().rgb(); |
| defaultColor = TRgb(qRed(widgetColor), qGreen(widgetColor), qBlue(widgetColor)); |
| } |
| |
| const bool rotatedBy90or270 = |
| (flags & (QS60StylePrivate::SF_PointEast | QS60StylePrivate::SF_PointWest)); |
| const TSize targetSize = |
| rotatedBy90or270?TSize(size.height(), size.width()):TSize(size.width(), size.height()); |
| CFbsBitmap *icon = 0; |
| CFbsBitmap *iconMask = 0; |
| const TInt fallbackGraphicsMaskID = |
| fallbackGraphicID == KErrNotFound?KErrNotFound:fallbackGraphicID+1; //masks are auto-generated as next in mif files |
| MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); |
| AknsUtils::CreateColorIconLC( |
| skinInstance, |
| skinId, |
| colorGroup, |
| colorIndex, |
| icon, |
| iconMask, |
| AknIconUtils::AvkonIconFileName(), |
| fallbackGraphicID, |
| fallbackGraphicsMaskID, |
| defaultColor); |
| |
| QPixmap result = fromFbsBitmap(icon, iconMask, flags, targetSize); |
| CleanupStack::PopAndDestroy(3); //icon, iconMask, iconFile |
| return result; |
| } |
| |
| QColor QS60StyleModeSpecifics::colorValue(const TAknsItemID &colorGroup, int colorIndex) |
| { |
| TRgb skinnedColor; |
| MAknsSkinInstance* skin = AknsUtils::SkinInstance(); |
| AknsUtils::GetCachedColor(skin, skinnedColor, colorGroup, colorIndex); |
| return QColor(skinnedColor.Red(),skinnedColor.Green(),skinnedColor.Blue()); |
| } |
| |
| struct QAutoFbsBitmapHeapLock |
| { |
| QAutoFbsBitmapHeapLock(CFbsBitmap* aBmp) : mBmp(aBmp) { mBmp->LockHeap(); } |
| ~QAutoFbsBitmapHeapLock() { mBmp->UnlockHeap(); } |
| CFbsBitmap* mBmp; |
| }; |
| |
| QPixmap QS60StyleModeSpecifics::fromFbsBitmap(CFbsBitmap *icon, CFbsBitmap *mask, QS60StylePrivate::SkinElementFlags flags, const TSize &targetSize) |
| { |
| Q_ASSERT(icon); |
| |
| AknIconUtils::DisableCompression(icon); |
| TInt error = AknIconUtils::SetSize(icon, targetSize, EAspectRatioNotPreserved); |
| |
| if (mask && !error) { |
| AknIconUtils::DisableCompression(mask); |
| error = AknIconUtils::SetSize(mask, targetSize, EAspectRatioNotPreserved); |
| } |
| if (error) |
| return QPixmap(); |
| |
| QPixmap pixmap; |
| QScopedPointer<QPixmapData> pd(QPixmapData::create(0, 0, QPixmapData::PixmapType)); |
| if (mask) { |
| // Try the efficient path with less copying and conversion. |
| QVolatileImage img(icon, mask); |
| pd->fromNativeType(&img, QPixmapData::VolatileImage); |
| if (!pd->isNull()) |
| pixmap = QPixmap(pd.take()); |
| } |
| if (pixmap.isNull()) { |
| // Potentially more expensive path. |
| pd->fromNativeType(icon, QPixmapData::FbsBitmap); |
| pixmap = QPixmap(pd.take()); |
| if (mask) { |
| pixmap.setAlphaChannel(QPixmap::fromSymbianCFbsBitmap(mask)); |
| } |
| } |
| |
| if ((flags & QS60StylePrivate::SF_PointEast) || |
| (flags & QS60StylePrivate::SF_PointSouth) || |
| (flags & QS60StylePrivate::SF_PointWest)) { |
| QImage iconImage = pixmap.toImage(); |
| QTransform imageTransform; |
| if (flags & QS60StylePrivate::SF_PointEast) { |
| imageTransform.rotate(90); |
| } else if (flags & QS60StylePrivate::SF_PointSouth) { |
| imageTransform.rotate(180); |
| iconImage = iconImage.transformed(imageTransform); |
| } else if (flags & QS60StylePrivate::SF_PointWest) { |
| imageTransform.rotate(270); |
| } |
| if (imageTransform.isRotating()) |
| iconImage = iconImage.transformed(imageTransform); |
| |
| pixmap = QPixmap::fromImage(iconImage); |
| } |
| if ((flags & QS60StylePrivate::SF_Mirrored_X_Axis) || |
| (flags & QS60StylePrivate::SF_Mirrored_Y_Axis)) { |
| QImage iconImage = pixmap.toImage().mirrored( |
| flags & QS60StylePrivate::SF_Mirrored_X_Axis, |
| flags & QS60StylePrivate::SF_Mirrored_Y_Axis); |
| pixmap = QPixmap::fromImage(iconImage); |
| } |
| |
| return pixmap; |
| } |
| |
| bool QS60StylePrivate::isTouchSupported() |
| { |
| return bool(AknLayoutUtils::PenEnabled()); |
| } |
| |
| bool QS60StylePrivate::isToolBarBackground() |
| { |
| return (QSysInfo::s60Version() == QSysInfo::SV_S60_3_1 || QSysInfo::s60Version() == QSysInfo::SV_S60_3_2); |
| } |
| |
| bool QS60StylePrivate::hasSliderGrooveGraphic() |
| { |
| return QSysInfo::s60Version() != QSysInfo::SV_S60_3_1; |
| } |
| |
| bool QS60StylePrivate::isSingleClickUi() |
| { |
| return (QSysInfo::s60Version() > QSysInfo::SV_S60_5_0); |
| } |
| |
| void QS60StylePrivate::deleteStoredSettings() |
| { |
| QSettings settings(QSettings::UserScope, QLatin1String("Trolltech")); |
| settings.beginGroup(QLatin1String("QS60Style")); |
| settings.remove(QString()); |
| settings.endGroup(); |
| } |
| |
| // Since S60Style has 'button' as a graphic, we don't have any native color which to use |
| // for QPalette::Button. Therefore S60Style needs to guesstimate palette color by calculating |
| // average rgb values for button pixels. |
| // Returns Qt::black if there is an issue with the graphics (image is NULL, or no constBits() found). |
| QColor QS60StylePrivate::colorFromFrameGraphics(SkinFrameElements frame) const |
| { |
| #ifndef QT_NO_SETTINGS |
| TInt themeID = 0; |
| //First we need to fetch active theme ID. We need to store the themeID at the same time |
| //as color, so that we can later check if the stored color is still from the same theme. |
| //Native side stores active theme UID/Timestamp into central repository. |
| int error = 0; |
| QT_TRAP_THROWING( |
| CRepository *themeRepository = CRepository::NewLC(personalisationUID); |
| if (themeRepository) { |
| TBuf<32> value; //themeID is currently max of 8 + 1 + 8 characters, but lets have some extra space |
| const TUint32 key = 0x00000002; //active theme key in the repository |
| error = themeRepository->Get(key, value); |
| if (error == KErrNone) { |
| TLex lex(value); |
| TPtrC numberToken(lex.NextToken()); |
| if (numberToken.Length()) |
| error = TLex(numberToken).Val(themeID); |
| else |
| error = KErrArgument; |
| } |
| } |
| CleanupStack::PopAndDestroy(themeRepository); |
| ); |
| |
| QSettings settings(QSettings::UserScope, QLatin1String("Trolltech")); |
| settings.beginGroup(QLatin1String("QS60Style")); |
| if (themeID != 0) { |
| QVariant buttonColor = settings.value(QLatin1String("ButtonColor")); |
| if (!buttonColor.isNull()) { |
| //there is a stored color value, lets see if the theme ID matches |
| if (error == KErrNone) { |
| QVariant themeUID = settings.value(QLatin1String("ThemeUID")); |
| if (!themeUID.isNull() && themeUID.toInt() == themeID) { |
| QColor storedColor(buttonColor.value<QColor>()); |
| if (storedColor.isValid()) |
| return storedColor; |
| } |
| } |
| settings.remove(QString()); //if color was invalid, or theme has been changed, just delete all stored settings |
| } |
| } |
| #endif |
| |
| QColor color = calculatedColor(frame); |
| |
| #ifndef QT_NO_SETTINGS |
| settings.setValue(QLatin1String("ThemeUID"), QVariant(themeID)); |
| if (frame == SF_ButtonNormal) //other colors are not currently calculated from graphics |
| settings.setValue(QLatin1String("ButtonColor"), QVariant(color)); |
| settings.endGroup(); |
| #endif |
| |
| return color; |
| } |
| |
| QPoint qt_s60_fill_background_offset(const QWidget *targetWidget) |
| { |
| CCoeControl *control = targetWidget->effectiveWinId(); |
| TPoint pos(0,0); |
| if (control) { |
| // FIXME properly: S60 3.1 has a bug that CCoeControl::PositionRelativeToScreen sometimes |
| // freezes the device, possibly in cases where we run out of memory. |
| // We use CCoeControl::Position instead in S60 3.1, which returns same values |
| // in most cases. |
| if (QSysInfo::s60Version() == QSysInfo::SV_S60_3_1) |
| pos = control->Position(); |
| else |
| pos = control->PositionRelativeToScreen(); |
| } |
| return QPoint(pos.iX, pos.iY); |
| } |
| |
| QPixmap QS60StyleModeSpecifics::createSkinnedGraphicsLX( |
| QS60StyleEnums::SkinParts part, const QSize &size, |
| QS60StylePrivate::SkinElementFlags flags) |
| { |
| // this function can throw both exceptions and leaves. There are no cleanup dependencies between Qt and Symbian parts. |
| if (!size.isValid()) |
| return QPixmap(); |
| |
| // Check release support and change part, if necessary. |
| const TAknsItemID skinId = partSpecificThemeId((int)part); |
| const int stylepartIndex = (int)part; |
| const TDrawType drawType = m_partMap[stylepartIndex].drawType; |
| Q_ASSERT(drawType != ENoDraw); |
| const bool rotatedBy90or270 = |
| (flags & (QS60StylePrivate::SF_PointEast | QS60StylePrivate::SF_PointWest)); |
| const TSize targetSize = |
| rotatedBy90or270 ? TSize(size.height(), size.width()) : qt_QSize2TSize(size); |
| |
| MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); |
| static const TDisplayMode displayMode = S60->supportsPremultipliedAlpha ? Q_SYMBIAN_ECOLOR16MAP : EColor16MA; |
| static const TInt drawParam = S60->supportsPremultipliedAlpha ? KAknsDrawParamDefault : KAknsDrawParamRGBOnly; |
| |
| QPixmap result; |
| |
| switch (drawType) { |
| case EDrawGulIcon: { |
| CGulIcon* icon = AknsUtils::CreateGulIconL( AknsUtils::SkinInstance(), skinId, EFalse ); |
| if (icon) |
| result = fromFbsBitmap(icon->Bitmap(), icon->Mask(), flags, targetSize); |
| delete icon; |
| break; |
| } |
| case EDrawIcon: { |
| TInt fallbackGraphicID = -1; |
| fallbackInfo(part, fallbackGraphicID); |
| |
| CFbsBitmap *icon = 0; |
| CFbsBitmap *iconMask = 0; |
| const TInt fallbackGraphicsMaskID = |
| fallbackGraphicID == KErrNotFound?KErrNotFound:fallbackGraphicID+1; //masks are auto-generated as next in mif files |
| |
| AknsUtils::CreateIconL( |
| skinInstance, |
| skinId, |
| icon, |
| iconMask, |
| AknIconUtils::AvkonIconFileName(), |
| fallbackGraphicID , |
| fallbackGraphicsMaskID); |
| |
| result = fromFbsBitmap(icon, iconMask, flags, targetSize); |
| delete icon; |
| delete iconMask; |
| break; |
| } |
| case EDrawBackground: { |
| // QS60WindowSurface::unlockBitmapHeap(); |
| CFbsBitmap *background = new (ELeave) CFbsBitmap(); //offscreen |
| CleanupStack::PushL(background); |
| User::LeaveIfError(background->Create(targetSize, displayMode)); |
| |
| CFbsBitmapDevice *dev = CFbsBitmapDevice::NewL(background); |
| CleanupStack::PushL(dev); |
| CFbsBitGc *gc = NULL; |
| User::LeaveIfError(dev->CreateContext(gc)); |
| CleanupStack::PushL(gc); |
| |
| CAknsBasicBackgroundControlContext *bgContext = CAknsBasicBackgroundControlContext::NewL( |
| skinId, |
| targetSize, |
| EFalse); |
| CleanupStack::PushL(bgContext); |
| |
| const TBool drawn = AknsDrawUtils::DrawBackground( |
| skinInstance, |
| bgContext, |
| NULL, |
| *gc, |
| TPoint(), |
| targetSize, |
| drawParam); |
| |
| if (drawn) |
| result = fromFbsBitmap(background, NULL, flags, targetSize); |
| // if drawing fails in skin server, just ignore the background (probably OOM case) |
| |
| CleanupStack::PopAndDestroy(4, background); //background, dev, gc, bgContext |
| // QS60WindowSurface::lockBitmapHeap(); |
| break; |
| } |
| case EDrawAnimation: { |
| CFbsBitmap* animationFrame; |
| CFbsBitmap* frameMask; |
| CAknBitmapAnimation* aknAnimation = 0; |
| TBool constructedFromTheme = ETrue; |
| |
| QS60StyleAnimation* animation = QS60StylePrivate::animationDefinition(part); //ownership is not passed |
| if (animation) { |
| if (!animation->animationObject() && !animation->isResourceBased()) {// no pre-made item exists, create new animation |
| CAknBitmapAnimation* newAnimation = CAknBitmapAnimation::NewL(); |
| CleanupStack::PushL(newAnimation); |
| if (newAnimation) |
| constructedFromTheme = newAnimation->ConstructFromSkinL(skinId); |
| if (constructedFromTheme && newAnimation->BitmapAnimData()->FrameArray().Count() > 0) { |
| animation->setResourceBased(false); |
| animation->setAnimationObject(newAnimation); //animation takes ownership |
| } |
| CleanupStack::Pop(newAnimation); |
| } |
| //fill-in stored information |
| aknAnimation = animation->animationObject(); |
| constructedFromTheme = !animation->isResourceBased(); |
| } |
| |
| const int currentFrame = QS60StylePrivate::currentAnimationFrame(part); |
| if (constructedFromTheme && aknAnimation && aknAnimation->BitmapAnimData()->FrameArray().Count() > 0) { |
| //Animation was created successfully and contains frames, just fetch current frame |
| if(currentFrame >= aknAnimation->BitmapAnimData()->FrameArray().Count()) |
| User::Leave(KErrOverflow); |
| const CBitmapFrameData* frameData = aknAnimation->BitmapAnimData()->FrameArray().At(currentFrame); |
| if (frameData) { |
| animationFrame = frameData->Bitmap(); |
| frameMask = frameData->Mask(); |
| } |
| } else { |
| //Theme does not contain animation theming, create frames from resource file |
| TInt fallbackGraphicID = -1; |
| fallbackInfo(part, fallbackGraphicID); |
| fallbackGraphicID = fallbackGraphicID + (currentFrame * 2); //skip masks |
| TInt fallbackGraphicsMaskID = |
| (fallbackGraphicID == KErrNotFound) ? KErrNotFound : fallbackGraphicID + 1; //masks are auto-generated as next in mif files |
| if (fallbackGraphicsMaskID != KErrNotFound) |
| fallbackGraphicsMaskID = fallbackGraphicsMaskID + (currentFrame * 2); //skip actual graphics |
| |
| //Then draw animation frame |
| AknsUtils::CreateIconL( |
| skinInstance, |
| KAknsIIDDefault, //animation is not themed, lets force fallback graphics |
| animationFrame, |
| frameMask, |
| AknIconUtils::AvkonIconFileName(), |
| fallbackGraphicID , |
| fallbackGraphicsMaskID); |
| } |
| result = fromFbsBitmap(animationFrame, frameMask, flags, targetSize); |
| if (!constructedFromTheme) { |
| delete animationFrame; |
| animationFrame = 0; |
| delete frameMask; |
| frameMask = 0; |
| } |
| break; |
| } |
| } |
| if (!result) |
| result = QPixmap(); |
| |
| return result; |
| } |
| |
| QPixmap QS60StyleModeSpecifics::createSkinnedGraphicsLX(QS60StylePrivate::SkinFrameElements frameElement, |
| const QSize &size, QS60StylePrivate::SkinElementFlags flags) |
| { |
| // this function can throw both exceptions and leaves. There are no cleanup dependencies between Qt and Symbian parts. |
| if (!size.isValid()) |
| return QPixmap(); |
| |
| const bool rotatedBy90or270 = |
| (flags & (QS60StylePrivate::SF_PointEast | QS60StylePrivate::SF_PointWest)); |
| const TSize targetSize = |
| rotatedBy90or270 ? TSize(size.height(), size.width()) : qt_QSize2TSize(size); |
| |
| MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); |
| QPixmap result; |
| |
| static const TDisplayMode displayMode = S60->supportsPremultipliedAlpha ? Q_SYMBIAN_ECOLOR16MAP : EColor16MA; |
| static const TInt drawParam = S60->supportsPremultipliedAlpha ? KAknsDrawParamDefault : KAknsDrawParamNoClearUnderImage|KAknsDrawParamRGBOnly; |
| |
| CFbsBitmap *frame = new (ELeave) CFbsBitmap(); //offscreen |
| CleanupStack::PushL(frame); |
| User::LeaveIfError(frame->Create(targetSize, displayMode)); |
| |
| CFbsBitmapDevice* bitmapDev = CFbsBitmapDevice::NewL(frame); |
| CleanupStack::PushL(bitmapDev); |
| CFbsBitGc* bitmapGc = NULL; |
| User::LeaveIfError(bitmapDev->CreateContext(bitmapGc)); |
| CleanupStack::PushL(bitmapGc); |
| |
| frame->LockHeap(); |
| memset(frame->DataAddress(), 0, frame->SizeInPixels().iWidth * frame->SizeInPixels().iHeight * 4); // 4: argb bytes |
| frame->UnlockHeap(); |
| |
| const TRect outerRect(TPoint(0, 0), targetSize); |
| const TRect innerRect = innerRectFromElement(frameElement, outerRect); |
| |
| TAknsItemID frameSkinID, centerSkinID; |
| frameSkinID = centerSkinID = partSpecificThemeId(QS60StylePrivate::m_frameElementsData[frameElement].center); |
| frameIdAndCenterId(frameElement, frameSkinID, centerSkinID); |
| |
| TBool drawn = AknsDrawUtils::DrawFrame( |
| skinInstance, |
| *bitmapGc, |
| outerRect, |
| innerRect, |
| frameSkinID, |
| centerSkinID, |
| drawParam ); |
| |
| if (S60->supportsPremultipliedAlpha) { |
| if (drawn) { |
| result = fromFbsBitmap(frame, NULL, flags, targetSize); |
| } else { |
| // Drawing might fail due to OOM (we can do nothing about that), |
| // or due to skin item not being available. |
| // If the latter occurs, lets try switch to non-release specific items (if available) |
| // and re-try the drawing. |
| frameSkinID = centerSkinID = m_partMap[(int)QS60StylePrivate::m_frameElementsData[frameElement].center].skinID; |
| frameIdAndCenterId(frameElement, frameSkinID, centerSkinID); |
| drawn = AknsDrawUtils::DrawFrame( skinInstance, |
| *bitmapGc, outerRect, innerRect, |
| frameSkinID, centerSkinID, |
| drawParam ); |
| // in case drawing fails, even after using default graphics, ignore the error |
| if (drawn) |
| result = fromFbsBitmap(frame, NULL, flags, targetSize); |
| } |
| } else { |
| TDisplayMode maskDepth = EGray256; |
| // Query the skin item for possible frame graphics mask details. |
| if (skinInstance) { |
| CAknsMaskedBitmapItemData* skinMaskedBmp = static_cast<CAknsMaskedBitmapItemData*>( |
| skinInstance->GetCachedItemData(frameSkinID,EAknsITMaskedBitmap)); |
| if (skinMaskedBmp && skinMaskedBmp->Mask()) |
| maskDepth = skinMaskedBmp->Mask()->DisplayMode(); |
| } |
| if (maskDepth != ENone) { |
| CFbsBitmap *frameMask = new (ELeave) CFbsBitmap(); //offscreen |
| CleanupStack::PushL(frameMask); |
| User::LeaveIfError(frameMask->Create(targetSize, maskDepth)); |
| |
| CFbsBitmapDevice* maskBitmapDevice = CFbsBitmapDevice::NewL(frameMask); |
| CleanupStack::PushL(maskBitmapDevice); |
| CFbsBitGc* maskBitGc = NULL; |
| User::LeaveIfError(maskBitmapDevice->CreateContext(maskBitGc)); |
| CleanupStack::PushL(maskBitGc); |
| |
| if (drawn) { |
| //ensure that the mask is really transparent |
| maskBitGc->Activate( maskBitmapDevice ); |
| maskBitGc->SetPenStyle(CGraphicsContext::ENullPen); |
| maskBitGc->SetBrushStyle(CGraphicsContext::ESolidBrush); |
| maskBitGc->SetBrushColor(KRgbWhite); |
| maskBitGc->Clear(); |
| maskBitGc->SetBrushStyle(CGraphicsContext::ENullBrush); |
| |
| drawn = AknsDrawUtils::DrawFrame(skinInstance, |
| *maskBitGc, outerRect, innerRect, |
| frameSkinID, centerSkinID, |
| KAknsSDMAlphaOnly |KAknsDrawParamNoClearUnderImage); |
| if (drawn) |
| result = fromFbsBitmap(frame, frameMask, flags, targetSize); |
| } |
| CleanupStack::PopAndDestroy(3, frameMask); |
| } |
| } |
| CleanupStack::PopAndDestroy(3, frame); //frame, bitmapDev, bitmapGc |
| return result; |
| } |
| |
| void QS60StyleModeSpecifics::frameIdAndCenterId(QS60StylePrivate::SkinFrameElements frameElement, TAknsItemID &frameId, TAknsItemID ¢erId) |
| { |
| // There are some major mix-ups in skin declarations for some frames. |
| // First, the frames are not declared in sequence. |
| // Second, the parts use different major than the frame-master. |
| |
| switch(frameElement) { |
| case QS60StylePrivate::SF_ToolTip: |
| if (QSysInfo::s60Version() != QSysInfo::SV_S60_3_1) { |
| centerId.Set(EAknsMajorGeneric, 0x19c2); |
| frameId.Set(EAknsMajorSkin, 0x5300); |
| } else { |
| centerId.Set(KAknsIIDQsnFrPopupCenter); |
| frameId.iMinor = centerId.iMinor - 9; |
| } |
| break; |
| case QS60StylePrivate::SF_ToolBar: |
| if (QSysInfo::s60Version() == QSysInfo::SV_S60_3_1 || |
| QSysInfo::s60Version() == QSysInfo::SV_S60_3_2) { |
| centerId.Set(KAknsIIDQsnFrPopupCenterSubmenu); |
| frameId.Set(KAknsIIDQsnFrPopupSub); |
| } |
| break; |
| case QS60StylePrivate::SF_PopupBackground: |
| centerId.Set(KAknsIIDQsnFrPopupCenterSubmenu); |
| frameId.Set(KAknsIIDQsnFrPopupSub); |
| break; |
| case QS60StylePrivate::SF_DialogBackground: |
| centerId.Set(KAknsIIDQsnFrPopupCenter); |
| frameId.Set(KAknsIIDQsnFrPopup); |
| break; |
| case QS60StylePrivate::SF_SettingsList: |
| // Starting from S60_5_3, the root theme has been changed so that KAknsIIDQsnFrSetOpt is empty. |
| // Set the theme ID to None, to avoid theme server trying to draw the empty frame. |
| if (QSysInfo::s60Version() > QSysInfo::SV_S60_5_2) { |
| centerId.Set(KAknsIIDNone); |
| frameId.Set(KAknsIIDNone); |
| } |
| break; |
| case QS60StylePrivate::SF_PanelBackground: |
| // remove center piece for panel graphics, so that only border is drawn |
| centerId.Set(KAknsIIDNone); |
| frameId.Set(KAknsIIDQsnFrSetOpt); |
| break; |
| default: |
| // center should be correct here |
| frameId.iMinor = centerId.iMinor - 9; |
| break; |
| } |
| } |
| |
| TRect QS60StyleModeSpecifics::innerRectFromElement(QS60StylePrivate::SkinFrameElements frameElement, const TRect &outerRect) |
| { |
| TInt widthShrink = QS60StylePrivate::pixelMetric(PM_FrameCornerWidth); |
| TInt heightShrink = QS60StylePrivate::pixelMetric(PM_FrameCornerHeight); |
| switch(frameElement) { |
| case QS60StylePrivate::SF_PanelBackground: |
| // panel should have slightly slimmer border to enable thin line of background graphics between closest component |
| widthShrink = widthShrink - 2; |
| heightShrink = heightShrink - 2; |
| break; |
| case QS60StylePrivate::SF_ToolTip: |
| widthShrink = widthShrink >> 1; |
| heightShrink = heightShrink >> 1; |
| break; |
| case QS60StylePrivate::SF_ListHighlight: |
| //In Sym^3 devices highlights are less blocky |
| if (QSysInfo::s60Version() > QSysInfo::SV_S60_5_0) { |
| widthShrink += 2; |
| heightShrink += 2; |
| } else { |
| widthShrink -= 2; |
| heightShrink -= 2; |
| } |
| break; |
| case QS60StylePrivate::SF_PopupBackground: |
| widthShrink = widthShrink + 5; |
| heightShrink = heightShrink + 5; |
| break; |
| default: |
| break; |
| } |
| TRect innerRect(outerRect); |
| innerRect.Shrink(widthShrink, heightShrink); |
| return innerRect; |
| } |
| |
| bool QS60StyleModeSpecifics::checkSupport(const int supportedRelease) |
| { |
| const QSysInfo::S60Version currentRelease = QSysInfo::s60Version(); |
| return ( (currentRelease == QSysInfo::SV_S60_3_1 && supportedRelease & ES60_3_1) || |
| (currentRelease == QSysInfo::SV_S60_3_2 && supportedRelease & ES60_3_2) || |
| (currentRelease == QSysInfo::SV_S60_5_0 && supportedRelease & ES60_5_0) || |
| (currentRelease == QSysInfo::SV_S60_5_1 && supportedRelease & ES60_5_1) || |
| (currentRelease == QSysInfo::SV_S60_5_2 && supportedRelease & ES60_5_2) || |
| (currentRelease == QSysInfo::SV_S60_5_3 && supportedRelease & ES60_5_3) ); |
| } |
| |
| TAknsItemID QS60StyleModeSpecifics::partSpecificThemeId(int part) |
| { |
| TAknsItemID newSkinId; |
| if (!checkSupport(m_partMap[(int)part].supportInfo)) |
| newSkinId.Set(m_partMap[(int)part].newMajorSkinId, m_partMap[(int)part].newMinorSkinId); |
| else |
| newSkinId.Set(m_partMap[(int)part].skinID); |
| return newSkinId; |
| } |
| |
| QFont QS60StylePrivate::s60Font_specific( |
| QS60StyleEnums::FontCategories fontCategory, |
| int pointSize, bool resolveFontSize) |
| { |
| Q_UNUSED(resolveFontSize); |
| |
| TAknFontCategory aknFontCategory = EAknFontCategoryUndefined; |
| switch (fontCategory) { |
| case QS60StyleEnums::FC_Primary: |
| aknFontCategory = EAknFontCategoryPrimary; |
| break; |
| case QS60StyleEnums::FC_Secondary: |
| aknFontCategory = EAknFontCategorySecondary; |
| break; |
| case QS60StyleEnums::FC_Title: |
| aknFontCategory = EAknFontCategoryTitle; |
| break; |
| case QS60StyleEnums::FC_PrimarySmall: |
| aknFontCategory = EAknFontCategoryPrimarySmall; |
| break; |
| case QS60StyleEnums::FC_Digital: |
| aknFontCategory = EAknFontCategoryDigital; |
| break; |
| case QS60StyleEnums::FC_Undefined: |
| default: |
| break; |
| } |
| |
| // Create AVKON font according the given parameters |
| CWsScreenDevice* dev = CCoeEnv::Static()->ScreenDevice(); |
| TAknFontSpecification spec(aknFontCategory, TFontSpec(), NULL); |
| if (pointSize > 0) { |
| const TInt pixelSize = dev->VerticalTwipsToPixels(pointSize * KTwipsPerPoint); |
| spec.SetTextPaneHeight(pixelSize + 4); // TODO: Is 4 a reasonable top+bottom margin? |
| } |
| |
| QFont result; |
| TRAPD( error, QT_TRYCATCH_LEAVING({ |
| const CAknLayoutFont* aknFont = |
| AknFontAccess::CreateLayoutFontFromSpecificationL(*dev, spec); |
| |
| result = qt_TFontSpec2QFontL(aknFont->DoFontSpecInTwips()); |
| if (result.pointSize() != pointSize) |
| result.setPointSize(pointSize); // Correct the font size returned by CreateLayoutFontFromSpecificationL() |
| |
| delete aknFont; |
| })); |
| if (error) result = QFont(); |
| return result; |
| } |
| |
| void QS60StylePrivate::setActiveLayout() |
| { |
| const QSize activeScreenSize(screenSize()); |
| int activeLayoutIndex = -1; |
| const short screenHeight = (short)activeScreenSize.height(); |
| const short screenWidth = (short)activeScreenSize.width(); |
| for (int i=0; i<m_numberOfLayouts; i++) { |
| if (screenHeight==m_layoutHeaders[i].height && |
| screenWidth==m_layoutHeaders[i].width) { |
| activeLayoutIndex = i; |
| break; |
| } |
| } |
| |
| //not found, lets try with either of dimensions |
| if (activeLayoutIndex==-1){ |
| const QSysInfo::S60Version currentRelease = QSysInfo::s60Version(); |
| const bool landscape = screenHeight < screenWidth; |
| |
| activeLayoutIndex = (currentRelease == QSysInfo::SV_S60_3_1 || currentRelease == QSysInfo::SV_S60_3_2) ? 0 : 2; |
| activeLayoutIndex += (!landscape) ? 1 : 0; |
| } |
| |
| setCurrentLayout(activeLayoutIndex); |
| } |
| |
| Q_GLOBAL_STATIC(QList<QS60StyleAnimation *>, m_animations) |
| |
| QS60StylePrivate::QS60StylePrivate() |
| { |
| //Animation defaults need to be created when style is instantiated |
| QS60StyleAnimation* progressBarAnimation = new QS60StyleAnimation(QS60StyleEnums::SP_QgnGrafBarWaitAnim, 7, 100); |
| m_animations()->append(progressBarAnimation); |
| // No need to set active layout, if dynamic metrics API is available |
| setActiveLayout(); |
| } |
| |
| void QS60StylePrivate::removeAnimations() |
| { |
| //currently only one animation in the list. |
| m_animations()->removeFirst(); |
| } |
| |
| QColor QS60StylePrivate::s60Color(QS60StyleEnums::ColorLists list, |
| int index, const QStyleOption *option) |
| { |
| static const TAknsItemID *idMap[] = { |
| &KAknsIIDQsnHighlightColors, |
| &KAknsIIDQsnIconColors, |
| &KAknsIIDQsnLineColors, |
| &KAknsIIDQsnOtherColors, |
| &KAknsIIDQsnParentColors, |
| &KAknsIIDQsnTextColors |
| }; |
| Q_ASSERT((int)list < (int)sizeof(idMap)/sizeof(idMap[0])); |
| const QColor color = QS60StyleModeSpecifics::colorValue(*idMap[(int) list], index - 1); |
| return option ? QS60StylePrivate::stateColor(color, option) : color; |
| } |
| |
| // In some cases, the AVKON UI themegraphic is already in 'disabled state'. |
| // If so, return true for these parts. |
| bool QS60StyleModeSpecifics::disabledPartGraphic(QS60StyleEnums::SkinParts &part) |
| { |
| bool disabledGraphic = false; |
| switch(part){ |
| // inactive button graphics are available from 5.0 onwards |
| case QS60StyleEnums::SP_QsnFrButtonCornerTlInactive: |
| case QS60StyleEnums::SP_QsnFrButtonCornerTrInactive: |
| case QS60StyleEnums::SP_QsnFrButtonCornerBlInactive: |
| case QS60StyleEnums::SP_QsnFrButtonCornerBrInactive: |
| case QS60StyleEnums::SP_QsnFrButtonSideTInactive: |
| case QS60StyleEnums::SP_QsnFrButtonSideBInactive: |
| case QS60StyleEnums::SP_QsnFrButtonSideLInactive: |
| case QS60StyleEnums::SP_QsnFrButtonSideRInactive: |
| case QS60StyleEnums::SP_QsnFrButtonCenterInactive: |
| if (!(QSysInfo::s60Version()==QSysInfo::SV_S60_3_1 || |
| QSysInfo::s60Version()==QSysInfo::SV_S60_3_2)) |
| disabledGraphic = true; |
| break; |
| default: |
| break; |
| } |
| return disabledGraphic; |
| } |
| |
| // In some cases, the AVKON UI themegraphic is already in 'disabled state'. |
| // If so, return true for these frames. |
| bool QS60StyleModeSpecifics::disabledFrameGraphic(QS60StylePrivate::SkinFrameElements &frame) |
| { |
| bool disabledGraphic = false; |
| switch(frame){ |
| // inactive button graphics are available from 5.0 onwards |
| case QS60StylePrivate::SF_ButtonInactive: |
| if (!(QSysInfo::s60Version()==QSysInfo::SV_S60_3_1 || |
| QSysInfo::s60Version()==QSysInfo::SV_S60_3_2)) |
| disabledGraphic = true; |
| break; |
| default: |
| break; |
| } |
| return disabledGraphic; |
| } |
| |
| QPixmap QS60StyleModeSpecifics::generateMissingThemeGraphic(QS60StyleEnums::SkinParts &part, |
| const QSize &size, QS60StylePrivate::SkinElementFlags flags) |
| { |
| if (!QS60StylePrivate::isTouchSupported()) |
| return QPixmap(); |
| |
| QS60StyleEnums::SkinParts updatedPart = part; |
| switch(part){ |
| // AVKON UI has a abnormal handling for scrollbar graphics. It is possible that the root |
| // skin does not contain mandatory graphics for scrollbar pressed states. Therefore, AVKON UI |
| // creates dynamically these graphics by modifying the normal state scrollbar graphics slightly. |
| // S60Style needs to work similarly. Therefore if skingraphics call provides to be a miss |
| // (i.e. result is not valid), style needs to draw normal graphics instead and apply some |
| // modifications (similar to generatedIconPixmap()) to the result. |
| case QS60StyleEnums::SP_QsnCpScrollHandleBottomPressed: |
| updatedPart = QS60StyleEnums::SP_QsnCpScrollHandleBottom; |
| break; |
| case QS60StyleEnums::SP_QsnCpScrollHandleMiddlePressed: |
| updatedPart = QS60StyleEnums::SP_QsnCpScrollHandleMiddle; |
| break; |
| case QS60StyleEnums::SP_QsnCpScrollHandleTopPressed: |
| updatedPart = QS60StyleEnums::SP_QsnCpScrollHandleTop; |
| break; |
| default: |
| break; |
| } |
| if (part==updatedPart) { |
| return QPixmap(); |
| } else { |
| QPixmap result = skinnedGraphics(updatedPart, size, flags); |
| QStyleOption opt; |
| QPalette *themePalette = QS60StylePrivate::themePalette(); |
| if (themePalette) |
| opt.palette = *themePalette; |
| |
| // For now, always generate new icon based on "selected". In the future possibly, expand |
| // this to consist other possibilities as well. |
| result = QApplication::style()->generatedIconPixmap(QIcon::Selected, result, &opt); |
| return result; |
| } |
| } |
| |
| QPixmap QS60StylePrivate::part(QS60StyleEnums::SkinParts part, |
| const QSize &size, QPainter *painter, SkinElementFlags flags) |
| { |
| QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock); |
| |
| QPixmap result = (flags & SF_ColorSkinned)? |
| QS60StyleModeSpecifics::colorSkinnedGraphics(part, size, painter, flags) |
| : QS60StyleModeSpecifics::skinnedGraphics(part, size, flags); |
| |
| lock.relock(); |
| |
| if (flags & SF_StateDisabled && !QS60StyleModeSpecifics::disabledPartGraphic(part)) { |
| QStyleOption opt; |
| QPalette *themePalette = QS60StylePrivate::themePalette(); |
| if (themePalette) |
| opt.palette = *themePalette; |
| result = QApplication::style()->generatedIconPixmap(QIcon::Disabled, result, &opt); |
| } |
| |
| if (!result) |
| result = QS60StyleModeSpecifics::generateMissingThemeGraphic(part, size, flags); |
| |
| return result; |
| } |
| |
| QPixmap QS60StylePrivate::frame(SkinFrameElements frame, const QSize &size, SkinElementFlags flags) |
| { |
| QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock); |
| QPixmap result = QS60StyleModeSpecifics::skinnedGraphics(frame, size, flags); |
| lock.relock(); |
| |
| if (flags & SF_StateDisabled && !QS60StyleModeSpecifics::disabledFrameGraphic(frame)) { |
| QStyleOption opt; |
| QPalette *themePalette = QS60StylePrivate::themePalette(); |
| if (themePalette) |
| opt.palette = *themePalette; |
| result = QApplication::style()->generatedIconPixmap(QIcon::Disabled, result, &opt); |
| } |
| return result; |
| } |
| |
| QPixmap QS60StylePrivate::backgroundTexture(bool skipCreation) |
| { |
| bool createNewBackground = false; |
| TRect applicationRect = (static_cast<CEikAppUi*>(S60->appUi())->ApplicationRect()); |
| if (!m_background) { |
| createNewBackground = true; |
| } else { |
| //if background brush does not match screensize, re-create it |
| if (m_background->width() != applicationRect.Width() || |
| m_background->height() != applicationRect.Height()) { |
| delete m_background; |
| m_background = 0; |
| createNewBackground = true; |
| } |
| } |
| |
| if (createNewBackground && !skipCreation) { |
| QPixmap background = part(QS60StyleEnums::SP_QsnBgScreen, |
| QSize(applicationRect.Width(), applicationRect.Height()), 0, SkinElementFlags()); |
| m_background = new QPixmap(background); |
| |
| // Notify all widgets that palette is updated with the actual background texture. |
| QPalette pal = QApplication::palette(); |
| pal.setBrush(QPalette::Window, *m_background); |
| |
| //Application palette hash is automatically cleared when QApplication::setPalette is called. |
| //To avoid losing palette hash data, back it up before calling the setPalette() API and |
| //restore it afterwards. |
| typedef QHash<QByteArray, QPalette> PaletteHash; |
| PaletteHash hash; |
| if (qt_app_palettes_hash() || !qt_app_palettes_hash()->isEmpty()) |
| hash = *qt_app_palettes_hash(); |
| QApplication::setPalette(pal); |
| if (hash.isEmpty()) { |
| //set default theme palette hash |
| setThemePaletteHash(&pal); |
| } else { |
| for (int i = 0; i < hash.count() - 1; i++) { |
| QByteArray widgetClassName = hash.keys().at(i); |
| QApplication::setPalette(hash.value(widgetClassName), widgetClassName); |
| } |
| } |
| storeThemePalette(&pal); |
| foreach (QWidget *widget, QApplication::allWidgets()) { |
| setThemePalette(widget); |
| widget->ensurePolished(); |
| } |
| } |
| if (!m_background) |
| return QPixmap(); |
| return *m_background; |
| } |
| |
| QSize QS60StylePrivate::screenSize() |
| { |
| return QSize(S60->screenWidthInPixels, S60->screenHeightInPixels); |
| } |
| |
| QS60Style::QS60Style() |
| : QCommonStyle(*new QS60StylePrivate) |
| { |
| } |
| |
| #ifdef Q_WS_S60 |
| void QS60StylePrivate::handleDynamicLayoutVariantSwitch() |
| { |
| clearCaches(QS60StylePrivate::CC_LayoutChange); |
| setBackgroundTexture(qApp); |
| setActiveLayout(); |
| foreach (QWidget *widget, QApplication::allWidgets()) |
| widget->ensurePolished(); |
| } |
| |
| void QS60StylePrivate::handleSkinChange() |
| { |
| clearCaches(QS60StylePrivate::CC_ThemeChange); |
| setThemePalette(qApp); |
| foreach (QWidget *topLevelWidget, QApplication::allWidgets()){ |
| QEvent e(QEvent::StyleChange); |
| QApplication::sendEvent(topLevelWidget, &e); |
| setThemePalette(topLevelWidget); |
| topLevelWidget->ensurePolished(); |
| } |
| #ifndef QT_NO_PROGRESSBAR |
| //re-start animation timer |
| stopAnimation(QS60StyleEnums::SP_QgnGrafBarWaitAnim); //todo: once we have more animations, we could say "stop all running ones" |
| startAnimation(QS60StyleEnums::SP_QgnGrafBarWaitAnim); //and "re-start all previously running ones" |
| #endif |
| } |
| |
| int QS60StylePrivate::currentAnimationFrame(QS60StyleEnums::SkinParts part) |
| { |
| QS60StyleAnimation *animation = animationDefinition(part); |
| // todo: looping could be done in QS60Style::timerEvent |
| if (animation->frameCount() == animation->currentFrame()) |
| animation->setCurrentFrame(0); |
| return animation->currentFrame(); |
| } |
| |
| QS60StyleAnimation* QS60StylePrivate::animationDefinition(QS60StyleEnums::SkinParts part) |
| { |
| int i = 0; |
| const int animationsCount = m_animations()->isEmpty() ? 0 : m_animations()->count(); |
| for(; i < animationsCount; i++) { |
| if (part == m_animations()->at(i)->animationId()) |
| break; |
| } |
| return m_animations()->at(i); |
| } |
| |
| void QS60StylePrivate::startAnimation(QS60StyleEnums::SkinParts animationPart) |
| { |
| Q_Q(QS60Style); |
| |
| //Query animation data from theme and store values to local struct. |
| QVariant themeAnimationDataVariant = QS60StyleModeSpecifics::themeDefinition( |
| QS60StyleEnums::TD_AnimationData, animationPart); |
| QList<QVariant> themeAnimationData = themeAnimationDataVariant.toList(); |
| |
| QS60StyleAnimation *animation = QS60StylePrivate::animationDefinition(animationPart); |
| if (animation) { |
| if (themeAnimationData.at(QS60StyleEnums::AD_Interval).toInt() != 0) |
| animation->setInterval(themeAnimationData.at(QS60StyleEnums::AD_Interval).toInt()); |
| |
| if (themeAnimationData.at(QS60StyleEnums::AD_NumberOfFrames).toInt() != 0) |
| animation->setFrameCount(themeAnimationData.at(QS60StyleEnums::AD_NumberOfFrames).toInt()); |
| |
| //todo: playmode is ignored for now, since it seems to return invalid data on some themes |
| //lets use the table values for play mode |
| |
| animation->setCurrentFrame(0); //always initialize |
| const int timerId = q->startTimer(animation->interval()); |
| animation->setTimerId(timerId); |
| } |
| } |
| |
| void QS60StylePrivate::stopAnimation(QS60StyleEnums::SkinParts animationPart) |
| { |
| Q_Q(QS60Style); |
| |
| QS60StyleAnimation *animation = QS60StylePrivate::animationDefinition(animationPart); |
| if (animation) { |
| animation->setCurrentFrame(0); |
| if (animation->timerId() != 0) { |
| q->killTimer(animation->timerId()); |
| animation->setTimerId(0); |
| } |
| animation->resetToDefaults(); |
| } |
| } |
| |
| QVariant QS60StyleModeSpecifics::themeDefinition( |
| QS60StyleEnums::ThemeDefinitions definition, QS60StyleEnums::SkinParts part) |
| { |
| MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); |
| |
| Q_ASSERT(skinInstance); |
| |
| switch(definition) { |
| //Animation definitions |
| case QS60StyleEnums::TD_AnimationData: |
| { |
| CAknsBmpAnimItemData *animationData; |
| TAknsItemID animationSkinId = partSpecificThemeId(part); |
| QList<QVariant> list; |
| |
| TRAPD( error, QT_TRYCATCH_LEAVING( |
| animationData = static_cast<CAknsBmpAnimItemData*>(skinInstance->CreateUncachedItemDataL( |
| animationSkinId, EAknsITBmpAnim)))); |
| if (error) |
| return list; |
| |
| if (animationData) { |
| list.append((int)animationData->FrameInterval()); |
| list.append((int)animationData->NumberOfImages()); |
| |
| QS60StyleEnums::AnimationMode playMode; |
| switch(animationData->PlayMode()) { |
| case CBitmapAnimClientData::EPlay: |
| playMode = QS60StyleEnums::AM_PlayOnce; |
| break; |
| case CBitmapAnimClientData::ECycle: |
| playMode = QS60StyleEnums::AM_Looping; |
| break; |
| case CBitmapAnimClientData::EBounce: |
| playMode = QS60StyleEnums::AM_Bounce; |
| break; |
| default: |
| break; |
| } |
| list.append(QVariant((int)playMode)); |
| delete animationData; |
| } else { |
| list.append(0); |
| list.append(0); |
| } |
| return list; |
| } |
| break; |
| default: |
| break; |
| } |
| return QVariant(); |
| } |
| |
| #endif // Q_WS_S60 |
| |
| QT_END_NAMESPACE |
| |
| #endif // QT_NO_STYLE_S60 || QT_PLUGIN |