diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/ServerStub/Proxy_src/AlfAppFwProxy.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/ServerStub/Proxy_src/AlfAppFwProxy.cpp	Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,420 @@
+// Copyright (c) 1997-2009 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:
+
+#include <eiknotapi.h>
+#include <AknUtils.h>
+#include <AknLayoutFont.h>
+#include <AknBidiTextUtils.h>
+#include <AknsUtils.h>
+#include <AknsDrawUtils.h>
+#include <ecom/implementationproxy.h>
+#include <AknsBasicBackgroundControlContext.h>
+#include <AknWsEventObserver.h>
+#include <apgwgnam.h> 
+//#include <aknappui.h> 
+#include "alfappfwproxyops.h"
+#include "huiskinbackroundlayout.h"
+
+// hollow notifier implementation to get access on AppFw inside eikon server
+class CAlfAppFwNotifier : public CBase, public MEikSrvNotifierBase2, public MCoeMessageMonitorObserver	
+    {
+public:    
+    ~CAlfAppFwNotifier()
+        {
+        delete iBitmap;
+        delete iTempSkinBmp;
+        delete iTempMaskBmp;
+        delete iSkinControlContext;
+        }
+    
+    void MonitorWsMessage(const TWsEvent& aEvent)
+        {
+        if (aEvent.Type() == EEventWindowGroupListChanged)
+            {
+            UpdateWgListL();
+            }
+       else if (aEvent.Type() == KEikDynamicLayoutVariantSwitch ||
+                aEvent.Type() == KEikInputLanguageChange)
+           {
+           if (iLayoutMirrored != AknLayoutUtils::LayoutMirrored())
+               {
+               iLayoutMirrored  = AknLayoutUtils::LayoutMirrored();
+               if (iLayoutMirroredMessage.IsNull())
+                    { 
+                    iLayoutMirroredUpdated = ETrue;
+                    }
+               else
+                    {
+                    iLayoutMirroredMessage.Complete(iLayoutMirrored);
+                    iLayoutMirroredUpdated = EFalse;
+                    }      
+                } 
+            }
+        }        
+    
+    CAlfAppFwNotifier(
+        TUid aNotifierUid, 
+        TUid aChannel, 
+        TInt aPriority )
+        : iWsSession(CCoeEnv::Static()->WsSession())
+        {
+        iInfo.iUid = aNotifierUid;
+        iInfo.iChannel= aChannel;
+        iInfo.iPriority = aPriority;
+        *iWgIdArray = -1; // indicates array uninitialized
+        iLayoutMirrored  = AknLayoutUtils::LayoutMirrored();
+        iLayoutMirroredUpdated = ETrue;    
+        CCoeEnv::Static()->AddMessageMonitorObserverL(*this);
+        CCoeEnv::Static()->RootWin().EnableScreenChangeEvents();
+        }        
+   
+public:
+    // from MEikSrvNotifierBase2
+    TPtrC8 UpdateL(const TDesC8&)
+        {
+        return KNullDesC8();
+        }
+   
+   void Cancel()
+        {
+        }
+        
+    void StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)
+        {
+        TInt err = KErrNone;
+        TAlfCommandParams* params =  (TAlfCommandParams*) aBuffer.Ptr();
+        switch (params->iCommand)
+            {
+            case EAlfIsMirrorred:
+                {
+                if (iLayoutMirroredUpdated)
+                    {
+                    aMessage.Complete(iLayoutMirrored);
+                    iLayoutMirroredUpdated = EFalse;
+                    }    
+                else
+                    {            
+                    iLayoutMirroredMessage = aMessage;
+                    }
+                return;    
+                }            
+            case EAlfCbaLocation:
+                {
+                err = AknLayoutUtils::CbaLocation();
+                break;
+                }            
+            case EAlfLayoutMetricsRect:
+                {
+                TRect rect(0,0,0,0);
+                AknLayoutUtils::LayoutMetricsRect((AknLayoutUtils::TAknLayoutMetrics)params->iInt1, rect);
+                TPckgC<TRect> response(rect);
+                err = aMessage.Write(aReplySlot, response);
+                break;
+                }            
+            case EAlfGetCachedColor:
+                {
+                TAknsItemID id;
+                id.iMajor = params->iInt1;
+                id.iMinor = params->iInt2;
+                MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+                TRgb color = KRgbBlack;
+                err = AknsUtils::GetCachedColor(skin, color, id, params->iInt3 );
+                if (!err)
+                    {
+                    TPckgC<TRgb> ret(color);
+                    err = aMessage.Write(aReplySlot, ret);
+                    }
+                break;
+                }
+            case EAlfConvertVisualAndClip:
+                {
+                TUint desLength = aMessage.GetDesMaxLength(aReplySlot);
+                HBufC* replyDes = HBufC::NewLC(desLength/2+1);
+                TPtr ptr = replyDes->Des();                
+                aMessage.Read(aReplySlot, ptr);
+                // ToDo: Wo to get font from client..
+                //CFont font = Use Font spec to get the font??
+                //AknBidiTextUtils::ConvertToVisualAndClipL(ptr, font, params->iInt2, params->iInt3);
+                err = aMessage.Write(aReplySlot, ptr);
+                CleanupStack::PopAndDestroy();
+                break;
+                }
+            case EAlfGetSkinBackgroundBitmap:
+                {
+                TRect dummy;
+                TRect skinRect;
+                TAknsItemID id;
+                
+                id.iMajor = params->iInt1;
+                id.iMinor = params->iInt2;
+                
+                GetRectForItem(id, dummy, skinRect);
+
+                if (!iBitmap)
+                    {
+                    iBitmap = new (ELeave) CFbsBitmap();
+                    User::LeaveIfError( iBitmap->Create(skinRect.Size(), EColor64K) ); // is 64k still valid?        
+                    }
+                
+                User::LeaveIfError(iBitmap->Resize(skinRect.Size()));
+                
+                if (!iSkinControlContext)
+                    {
+                    iSkinControlContext = CAknsBasicBackgroundControlContext::NewL(
+                    KAknsIIDQsnBgScreen, TRect(TPoint(0, 0), CCoeEnv::Static()->ScreenDevice()->SizeInPixels()), ETrue);
+                    }
+                
+                CFbsBitmapDevice* device = CFbsBitmapDevice::NewL(iBitmap);
+                CleanupStack::PushL(device);
+
+                CFbsBitGc* gc = 0;
+                User::LeaveIfError( device->CreateContext(gc) );
+                CleanupStack::PushL(gc);
+                iSkinControlContext->SetRect(skinRect);
+                iSkinControlContext->SetBitmap(id);
+
+                AknsDrawUtils::DrawBackground(AknsUtils::SkinInstance(), iSkinControlContext, NULL, *gc, TPoint(0,0), skinRect,
+                                  KAknsDrawParamDefault);
+
+                CleanupStack::PopAndDestroy(gc);
+                CleanupStack::PopAndDestroy(device);
+                TPckg<TInt> ret(iBitmap->Handle());
+                err = aMessage.Write(aReplySlot, ret);
+                break;
+                }
+            case EAlfGetSkinBitmap:
+                {
+                // local override input params
+                TAlfCommandParams2* params =  (TAlfCommandParams2*) aBuffer.Ptr();                
+                TAknsItemID id;
+                
+                id.iMajor = params->iInt1;
+                id.iMinor = params->iInt2;
+                
+                // recycle ownership through these, assuming synchronized client implementation !!
+                delete iTempSkinBmp;
+                iTempSkinBmp = 0;
+                delete iTempMaskBmp;
+                iTempMaskBmp = 0;
+                
+                TRAP(err, AknsUtils::CreateIconL(	AknsUtils::SkinInstance(), id,
+					                    iTempSkinBmp, iTempMaskBmp, 
+					                    params->iFileName, params->iInt3,params->iInt4));
+
+                if (err == KErrNotFound) // lets retry without mask
+                    { 
+                    delete iTempSkinBmp;
+                    iTempSkinBmp = 0;
+                    delete iTempMaskBmp;
+                    iTempMaskBmp = 0;
+                    // try if we have better luck without mask
+                    AknsUtils::CreateIconL(	AknsUtils::SkinInstance(), id,
+					                    iTempSkinBmp, params->iFileName, params->iInt3);
+
+                    }
+                
+                if (iTempSkinBmp)
+                    {
+                    AknIconUtils::DisableCompression(iTempSkinBmp);
+                    AknIconUtils::SetSize( iTempSkinBmp, params->iSize, params->iScaleMode );    
+                    }
+                
+                if (iTempMaskBmp)
+                    {
+                    AknIconUtils::DisableCompression(iTempSkinBmp);
+                    AknIconUtils::SetSize( iTempMaskBmp, params->iSize, params->iScaleMode );    
+                    }
+                        
+                TInt2 ret;
+                ret.iInt1 = iTempSkinBmp->Handle();
+                ret.iInt2 = iTempMaskBmp?iTempMaskBmp->Handle():0;
+                TPckg<TInt2> retp = ret;
+                err = aMessage.Write(aReplySlot, retp);
+                break;
+                }
+            case EGetCachedSkinItemData:
+                {
+                TAknsItemID id;
+                
+                id.iMajor = params->iInt1;
+                id.iMinor = params->iInt2;
+                
+                TAlfCachedSkinItemArray array;
+                array.iCount = 0;
+                CAknsItemData* data = AknsUtils::SkinInstance()->CreateUncachedItemDataL( id, (TAknsItemType)params->iInt3 );
+                
+                if (data)
+                    {
+                    CAknsImageTableItemData* itdata = static_cast<CAknsImageTableItemData*>(data);    
+                    array.iCount = Min(9, itdata->NumberOfImages());   
+                    for(TInt i = 0; i<array.iCount;i++)
+                        {
+                        array.iImages[i] = itdata->ImageIID(i);
+                        } 
+                    delete data;        
+                    }
+                TPckgC<TAlfCachedSkinItemArray> retp(array);
+                err = aMessage.Write(aReplySlot, retp);
+                break;
+                }
+            
+            case EGetListOfWindowGroups:
+                {
+                if (*iWgIdArray == -1) // uninitialized  
+                    {
+                    CCoeEnv::Static()->RootWin().EnableGroupListChangeEvents();
+                    UpdateWgListL();
+                    }
+                
+                if (*iWgIdArray != 0)
+                    { // updated array exists, return it
+                    CompleteWgListMessage(aMessage, aReplySlot);
+                    }
+                else
+                    { // let messages wait for updates
+                    iWgMessage = aMessage;
+                    iWgReplySlot = aReplySlot;            
+                    }
+                
+                return; // message completed asynchronously
+                }    
+                
+
+            default:
+                {
+                err = KErrNotSupported;
+                break;
+                }
+            }
+        aMessage.Complete(err);
+        }
+            
+    TPtrC8 StartL(const TDesC8&)
+        { 
+        return KNullDesC8();
+        }
+        
+   MEikSrvNotifierBase2::TNotifierInfo Info() const        
+        {
+        return iInfo;
+        }
+        
+   MEikSrvNotifierBase2::TNotifierInfo RegisterL()
+        {
+        return iInfo;
+        }
+
+   void Release()
+        {
+        delete this;
+        }    
+
+    void UpdateWgListL()
+        {
+        TInt wgId=0;
+        const TInt count=iWsSession.NumWindowGroups();
+        if (count)
+            {
+            TInt* ptr = iWgIdArray;    
+            Mem::FillZ(iWgIdArray,160);
+            CArrayFixFlat<TInt>* wgIdArray=new(ELeave) CArrayFixFlat<TInt>(count);
+            CleanupStack::PushL(wgIdArray);
+            CApaWindowGroupName* wgName=CApaWindowGroupName::NewL(iWsSession);
+            CleanupStack::PushL(wgName);
+            User::LeaveIfError(iWsSession.WindowGroupList(wgIdArray)); // all groups
+            iWgEntriesWritten = 0;
+            for (TInt ii=0; ii < count-1; ii++)
+                { 
+                wgId=(*wgIdArray)[ii];
+                wgName->ConstructFromWgIdL(wgId);
+                if(!wgName->Hidden() && wgName->AppUid().iUid) // lets skip the hidden groups  and groups w/o AppUid at the time being
+                    {
+                    *ptr = wgId;
+                    ptr++;
+                    *ptr = wgName->AppUid().iUid;
+                    ptr++;                           
+                    iWgEntriesWritten++;
+                    }
+                if (iWgEntriesWritten == 20) // magic, interim patch until we have better way to pair wg ids & clien app uids
+                    {
+                    break;
+                    }    
+                }
+            CleanupStack::PopAndDestroy(2); // wgIdArray, wgName
+            if (iWgIdArray[0] && !iWgMessage.IsNull())
+                {
+                CompleteWgListMessage(iWgMessage, iWgReplySlot);
+                }
+            }
+        }
+    
+    void CompleteWgListMessage(const RMessagePtr2& aMessage, TInt aReplySlot)
+        {
+        if (Mem::Compare((TUint8*)iWgIdArray, 8*iWgEntriesWritten, (TUint8*)iWgIdArray2,8*iWgEntriesWritten))
+            {
+            TPtrC8 ret((TUint8*)iWgIdArray, 160);   
+            if (!aMessage.IsNull())
+                {
+                TInt err = aMessage.Write(aReplySlot, ret);
+                aMessage.Complete(err);
+                }
+            Mem::Copy((TUint8*)iWgIdArray2, (TUint8*)iWgIdArray,160);
+            }
+        Mem::FillZ(iWgIdArray, 160);
+        }
+        
+private:
+    MEikSrvNotifierBase2::TNotifierInfo iInfo;
+    CFbsBitmap* iBitmap;
+    CFbsBitmap* iTempSkinBmp;
+    CFbsBitmap* iTempMaskBmp;
+    CAknsBasicBackgroundControlContext* iSkinControlContext;
+    TInt iWgIdArray[40]; // magic, cool
+    TInt iWgIdArray2[40]; // magic, cool
+    RMessagePtr2 iWgMessage;
+    TInt iWgReplySlot;
+    RWsSession& iWsSession;
+    TUint iWgEntriesWritten;
+    RMessagePtr2 iLayoutMirroredMessage;
+    TBool iLayoutMirrored;
+    TBool iLayoutMirroredUpdated;
+    };
+
+CArrayPtr<MEikSrvNotifierBase2>* NotifierArray()
+    {
+    CArrayPtrFlat<MEikSrvNotifierBase2>* array = new CArrayPtrFlat<MEikSrvNotifierBase2>(1);
+    if ( array )
+        {
+        CAlfAppFwNotifier* notif = new CAlfAppFwNotifier(TUid::Uid(KAlfAppFwProxyUid),TUid::Uid(KAlfAppFwProxyUid), MEikSrvNotifierBase2::ENotifierPriorityHigh); 
+        if ( notif )
+            {
+            TRAP_IGNORE(array->AppendL(notif));  // we have reserver granularity of one already
+            }
+        }
+    return array;
+    }
+    
+
+const TImplementationProxy ImplementationTable[] =
+    {
+    IMPLEMENTATION_PROXY_ENTRY(KAlfAppFwProxyUid,NotifierArray)
+    };
+ 
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+    {
+    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy) ;
+    return ImplementationTable;
+    }
+    
+// end of file