1 /*

     2  * Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:  CSWVGTargetSurfaceImpl source file

    15  *

    16 */

    17 

    18 #include "swopenvgtargetSurfaceImpl.h"

    19     

    20 #include <platform/vg/vgcontext.h>

    21 

    22 #include <svgtbitmap.h>

    23 

    24 CSWVGTargetSurfaceImpl::CSWVGTargetSurfaceImpl()

    25     {

    26     }

    27 

    28 CSWVGTargetSurfaceImpl::~CSWVGTargetSurfaceImpl()

    29     {

    30     }

    31 

    32 CSWVGTargetSurfaceImpl* CSWVGTargetSurfaceImpl::NewL()

    33     {

    34     CSWVGTargetSurfaceImpl* self = CSWVGTargetSurfaceImpl::NewLC();

    35     CleanupStack::Pop();

    36     return self;

    37     }

    38 

    39 CSWVGTargetSurfaceImpl* CSWVGTargetSurfaceImpl::NewLC()

    40     {

    41     CSWVGTargetSurfaceImpl* self = new (ELeave) CSWVGTargetSurfaceImpl();

    42     CleanupStack::PushL(self);

    43     self->ConstructL();

    44     return self;

    45     }

    46 

    47 inline void CSWVGTargetSurfaceImpl::ConstructL()

    48     {

    49     }

    50 

    51 TInt CSWVGTargetSurfaceImpl::InitializeSurface(TSize aSize, TInt aColorSpace)

    52     {

    53     iSize = aSize;

    54     TInt vgError = ::VGIInitialize(aSize.iWidth,aSize.iHeight, (VGIColorSpace)aColorSpace);

    55     return MapOpenVGErrorToSymbianError(vgError);

    56     }

    57 

    58 void CSWVGTargetSurfaceImpl::SetConfiguration(TInt /*aOption*/, const TAny* /*aValue*/)

    59     {    

    60     }

    61 

    62 TInt CSWVGTargetSurfaceImpl::CreateSurface(TInt /*aDisplayMode*/, RWindow */*aSurface*/, CFbsBitmap */*aBitmap*/)

    63     { 

    64     return KErrNotSupported;

    65     }

    66 

    67 TInt CSWVGTargetSurfaceImpl::CreateSurface(TInt /*aDisplayMode*/, RWindow */*aSurface*/, CSvgtBitmap */*aBitmap*/)

    68     {

    69     return KErrNone;

    70     }

    71 

    72 TInt CSWVGTargetSurfaceImpl::ResizeSurface(TSize aSize)

    73     {

    74     iSize = aSize;

    75     TInt vgError = ::VGIResize(aSize.iWidth,aSize.iHeight);

    76     return MapOpenVGErrorToSymbianError(vgError);

    77     }

    78 

    79 TInt CSWVGTargetSurfaceImpl::CopyBitmap(TInt /*aDisplayMode*/, TInt /*aMaskMode*/, CFbsBitmap */*aBitmap*/, CFbsBitmap */*aMask*/, TSize /*aSize*/)

    80     {

    81     return KErrNotSupported;

    82     }

    83 TInt CSWVGTargetSurfaceImpl::CopyBitmap(TInt /*aDisplayMode*/,TInt /*aMaskMode*/,CSvgtBitmap *aBitmap, CSvgtBitmap *aMask, TSize /*aSize*/)

    84     {

    85     VGIColorBufferFormat format = 

    86             (VGIColorBufferFormat)MapSymbianDisplayModeToOpenVG( (TDisplayMode)aBitmap->DisplayMode() );

    87     

    88     TInt vgError = KErrNone;

    89     if(aMask) 

    90         {

    91         vgError = ::VGICopyToTarget(format, 

    92                     aBitmap->Stride(), aBitmap->BitmapBuffer(), 

    93                     aMask->Stride(), aMask->BitmapBuffer(), 

    94                     VGI_SKIP_TRANSPARENT_PIXELS);

    95         }

    96     else

    97         {

    98         vgError = ::VGICopyToTarget(format, 

    99                     aBitmap->Stride(), aBitmap->BitmapBuffer(), 

   100                     0, NULL, 

   101                     VGI_COPY_TRANSPARENT_PIXELS);

   102         }

   103         

   104     return MapOpenVGErrorToSymbianError(vgError);

   105     }

   106 

   107 TInt CSWVGTargetSurfaceImpl::PrepareToBindClientBuffer()

   108     {

   109     return KErrNone;

   110     }

   111 

   112 TInt CSWVGTargetSurfaceImpl::BindClientBuffer(TInt buffer)

   113     {

   114     return MapOpenVGErrorToSymbianError(::VGIBindToImage(buffer));

   115     }

   116   

   117 TInt CSWVGTargetSurfaceImpl::UnBindClientBuffer()

   118     {

   119     return MapOpenVGErrorToSymbianError(::VGIUnBindImage());

   120     }

   121 

   122 void CSWVGTargetSurfaceImpl::TerminateSurface()

   123     {

   124     ::VGITerminate();

   125     }

   126 

   127 TInt CSWVGTargetSurfaceImpl::MapSymbianDisplayModeToOpenVG( TDisplayMode aMode) const

   128     {

   129     VGIColorBufferFormat format;

   130     switch( aMode )

   131     {

   132     case EColor16MA:

   133         format = VGI_COLOR_BUFFER_FORMAT_ARGB8888;

   134         break;

   135 

   136     case EColor16MU:

   137         format = VGI_COLOR_BUFFER_FORMAT_XRGB8888;

   138         break;

   139 

   140     case EColor16MAP:

   141         format = VGI_COLOR_BUFFER_FORMAT_ARGB8888_PRE;

   142         break;

   143         

   144     case EColor16M:

   145         format = VGI_COLOR_BUFFER_FORMAT_RGB888;

   146         break;

   147 

   148     case EColor64K:

   149         format = VGI_COLOR_BUFFER_FORMAT_RGB565;

   150         break;

   151 

   152     case EColor4K:

   153         format = VGI_COLOR_BUFFER_FORMAT_XRGB4444;

   154         break;

   155 

   156     default:

   157         return KErrNotSupported;

   158     }

   159     return format;

   160     }

   161 

   162 TInt CSWVGTargetSurfaceImpl::MapOpenVGErrorToSymbianError( TInt aError ) const

   163     {

   164     TInt error = KErrNone;

   165     switch (aError)

   166         {

   167         case VGI_OK:

   168             {

   169             error = KErrNone;

   170             break;

   171             }

   172         case VG_OUT_OF_MEMORY_ERROR:

   173         case VGI_ERROR_OUT_OF_MEMORY:

   174             {

   175             error = KErrNoMemory;

   176             break;

   177             }

   178         case VG_ILLEGAL_ARGUMENT_ERROR:

   179         case VGI_ERROR_INVALID_ARGUMENTS:

   180             {

   181             error = KErrArgument;

   182             break;

   183             }

   184         case VGI_ERROR_ALREADY_EXISTS:

   185             {

   186             error = KErrAlreadyExists;

   187             break;

   188             }

   189         case VG_UNSUPPORTED_PATH_FORMAT_ERROR:

   190         case VGI_ERROR_COLORSPACE_NOT_SUPPORTED:

   191         case VG_UNSUPPORTED_IMAGE_FORMAT_ERROR:

   192         case VGI_ERROR_NOT_SUPPORTED:

   193             {

   194             error = KErrNotSupported;

   195             break;

   196             }

   197         case VGI_ERROR_ILLEGAL_IMAGE_HANDLE:

   198             {

   199             error = KErrBadHandle;

   200             break;

   201             }

   202         case VG_IMAGE_IN_USE_ERROR:

   203         case VGI_ERROR_IMAGE_IN_USE:

   204             {

   205             error = KErrInUse;

   206             break;

   207             }

   208         case VGI_ERROR_ILLEGAL_OPERATION:

   209             {

   210             error = KErrPermissionDenied;

   211             break;

   212             }

   213         case VG_BAD_HANDLE_ERROR:

   214         case VG_PATH_CAPABILITY_ERROR:

   215             {

   216             error = KErrUnknown;

   217             break;

   218             }

   219         default:

   220             {

   221             error = KErrUnknown;

   222             }

   223         }

   224 

   225     return error;

   226     }