Ejemplo n.º 1
0
// -----------------------------------------------------------------------------
// Blit
//
// Blits given image to gc.
//
// -----------------------------------------------------------------------------
//
inline static TBool Blit(
    MAknsSkinInstance* aSkin, CBitmapContext& aGc, const TRect& aTrgRect,
    CAknsImageItemData* aImgData, const TAknsItemID& aIID,
    const TAknsBackground* aLayout, const TPoint& aPADelta,
    const TInt aDrawParam )
    {
    CAknsAppSkinInstance* appInstance = 
        static_cast<CAknsAppSkinInstance*>(aSkin);
        
    if ( IsBackgroundItem( aIID,appInstance ) && 
            appInstance && appInstance->AnimBackgroundState() )
        {
        if( (aDrawParam&KAknsDrawParamPrepareOnly) )
            {
            return ETrue;
            }        
        
        TRgb color = KRgbWhite;
        color.SetAlpha(0x00);
        aGc.SetPenColor(color);
        aGc.SetBrushColor(color);
        aGc.SetPenStyle(CGraphicsContext::ESolidPen);
        aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
        aGc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
        TRect layoutRect( aTrgRect );
        if( aLayout )
            {
            layoutRect = aLayout->iRect;
            }
        layoutRect.Move( -aPADelta );

        TRect drawRect = aTrgRect;
        drawRect.Intersection( layoutRect );

        aGc.Clear(drawRect);
        return ETrue;
        }

    TRect layoutRect( aTrgRect );

    const TAknsImageAttributeData* attr = NULL;

    if( aLayout )
        {
        layoutRect = aLayout->iRect;

        if( aLayout->iAttr.iAttributes != EAknsImageAttributeNone )
            {
            attr = &(aLayout->iAttr);
            }
        }

    layoutRect.Move( -aPADelta );

    TRect drawRect(aTrgRect);
    drawRect.Intersection( layoutRect );

    return DrawPartialCachedImage( aSkin, aGc, layoutRect, drawRect,
        aImgData, aIID, attr, aDrawParam );
    }
void CListBoxHighLightControl::Draw(CBitmapContext& gc) const
	{
	gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
	if (iPainter)
		gc.SetBrushColor( iPainter->GetHightLightClock() );
	
	gc.Clear(Rect());
	}
Ejemplo n.º 3
0
TBool CAknAnimationData::ExecutePendingAnimationStep(CBitmapContext& aGc, TAnimMultiStep* aStep)
{
    TBool done = EFalse;
    switch (aStep->iDrawStep.Type())
    {
    case EAnimDrawLine:
    {
        TAnimLineDrawStep* step = (aStep->iDrawStep.LineDrawStep());

        if (aStep->iSubStep == step->iSteps -1)
        {
            done = ETrue;
        }
        {
            TInt diffX = step->iEndX - step->iStartX;
            TInt diffY = step->iEndY - step->iStartY;
            TInt startX = step->iStartX + (diffX * aStep->iSubStep / step->iSteps);
            TInt startY = step->iStartY + (diffY * aStep->iSubStep / step->iSteps);
            TInt endX = step->iStartX + (diffX * (aStep->iSubStep+1)/ step->iSteps);
            TInt endY = step->iStartY + (diffY * (aStep->iSubStep+1) / step->iSteps);
            aGc.SetBrushColor(iDrawColor);
            aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
            aGc.Clear(TRect(TPoint(startX,startY),TPoint(endX+1, endY+1)));
        }
    }
    break;
    case EAnimRevealPartNewViewFromLeft:
    {
        TAnimBlitStep* step = (aStep->iDrawStep.BlitStep());
        TPoint offset((step->iWidth * aStep->iSubStep) / step->iSteps, 0);
        TSize size((step->iWidth / step->iSteps)+1, step->iHeight);
        aGc.BitBlt(TPoint(step->iDestX, step->iDestY) + offset, iViewBitmap,
                   TRect(TPoint(step->iSrcX, step->iSrcY) + offset, size));
        if (aStep->iSubStep == step->iSteps-1)
            done = ETrue;
    }
    break;
    case EAnimRevealPartNewViewFromRight:
    {
        TAnimBlitStep* step = (aStep->iDrawStep.BlitStep());
        TInt thisStep = (step->iSteps - aStep->iSubStep) - 1;
        TPoint offset((step->iWidth * thisStep) / step->iSteps, 0);
        TSize size((step->iWidth / step->iSteps)+1, step->iHeight);
        aGc.BitBlt(TPoint(step->iDestX, step->iDestY) + offset, iViewBitmap,
                   TRect(TPoint(step->iSrcX, step->iSrcY) + offset, size));
        if (aStep->iSubStep == step->iSteps-1)
            done = ETrue;
    }
    break;
    case EAnimRevealPartNewViewFromTop:
    {
        TAnimBlitStep* step = (aStep->iDrawStep.BlitStep());
        TPoint offset(0,(step->iHeight * aStep->iSubStep) / step->iSteps);
        TSize size(step->iWidth,(step->iHeight / step->iSteps)+1);
        aGc.BitBlt(TPoint(step->iDestX, step->iDestY) + offset, iViewBitmap,
                   TRect(TPoint(step->iSrcX, step->iSrcY) + offset, size));
        if (aStep->iSubStep == step->iSteps-1)
            done = ETrue;
    }
    break;
    case EAnimRevealPartNewViewFromBottom:
    {
        TAnimBlitStep* step = (aStep->iDrawStep.BlitStep());
        TInt thisStep = (step->iSteps - aStep->iSubStep) - 1;
        TPoint offset(0,(step->iHeight * thisStep) / step->iSteps);
        TSize size(step->iWidth,(step->iHeight / step->iSteps)+1);
        aGc.BitBlt(TPoint(step->iDestX, step->iDestY) + offset, iViewBitmap,
                   TRect(TPoint(step->iSrcX, step->iSrcY) + offset, size));
        if (aStep->iSubStep == step->iSteps-1)
            done = ETrue;
    }
    break;
    case EAnimBlitSlideNewView:
        // Slide the bitmap between two screen positions
    {
        TAnimSlideStep* step = (aStep->iDrawStep.SlideStep());
        TSize bitmapSize(step->iWidth, step->iHeight);
        TInt slideDifferenceX = step->iSlideToX - step->iSlideFromX;
        TInt slideDifferenceY = step->iSlideToY - step->iSlideFromY;
        TInt slidePosX = step->iSlideFromX + ((slideDifferenceX * aStep->iSubStep) / step->iSteps);
        TInt slidePosY = step->iSlideFromY + ((slideDifferenceY * aStep->iSubStep) / step->iSteps);
        aGc.BitBlt(TPoint(slidePosX, slidePosY), iViewBitmap,
                   TRect(TPoint(step->iSrcX, step->iSrcY), bitmapSize));
        if (aStep->iSubStep == step->iSteps)
            done = ETrue;
    }
    break;
    case EAnimBlitSlideNewViewClearBehind:
        // Slide the bitmap between two screen positions, clearing the screen behind it
    {
        TAnimSlideStep* step = (aStep->iDrawStep.SlideStep());
        TSize bitmapSize(step->iWidth, step->iHeight);
        TInt slideDifferenceX = step->iSlideToX - step->iSlideFromX;
        TInt slideDifferenceY = step->iSlideToY - step->iSlideFromY;
        if (aStep->iSubStep > 0)
        {
            // This is not the first step, so clear over the area of the previous step
            TInt slidePosX = step->iSlideFromX + ((slideDifferenceX * (aStep->iSubStep-1)) / step->iSteps);
            TInt slidePosY = step->iSlideFromY + ((slideDifferenceY * (aStep->iSubStep-1)) / step->iSteps);
            aGc.Clear(TRect(TPoint(slidePosX, slidePosY), bitmapSize));
        }
        TInt slidePosX = step->iSlideFromX + ((slideDifferenceX * aStep->iSubStep) / step->iSteps);
        TInt slidePosY = step->iSlideFromY + ((slideDifferenceY * aStep->iSubStep) / step->iSteps);
        aGc.BitBlt(TPoint(slidePosX, slidePosY), iViewBitmap,
                   TRect(TPoint(step->iSrcX, step->iSrcY), bitmapSize));
        if (aStep->iSubStep == step->iSteps)
            done = ETrue;
    }
    break;
    default:
        done = DrawUserAnimationStep(aGc, *aStep);
        break;
    }

    aStep->iSubStep++;
    return done;
}
Ejemplo n.º 4
0
EXPORT_C TBool CAknAnimationData::DrawNextAnimationStep(CBitmapContext& aGc)
{
    if (Count() == 0)
    {
        // Call the user animation step
        TAnimStep step;
        TAnimMultiStep nullStep(step);
        nullStep.iDrawStep.SetType(EAnimNullStep);
        nullStep.iSubStep = (TUint16)iCurrentDrawStep;
        TBool done = DrawUserAnimationStep(aGc, nullStep);
        iCurrentDrawStep++;
        return done;
    }

    if (iCurrentDrawStep < Count())
    {
        TInt drawSteps = (*iDrawStepsPerAnimStep)[iCurrentAnimStep];
        TInt startingDrawStep = iCurrentDrawStep;
        TBool repeatAnimStep = EFalse;

        for (TInt ii=0; ii<drawSteps; ii++)
        {
            TAnimStep* drawStep = &(At(iCurrentDrawStep));

            switch (drawStep->Type())
            {
            case EAnimBlitPreviousView:
            {
                TAnimBlitStep* step = drawStep->BlitStep();
                aGc.BitBlt(TPoint(step->iDestX, step->iDestY), iOldBitmap);
            }
            break;
            case EAnimBlitNewView:
            {
                TAnimBlitStep* step = drawStep->BlitStep();
                aGc.BitBlt(TPoint(step->iDestX, step->iDestY), iViewBitmap);
            }
            break;
            case EAnimBlitPartPreviousView:
            {
                TAnimBlitStep* step = drawStep->BlitStep();
                aGc.BitBlt(TPoint(step->iDestX, step->iDestY), iOldBitmap,
                           TRect(TPoint(step->iSrcX, step->iSrcY), TSize(step->iWidth, step->iHeight)));
            }
            break;
            case EAnimBlitPartNewView:
            {
                TAnimBlitStep* step = drawStep->BlitStep();
                aGc.BitBlt(TPoint(step->iDestX, step->iDestY), iViewBitmap,
                           TRect(TPoint(step->iSrcX, step->iSrcY), TSize(step->iWidth, step->iHeight)));
            }
            break;
            case EAnimDrawLine:
            case EAnimRevealPartNewViewFromLeft:
            case EAnimRevealPartNewViewFromRight:
            case EAnimRevealPartNewViewFromTop:
            case EAnimRevealPartNewViewFromBottom:
            case EAnimBlitSlideNewView:
            case EAnimBlitSlideNewViewClearBehind:
            {
                // Make this a pending step. Cancel the animation if the append fails
                TRAPD(err, iPendingSteps->AppendL(TAnimMultiStep(*drawStep)));
                if (err != KErrNone)
                    return ETrue;
            }
            break;
            case EAnimSetColor:
            {
                TAnimSetColorStep* step = drawStep->SetColorStep();
                iDrawColor = TRgb(step->iRed, step->iGreen, step->iBlue);
            }
            break;
            case EAnimDrawRect:
            {
                TAnimLineDrawStep* step = drawStep->LineDrawStep();
                aGc.SetPenColor(iDrawColor);
                aGc.SetPenStyle(CGraphicsContext::ESolidPen);
                aGc.DrawRect(TRect(TPoint(step->iStartX, step->iStartY),TPoint(step->iEndX, step->iEndY)));
            }
            break;
            case EAnimDrawFilledRect:
            {
                TAnimLineDrawStep* step = drawStep->LineDrawStep();
                aGc.SetBrushColor(iDrawColor);
                aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
                aGc.SetPenStyle(CGraphicsContext::ENullPen);
                aGc.DrawRect(TRect(TPoint(step->iStartX, step->iStartY),TPoint(step->iEndX, step->iEndY)));
            }
            break;
            case EAnimWait:
            {
                TAnimWaitStep* step = drawStep->WaitStep();
                repeatAnimStep = ETrue;
                if (step->iSteps > 0)
                {
                    step->iSteps--;
                    if (step->iSteps == 0)
                        repeatAnimStep = EFalse;
                }
            }
            break;
            case EAnimWaitUntilComplete:
                if (iPendingSteps->Count())
                    repeatAnimStep = ETrue;
                break;
            default:
                // Type is user-defined, so add to the pending steps
                TRAPD(err, iPendingSteps->AppendL(TAnimMultiStep(*drawStep)));
                if (err != KErrNone)
                    return ETrue;
                break;
            }
            iCurrentDrawStep++;
        }

        // If this step needs to be repeated, reset the draw step counter
        // otherwise increment the current animation step
        if (repeatAnimStep)
        {
            iCurrentDrawStep = startingDrawStep;
        }
        else
        {
            iCurrentAnimStep++;
        }
    }


    TInt done = DrawPendingAnimationSteps(aGc);

    if (iCurrentDrawStep == Count() && done)
        return ETrue;

    return EFalse;
}
Ejemplo n.º 5
0
// -----------------------------------------------------------------------------
// AknsDrawUtils::DrawBackground()
// (commented in the header).
// -----------------------------------------------------------------------------
EXPORT_C TBool AknsDrawUtils::DrawBackground( MAknsSkinInstance* aInstance,
    MAknsControlContext* aContext, const CCoeControl* aControl,
    CBitmapContext& aGc, const TPoint& aDstPos,
    const TRect& aControlRect, const TInt aDrawParam )
    {
    TInt drawParam = aDrawParam;
    TInt originalParam = aDrawParam;
    TBool retVal = EFalse;
    TBool blitFailed = EFalse;
    TBool blit = EFalse;
    TBool blitAttempted = EFalse;

    if ( !&aGc )
        {
        return retVal;
        }

    MAknsControlContext* parentContext = GetParentContext( aContext );
    if( parentContext )
        {
        retVal = DrawBackground( aInstance, parentContext, aControl, aGc,
            aDstPos, aControlRect, aDrawParam );
        drawParam |= KAknsDrawParamNoClearUnderImage;
        }
    else if( drawParam & KAknsDrawParamBottomLevelRGBOnly )
        {
        drawParam |= KAknsDrawParamRGBOnly;
        }

    originalParam = drawParam;

    if( aContext )
        {
        aContext->UpdateContext();
        }

    TAknsBackground* bgLayout = RetrieveBackgroundLayout( aContext );

    TAknsItemID imgIID( KAknsIIDNone );
    CAknsImageItemData* imgData = RetrieveBackgroundImage(
        aInstance, bgLayout, imgIID );

    // chained background
    if (imgData && imgData->ParentIID() != KAknsIIDNone)
        {
        TAknsItemID parentiid = imgData->ParentIID();
        TRect parentDrawRect = imgData->DrawRect();

        imgData = RetrieveKnownBackgroundImage(
            aInstance, parentiid );
        if (imgData)
            {
            imgData->SetDrawRect(parentDrawRect);
            drawParam |= KAknsDrawParamChained ;
            }
        }

    TPoint paDelta = GetParentAbsoluteDelta( bgLayout, aControl );

    TRect drawRect = aControlRect;
    drawRect.Move( aDstPos-aControlRect.iTl );
    paDelta += aControlRect.iTl-aDstPos;

    if (!(aDrawParam & KAknsDrawParamPrepareOnly))
        {
        aGc.SetPenStyle(CGraphicsContext::ENullPen);
        aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
        }

    if ( !(aDrawParam & KAknsDrawParamIgnoreLayerMask))
        {
        if( imgData )
            {
            blitAttempted = ETrue;
            if( (drawParam&KAknsDrawParamNoClearUnderImage)==0 )
                {
                blit = BlitAndClear( aInstance, aGc, drawRect,
                    imgData, imgIID, bgLayout, paDelta, drawParam );
                }
            else
                {
                blit = Blit( aInstance, aGc, drawRect,
                    imgData, imgIID, bgLayout, paDelta, drawParam );
                }
            if ( !blit )
                {
                blitFailed = ETrue;
                }
            }
        else
            {
            if( !(drawParam&KAknsDrawParamNoClearUnderImage) &&
                !(drawParam&KAknsDrawParamPrepareOnly) )
                {
                // Clear only if permitted
                aGc.DrawRect( drawRect );
                }
            }
        }

    if( bgLayout )
        {
        if (!(aDrawParam & KAknsDrawParamIgnoreLayerMask) && aContext->IsCompatibleWithType(EAknsControlContextTypeMasked))
            {
            CAknsMaskedLayerBackgroundControlContext* layeredCxt = static_cast<CAknsMaskedLayerBackgroundControlContext*>(aContext);
            if (layeredCxt->iOffScreenBmp)
                {
                CAknsMaskedBitmapItemData* maskedImgData = NULL;
                TRAPD( err, maskedImgData = CAknsMaskedBitmapItemData::NewL() );
                if ( err != KErrNone )
                    {
                    return EFalse;
                    }
                maskedImgData->SetBitmap(layeredCxt->iOffScreenBmp);
                maskedImgData->SetMask(layeredCxt->iLayerMask);

                TAknsBackground* childLayout = bgLayout->iNext;

                blitAttempted = ETrue;
                blit = Blit( aInstance, aGc, drawRect, maskedImgData,
                    KAknsIIDNone, childLayout, paDelta, drawParam );
                if ( !blit )
                    {
                    blitFailed = ETrue;
                    }

                maskedImgData->SetBitmap(NULL);
                maskedImgData->SetMask(NULL);
                delete maskedImgData;
                if (!(aDrawParam & KAknsDrawParamPrepareOnly))
                    {
                    aGc.SetPenStyle(CGraphicsContext::ESolidPen);
                    aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
                    }
                retVal = !blitFailed;
                return retVal;
                }
            }

        if (!aContext->IsCompatibleWithType(EAknsControlContextTypeFrame))
            {
            // special handling for frames
            drawParam|=KAknsDrawParamNoClearUnderImage;
            originalParam|=KAknsDrawParamNoClearUnderImage;
            }
        TAknsBackground* nextLayout = bgLayout->iNext;
        while( nextLayout &&
            ((drawParam & KAknsDrawParamLimitToFirstLevel) == 0) )
            {
            imgData = RetrieveKnownBackgroundImage( aInstance,
                nextLayout->iImageID );
            if (imgData && imgData->ParentIID() != KAknsIIDNone)
                {
                TAknsItemID parentiid = imgData->ParentIID();
                TRect parentDrawRect = imgData->DrawRect();

                imgData = RetrieveKnownBackgroundImage(
                    aInstance, parentiid );
                if (imgData)
                    {
                    imgData->SetDrawRect(parentDrawRect);
                    drawParam |= KAknsDrawParamChained ;
                    }
                }
            else
                {
                drawParam=originalParam;
                }
            if( imgData )
                {
                blitAttempted = ETrue;
                blit = BlitAndClear( aInstance, aGc, drawRect, imgData,
                    nextLayout->iImageID, nextLayout, paDelta, drawParam );
                if ( !blit )
                    {
                    blitFailed = ETrue;
                    }
                }
            nextLayout = nextLayout->iNext;
            }
        }

    if (!(aDrawParam & KAknsDrawParamPrepareOnly))
        {
        aGc.SetPenStyle(CGraphicsContext::ESolidPen);
        aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
        }

    // If Blit failed, or was not even attempted => return EFalse
    if ( blitFailed )
        {
        retVal = EFalse;
        }
    else if ( !retVal )
        {
        retVal = blitAttempted;
        }

    return retVal;
    }
Ejemplo n.º 6
0
// -----------------------------------------------------------------------------
// CheckAndDrawFrame
//
// -----------------------------------------------------------------------------
//
static TBool CheckAndDrawFrame( MAknsSkinInstance* aInstance,
    CBitmapContext& aGc, const TRect& aOuterRect, const TRect& aInnerRect,
    const TAknsItemID& aFrameID, const TAknsItemID& aCenterID,
    const TInt aDrawParam )
    {
    if( !aInstance )
        {
        return EFalse;
        }
    
    if( !(aDrawParam & KAknsDrawParamPrepareOnly) )
        {
        // Prepare before drawing
        CheckAndDrawFrame( aInstance, aGc, aOuterRect, aInnerRect,
            aFrameID, aCenterID, aDrawParam|KAknsDrawParamPrepareOnly );
        }

    CAknsImageItemData* rawData = static_cast<CAknsImageItemData*>(
        aInstance->GetCachedItemData( aFrameID, EAknsITImage ) );
    if( !rawData )
        {
        return EFalse;
        }

    if (!(aDrawParam & KAknsDrawParamPrepareOnly))
        {
        aGc.SetPenStyle(CGraphicsContext::ENullPen);
        aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
        }

    TBool retVal = EFalse;

    if( AknsUtils::IsDerivedType( EAknsITImageTable, rawData->Type() ) )
        {
        CAknsImageTableItemData* data =
            static_cast<CAknsImageTableItemData*>(rawData);
        if( data->NumberOfImages() != EAknsFrameElementsN )
            {
            return EFalse;
            }

        // Corners
        retVal |= CheckAndDrawCachedImage( aInstance, aGc,
            TRect( aOuterRect.iTl, aInnerRect.iTl ),
            data->ImageIID( EAknsFrameIndexTl ), aDrawParam );
        retVal |= CheckAndDrawCachedImage( aInstance, aGc,
            TRect( aInnerRect.iBr.iX, aOuterRect.iTl.iY,
            aOuterRect.iBr.iX, aInnerRect.iTl.iY ),
            data->ImageIID( EAknsFrameIndexTr ), aDrawParam );
        retVal |= CheckAndDrawCachedImage( aInstance, aGc,
            TRect( aOuterRect.iTl.iX, aInnerRect.iBr.iY,
            aInnerRect.iTl.iX, aOuterRect.iBr.iY ),
            data->ImageIID( EAknsFrameIndexBl ), aDrawParam );
        retVal |= CheckAndDrawCachedImage( aInstance, aGc,
            TRect( aInnerRect.iBr, aOuterRect.iBr ),
            data->ImageIID( EAknsFrameIndexBr ), aDrawParam );

        // Sides
        TRect sideRect( aInnerRect.iTl.iX, aOuterRect.iTl.iY,
            aInnerRect.iBr.iX, aInnerRect.iTl.iY );
        retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,
            data->ImageIID( EAknsFrameIndexT ), aDrawParam );
        sideRect.SetRect( aInnerRect.iTl.iX, aInnerRect.iBr.iY,
            aInnerRect.iBr.iX, aOuterRect.iBr.iY );
        retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,
            data->ImageIID( EAknsFrameIndexB ), aDrawParam );
        sideRect.SetRect( aOuterRect.iTl.iX, aInnerRect.iTl.iY,
            aInnerRect.iTl.iX, aInnerRect.iBr.iY );
        retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,
            data->ImageIID( EAknsFrameIndexL ), aDrawParam );
        sideRect.SetRect( aInnerRect.iBr.iX, aInnerRect.iTl.iY,
            aOuterRect.iBr.iX, aInnerRect.iBr.iY );
        retVal |= CheckAndDrawCachedImage( aInstance, aGc, sideRect,
            data->ImageIID( EAknsFrameIndexR ), aDrawParam );

        // Center
        //lint --e{961} Valid logic
        if( aCenterID == KAknsIIDDefault )
            {
            retVal |= CheckAndDrawCachedImage( aInstance, aGc, aInnerRect,
                data->ImageIID( EAknsFrameIndexCenter ), aDrawParam );
            }
        else if( aCenterID != KAknsIIDNone )
            {
            retVal |= CheckAndDrawCachedImage( aInstance, aGc, aInnerRect,
                aCenterID, aDrawParam );
            }
        }
    else if( AknsUtils::IsDerivedType( EAknsITBitmap, rawData->Type() ) )
        {
        // Center only
        retVal |= CheckAndDrawCachedImage( aInstance, aGc, aOuterRect,
            aFrameID, aDrawParam );
        }

    if (!(aDrawParam & KAknsDrawParamPrepareOnly))
        {
        aGc.SetPenStyle(CGraphicsContext::ESolidPen); //lint !e961 Intentional
        aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
        }
    return retVal;
    }