static void DrawIconL(CWindowGc& aGc, CGulIcon& aIcon, const TJuikLayoutItem& aL, TBool aDoCenter=ETrue) 
{
	CALLSTACKITEMSTATIC_N(_CL(""), _CL("DrawIconL"));
	CFbsBitmap* bmp = aIcon.Bitmap();
	CFbsBitmap* mask = aIcon.Mask();
	
	aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
	// center 
	TInt bmpW = bmp->SizeInPixels().iWidth;
	TInt areaW = aL.Size().iWidth;
	
	TInt dx = 0;
	TInt dy = 0;
	if ( aDoCenter && bmpW < areaW )
		{
			dx = (areaW - bmpW) / 2;
		}


	TPoint tl = aL.TopLeft();
	tl += TPoint(dx,dy);
	TRect r(TPoint(0,0), bmp->SizeInPixels());
 	if ( mask )
 		{
 			aGc.BitBltMasked( tl, bmp, r, mask, ETrue);
 		}
 	else
 		{
			aGc.BitBlt( tl, bmp, r);
  		}
}
// ---------------------------------------------------------
// CSymTorrentSearchContainer::ConstructL
// EPOC two phased constructor
// ---------------------------------------------------------
//
void CSymTorrentSearchContainer::ConstructL(const TRect& aRect, 
	CSymTorrentAppUi* aAppUi, CSTTorrentManager* aTorrentMgr)
{
	iAppUi=aAppUi;
	iTorrentMgr=aTorrentMgr;
    CreateWindowL();

    iListBox = new (ELeave) CAknDoubleGraphicStyleListBox();
    iListBox->SetMopParent(this);
	iListBox->ConstructL(this, EAknListBoxSelectionList);
	iListBox->SetContainerWindowL(*this);
	
	iListBox->View()->SetListEmptyTextL(_L("(empty)"));

	//create scrollbar
	iListBox->CreateScrollBarFrameL();
	iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(
		CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);
	
	CArrayPtr<CGulIcon>* icons = new (ELeave) CAknIconArray(1);  // must be initialized with the number of icons used by the list!
	CleanupStack::PushL(icons);

	#ifdef EKA2
	{
		CGulIcon* chainLinkIcon = CGulIcon::NewL();
		CleanupStack::PushL(chainLinkIcon);
		
		CFbsBitmap* chainLinkBmp = NULL;
		CFbsBitmap* chainLinkMask = NULL;
		AknIconUtils::CreateIconLC(chainLinkBmp, chainLinkMask, KBitmapFile,
			EMbmSymtorrentChainlink, EMbmSymtorrentChainlink_mask);	
		chainLinkIcon->SetBitmap(chainLinkBmp);
		chainLinkIcon->SetMask(chainLinkMask);
		CleanupStack::Pop(2);
		icons->InsertL(0, chainLinkIcon);
		CleanupStack::Pop();				
	}
	#else
	{
		CEikonEnv* eikEnv = CEikonEnv::Static();
		
		icons->AppendL(eikEnv->CreateIconL(KBitmapFile, 
			EMbmSymtorrentChainlink, EMbmSymtorrentChainlink_mask));	
	}
	#endif
			
	CleanupStack::Pop(icons); // icons
	iListBox->ItemDrawer()->ColumnData()->SetIconArray(icons);

    SetRect(aRect);
    
    CDesCArray* itemArray = static_cast<CDesCArray*>
		(iListBox->Model()->ItemTextArray());
	itemArray->InsertL(0, _L("0\tFirst line\tSecond line"));			
    
   
    ActivateL();
}
void CFileSelectDialog::PostLayoutDynInitL()
	{
	CAknListQueryDialog::PostLayoutDynInitL();
	CArrayPtr<CGulIcon>* icons;
	icons=new (ELeave) CAknIconArray(1);
    CGulIcon* icon = AknsUtils::CreateGulIconL(AknsUtils::SkinInstance(),KAknsIIDQgnPropEmpty, AknIconUtils::AvkonIconFileName(),EMbmAvkonQgn_prop_empty,EMbmAvkonQgn_prop_empty_mask);	
	icon->SetBitmapsOwnedExternally(EFalse);
	icons->AppendL(icon);
	SetIconArrayL(icons);
	Update();
	Show();
	}
Exemple #4
0
/**
 * Load svg element.
 */
CGulIcon* CFuiTheme::SvgIconL( TInt aElementId )
{
	CFbsBitmap* a = NULL;
	CFbsBitmap* b = NULL;
	
	TFileName svgFile;
	SvgFile( svgFile );
		
	AknIconUtils::CreateIconL( a, b, svgFile, aElementId, aElementId );
		
	CGulIcon* c = CGulIcon::NewL( a, b );
	
	AknIconUtils::PreserveIconData( c->Bitmap() );
	AknIconUtils::PreserveIconData( c->Mask() );
	
	TSize contentSize;
	AknIconUtils::GetContentDimensions( c->Bitmap(), contentSize );
	
	AknIconUtils::SetSize( c->Bitmap(), contentSize );
	AknIconUtils::SetSize( c->Mask(), contentSize );
	
	AknIconUtils::DestroyIconData( c->Bitmap() );
	AknIconUtils::DestroyIconData( c->Mask() );
	
	iElements.Append( c );
	
	return c;
}
// ---------------------------------------------------------------------------
// CAppMngr2SisxRuntime::LoadIconsL()
// ---------------------------------------------------------------------------
//
void CAppMngr2SisxRuntime::LoadIconsL( CAknIconArray& aIconArray )
    {
    MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();
    HBufC* iconFilePath = NULL;
    
    iconFilePath = FullBitmapFileNameLC( KAppMngr2SisxIconFileNameMif );

    // Icon loading order in must be the same in which SISX icons
    // are defined in TAppMngr2SisxIcons enum in appmngr2sisx.hrh.
    
    // Icon 0: SIS application icon, EQgnMenuAmSis
    CGulIcon* icon = AknsUtils::CreateGulIconL( skinInstance,
            KAknsIIDQgnMenuAmSis, *iconFilePath,
            EMbmAppmngr2sisxQgn_menu_am_sis,
            EMbmAppmngr2sisxQgn_menu_am_sis_mask );
    CleanupStack::PushL( icon );
    aIconArray.AppendL( icon );
    CleanupStack::Pop( icon );

    // Icon 1: DRM expired rights icon, EQgnPropDrmExpLarge
    icon = AknsUtils::CreateGulIconL( skinInstance,
            KAknsIIDQgnPropDrmRightsExpLarge, *iconFilePath,
            EMbmAppmngr2sisxQgn_prop_drm_exp_large,
            EMbmAppmngr2sisxQgn_prop_drm_exp_large_mask );
    CleanupStack::PushL( icon );
    aIconArray.AppendL( icon );
    CleanupStack::Pop( icon );                                                

    // Icon 2: untrusted SIS application, EQgnIndiAmInstNoAdd
    // Indicator icons are color-skinned as normal icons are
    // graphically-skinned. CreateColorIconL() must be used to
    // create color-skinned icon.
    CFbsBitmap* bitmap = NULL;
    CFbsBitmap* mask = NULL;
    AknsUtils::CreateColorIconLC( skinInstance,
            KAknsIIDQgnIndiAmInstNoAdd,
            KAknsIIDQsnIconColors, EAknsCIQsnIconColorsCG13,
            bitmap, mask, *iconFilePath,
            EMbmAppmngr2sisxQgn_indi_am_inst_no_add,
            EMbmAppmngr2sisxQgn_indi_am_inst_no_add_mask,
            KRgbBlack );
    icon = CGulIcon::NewL( bitmap, mask );
    icon->SetBitmapsOwnedExternally( EFalse );
    CleanupStack::Pop( 2 );   // bitmap and mask, order may vary
    CleanupStack::PushL( icon );
    aIconArray.AppendL( icon );
    CleanupStack::Pop( icon );

    CleanupStack::PopAndDestroy( iconFilePath );
    }
// -----------------------------------------------------------------------------
// CLandmarksModel::AppendIconL
// 
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CLandmarksModel::AppendIconL(
    const TDesC& aMbmFile, 
    TInt aIconOffset, 
    TInt aMaskOffset)
    {
    TAknsItemID aknsItemId = {0,0};
    CGulIcon* icon = AknsUtils::CreateGulIconL(NULL, aknsItemId,
        aMbmFile, 
        aIconOffset, 
        aMaskOffset);
    CleanupStack::PushL(icon);
    icon->SetBitmapsOwnedExternally(EFalse);
    iIconList->AppendL(icon);
    CleanupStack::Pop(icon);
    }
void CUiLoftAppView::InsertMyPictureL(TInt aPos)
	{
	CMyPicture* picture;
	// Create a CPicture derived class which will draw our image, depending this Size
	CGulIcon* icon = iIcons->At(iIcons->Count()-1);
	CFbsBitmap* bmp = icon->Bitmap();
	CFbsBitmap* mask = icon->Mask();
	picture = new( ELeave )CMyPicture(TSize(400, 400),*bmp, mask);
						
	CleanupStack::PushL(picture);
	// Prepare the Picture header, which will be instered into the Richtext
	TPictureHeader header;
	header.iPicture =TSwizzle<CPicture>(picture);
	iEditor->RichText()->InsertL( aPos,header); 
	CleanupStack::Pop(); // picture - Richtext take the ownership 
	}
Exemple #8
0
/**
 * Load svg element and scale it to given size. 
 */
 CGulIcon* CFuiTheme::SvgIconL( TInt aElementId, const TSize& aSize )
{
	CFbsBitmap* a = NULL;
	CFbsBitmap* b = NULL;
	
	TFileName svgFile;
	SvgFile( svgFile );
		
	AknIconUtils::CreateIconL( a, b, svgFile, aElementId, aElementId );
	
	CGulIcon* c = CGulIcon::NewL( a, b );
	
	AknIconUtils::SetSize( c->Bitmap(), aSize, EAspectRatioNotPreserved );
	AknIconUtils::SetSize( c->Mask(), aSize, EAspectRatioNotPreserved );
	
	iElements.Append( c );
	
	return c;
}
void CCustomControlList::Draw(CBitmapContext& gc)
	{
	TInt x = iDrawPoint.iX + iDisplayPoint.iX;
	TInt x2 = iDrawPoint.iX + iDisplayPoint.iX + 16;
	TInt y;
	TInt dy = iDrawPoint.iY;
	for (TInt i=0; i<iList->Count(); i++)
		{
		if (dy < 0)
			{
			dy += iRowHeight;
			continue;
			}
		if (dy >= iDisplaySize.iHeight)
			{
			break;
			}
		y = dy + iDisplayPoint.iY;
		pListItemStruct item = (*iList)[i];
		CGulIcon* icon = (*iIcons)[item->iIconIndex];
		CFbsBitmap* bitmap = icon->Bitmap();
		gc.BitBlt(TPoint(x, y), bitmap);

		gc.UseFont(iFont);
		if (i!=iSelectIndex)
			{
			gc.SetPenColor(iTextColor);
			//			HBufC* text = item->iShowName;
			//			gc.DrawText(*(item->iShowName), TPoint(x2, y));
			}
		else
			{
			gc.SetPenColor(iSelectTextColor);
			//			HBufC* text = item->iShowName;
			//			gc.DrawText(*(item->iShowName), TPoint(x2, y));
			}
		y += iFontHeight;
		gc.DrawText(*(item->iShowName), TPoint(x2, y));
		gc.DiscardFont();

		dy += iRowHeight;
		}
	}
// -----------------------------------------------------------------------------
// CLandmarksModel::CreateIconListL
// 
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CIconList* CLandmarksModel::CreateIconListL()
    {
    CIconList* iconList = new (ELeave) CAknIconArray( KGranularity );

    CleanupStack::PushL(iconList);
    
    // Create the default landmark icon consisting of its image and mask
    TAknsItemID aknsItemId = {0,0};
    CGulIcon* icon = AknsUtils::CreateGulIconL(NULL, aknsItemId,
        KLandmarksMbmFileName, 
        EMbmLmrefappDefault_lm, 
        EMbmLmrefappDefault_lm_mask);
    CleanupStack::PushL(icon);
    icon->SetBitmapsOwnedExternally(EFalse);
    iconList->AppendL(icon);
    CleanupStack::Pop(2, iconList);

    // initialze iIconList. We don't need to delete any possible previous 
    // iIconList since ownership is transferred to calling object.
    iIconList = iconList;

    return iIconList;
    }
EXPORT_C void JuikIcons::SetIconSizeL( CGulIcon& aIcon, const TSize& aSize, TScaleMode aMode)
{
	CALLSTACKITEMSTATIC_N(_CL("JuikIcons"), _CL("SetIconSizeL"));
#ifdef __SCALABLEUI_VARIANT__
	
	AknIconUtils::SetSize( aIcon.Bitmap(), aSize, aMode);
	// no need to set mask size - it's automatically set
	
#else // not  __SCALABLEUI_VARIANT__
	
	// do nothing, non-svg icons have correct size when loaded

#endif //   __SCALABLEUI_VARIANT__
}
// --------------------------------------------------------------------------
// CHomeMediaContainer::UpdatePluginsL
// --------------------------------------------------------------------------
//
void CHomeMediaContainer::UpdatePluginsL()
    {
    __LOG("CHomeMediaContainer::UpdatePluginsL begin");
    CEikFormattedCellListBox* listBox = 
        static_cast<CEikFormattedCellListBox*>( &ListBox() );

    CArrayPtr<CGulIcon>& icons = 
        *listBox->ItemDrawer()->FormattedCellData()->IconArray();
    // Remove old plugins icons
    TInt pluginIcons = icons.Count() - KNumberOfItemsBeforePlugins;
    while( pluginIcons )
        {
        pluginIcons--;
        CGulIcon* icon = icons[ KNumberOfItemsBeforePlugins ];
        icons.Delete( KNumberOfItemsBeforePlugins );
        delete icon;
        icon = NULL;
        }

    for( TInt i = 0; i < iPluginArray.Count(); i++ )
        {
        //append icon
        const CGulIcon& icon = iPluginArray[i]->GetIcon();
        CGulIcon* copyIcon = CGulIcon::NewL( icon.Bitmap(), icon.Mask() );
        CleanupStack::PushL( copyIcon );
        // Icon is handled by us, but bitmaps by plugin
        // when we delete icon, we delete icon only but not bitmaps
        copyIcon->SetBitmapsOwnedExternally( ETrue );
        icons.AppendL( copyIcon ); //Ownership goes to array
        CleanupStack::Pop( copyIcon );

        HBufC* primary = NULL;
        HBufC* secondary = NULL;

        // if title of the plugin is not null alloc space for it
        if ( &(iPluginArray[i]->GetTitle()) )
            {
            primary = ( iPluginArray[i]->GetTitle() ).AllocLC();
            }
        else
            {
            primary = KNullDesC().AllocLC();
            }

        // if secondary text of the plugin is not null alloc space for it
        if ( &(iPluginArray[i]->GetSecondaryText()) )
            {
            secondary = ( iPluginArray[i]->GetSecondaryText() ).AllocLC();
            }
        else
            {
            secondary = KNullDesC().AllocLC();
            }

        AddColumnL( KFormatWithTwoStr,
                    i + KNumberOfItemsBeforePlugins,
                    primary,
                    secondary );

        // deletion of the texts after they have been set to listbox item
        CleanupStack::PopAndDestroy( secondary );
        CleanupStack::PopAndDestroy( primary );
        }
    __LOG("CHomeMediaContainer::UpdatePluginsL end");
    }
void CSpriteSet::RenderSprite(TInt aSpriteType, TInternalSpriteResizeMode aInternalSpriteResizeMode, const TSize& aSourceSize, const TSize& aSpriteSize)
	{
	const TInt sourceWidth = aSourceSize.iWidth;
	const TInt sourceHeight = aSourceSize.iHeight;
	const TInt spriteWidth = aSpriteSize.iWidth;
	const TInt spriteHeight = aSpriteSize.iHeight;
	const TInt numOfHorizAddedLines = spriteHeight-sourceHeight;
	const TInt numOfVertAddedLines = spriteWidth-sourceWidth;
	const TPoint posZeroZero(0,0);	// cached for repeated use
	CGulIcon* spriteSetMember = iSourceMembers[aSpriteType];
	CFbsBitmap* bitmapToUse = spriteSetMember->Bitmap();
	CFbsBitmap* maskToUse = spriteSetMember->Mask();
	TRect fromRect;
	TPoint toPoint;

	switch(aInternalSpriteResizeMode)
		{
	case EHSameVSame:
		{
		fromRect.SetRect(0,0,sourceWidth,sourceHeight);
		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);
		break;
		}
	case EHSameVShrink:
		{
		const TInt halfSpriteHeight = spriteHeight/2;
		fromRect.SetRect(0,0,spriteWidth,halfSpriteHeight);
		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);
		fromRect.SetRect(0,sourceHeight - (halfSpriteHeight) - (spriteHeight%2),sourceWidth,sourceHeight);
		toPoint.SetXY(0,halfSpriteHeight);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		break;
		}
	case EHSameVStretch:
		{
		const TInt halfSourceHeight = sourceHeight/2;
		fromRect.SetRect(0,0,sourceWidth,halfSourceHeight);
		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);
		fromRect.SetRect(0,halfSourceHeight,sourceWidth,sourceHeight);
		toPoint.SetXY(0,spriteHeight-(halfSourceHeight)-(sourceHeight%2));
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		for(TInt i = 0; i < numOfHorizAddedLines;i++)
			{
			fromRect.SetRect(0,halfSourceHeight,sourceWidth,(halfSourceHeight)+1);
			toPoint.SetXY(0,(halfSourceHeight)+i);
			iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
			iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
			}
		break;
		}
	case EHShrinkVSame:
		{
		const TInt halfSpriteWidth = spriteWidth/2;
		fromRect.SetRect(0,0,halfSpriteWidth,spriteHeight);
		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);
		fromRect.SetRect(sourceWidth - (halfSpriteWidth) - (spriteWidth%2),0,sourceWidth,sourceHeight);
		toPoint.SetXY(halfSpriteWidth,0);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		break;
		}
	case EHShrinkVShrink:
		{
		const TInt halfSpriteWidth = spriteWidth/2;
		const TInt halfSpriteHeight = spriteHeight/2;
		const TInt spriteHeightModTwo = spriteHeight%2;
		const TInt spriteWidthModTwo = spriteWidth%2;
		fromRect.SetRect(0,0,halfSpriteWidth,halfSpriteHeight);
		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);
		fromRect.SetRect(sourceWidth - (halfSpriteWidth) - (spriteWidthModTwo),0,sourceWidth,halfSpriteHeight);
		toPoint.SetXY(halfSpriteWidth,0);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		fromRect.SetRect(0,sourceHeight - (halfSpriteHeight) - (spriteHeightModTwo),halfSpriteWidth,sourceHeight);
		toPoint.SetXY(0,halfSpriteHeight);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		fromRect.SetRect(sourceWidth - (halfSpriteWidth) - (spriteWidthModTwo),sourceHeight - (halfSpriteHeight) - (spriteHeightModTwo),sourceWidth,sourceHeight);
		toPoint.SetXY(halfSpriteWidth,halfSpriteHeight);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		break;
		}
	case EHShrinkVStretch:
		{
		const TInt halfSourceHeight = sourceHeight/2;
		const TInt halfSpriteWidth = spriteWidth/2;
		const TInt sourceHeightModTwo = sourceHeight%2;
		const TInt spriteWidthModTwo = spriteWidth%2;
		fromRect.SetRect(0,0,halfSpriteWidth,halfSourceHeight);	
		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);
		fromRect.SetRect(sourceWidth - (halfSpriteWidth) - (spriteWidthModTwo),0,sourceWidth,halfSourceHeight);
		toPoint.SetXY(halfSpriteWidth,0);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		fromRect.SetRect(0,sourceHeight - (halfSourceHeight) - (sourceHeightModTwo),halfSpriteWidth,sourceHeight);
		toPoint.SetXY(0,spriteHeight - (halfSourceHeight) - (sourceHeightModTwo));
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		fromRect.SetRect(sourceWidth - (halfSpriteWidth) - (spriteWidthModTwo),sourceHeight - (halfSourceHeight) - (sourceHeightModTwo),sourceWidth,sourceHeight);
		toPoint.SetXY(halfSpriteWidth,spriteHeight - (halfSourceHeight) - (sourceHeightModTwo));
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		for(TInt j = 0; j < numOfHorizAddedLines;j++)
			{
			fromRect.SetRect(0,spriteHeight - (halfSourceHeight) - (sourceHeightModTwo),spriteWidth,spriteHeight - (halfSourceHeight) - (sourceHeightModTwo)+1);
			toPoint.SetXY(0,(halfSourceHeight)+j);
			iMainFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);
			iMaskFbsBitGc->BitBlt(toPoint,iTargetMaskBitmap,fromRect);
			}
		break;
		}
	case EHStretchVSame:
		{
		const TInt halfSourceWidth = sourceWidth/2;
		fromRect.SetRect(0,0,halfSourceWidth,sourceHeight);
		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);
		fromRect.SetRect(halfSourceWidth,0,sourceWidth,sourceHeight);
		toPoint.SetXY(spriteWidth-(halfSourceWidth)-(sourceWidth%2),0);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		for(TInt i = 0; i < numOfVertAddedLines;i++)
			{
			fromRect.SetRect(halfSourceWidth,0,(halfSourceWidth)+1,sourceHeight);
			toPoint.SetXY((halfSourceWidth)+i,0);
			iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
			iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
			}
		break;
		}
	case EHStretchVShrink:
		{
		const TInt halfSourceWidth = sourceWidth/2;
		const TInt halfSpriteHeight = spriteHeight/2;
		const TInt sourceWidthModTwo = sourceWidth%2;
		const TInt spriteHeightModTwo = spriteHeight%2;
		fromRect.SetRect(0,0,halfSourceWidth,halfSpriteHeight);
		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);
		fromRect.SetRect(sourceWidth - (halfSourceWidth) - (sourceWidthModTwo),0,sourceWidth,halfSpriteHeight);
		toPoint.SetXY(spriteWidth - (halfSourceWidth) - (sourceWidthModTwo),0);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		fromRect.SetRect(0,sourceHeight - (halfSpriteHeight) - (spriteHeightModTwo),halfSourceWidth,sourceHeight);
		toPoint.SetXY(0,halfSpriteHeight);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		fromRect.SetRect(sourceWidth - (halfSourceWidth) - (sourceWidthModTwo),sourceHeight - (halfSpriteHeight) - (spriteHeightModTwo),sourceWidth,sourceHeight);
		toPoint.SetXY(spriteWidth - (halfSourceWidth) - (sourceWidthModTwo),halfSpriteHeight);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		for(TInt j = 0; j < numOfVertAddedLines;j++)
			{
			fromRect.SetRect(spriteWidth - (halfSourceWidth) - (sourceWidthModTwo),0,spriteWidth - (halfSourceWidth) - (sourceWidthModTwo)+1,spriteHeight);
			toPoint.SetXY((halfSourceWidth)+j,0);
			iMainFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);
			iMaskFbsBitGc->BitBlt(toPoint,iTargetMaskBitmap,fromRect);
			}
		break;
		}
	case EHStretchVStretch:
		{
		const TInt halfSourceWidth = sourceWidth/2;
		const TInt halfSourceHeight = sourceHeight/2;
		const TInt sourceWidthModTwo = sourceWidth%2;
		const TInt sourceHeightModTwo = sourceHeight%2;
		fromRect.SetRect(0,0,halfSourceWidth,halfSourceHeight);
		iMaskFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);
		iMainFbsBitGc->BitBlt(posZeroZero,maskToUse,fromRect);
		fromRect.SetRect(0,halfSourceHeight,halfSourceWidth,sourceHeight);
		toPoint.SetXY(0,spriteHeight-(halfSourceHeight)-(sourceHeightModTwo));
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		iMainFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		fromRect.SetRect(halfSourceWidth,0,sourceWidth,halfSourceHeight);
		toPoint.SetXY(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),0);
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		iMainFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		fromRect.SetRect(halfSourceWidth,halfSourceHeight,sourceWidth,sourceHeight);
		toPoint.SetXY(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),spriteHeight-(halfSourceHeight)-(sourceHeightModTwo));
		iMaskFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		iMainFbsBitGc->BitBlt(toPoint,maskToUse,fromRect);
		for(TInt h = 0; h < numOfVertAddedLines;h++)
			{
			fromRect.SetRect(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),0,spriteWidth-(halfSourceWidth)-(sourceWidthModTwo)+1,spriteHeight);
			toPoint.SetXY((halfSourceWidth)+h,0);
			iMainFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);
			iMaskFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);
			}
		for(TInt m = 0; m < numOfHorizAddedLines;m++)
			{
			fromRect.SetRect(0,spriteHeight-(halfSourceHeight)-(sourceHeightModTwo),spriteWidth,spriteHeight-(halfSourceHeight)-(sourceHeightModTwo)+1);
			toPoint.SetXY(0,(halfSourceHeight)+m);
			iMaskFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);
			}
		fromRect.SetRect(0,0,halfSourceWidth,halfSourceHeight);
		iMainFbsBitGc->BitBlt(posZeroZero,bitmapToUse,fromRect);
		fromRect.SetRect(0,halfSourceHeight,halfSourceWidth,sourceHeight);
		toPoint.SetXY(0,spriteHeight-(halfSourceHeight)-(sourceHeightModTwo));
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		fromRect.SetRect(halfSourceWidth,0,sourceWidth,halfSourceHeight);
		toPoint.SetXY(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),0);
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		fromRect.SetRect(halfSourceWidth,halfSourceHeight,sourceWidth,sourceHeight);
		toPoint.SetXY(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),spriteHeight-(halfSourceHeight)-(sourceHeightModTwo));
		iMainFbsBitGc->BitBlt(toPoint,bitmapToUse,fromRect);
		for(TInt j = 0; j < numOfVertAddedLines;j++)
			{
			fromRect.SetRect(spriteWidth-(halfSourceWidth)-(sourceWidthModTwo),0,spriteWidth-(halfSourceWidth)-(sourceWidthModTwo)+1,spriteHeight);
			toPoint.SetXY((halfSourceWidth)+j,0);
			iMainFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);
			}
		for(TInt i = 0; i < numOfHorizAddedLines;i++)
			{
			fromRect.SetRect(0,spriteHeight-(halfSourceHeight)-(sourceHeightModTwo),spriteWidth,spriteHeight-(halfSourceHeight)-(sourceHeightModTwo)+1);
			toPoint.SetXY(0,(halfSourceHeight)+i);
			iMainFbsBitGc->BitBlt(toPoint,iTargetBitmap,fromRect);
			}
		break;
		}
	default:
		Panic(EEgulPanicInvalidInternalSpriteResizeMode);
		break;
		}
	}
// ---------------------------------------------------------
// CDisconnectDlgDialog::PreLayoutDynInitL
// ---------------------------------------------------------
//
void CDisconnectDlgDialog::PreLayoutDynInitL()
    {
    CLOG_ENTERFN("CDisconnectDlgDialog::PreLayoutDynInitL");    
    
    CAknListQueryDialog::PreLayoutDynInitL();
    
    STATIC_CAST( CEikServAppUi*, 
                CCoeEnv::Static()->AppUi() )->SuppressAppSwitching( ETrue );
    
    CConnectionCArray* connArray = iConnModel->GetConnArray();

    // items: application and IAP names
    CDesCArrayFlat* items = new( ELeave )CDesCArrayFlat( connArray->Count() );
    CleanupStack::PushL( items );
    // icons: application icons
    CArrayPtr< CGulIcon >* icons = new( ELeave )CAknIconArray( 
                                                        connArray->Count() );
    CleanupStack::PushL( icons );

    CGulIcon* iconTemp = NULL;
    CGulIcon* icon = NULL;

    TInt count = connArray->Count();
    CLOG_WRITEF(_L( "count: %d" ), count );     

    // Get the info of every connection and initialize the list of dialog
    for( TInt i = 0; i < count; i++ )
        {
        CConnectionInfo* info = connArray->At( i );

        TBool useSharedIcon = EFalse;
        // Application and IAP name
        HBufC* listItem = HBufC::NewLC( KListItemTextBuf );
        TPtrC iap = info->GetIapNameL();
        
        TPtrC app = info->GetAppNameL( useSharedIcon ); 

        // Application icon
        iconTemp = info->GetAppIconL( useSharedIcon );
        icon = CGulIcon::NewL();
        icon->SetBitmapsOwnedExternally( ETrue );
        icon->SetBitmap( iconTemp->Bitmap() );
        icon->SetMask( iconTemp->Mask() );

        icons->AppendL( icon );

        listItem->Des().Format( KFormat, i, &iap, &app );
        items->AppendL( listItem->Des() );

        CleanupStack::PopAndDestroy( listItem ); // listItem
        }

    // set new item list
    SetItemTextArray( items );
    // set icon list
    SetIconArrayL( icons );
    // we don't have to take care of delete items
    SetOwnershipType( ELbmOwnsItemArray );

    CleanupStack::Pop( icons );
    CleanupStack::Pop( items );
    
    iExpiryTimer = CExpiryTimer::NewL( *this );
    iExpiryTimer->Start();

    CLOG_LEAVEFN("CDisconnectDlgDialog::PreLayoutDynInitL");
    }
Exemple #15
0
/*
 * Landmark objects will make use of an SVG file for rendering (demo purposes)
 */
void CLMXObject::ConstructL()
{
    _LIT(KIconFile, "\\resource\\apps\\Landmarks_0x2002E1AF.mif");

    CGulIcon* icon = CreateIconL(KIconFile, EMbmLandmarks_0x2002e1afIcon, EMbmLandmarks_0x2002e1afIcon_mask);
    CleanupStack::PushL(icon);

    CFbsBitmap* bitmap = icon->Bitmap();    // Ownership NOT transferred
    CFbsBitmap* mask   = icon->Mask();      // Ownership NOT transferred

    // Always expect 16M bitmap to make conversion to GL_RGBA easier 
    if (bitmap->DisplayMode() != EColor16M)
    {
        bitmap = new(ELeave) CFbsBitmap;
        CleanupStack::PushL(bitmap);

        User::LeaveIfError(bitmap->Create(icon->Bitmap()->SizeInPixels(), EColor16M));

        CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmap);
        CleanupStack::PushL(bitmapDevice);

        CFbsBitGc* bitmapContext = 0;
        User::LeaveIfError(bitmapDevice->CreateContext(bitmapContext));
        CleanupStack::PushL(bitmapContext);

        bitmapContext->BitBlt(TPoint(0, 0), icon->Bitmap());

        CleanupStack::PopAndDestroy(2, bitmapDevice);

        icon->SetBitmap(bitmap);    // Ownership transferred

        CleanupStack::Pop(bitmap);
    }

    // Always expect 256 mask to make conversion to GL_RGBA easier 
    if (mask->DisplayMode() != EGray256)
    {
        mask = new(ELeave) CFbsBitmap;
        CleanupStack::PushL(mask);

        User::LeaveIfError(mask->Create(icon->Mask()->SizeInPixels(), EGray256));

        CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(mask);
        CleanupStack::PushL(bitmapDevice);

        CFbsBitGc* bitmapContext = 0;
        User::LeaveIfError(bitmapDevice->CreateContext(bitmapContext));
        CleanupStack::PushL(bitmapContext);

        bitmapContext->BitBlt(TPoint(0, 0), icon->Mask());

        CleanupStack::PopAndDestroy(2, bitmapDevice);

        icon->SetMask(mask);    // Ownership transferred

        CleanupStack::Pop(mask);
    }

    // Now bitmap and mask point to either original or converted bitmaps, 
    // and ownership belongs to icon

    const TSize bitmapSize = bitmap->SizeInPixels();

    // sizeof(TUint32) == sizeof(RGBA)
    const TInt dataSize = bitmapSize.iWidth * bitmapSize.iHeight * sizeof(TUint32);
    TUint8* data = new(ELeave) TUint8[dataSize];

    // Perform copy and conversion from BGR(A) to RGB(A)
    bitmap->LockHeap();
    mask->LockHeap();

    // TODO: Alpha component removed, as it seems to be corrupted from
    // subsequent reads from SVG file

    TUint8* rgb = reinterpret_cast<TUint8*>(bitmap->DataAddress());
//    TUint8* alpha = reinterpret_cast<TUint8*>(mask->DataAddress());

    for(TInt i = 0, j = 0; i < dataSize; i += 4, j += 3)
    {
        data[i + 0] = rgb[j + 2];
        data[i + 1] = rgb[j + 1];
        data[i + 2] = rgb[j + 0];
        data[i + 3] = 0xc0; //alpha[i / 4];
    }

    // Generate OpenGL texture
    ::glGenTextures(1, &iTextureId); 
    ::glBindTexture(GL_TEXTURE_2D, iTextureId);

    ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    ::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bitmapSize.iWidth, bitmapSize.iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);

    mask->UnlockHeap();
    bitmap->UnlockHeap();

    delete data;

    CleanupStack::PopAndDestroy(icon);
}