1 /*

     2 * Copyright (c) 2004-2008 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:  Alpha Blend provides functionality to combine masked images with

    15 *                Porter-Duff operations.

    16 *

    17 */

    18 

    19 

    20 // INCLUDE FILES

    21 #include "AknsRlEffectPluginAlphaBlend.h"

    22 #include "AknsRlEffectUtil.h"

    23 #include "AknsRlExpand.h"

    24 

    25 // =================== INTERNAL IMPL. OF ALPHA BLEND ===========================

    26 

    27 // "clean" Porter-Duff alpha blend implementation for reference

    28 //TUint8 AknsRlAlphaBlend::Blend( const TAknsRlAlphaBlendMode aMode,

    29 //                                const TUint8 aColorA,

    30 //                                const TUint8 aAlphaA,

    31 //                                const TUint8 aColorB,

    32 //                                const TUint8 aAlphaB )

    33 //    {

    34 //    TInt colorA = (aAlphaA * aColorA) >> 8;

    35 //    TInt colorB = (aAlphaB * aColorB) >> 8;

    36 //

    37 //    // No need to do clamping, results are always in range [0, 255]

    38 //    switch(aMode)

    39 //        {

    40 //        case EAknsRlAlphaBlendAOverB:

    41 //            return TUint8( colorA + ((colorB * (255 - aAlphaA)) >> 8) );

    42 //        case EAknsRlAlphaBlendBOverA:

    43 //            return TUint8( ((colorA * (255 - aAlphaB)) >> 8) + colorB );

    44 //        case EAknsRlAlphaBlendAInB:

    45 //            return TUint8( (colorA * aAlphaB) >> 8 );

    46 //        case EAknsRlAlphaBlendBInA:

    47 //            return TUint8( (colorB * aAlphaA) >> 8 );

    48 //        case EAknsRlAlphaBlendAOutB:

    49 //            return TUint8( (colorA * (255 - aAlphaB)) >> 8 );

    50 //        case EAknsRlAlphaBlendBOutA:

    51 //            return TUint8( (colorB * (255 - aAlphaA)) >> 8 );

    52 //        case EAknsRlAlphaBlendAAtopB:

    53 //            return TUint8( (colorA * (aAlphaB) + colorB * (255 - aAlphaA)) >> 8 );

    54 //        case EAknsRlAlphaBlendBAtopA:

    55 //            return TUint8( (colorA * (255 - aAlphaB) + colorB * (aAlphaA)) >> 8 );

    56 //        case EAknsRlAlphaBlendAXorB:

    57 //            return TUint8( (colorA * (255 - aAlphaB) + colorB * (255 - aAlphaA)) >> 8 );

    58 //        default:

    59 //            break;

    60 //        }

    61 //

    62 //    return 0;

    63 //    }

    64 

    65 /**

    66 * Template implementation of AlphaBlend. Pitch is the number of data elements

    67 * to skip before moving to next line. The next parameters are passed to blend

    68 * functions:

    69 * aW      Bitmap width in pixels

    70 * aH      Bitmap height in pixels

    71 * aT      Target bitmap data address

    72 * aPT     Target bitmap scanline pitch

    73 * aA      Source bitmap A data address

    74 * aPA     Source bitmap A scanline pitch

    75 * aMA     Source bitmap A mask data address

    76 * aPMA    Source bitmap A mask scanline pitch

    77 * aB      Source bitmap B data address

    78 * aPB     Source bitmap B scanline pitch

    79 * aMB     Source bitmap B mask data address

    80 * aPMA    Source bitmap B mask scanline pitch

    81 *

    82 * Inside methods local variables have the following roles:

    83 * x   The current pixel's x position

    84 * y   The current pixel's y position

    85 * r   The resulting red color component

    86 * g   The resulting green color component

    87 * b   The resulting blue color component

    88 * sa  Currently processed source A color component

    89 * sb  Currently processed source B color component

    90 * ma  Mask A value for current pixel position

    91 * mb  Mask B value for current pixel position

    92 * ca  A RGB color value for current pixel position

    93 * cb  B RGB color value for current pixel position

    94 */

    95 template <class T, TInt X, TInt R, TInt G, TInt B>

    96 class AknsRlAlpha

    97     {

    98     public:

    99 

   100     static void AoverB( TInt aW, TInt aH, T* aT, TInt aPT,

   101                         const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   102                         const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   103 

   104     static void BoverA( TInt aW, TInt aH, T* aT, TInt aPT,

   105                         const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   106                         const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   107 

   108     // Bitmap B is not accessed -> aB and aPB not required

   109     static void AinB( TInt aW, TInt aH, T* aT, TInt aPT,

   110                       const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   111                       const TUint8* aMB, TInt aPMB );

   112 

   113     // Bitmap A is not accessed -> aA and aPA not required

   114     static void BinA( TInt aW, TInt aH, T* aT, TInt aPT,

   115                       const TUint8* aMA, TInt aPMA,

   116                       const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   117 

   118     // Bitmap B is not accessed -> aB and aPB not required

   119     static void AoutB( TInt aW, TInt aH, T* aT, TInt aPT,

   120                        const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   121                        const TUint8* aMB, TInt aPMB );

   122 

   123     // Bitmap A is not accessed -> aA and aPA not required

   124     static void BoutA( TInt aW, TInt aH, T* aT, TInt aPT,

   125                        const TUint8* aMA, TInt aPMA,

   126                        const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   127 

   128     static void AatopB( TInt aW, TInt aH, T* aT, TInt aPT,

   129                         const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   130                         const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   131 

   132     static void BatopA( TInt aW, TInt aH, T* aT, TInt aPT,

   133                         const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   134                         const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   135 

   136     static void AxorB( TInt aW, TInt aH, T* aT, TInt aPT,

   137                        const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   138                        const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   139     }; // End of AknsRlAlpha

   140 

   141 // -----------------------------------------------------------------------------

   142 // AknsRlAlpha::AoverB

   143 // -----------------------------------------------------------------------------

   144 //

   145 template <class T, TInt X, TInt R, TInt G, TInt B>

   146 void AknsRlAlpha<T,X,R,G,B>::AoverB( TInt aW, TInt aH, T* aT, TInt aPT,

   147                                      const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   148                                      const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   149     {

   150     TInt x, y;

   151     TUint r, g, b, sa, sb, ma, mb, ca, cb;

   152     for( y= 0; y < aH; y++ )

   153         {

   154         for( x=0; x < aW; x++ )

   155             {

   156             ma = *aMA; mb = *aMB; ca = *aA; cb = *aB;

   157 

   158             sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

   159             sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

   160             r = sa + ((sb * (255 - ma)) >> 8);

   161 

   162             sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

   163             sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

   164             g = sa + ((sb * (255 - ma)) >> 8);

   165 

   166             sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

   167             sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

   168             b = sa + ((sb * (255 - ma)) >> 8);

   169 

   170             AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

   171 

   172             aT++; aA++; aMA++; aB++; aMB++;

   173             }

   174 

   175         aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

   176         }

   177     }

   178 

   179 // -----------------------------------------------------------------------------

   180 // AknsRlAlpha::BoverA

   181 // -----------------------------------------------------------------------------

   182 //

   183 template <class T, TInt X, TInt R, TInt G, TInt B>

   184 void AknsRlAlpha<T,X,R,G,B>::BoverA( TInt aW, TInt aH, T* aT, TInt aPT,

   185                                      const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   186                                      const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   187     {

   188     TInt x, y;

   189     TUint r, g, b, sa, sb, ma, mb, ca, cb;

   190     for( y= 0; y < aH; y++ )

   191         {

   192         for( x=0; x < aW; x++ )

   193             {

   194             ma = *aMA; mb = *aMB; ca = *aA; cb = *aB;

   195 

   196             sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

   197             sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

   198             r = sb + ((sa * (255 - mb)) >> 8);

   199 

   200             sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

   201             sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

   202             g = sb + ((sa * (255 - mb)) >> 8);

   203 

   204             sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

   205             sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

   206             b = sb + ((sa * (255 - mb)) >> 8);

   207 

   208             AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

   209 

   210             aT++; aA++; aMA++; aB++; aMB++;

   211             }

   212 

   213         aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

   214         }

   215     }

   216 

   217 // -----------------------------------------------------------------------------

   218 // AknsRlAlpha::AinB

   219 // -----------------------------------------------------------------------------

   220 //

   221 template <class T, TInt X, TInt R, TInt G, TInt B>

   222 void AknsRlAlpha<T,X,R,G,B>::AinB( TInt aW, TInt aH, T* aT, TInt aPT,

   223                                    const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   224                                    const TUint8* aMB, TInt aPMB )

   225     {

   226     TInt x, y;

   227     TUint r, g, b, sa, ma, mb, ca;

   228     for( y= 0; y < aH; y++ )

   229         {

   230         for( x=0; x < aW; x++ )

   231             {

   232             ma = *aMA; mb = *aMB; ca = *aA;

   233 

   234             sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

   235             r = (sa * mb) >> 8;

   236 

   237             sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

   238             g = (sa * mb) >> 8;

   239 

   240             sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

   241             b = (sa * mb) >> 8;

   242 

   243             AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

   244 

   245             aT++; aA++; aMA++; aMB++;

   246             }

   247 

   248         aT += aPT; aA += aPA; aMA += aPMA; aMB += aPMB;

   249         }

   250     }

   251 

   252 // -----------------------------------------------------------------------------

   253 // AknsRlAlpha::BinA

   254 // -----------------------------------------------------------------------------

   255 //

   256 template <class T, TInt X, TInt R, TInt G, TInt B>

   257 void AknsRlAlpha<T,X,R,G,B>::BinA( TInt aW, TInt aH, T* aT, TInt aPT,

   258                                    const TUint8* aMA, TInt aPMA,

   259                                    const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   260     {

   261     TInt x, y;

   262     TUint r, g, b, sb, ma, mb, cb;

   263     for( y= 0; y < aH; y++ )

   264         {

   265         for( x=0; x < aW; x++ )

   266             {

   267             ma = *aMA; mb = *aMB; cb = *aB;

   268 

   269             sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

   270             r = (sb * ma) >> 8;

   271 

   272             sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

   273             g = (sb * ma) >> 8;

   274 

   275             sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

   276             b = (sb * ma) >> 8;

   277 

   278             AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

   279 

   280             aT++; aMA++; aB++; aMB++;

   281             }

   282 

   283         aT += aPT; aMA += aPMA; aB += aPB; aMB += aPMB;

   284         }

   285     }

   286 

   287 // -----------------------------------------------------------------------------

   288 // AknsRlAlpha::AoutB

   289 // -----------------------------------------------------------------------------

   290 //

   291 template <class T, TInt X, TInt R, TInt G, TInt B>

   292 void AknsRlAlpha<T,X,R,G,B>::AoutB( TInt aW, TInt aH, T* aT, TInt aPT,

   293                                     const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   294                                     const TUint8* aMB, TInt aPMB )

   295     {

   296     TInt x, y;

   297     TUint r, g, b, sa, ma, mb, ca;

   298     for( y= 0; y < aH; y++ )

   299         {

   300         for( x=0; x < aW; x++ )

   301             {

   302             ma = *aMA; mb = *aMB; ca = *aA;

   303 

   304             sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

   305             r = (sa * (255 - mb)) >> 8;

   306 

   307             sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

   308             g = (sa * (255 - mb)) >> 8;

   309 

   310             sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

   311             b = (sa * (255 - mb)) >> 8;

   312 

   313             AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

   314 

   315             aT++; aA++; aMA++; aMB++;

   316             }

   317 

   318         aT += aPT; aA += aPA; aMA += aPMA; aMB += aPMB;

   319         }

   320     }

   321 

   322 // -----------------------------------------------------------------------------

   323 // AknsRlAlpha::BoutA

   324 // -----------------------------------------------------------------------------

   325 //

   326 template <class T, TInt X, TInt R, TInt G, TInt B>

   327 void AknsRlAlpha<T,X,R,G,B>::BoutA( TInt aW, TInt aH, T* aT, TInt aPT,

   328                                     const TUint8* aMA, TInt aPMA,

   329                                     const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   330     {

   331     TInt x, y;

   332     TUint r, g, b, sb, ma, mb, cb;

   333     for( y= 0; y < aH; y++ )

   334         {

   335         for( x=0; x < aW; x++ )

   336             {

   337             ma = *aMA; mb = *aMB; cb = *aB;

   338 

   339             sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

   340             r = (sb * (255 - ma)) >> 8;

   341 

   342             sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

   343             g = (sb * (255 - ma)) >> 8;

   344 

   345             sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

   346             b = (sb * (255 - ma)) >> 8;

   347 

   348             AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

   349 

   350             aT++; aMA++; aB++; aMB++;

   351             }

   352 

   353         aT += aPT; aMA += aPMA; aB += aPB; aMB += aPMB;

   354         }

   355     }

   356 

   357 // -----------------------------------------------------------------------------

   358 // AknsRlAlpha::AatopB

   359 // -----------------------------------------------------------------------------

   360 //

   361 template <class T, TInt X, TInt R, TInt G, TInt B>

   362 void AknsRlAlpha<T,X,R,G,B>::AatopB( TInt aW, TInt aH, T* aT, TInt aPT,

   363                                      const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   364                                      const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   365     {

   366     TInt x, y;

   367     TUint r, g, b, sa, sb, ma, mb, ca, cb;

   368     for( y= 0; y < aH; y++ )

   369         {

   370         for( x=0; x < aW; x++ )

   371             {

   372             ma = *aMA; mb = *aMB; ca = *aA; cb = *aB;

   373 

   374             sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

   375             sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

   376             r = (sa * mb + sb * (255 - ma)) >> 8;

   377 

   378             sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

   379             sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

   380             g = (sa * mb + sb * (255 - ma)) >> 8;

   381 

   382             sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

   383             sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

   384             b = (sa * mb + sb * (255 - ma)) >> 8;

   385 

   386             AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

   387 

   388             aT++; aA++; aMA++; aB++; aMB++;

   389             }

   390 

   391         aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

   392         }

   393     }

   394 

   395 // -----------------------------------------------------------------------------

   396 // AknsRlAlpha::BatopA

   397 // -----------------------------------------------------------------------------

   398 //

   399 template <class T, TInt X, TInt R, TInt G, TInt B>

   400 void AknsRlAlpha<T,X,R,G,B>::BatopA( TInt aW, TInt aH, T* aT, TInt aPT,

   401                                      const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   402                                      const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   403     {

   404     TInt x, y;

   405     TUint r, g, b, sa, sb, ma, mb, ca, cb;

   406     for( y= 0; y < aH; y++ )

   407         {

   408         for( x=0; x < aW; x++ )

   409             {

   410             ma = *aMA; mb = *aMB; ca = *aA; cb = *aB;

   411 

   412             sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

   413             sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

   414             r = (sa * (255 - mb) + sb * ma) >> 8;

   415 

   416             sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

   417             sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

   418             g = (sa * (255 - mb) + sb * ma) >> 8;

   419 

   420             sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

   421             sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

   422             b = (sa * (255 - mb) + sb * ma) >> 8;

   423 

   424             AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

   425 

   426             aT++; aA++; aMA++; aB++; aMB++;

   427             }

   428 

   429         aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

   430         }

   431     }

   432 

   433 // -----------------------------------------------------------------------------

   434 // AknsRlAlpha::AxorB

   435 // -----------------------------------------------------------------------------

   436 //

   437 template <class T, TInt X, TInt R, TInt G, TInt B>

   438 void AknsRlAlpha<T,X,R,G,B>::AxorB( TInt aW, TInt aH, T* aT, TInt aPT,

   439                                     const T* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   440                                     const T* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   441     {

   442     TInt x, y;

   443     TUint r, g, b, sa, sb, ma, mb, ca, cb;

   444     for( y= 0; y < aH; y++ )

   445         {

   446         for( x=0; x < aW; x++ )

   447             {

   448             ma = *aMA; mb = *aMB; ca = *aA; cb = *aB;

   449 

   450             sa = (ma * AknsRlRgb<T,X,R,G,B>::R8(ca)) >> 8;

   451             sb = (mb * AknsRlRgb<T,X,R,G,B>::R8(cb)) >> 8;

   452             r = (sa * (255 - mb) + sb * (255 - ma)) >> 8;

   453 

   454             sa = (ma * AknsRlRgb<T,X,R,G,B>::G8(ca)) >> 8;

   455             sb = (mb * AknsRlRgb<T,X,R,G,B>::G8(cb)) >> 8;

   456             g = (sa * (255 - mb) + sb * (255 - ma)) >> 8;

   457 

   458             sa = (ma * AknsRlRgb<T,X,R,G,B>::B8(ca)) >> 8;

   459             sb = (mb * AknsRlRgb<T,X,R,G,B>::B8(cb)) >> 8;

   460             b = (sa * (255 - mb) + sb * (255 - ma)) >> 8;

   461 

   462             AknsRlRgb<T,X,R,G,B>::SetRgb8( aT, r, g, b );

   463 

   464             aT++; aA++; aMA++; aB++; aMB++;

   465             }

   466 

   467         aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

   468         }

   469     }

   470 

   471 // ============== INTERNAL IMPL. OF GRAYSCALE ALPHA BLEND ======================

   472 /**

   473 * See RGB implementation above for comments.

   474 */

   475 NONSHARABLE_CLASS(AknsRlAlphaGray)

   476     {

   477     public:

   478 

   479     static void AoverB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   480                         const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   481                         const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   482 

   483     static void BoverA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   484                         const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   485                         const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   486 

   487     static void AinB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   488                       const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   489                       const TUint8* aMB, TInt aPMB );

   490 

   491     static void BinA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   492                       const TUint8* aMA, TInt aPMA,

   493                       const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   494 

   495     static void AoutB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   496                        const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   497                        const TUint8* aMB, TInt aPMB );

   498 

   499     static void BoutA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   500                        const TUint8* aMA, TInt aPMA,

   501                        const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   502 

   503     static void AatopB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   504                         const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   505                         const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   506 

   507     static void BatopA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   508                         const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   509                         const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   510 

   511     static void AxorB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   512                        const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   513                        const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB );

   514 

   515     }; // End of AknsRlAlphaGray

   516 

   517 // -----------------------------------------------------------------------------

   518 // AknsRlAlphaGray::AoverB

   519 // -----------------------------------------------------------------------------

   520 //

   521 void AknsRlAlphaGray::AoverB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   522                               const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   523                               const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   524     {

   525     TInt x, y, ca;

   526     TUint cb;

   527     for( y= 0; y < aH; y++ )

   528         {

   529         for( x=0; x < aW; x++ )

   530             {

   531             ca = ((*aMA) * (*aA)) >> 8;

   532             cb = ((*aMB) * (*aB)) >> 8;

   533             *aT = ca + ((cb * (255 - (*aMA))) >> 8);

   534             aT++; aA++; aMA++; aB++; aMB++;

   535             }

   536 

   537         aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

   538         }

   539     }

   540 

   541 // -----------------------------------------------------------------------------

   542 // AknsRlAlphaGray::BoverA

   543 // -----------------------------------------------------------------------------

   544 //

   545 void AknsRlAlphaGray::BoverA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   546                               const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   547                               const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   548     {

   549     TInt x, y;

   550     TUint ca, cb;

   551     for( y= 0; y < aH; y++ )

   552         {

   553         for( x=0; x < aW; x++ )

   554             {

   555             ca = ((*aMA) * (*aA)) >> 8;

   556             cb = ((*aMB) * (*aB)) >> 8;

   557             *aT = cb + ((ca * (255 - (*aMB))) >> 8);

   558             aT++; aA++; aMA++; aB++; aMB++;

   559             }

   560 

   561         aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

   562         }

   563     }

   564 

   565 // -----------------------------------------------------------------------------

   566 // AknsRlAlphaGray::AinB

   567 // -----------------------------------------------------------------------------

   568 //

   569 void AknsRlAlphaGray::AinB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   570                             const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   571                             const TUint8* aMB, TInt aPMB )

   572     {

   573     TInt x, y;

   574     TUint ca;

   575     for( y= 0; y < aH; y++ )

   576         {

   577         for( x=0; x < aW; x++ )

   578             {

   579             ca = ((*aMA) * (*aA)) >> 8;

   580             *aT = (ca * (*aMB)) >> 8;

   581             aT++; aA++; aMA++; aMB++;

   582             }

   583 

   584         aT += aPT; aA += aPA; aMA += aPMA; aMB += aPMB;

   585         }

   586     }

   587 

   588 // -----------------------------------------------------------------------------

   589 // AknsRlAlphaGray::BinA

   590 // -----------------------------------------------------------------------------

   591 //

   592 void AknsRlAlphaGray::BinA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   593                             const TUint8* aMA, TInt aPMA,

   594                             const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   595     {

   596     TInt x, y;

   597     TUint cb;

   598     for( y= 0; y < aH; y++ )

   599         {

   600         for( x=0; x < aW; x++ )

   601             {

   602             cb = ((*aMB) * (*aB)) >> 8;

   603             *aT = (cb * (*aMA)) >> 8;

   604             aT++; aMA++; aB++; aMB++;

   605             }

   606 

   607         aT += aPT; aMA += aPMA; aB += aPB; aMB += aPMB;

   608         }

   609     }

   610 

   611 // -----------------------------------------------------------------------------

   612 // AknsRlAlphaGray::AoutB

   613 // -----------------------------------------------------------------------------

   614 //

   615 void AknsRlAlphaGray::AoutB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   616                              const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   617                              const TUint8* aMB, TInt aPMB )

   618     {

   619     TInt x, y;

   620     TUint ca;

   621     for( y= 0; y < aH; y++ )

   622         {

   623         for( x=0; x < aW; x++ )

   624             {

   625             ca = ((*aMA) * (*aA)) >> 8;

   626             *aT = (ca * (255 - (*aMB))) >> 8;

   627             aT++; aA++; aMA++; aMB++;

   628             }

   629 

   630         aT += aPT; aA += aPA; aMA += aPMA; aMB += aPMB;

   631         }

   632     }

   633 

   634 // -----------------------------------------------------------------------------

   635 // AknsRlAlphaGray::BoutA

   636 // -----------------------------------------------------------------------------

   637 //

   638 void AknsRlAlphaGray::BoutA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   639                              const TUint8* aMA, TInt aPMA,

   640                              const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   641     {

   642     TInt x, y;

   643     TUint cb;

   644     for( y= 0; y < aH; y++ )

   645         {

   646         for( x=0; x < aW; x++ )

   647             {

   648             cb = ((*aMB) * (*aB)) >> 8;

   649             *aT = (cb * (255 - (*aMA))) >> 8;

   650             aT++; aMA++; aB++; aMB++;

   651             }

   652 

   653         aT += aPT; aMA += aPMA; aB += aPB; aMB += aPMB;

   654         }

   655     }

   656 

   657 // -----------------------------------------------------------------------------

   658 // AknsRlAlphaGray::AatopB

   659 // -----------------------------------------------------------------------------

   660 //

   661 void AknsRlAlphaGray::AatopB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   662                               const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   663                               const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   664     {

   665     TInt x, y;

   666     TUint ca, cb;

   667     for( y= 0; y < aH; y++ )

   668         {

   669         for( x=0; x < aW; x++ )

   670             {

   671             ca = ((*aMA) * (*aA)) >> 8;

   672             cb = ((*aMB) * (*aB)) >> 8;

   673             *aT = (ca * (*aMB) + cb * (255 - (*aMA))) >> 8;

   674             aT++; aA++; aMA++; aB++; aMB++;

   675             }

   676 

   677         aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

   678         }

   679     }

   680 

   681 // -----------------------------------------------------------------------------

   682 // AknsRlAlphaGray::BatopA

   683 // -----------------------------------------------------------------------------

   684 //

   685 void AknsRlAlphaGray::BatopA( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   686                               const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   687                               const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   688     {

   689     TInt x, y;

   690     TUint ca, cb;

   691     for( y= 0; y < aH; y++ )

   692         {

   693         for( x=0; x < aW; x++ )

   694             {

   695             ca = ((*aMA) * (*aA)) >> 8;

   696             cb = ((*aMB) * (*aB)) >> 8;

   697             *aT = (ca * (255 - (*aMB)) + cb * (*aMA)) >> 8;

   698             aT++; aA++; aMA++; aB++; aMB++;

   699             }

   700 

   701         aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

   702         }

   703     }

   704 

   705 // -----------------------------------------------------------------------------

   706 // AknsRlAlphaGray::AxorB

   707 // -----------------------------------------------------------------------------

   708 //

   709 void AknsRlAlphaGray::AxorB( TInt aW, TInt aH, TUint8* aT, TInt aPT,

   710                              const TUint8* aA, TInt aPA, const TUint8* aMA, TInt aPMA,

   711                              const TUint8* aB, TInt aPB, const TUint8* aMB, TInt aPMB )

   712     {

   713     TInt x, y;

   714     TUint ca, cb;

   715     for( y= 0; y < aH; y++ )

   716         {

   717         for( x=0; x < aW; x++ )

   718             {

   719             ca = ((*aMA) * (*aA)) >> 8;

   720             cb = ((*aMB) * (*aB)) >> 8;

   721             *aT = (ca * (255 - (*aMB)) + cb * (255 - (*aMA))) >> 8;

   722             aT++; aA++; aMA++; aB++; aMB++;

   723             }

   724 

   725         aT += aPT; aA += aPA; aMA += aPMA; aB += aPB; aMB += aPMB;

   726         }

   727     }

   728 

   729 // ============================ MEMBER FUNCTIONS ===============================

   730 

   731 // -----------------------------------------------------------------------------

   732 // CAknsRlEffectPluginAlphaBlend::CAknsRlEffectPluginAlphaBlend

   733 // C++ default constructor can NOT contain any code, that

   734 // might leave.

   735 // -----------------------------------------------------------------------------

   736 //

   737 CAknsRlEffectPluginAlphaBlend::CAknsRlEffectPluginAlphaBlend()

   738     {

   739     }

   740 

   741 // -----------------------------------------------------------------------------

   742 // Destructor

   743 // -----------------------------------------------------------------------------

   744 //

   745 CAknsRlEffectPluginAlphaBlend::~CAknsRlEffectPluginAlphaBlend()

   746     {

   747     iContext = NULL; // Removes lint nag

   748     delete iScans; //lint !e1551 No exception thrown

   749     }

   750 

   751 // -----------------------------------------------------------------------------

   752 // CAknsRlEffectPluginAlphaBlend::EffectUid

   753 // -----------------------------------------------------------------------------

   754 //

   755 TUid CAknsRlEffectPluginAlphaBlend::EffectUid() const

   756     {

   757     return TUid::Uid( KAknsRlEffectPluginAlphaBlendUID );

   758     }

   759 

   760 // -----------------------------------------------------------------------------

   761 // CAknsRlEffectPluginAlphaBlend::Effect

   762 // -----------------------------------------------------------------------------

   763 //

   764 MAknsRlEffect* CAknsRlEffectPluginAlphaBlend::Effect( const TInt aInterface )

   765     {

   766     if( aInterface == KAknsRlEffectPluginInterfaceEffect )

   767         return this;

   768     return NULL;

   769     }

   770 

   771 // -----------------------------------------------------------------------------

   772 // CAknsRlEffectPluginAlphaBlend::InitializeL

   773 // -----------------------------------------------------------------------------

   774 //

   775 void CAknsRlEffectPluginAlphaBlend::InitializeL()

   776     {

   777     iContext = NULL;

   778 

   779     delete iScans;

   780     iScans = NULL;

   781 

   782     iScans = CAknsRlScanlines::NewL();

   783     }

   784 

   785 // -----------------------------------------------------------------------------

   786 // CAknsRlEffectPluginAlphaBlend::Release

   787 // -----------------------------------------------------------------------------

   788 //

   789 void CAknsRlEffectPluginAlphaBlend::Release()

   790     {

   791     delete iScans;

   792     iScans = NULL;

   793     }

   794 

   795 // -----------------------------------------------------------------------------

   796 // CAknsRlEffectPluginAlphaBlend::ActivateL

   797 // -----------------------------------------------------------------------------

   798 //

   799 void CAknsRlEffectPluginAlphaBlend::ActivateL( MAknsRlEffectContext* aContext )

   800     {

   801     if( !aContext ) // We absolutely need the context

   802         {

   803         User::Leave( KErrArgument );

   804         }

   805 

   806     iContext = aContext;

   807 

   808     iFlags = 0;

   809 

   810     iBlendMode = EAknsRlAlphaBlendAOverB;

   811 

   812     iARed   = 255;

   813     iAGreen = 255;

   814     iABlue  = 255;

   815 

   816     iBRed   = 255;

   817     iBGreen = 255;

   818     iBBlue  = 255;

   819 

   820     iAMask  = 255;

   821     iBMask  = 255;

   822     }

   823 

   824 // -----------------------------------------------------------------------------

   825 // CAknsRlEffectPluginAlphaBlend::Deactivate

   826 // -----------------------------------------------------------------------------

   827 //

   828 void CAknsRlEffectPluginAlphaBlend::Deactivate()

   829     {

   830     iContext = NULL;

   831     }

   832 

   833 // -----------------------------------------------------------------------------

   834 // CAknsRlEffectPluginAlphaBlend::SetParametersL

   835 // -----------------------------------------------------------------------------

   836 //

   837 void CAknsRlEffectPluginAlphaBlend::SetParametersL( MAknsRlParameterIterator& aParameters )

   838     {

   839     // Iterate over available parameters

   840     while( aParameters.HasNext() )

   841         {

   842         const TAknsRlParameterData* param = aParameters.NextL();

   843 

   844         // Fetch blend mode values

   845         if( param->iName->Compare( KAknsRlEffectAlphaBlendMode ) == 0 )

   846             {

   847             if( param->iType != EAknsRlParameterTypeNumber )

   848                 User::Leave( KErrArgument );

   849 

   850             if( param->iNumber < EAknsRlAlphaBlendAOverB ||

   851                 param->iNumber > EAknsRlAlphaBlendAXorB )

   852                 User::Leave( KErrArgument );

   853 

   854             iBlendMode = TUint8( param->iNumber );

   855             }

   856         // Fetch Color A constant values

   857         else if( param->iName->Compare( KAknsRlEffectAlphaBlendARed ) == 0 )

   858             {

   859             if( param->iType != EAknsRlParameterTypeNumber )

   860                 User::Leave( KErrArgument );

   861 

   862             iFlags = TUint8( iFlags | EConstantAColor );

   863             iARed = TUint8( param->iNumber );

   864             }

   865         else if( param->iName->Compare( KAknsRlEffectAlphaBlendAGreen ) == 0 )

   866             {

   867             if( param->iType != EAknsRlParameterTypeNumber )

   868                 User::Leave( KErrArgument );

   869 

   870             iFlags = TUint8( iFlags | EConstantAColor );

   871             iAGreen = TUint8( param->iNumber );

   872             }

   873         else if( param->iName->Compare( KAknsRlEffectAlphaBlendABlue ) == 0 )

   874             {

   875             if( param->iType != EAknsRlParameterTypeNumber )

   876                 User::Leave( KErrArgument );

   877 

   878             iFlags = TUint8( iFlags | EConstantAColor );

   879             iABlue = TUint8( param->iNumber );

   880             }

   881         // Fetch Color B constant values

   882         else if( param->iName->Compare( KAknsRlEffectAlphaBlendBRed ) == 0 )

   883             {

   884             if( param->iType != EAknsRlParameterTypeNumber )

   885                 User::Leave( KErrArgument );

   886 

   887             iFlags = TUint8( iFlags | EConstantBColor );

   888             iBRed = TUint8( param->iNumber );

   889             }

   890         else if( param->iName->Compare( KAknsRlEffectAlphaBlendBGreen ) == 0 )

   891             {

   892             if( param->iType != EAknsRlParameterTypeNumber )

   893                 User::Leave( KErrArgument );

   894 

   895             iFlags = TUint8( iFlags | EConstantBColor );

   896             iBGreen = TUint8( param->iNumber );

   897             }

   898         else if( param->iName->Compare( KAknsRlEffectAlphaBlendBBlue ) == 0 )

   899             {

   900             if( param->iType != EAknsRlParameterTypeNumber )

   901                 User::Leave( KErrArgument );

   902 

   903             iFlags = TUint8( iFlags | EConstantBColor );

   904             iBBlue = TUint8( param->iNumber );

   905             }

   906         // Fetch Mask A constant value

   907         else if( param->iName->Compare( KAknsRlEffectAlphaBlendAMask ) == 0 )

   908             {

   909             if( param->iType != EAknsRlParameterTypeNumber )

   910                 User::Leave( KErrArgument );

   911 

   912             iFlags = TUint8( iFlags | EConstantAMask );

   913             iAMask = TUint8( param->iNumber );

   914             }

   915         // Fetch Mask B constant value

   916         else if( param->iName->Compare( KAknsRlEffectAlphaBlendBMask ) == 0 )

   917             {

   918             if( param->iType != EAknsRlParameterTypeNumber )

   919                 User::Leave( KErrArgument );

   920 

   921             iFlags = TUint8( iFlags | EConstantBMask );

   922             iBMask = TUint8( param->iNumber );

   923             }

   924         }

   925     }

   926 

   927 // -----------------------------------------------------------------------------

   928 // CAknsRlEffectPluginAlphaBlend::GetCapabilities

   929 // -----------------------------------------------------------------------------

   930 //

   931 void CAknsRlEffectPluginAlphaBlend::GetCapabilities( TAknsRlEffectCaps& aCaps )

   932     {

   933     // In all cases we can handle RGBOnly and RGBA output layers (alpha is

   934     // simply cleared to white if it exists).

   935     aCaps.iOutputLayerSupport = KAknsRlLayerRGBOnly | KAknsRlLayerRGBA;

   936 

   937     // In all cases we can handle RGBA input layers.

   938     aCaps.iInputLayerASupport = KAknsRlLayerRGBA;

   939     aCaps.iInputLayerBSupport = KAknsRlLayerRGBA;

   940 

   941     // If mask is constant we can handle RGBOnly as input layer

   942     if( iFlags & EConstantAMask )

   943         aCaps.iInputLayerASupport = aCaps.iInputLayerASupport | KAknsRlLayerRGBOnly;

   944 

   945     if( iFlags & EConstantBMask )

   946         aCaps.iInputLayerBSupport = aCaps.iInputLayerBSupport | KAknsRlLayerRGBOnly;

   947 

   948     // If both mask and color are constant we can handle None as input layer

   949     if( (iFlags & EConstantAMask) && (iFlags & EConstantAColor) )

   950         aCaps.iInputLayerASupport = aCaps.iInputLayerASupport | KAknsRlLayerNone;

   951 

   952     if( (iFlags & EConstantBMask) && (iFlags & EConstantBColor) )

   953         aCaps.iInputLayerBSupport = aCaps.iInputLayerBSupport | KAknsRlLayerNone;

   954     }

   955 

   956 // -----------------------------------------------------------------------------

   957 // CAknsRlEffectPluginAlphaBlend::Render

   958 // -----------------------------------------------------------------------------

   959 //

   960 TInt CAknsRlEffectPluginAlphaBlend::Render( const TAknsRlRenderOpParam& aParam )

   961     {

   962     TRAPD( err, DoRenderL( aParam ) );

   963     return err;

   964     }

   965 

   966 // -----------------------------------------------------------------------------

   967 // CAknsRlEffectPluginAlphaBlend::DoRenderL

   968 // -----------------------------------------------------------------------------

   969 //

   970 void CAknsRlEffectPluginAlphaBlend::DoRenderL( const TAknsRlRenderOpParam& aParam )

   971     {

   972     if( !iContext ) // We absolutely need the context

   973         {

   974         User::Leave( KErrBadHandle );

   975         }

   976 

   977     //---------------------------------

   978     // Step 1: Prepare layer query

   979 

   980     // In some cases involving constants we need not to query layer A or B

   981     TBool queryA = EFalse;

   982     TBool queryB = EFalse;

   983 

   984     // If constants are not defined we need to query both A and B

   985     if( 0 == iFlags )

   986         {

   987         queryA = ETrue;

   988         queryB = ETrue;

   989         }

   990     else // Constant flags were defined, queries may depend on constants

   991         {

   992         // No need to query A if constant color and constant mask are used

   993         if( ( iFlags & EConstantAColor ) && ( iFlags & EConstantAMask ) )

   994             queryA = EFalse;

   995         else

   996             queryA = ETrue;

   997 

   998         // No need to query B if constant color and constant mask are used

   999         if( ( iFlags & EConstantBColor ) && ( iFlags & EConstantBMask ) )

  1000             queryB = EFalse;

  1001         else

  1002             queryB = ETrue;

  1003         }

  1004 

  1005     //---------------------------------

  1006     // Step 2: Do layer query

  1007 

  1008     TAknsRlLayerData dataT;

  1009     TAknsRlLayerData dataA;

  1010     TAknsRlLayerData dataB;

  1011 

  1012     TDisplayMode modeT = ENone;

  1013     TDisplayMode modeA = ENone;

  1014     TDisplayMode modeB = ENone;

  1015 

  1016     // We need to query the output layer in any case

  1017     if( !( ( aParam.iOutputLayerStatus & KAknsRlLayerRGBOnly ) ||

  1018            ( aParam.iOutputLayerStatus & KAknsRlLayerRGBA ) ) )

  1019         User::Leave( KErrArgument ); // The output must be some sort of RGB layer

  1020 

  1021     iContext->GetLayerDataL( dataT, aParam.iOutputLayerIndex,

  1022                              aParam.iOutputLayerStatus, EFalse );

  1023 

  1024     if( !dataT.iRGBBitmap ) // The target bitmap must exist

  1025         User::Leave( KErrBadHandle );

  1026 

  1027     modeT = dataT.iRGBBitmap->DisplayMode();

  1028 

  1029     // Check for non-supported display modes

  1030     if( modeT != EColor64K && modeT != EColor16MU && modeT != EGray256 )

  1031         User::Leave( KErrArgument );

  1032 

  1033     // Query layer A

  1034     if( queryA )

  1035         {

  1036         iContext->GetLayerDataL( dataA, aParam.iInputLayerAIndex,

  1037                                  aParam.iInputLayerAStatus, EFalse );

  1038 

  1039         // If we don't use constant color A check that the bitmap is ok

  1040         if( !( iFlags & EConstantAColor ) )

  1041             {

  1042             if( !dataA.iRGBBitmap ) // We need the bitmap A

  1043                 User::Leave( KErrBadHandle );

  1044 

  1045             modeA = dataA.iRGBBitmap->DisplayMode();

  1046 

  1047             if( modeT != modeA ) // Display mode must match target

  1048                 User::Leave( KErrArgument );

  1049             }

  1050         }

  1051 

  1052     // Query layer B

  1053     if( queryB )

  1054         {

  1055         iContext->GetLayerDataL( dataB, aParam.iInputLayerBIndex,

  1056                                  aParam.iInputLayerBStatus, EFalse );

  1057 

  1058         // If we don't use constant color B check that the bitmap is ok

  1059         if( !( iFlags & EConstantBColor ) )

  1060             {

  1061             if( !dataB.iRGBBitmap ) // We need the bitmap B

  1062                 User::Leave( KErrBadHandle );

  1063 

  1064             modeB = dataB.iRGBBitmap->DisplayMode();

  1065 

  1066             if( modeT != modeB ) // Display mode must match target

  1067                 User::Leave( KErrArgument );

  1068             }

  1069         }

  1070 

  1071     // Check that alpha bitmaps are ok

  1072     if( !( iFlags & EConstantAMask ) )

  1073         {

  1074         if( !dataA.iAlphaBitmap ) // We need the mask A bitmap

  1075             User::Leave( KErrBadHandle );

  1076 

  1077         if( EGray256 != dataA.iAlphaBitmap->DisplayMode() )

  1078             User::Leave( KErrArgument );

  1079         }

  1080 

  1081     if( !( iFlags & EConstantBMask ) )

  1082         {

  1083         if( !dataB.iAlphaBitmap ) // We need the mask B bitmap

  1084             User::Leave( KErrBadHandle );

  1085 

  1086         if( EGray256 != dataB.iAlphaBitmap->DisplayMode() )

  1087             User::Leave( KErrArgument );

  1088         }

  1089 

  1090     // If we got this far:

  1091     // 1. We know used display mode, same on all layers

  1092     // 2. Relevant layers have been queried and are ready to be used

  1093     // 3. Alpha bitmaps are ok (if needed)

  1094 

  1095     // Clear the target alpha if it exists

  1096     if( dataT.iAlphaGc )

  1097         {

  1098         dataT.iAlphaGc->SetBrushColor( KRgbWhite );

  1099         dataT.iAlphaGc->Clear();

  1100         }

  1101 

  1102     TSize size = dataT.iRGBBitmap->SizeInPixels();

  1103 

  1104     // Lock the global bitmap heap

  1105     dataT.iRGBBitmap->LockHeap( ETrue );

  1106     CleanupStack::PushL( TCleanupItem( AknsRlLockCleanup, dataT.iRGBBitmap ) );

  1107 

  1108     // Leaves are ok because the cleanup item will take care of unlocking the

  1109     // bitmap heap.

  1110 

  1111     // Mask scanlines are the same for all color modes, we can prepare them

  1112     // here

  1113     if ( !iScans )

  1114         {

  1115         User::Leave( KErrNotReady );

  1116         }

  1117     if( iFlags & EConstantAMask ) // MA is a constant

  1118         {

  1119         iScans->Config8L( AknsRlIMA, size.iWidth, iAMask );

  1120         }

  1121     else // MA is bitmap

  1122         {

  1123         iScans->Config8L( AknsRlIMA, size.iWidth, *dataA.iAlphaBitmap );

  1124         }

  1125 

  1126     if( iFlags & EConstantBMask ) // MB is a constant

  1127         {

  1128         iScans->Config8L( AknsRlIMB, size.iWidth, iBMask );

  1129         }

  1130     else // MB is bitmap

  1131         {

  1132         iScans->Config8L( AknsRlIMB, size.iWidth, *dataB.iAlphaBitmap );

  1133         }

  1134 

  1135     //---------------------------