00001 #define INITGUID
00002 #include "../../Library/SDK_Manila_Sense.h"
00003 #include "textfile.h"
00004
00005
00006 map<DWORD,IImagingFactory*> Element::runningThread;
00007 vector<Element*> Element::listElements;
00008 EventHandler* Element::gestEvent=NULL;
00009 bool Element::noError=false;
00010
00011 IImagingFactory *Element::pImgFactory=NULL;
00012
00013 Element::Element(int idElement, int &x,int &y, int type,bool rP){
00014 gi=GlobalInformations::getInstance();
00015 typeElement=type;
00016 paddingSup=0;
00017 if(!rP){
00018 x=x*gi->percentOfVGA;
00019 y=y*gi->percentOfVGA;
00020 }
00021
00022 listElements.push_back(this);
00023 this->idElement=idElement;
00024 this->owner=NULL;
00025
00026 position.bottom=y;
00027 position.top=y;
00028 position.left=x;
00029 position.right=x;
00030
00031 positionAbsolute.bottom=0;
00032 positionAbsolute.top=0;
00033 positionAbsolute.left=0;
00034 positionAbsolute.right=0;
00035
00036 isActivated=false;
00037 mouseEvent=MouseCtrl::getInstance();
00038 };
00039
00040
00041 Element::~Element(){
00042 int nbElement=listElements.size()-1;
00043 int i=0;
00044 while(i<nbElement&&listElements[i]!=this){
00045 i++;
00046 }
00047 ASSERT(listElements[i]==this);
00048 for (int j=i;j<nbElement;j++)
00049 {
00050 listElements[j]=listElements[j+1];
00051 }
00052 listElements[nbElement]=NULL;
00053 listElements.pop_back();
00054 }
00055
00056 void Element::add(Element* e,int minHeight,int pos,bool mixWithOther){
00057 MessageBox(NULL,LocalisedString::AddElemError,L"Error : Element.add virtual !",MB_OK | MB_ICONEXCLAMATION);
00058 };
00059
00060 IImagingFactory* Element::getIImagingFactory(){
00061 DWORD idTmp=GetCurrentThreadId();
00062 map<DWORD,IImagingFactory*>::iterator it=runningThread.find(idTmp);
00063 if (it==runningThread.end())
00064 {
00065 IImagingFactory* tmp=NULL;
00066
00067 CoInitializeEx(NULL, COINIT_MULTITHREADED);
00068 CoCreateInstance (CLSID_ImagingFactory,NULL,
00069 CLSCTX_INPROC_SERVER,IID_IImagingFactory,
00070 (void **)&tmp);
00071 runningThread[idTmp]=tmp;
00072 return tmp;
00073 }else
00074 return runningThread[idTmp];
00075 }
00076
00077 RECT Element::patchImage(DIRECTDRAW_GDI * bkg,wstring *name,int nbPatch,int posX,int posY){
00078
00079 IImage *pImage = NULL;
00080
00081 unsigned char decal=name->length();
00082 if(decal>20)
00083 decal=name->length()-20;
00084
00085 getIImagingFactory()->CreateImageFromFile(name->c_str(),&pImage);
00086 if(pImage==NULL){
00087 const WCHAR* nameImg=name->c_str()+decal;
00088 LocalisedString::explainFail(LocalisedString::LoadImageError,nameImg,0);
00089 IBitmapImage* ibp;
00090 getIImagingFactory()->CreateNewBitmap(4,4,PixelFormat16bppRGB565,&ibp);
00091 ibp->QueryInterface(IID_IImage, (void**)&pImage);
00092 nbPatch=1;
00093 }
00094
00095 DIRECTDRAW_GDI *out=bkg;
00096
00097 ImageInfo im;
00098 pImage->GetImageInfo(&im);
00099
00100
00101
00102 RECT posPatch={0,posY,0,posY+im.Height};
00103 int widthImg=out->width/nbPatch;
00104
00105 HDC hdc=out->deviceInterface;
00106
00107 for(int i=0;i<nbPatch;i++){
00108 posPatch.left=posX+widthImg*i;
00109 posPatch.right=posPatch.left+im.Width;
00110 pImage->Draw(hdc, &posPatch, NULL);
00111 }
00112
00113 pImage->Release();
00114
00115 posPatch.left=0;
00116 posPatch.right=im.Width;
00117 posPatch.top=0;
00118 posPatch.bottom=im.Height;
00119
00120 return posPatch;
00121 };
00122
00123
00124
00125 bool Element::ConvertToDIB(HBITMAP& hBitmap)
00126 {
00127 bool bConverted = false;
00128 BITMAP stBitmap;
00129 if (GetObject(hBitmap, sizeof(stBitmap),
00130 &stBitmap) && !stBitmap.bmBits)
00131 {
00132
00133
00134
00135 HDC hScreen = GetDC(NULL);
00136 if (hScreen)
00137 {
00138 union {
00139 BITMAPINFO stBitmapInfo;
00140 BYTE pReserveSpace[sizeof(BITMAPINFO)
00141 + 0xFF * sizeof(RGBQUAD)];
00142 };
00143 ZeroMemory(pReserveSpace, sizeof(pReserveSpace));
00144 stBitmapInfo.bmiHeader.biSize = sizeof(stBitmapInfo.bmiHeader);
00145 stBitmapInfo.bmiHeader.biWidth = stBitmap.bmWidth;
00146 stBitmapInfo.bmiHeader.biHeight = -stBitmap.bmHeight;
00147 stBitmapInfo.bmiHeader.biPlanes = 1;
00148 stBitmapInfo.bmiHeader.biBitCount = stBitmap.bmBitsPixel;
00149 stBitmapInfo.bmiHeader.biCompression = BI_RGB;
00150
00151 if (stBitmap.bmBitsPixel <= 8)
00152 {
00153 stBitmapInfo.bmiHeader.biClrUsed =
00154 1 << stBitmap.bmBitsPixel;
00155
00156
00157
00158
00159 }
00160 stBitmapInfo.bmiHeader.biClrImportant =
00161 stBitmapInfo.bmiHeader.biClrUsed;
00162
00163 PVOID pBits;
00164 HBITMAP hDib = CreateDIBSection(hScreen,
00165 &stBitmapInfo, DIB_RGB_COLORS, &pBits, NULL, 0);
00166
00167 if (hDib)
00168 {
00169
00170
00171
00172
00173 HDC hMemSrc = CreateCompatibleDC(NULL);
00174 if (hMemSrc)
00175 {
00176 HGDIOBJ hOldSrc = SelectObject(hMemSrc, hBitmap);
00177 if (hOldSrc)
00178 {
00179 HDC hMemDst = CreateCompatibleDC(NULL);
00180 if (hMemDst)
00181 {
00182 HGDIOBJ hOldDst = SelectObject(hMemDst, hDib);
00183 if (hOldDst)
00184 {
00185 if (stBitmap.bmBitsPixel <= 8)
00186 {
00187
00188
00189 HPALETTE hPalette =
00190 (HPALETTE) GetCurrentObject(hMemSrc, OBJ_PAL);
00191 if (hPalette)
00192 {
00193 PALETTEENTRY pPaletteEntries[0x100];
00194 UINT nEntries = GetPaletteEntries(hPalette,
00195 0, stBitmapInfo.bmiHeader.biClrUsed,
00196 pPaletteEntries);
00197 if (nEntries)
00198 {
00199 ASSERT(nEntries <= 0x100);
00200 for (UINT nIndex = 0; nIndex < nEntries; nIndex++)
00201 pPaletteEntries[nEntries].peFlags = 0;
00202 VERIFY(SetDIBColorTable(hMemDst, 0,
00203 nEntries, (RGBQUAD*) pPaletteEntries) == nEntries);
00204
00205 }
00206 }
00207 }
00208
00209
00210
00211
00212
00213
00214
00215 if (BitBlt(hMemDst, 0, 0, stBitmap.bmWidth,
00216 stBitmap.bmHeight, hMemSrc, 0, 0, SRCCOPY))
00217 bConverted = true;
00218
00219
00220 VERIFY(SelectObject(hMemDst, hOldDst));
00221 }
00222 VERIFY(DeleteDC(hMemDst));
00223 }
00224 VERIFY(SelectObject(hMemSrc, hOldSrc));
00225 }
00226 VERIFY(DeleteDC(hMemSrc));
00227 }
00228
00229 if (bConverted)
00230 {
00231 VERIFY(DeleteObject(hBitmap));
00232
00233 hBitmap = hDib;
00234 }
00235 else
00236 VERIFY(DeleteObject(hDib));
00237 }
00238 ReleaseDC(NULL, hScreen);
00239 }
00240 }
00241 return bConverted;
00242 }
00243
00244 IImage* Element::getImgFromBuffer(BitmapData* dataBuffer){
00245 IBitmapImage* pBitmapImg;
00246 HRESULT hres = getIImagingFactory()->CreateBitmapFromBuffer(dataBuffer, &pBitmapImg);
00247 if(hres!=S_OK)
00248 LocalisedString::explainFailIImage(hres,L"getImgFromBuffer CreateBitmapFromBuffer...");
00249
00250 IImage* pImage=NULL;
00251 hres = pBitmapImg->QueryInterface(IID_IImage, (void**)&pImage);
00252 if(hres!=S_OK)
00253 LocalisedString::explainFailIImage(hres,L"getImgFromBuffer QueryInterface...");
00254 return pImage;
00255 }
00256
00257
00258
00259
00260 bool Element::saveIcon(HICON myIcon,wstring fileDst){
00261 ICONINFO icInfo;
00262 GetIconInfo(myIcon,&icInfo);
00263
00264 BITMAP bmIcon,bmMask;
00265 GetObject(icInfo.hbmColor, sizeof(bmIcon), &bmIcon);
00266 GetObject(icInfo.hbmMask, sizeof(bmMask), &bmMask);
00267
00268 if(!ConvertToDIB(icInfo.hbmColor)){
00269 return false;
00270 };
00271 if(!ConvertToDIB(icInfo.hbmMask)){
00272 return false;
00273 };
00274 GetObject(icInfo.hbmColor, sizeof(bmIcon), &bmIcon);
00275 GetObject(icInfo.hbmMask, sizeof(bmMask), &bmMask);
00276
00277 if(bmIcon.bmBitsPixel==0){
00278 return false;
00279 }
00280 int iconSize=bmIcon.bmWidth;
00281
00282 PixelFormat pixelFormat;
00283 BitmapData bmData = {0};
00284
00285 int nStride = bmIcon.bmWidth * 32/8;
00286 if( (nStride % 4) != 0)
00287 nStride += 4-(nStride % 4);
00288
00289 bmData.Width = bmIcon.bmWidth;
00290 bmData.Height = bmIcon.bmHeight;
00291 bmData.Stride = nStride;
00292 int widthS;
00293 switch (bmIcon.bmBitsPixel)
00294 {
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320 default:
00321 pixelFormat = PixelFormat32bppARGB;
00322 widthS=bmData.Stride/4;
00323 }
00324
00325 bmData.PixelFormat=pixelFormat;
00326
00327
00328 int nbOpaque=0;
00329 DWORD* buff=new DWORD[widthS*bmData.Height];
00330 if(bmIcon.bmBitsPixel>24){
00331 for (unsigned int i=0;i<bmData.Height;i++)
00332 {
00333 for(int j=0;j<widthS;j++){
00334 buff[i*bmData.Width+j]=((DWORD*)bmIcon.bmBits)[i*bmData.Width+j];
00335 }
00336 }
00337 }else{
00338 if(bmIcon.bmBitsPixel==24){
00339 int posCpt=0;
00340 char* destBuff=(char*)buff;
00341 for (unsigned int i=0;i<bmData.Height;i++)
00342 {
00343 for(int j=0;j<widthS;j++){
00344 destBuff[i*4*bmData.Width+j*4]=((char*)bmIcon.bmBits)[posCpt++];
00345 destBuff[i*4*bmData.Width+j*4+1]=((char*)bmIcon.bmBits)[posCpt++];
00346 destBuff[i*4*bmData.Width+j*4+2]=((char*)bmIcon.bmBits)[posCpt++];
00347 destBuff[i*4*bmData.Width+j*4+3]=0xFF;
00348 }
00349 }
00350 nbOpaque=bmData.Height*bmData.Width;
00351 }else{
00352 WORD maskPxl;
00353 if(bmIcon.bmBitsPixel==16){
00354 WORD pixel;
00355 for (unsigned int i=0;i<bmData.Height;i++)
00356 {
00357 for(unsigned int j=0;j<bmData.Width;j++){
00358 pixel=((WORD*)bmIcon.bmBits)[i*bmData.Width+j];
00359
00360
00361
00362 if(bmMask.bmBitsPixel==1){
00363 uchar tmp1=i;
00364 uchar tmp2=j/8;
00365 uchar pixTmp=((uchar*)bmMask.bmBits)[tmp1*bmMask.bmWidthBytes+tmp2];
00366 maskPxl=pixTmp&(uchar)pow(2,7-(j%8));
00367 if (maskPxl==0)
00368 buff[i*bmData.Width+j]=RGBA555to32(0,pixel);
00369 else{
00370 buff[i*bmData.Width+j]=RGBA555to32(0xFF000000,pixel);
00371 nbOpaque++;
00372 }
00373 }else{
00374 buff[i*bmData.Width+j]=RGBA555to32(0xFF000000,pixel);
00375 nbOpaque=200;
00376 }
00377 }
00378 }
00379 }else{
00380 HDC hMemDC=NULL;
00381 HBITMAP hOldBitmap=NULL;
00382 RGBQUAD rgb[256];
00383
00384
00385 hMemDC = CreateCompatibleDC( NULL );
00386 hOldBitmap = (HBITMAP)SelectObject( hMemDC, icInfo.hbmColor );
00387
00388 GetDIBColorTable( hMemDC, 0, 256, rgb );
00389 SelectObject( hMemDC, hOldBitmap );
00390 DeleteDC( hMemDC );
00391
00392 uchar pixel;
00393 for (unsigned int i=0;i<bmData.Height;i++)
00394 {
00395 for(unsigned int j=0;j<bmData.Width;j++){
00396 pixel=((uchar*)bmIcon.bmBits)[i*bmData.Width+j];
00397 if(bmMask.bmBitsPixel==1){
00398 uchar tmp1=i;
00399 uchar tmp2=j/8;
00400 uchar pixTmp=((uchar*)bmMask.bmBits)[tmp1*bmMask.bmWidthBytes+tmp2];
00401 maskPxl=pixTmp&(uchar)pow(2,7-(j%8));
00402 if (maskPxl==0)
00403 buff[i*bmData.Width+j]=(DWORD)0x00FFFFFF&((DWORD)rgb[pixel].rgbReserved)<<24|((DWORD)rgb[pixel].rgbRed)<<16|((DWORD)rgb[pixel].rgbGreen)<<8|rgb[pixel].rgbBlue;
00404 else{
00405 buff[i*bmData.Width+j]=(DWORD)0xFF000000|((DWORD)rgb[pixel].rgbReserved)<<24|((DWORD)rgb[pixel].rgbRed)<<16|((DWORD)rgb[pixel].rgbGreen)<<8|rgb[pixel].rgbBlue;
00406 nbOpaque++;
00407 }
00408 }else{
00409 buff[i*bmData.Width+j]=(DWORD)0xFF000000|((DWORD)rgb[pixel].rgbReserved)<<24|((DWORD)rgb[pixel].rgbRed)<<16|((DWORD)rgb[pixel].rgbGreen)<<8|rgb[pixel].rgbBlue;
00410 nbOpaque=200;
00411 }
00412 }
00413 }
00414 }
00415 }
00416 }
00417
00418 if(nbOpaque==0){
00419 for (int i=0;i<bmData.Height;i++)
00420 {
00421 for(int j=0;j<bmData.Width;j++){
00422 if (buff[i*bmData.Width+j]!=0)
00423 buff[i*bmData.Width+j]=0xFF000000|buff[i*bmData.Width+j];
00424 }
00425 }
00426 }
00427
00428 if(nbOpaque==bmData.Height*bmData.Width){
00429 for (int i=0;i<bmData.Height;i++)
00430 {
00431 for(int j=0;j<bmData.Width;j++){
00432 if (buff[i*bmData.Width+j]==0xFF000000)
00433 buff[i*bmData.Width+j]=0;
00434 }
00435 }
00436 }
00437 bmData.Scan0 = buff;
00438
00439 HRESULT hres = S_OK;
00440 IImage* pImage=getImgFromBuffer(&bmData);
00441 ImageInfo imIn;
00442 hres = pImage->GetImageInfo(&imIn);
00443
00444
00445 UINT count=0;
00446 ImageCodecInfo* encoders=NULL;
00447 getIImagingFactory()->GetInstalledEncoders(&count,&encoders);
00448 int cpt=0;
00449 while(cpt<count&&encoders[cpt].FormatID!=ImageFormatPNG)
00450 cpt++;
00451 if(cpt<count){
00452
00453 IImageEncoder *myEncoder=NULL;
00454 HRESULT hr;
00455 if (FAILED(hr=getIImagingFactory()->CreateImageEncoderToFile(&encoders[cpt].Clsid,fileDst.c_str(), &myEncoder)))
00456 {
00457 LocalisedString::explainFailIImage(hr,L"CreateImageEncoderToFile");
00458 goto exit;
00459 }
00460 IImageSink* sinkOfImg=NULL;
00461 if (FAILED(hr=myEncoder->GetEncodeSink(&sinkOfImg)))
00462 {
00463 LocalisedString::explainFailIImage(hr,L"GetEncodeSink");
00464 goto exit;
00465 }
00466 if (FAILED(hr=sinkOfImg->BeginSink(&imIn,NULL)))
00467 {
00468 LocalisedString::explainFailIImage(hr,L"BeginSink");
00469 goto exit;
00470 }
00471
00472 if (FAILED(hr=pImage->PushIntoSink(sinkOfImg)))
00473 {
00474 LocalisedString::explainFailIImage(hr,L"PushIntoSink");
00475 goto exit;
00476 }
00477
00478 myEncoder->TerminateEncoder();
00479 myEncoder->Release();
00480 sinkOfImg->Release();
00481 myEncoder->Release();
00482 }
00483 CoTaskMemFree(&encoders);
00484
00485
00486 pImage->Release();
00487
00488 delete []buff;
00489 return true;
00490
00491 exit:
00492
00493 pImage->Release();
00494
00495 delete []buff;
00496 return false;
00497 };
00498
00499 HICON Element::loadIcon(wstring fileDst,wstring link){
00500 HICON hIconLarge=0, hIconSmall=0,myIcon=0;
00501
00502 myIcon=ExtractIconEx(fileDst.c_str(), 0,&hIconLarge, &hIconSmall,1);
00503 if(myIcon==NULL){
00504
00505 TextFile tf;
00506 if(tf.Open(link.c_str(),TF_READ)>=0){
00507 WCHAR *myLine=NULL;
00508 int nbChar=tf.ReadLine(NULL,&myLine);
00509 wstring line=myLine;
00510 int posInter=line.find(L"?");
00511 if(posInter!=wstring::npos){
00512 line=line.substr(posInter+1);
00513 posInter=line.find(L",");
00514 if(posInter!=wstring::npos){
00515 wstring indexRes=line.substr(posInter+1);
00516 if(line.find(L"ceshell")!=wstring::npos)
00517 line=L"\\windows\\shellres.dll";
00518 else
00519 line=line.substr(0,posInter);
00520 wstringstream outNB;
00521 outNB<<indexRes;
00522 int id;
00523 outNB>>id;
00524 myIcon=ExtractIconEx(line.c_str(), id,&hIconLarge, &hIconSmall,1);
00525 if(myIcon==NULL){
00526 wstring lineTmp=line.substr(0,line.find_last_of(L'.'));
00527 lineTmp=lineTmp+L".192";
00528 line=lineTmp+line.substr(line.find_last_of(L'.'));
00529 myIcon=ExtractIconEx(line.c_str(), id,&hIconLarge, &hIconSmall,1);
00530 }
00531 }
00532 }
00533 }
00534 }
00535 if(myIcon==NULL){
00536 return 0;
00537 }
00538 if(hIconLarge==myIcon&&hIconSmall!=0)
00539 DestroyIcon(hIconSmall);
00540 if(hIconSmall==myIcon&&hIconLarge!=0)
00541 DestroyIcon(hIconLarge);
00542
00543 return myIcon;
00544 }
00545
00546
00547 IImage * Element::loadIImage(wstring *name){
00548 IImage *pImage = NULL;
00549
00550 unsigned char decal=name->length();
00551 if(decal>20)
00552 decal=name->length()-20;
00553 else
00554 decal=0;
00555
00556 getIImagingFactory()->CreateImageFromFile(name->c_str(),&pImage);
00557 if(pImage==NULL){
00558 if(noError)
00559 return NULL;
00560 const WCHAR* nameImg=name->c_str()+decal;
00561 LocalisedString::explainFail(LocalisedString::LoadImageError,nameImg,0);
00562 IBitmapImage* ibp;
00563 getIImagingFactory()->CreateNewBitmap(4,4,PixelFormat16bppRGB565,&ibp);
00564 ibp->QueryInterface(IID_IImage, (void**)&pImage);
00565 return pImage;
00566 }
00567 return pImage;
00568 }
00569
00570 void Element::resizeIImage(wstring *name){
00571 IImage *pImage = NULL;
00572
00573 unsigned char decal=name->length();
00574 if(decal>20)
00575 decal=name->length()-20;
00576 else
00577 decal=0;
00578
00579 getIImagingFactory()->CreateImageFromFile(name->c_str(),&pImage);
00580 if(pImage==NULL){
00581 return;
00582 }
00583 ImageInfo imIn;
00584 pImage->GetImageInfo(&imIn);
00585 IBitmapImage* newImgResized=NULL;
00586 GlobalInformations* giGlobal=GlobalInformations::getInstance();
00587 imIn.Width*=giGlobal->percentOfVGA;
00588 imIn.Height*=giGlobal->percentOfVGA;
00589 getIImagingFactory()->CreateBitmapFromImage(pImage,imIn.Width,imIn.Height,
00590 imIn.PixelFormat,InterpolationHintBicubic,&newImgResized);
00591 pImage->Release();
00592 if(newImgResized!=NULL){
00593
00594 IImage *pImage1 = NULL;
00595 newImgResized->QueryInterface(IID_IImage, (void**)&pImage1);
00596 pImage1->GetImageInfo(&imIn);
00597
00598
00599 UINT count=0;
00600 ImageCodecInfo* encoders=NULL;
00601 getIImagingFactory()->GetInstalledEncoders(&count,&encoders);
00602 unsigned int cpt=0;
00603 while(cpt<count&&encoders[cpt].FormatID!=ImageFormatPNG)
00604 cpt++;
00605 if(cpt<count){
00606
00607 IImageEncoder *myEncoder=NULL;
00608 HRESULT hr;
00609 if (FAILED(hr=getIImagingFactory()->CreateImageEncoderToFile(&encoders[cpt].Clsid,name->c_str(), &myEncoder)))
00610 {
00611 LocalisedString::explainFailIImage(hr,L"CreateImageEncoderToFile");
00612 return;
00613 }
00614 IImageSink* sinkOfImg=NULL;
00615 if (FAILED(hr=myEncoder->GetEncodeSink(&sinkOfImg)))
00616 {
00617 LocalisedString::explainFailIImage(hr,L"GetEncodeSink");
00618 return;
00619 }
00620 if (FAILED(hr=sinkOfImg->BeginSink(&imIn,NULL)))
00621 {
00622 LocalisedString::explainFailIImage(hr,L"BeginSink");
00623 return;
00624 }
00625
00626 if (FAILED(hr=pImage1->PushIntoSink(sinkOfImg)))
00627 {
00628 LocalisedString::explainFailIImage(hr,L"PushIntoSink");
00629 return;
00630 }
00631
00632 myEncoder->TerminateEncoder();
00633 sinkOfImg->Release();
00634 myEncoder->Release();
00635 }
00636 CoTaskMemFree(&encoders);
00637
00638 newImgResized->Release();
00639 }
00640 }
00641
00642 DIRECTDRAW_GDI * Element::fromIImageToGDI( IImage** src,bool force32bits )
00643 {
00644 IImage* pImage=*src;
00645 DIRECTDRAW_GDI *out=new DIRECTDRAW_GDI;
00646 out->directDrawSurf=NULL;
00647
00648 ImageInfo imageInfo;
00649 pImage->GetImageInfo( &imageInfo );
00650 if(force32bits){
00651 imageInfo.PixelFormat=PixelFormat32bppPARGB;
00652 }
00653 IBitmapImage* pBitmapImage = NULL;
00654 getIImagingFactory()->CreateBitmapFromImage( pImage, 0, 0,imageInfo.PixelFormat, InterpolationHintNearestNeighbor , &pBitmapImage );
00655 RECT rect={ 0, 0, imageInfo.Width, imageInfo.Height };
00656 BitmapData bitmapData;
00657 pBitmapImage->LockBits(&rect, ImageLockModeRead, imageInfo.PixelFormat, &bitmapData );
00658 out->bitmap = CreateBitmap( imageInfo.Width, imageInfo.Height, 1, GetPixelFormatSize( imageInfo.PixelFormat ), bitmapData.Scan0 );
00659
00660 BITMAP bm;
00661 GetObject(out->bitmap, sizeof(bm), &bm);
00662 out->width=bm.bmWidth;
00663 out->height=bm.bmHeight;
00664 out->nbBPP=bm.bmBitsPixel;
00665
00666
00667
00668
00669 out->deviceInterface = CreateCompatibleDC(NULL);
00670 if (!out->deviceInterface) {
00671 LocalisedString::explainFail(LocalisedString::szGetDC,L"Section: CreateCompatibleDC(NULL);");
00672 return NULL;
00673 }
00674 out->oldObj=SelectObject(out->deviceInterface, out->bitmap);
00675 pImage->Release();
00676 pBitmapImage->Release();
00677 *src=NULL;
00678 return out;
00679 }
00680
00681 DIRECTDRAW_GDI * Element::loadImage(wstring *name,bool rescall,bool transparent){
00682 #ifdef DRAWING_GDI
00683 DIRECTDRAW_GDI *out;
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700 IImage* pImage=loadIImage( name);
00701 if(pImage==NULL)
00702 return NULL;
00703 bool force32b=name->find(L".png")!=wstring::npos;
00704 out=fromIImageToGDI(&pImage,force32b);
00705
00706 if(rescall){
00707 int oldH=out->height;
00708 int oldW=out->width;
00709 GlobalInformations* giGlobal=GlobalInformations::getInstance();
00710 out->width=out->width*giGlobal->percentOfVGA;
00711 out->height=out->height*giGlobal->percentOfVGA;
00712 HDC cDC = CreateCompatibleDC(NULL);
00713 HBITMAP hbmp = CreateCompatibleBitmap( out->deviceInterface, out->width, out->height );
00714 HGDIOBJ oldObj=SelectObject( cDC, hbmp );
00715 if (StretchBlt(cDC,
00716 0,0,out->width,out->height,
00717 out->deviceInterface,
00718 0,0,oldW,oldH,SRCCOPY)==0){
00719 LocalisedString::explainFailWinAPI(L"StretchBlt error");
00720 }
00721 SelectObject(out->deviceInterface, out->oldObj);
00722 DeleteObject (out->bitmap);
00723 DeleteDC(out->deviceInterface);
00724 out->oldObj=oldObj;
00725 out->bitmap=hbmp;
00726 out->deviceInterface=cDC;
00727 }
00728
00729 return out;
00730 #endif
00731
00732 #ifdef DRAWING_DDRAW
00733 IImage *pImage = NULL;
00734 DIRECTDRAW_GDI *out=new DIRECTDRAW_GDI;
00735
00736 unsigned char decal=name->length();
00737 if(decal>20)
00738 decal=name->length()-20;
00739 else
00740 decal=0;
00741
00742 getIImagingFactory()->CreateImageFromFile(name->c_str(),&pImage);
00743 if(pImage==NULL){
00744 const WCHAR* nameImg=name->c_str()+decal;
00745 LocalisedString::explainFail(LocalisedString::LoadImageError,nameImg,0);
00746 DDSURFACEDESC ddsd;
00747 memset(&ddsd, 0, sizeof(ddsd));
00748 ddsd.dwSize = sizeof(ddsd);
00749 ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
00750 ddsd.dwWidth = 4;
00751 ddsd.dwHeight = 4;
00752 HRESULT hRet = (*gi->ldDDraw)->CreateSurface(&ddsd, &out->directDrawSurf, NULL );
00753 if (hRet != DD_OK)
00754 LocalisedString::explainFailDirectDraw(hRet,L"loadImage CreateSurface");
00755 out->directDrawSurf->GetDC(&out->deviceInterface);
00756 return out;
00757 }
00758
00759 if(rescall){
00760 ImageInfo imIn;
00761 pImage->GetImageInfo(&imIn);
00762 IBitmapImage* newImgResized=NULL;
00763 imIn.Width*=gi->percentOfVGA;
00764 imIn.Height*=gi->percentOfVGA;
00765 getIImagingFactory()->CreateBitmapFromImage(pImage,imIn.Width,imIn.Height,
00766 imIn.PixelFormat,InterpolationHintBicubic,&newImgResized);
00767 if(newImgResized!=NULL){
00768 pImage->Release();
00769 pImage = NULL;
00770 newImgResized->QueryInterface(IID_IImage, (void**)&pImage);
00771 }
00772 }
00773
00774 ImageInfo im;
00775 pImage->GetImageInfo(&im);
00776
00777 DDSURFACEDESC ddsd;
00778 memset(&ddsd, 0, sizeof(ddsd));
00779 ddsd.dwSize = sizeof(ddsd);
00780 ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
00781 ddsd.dwWidth = im.Width;
00782 ddsd.dwHeight = im.Height;
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808
00809 HRESULT hRet = (*gi->ldDDraw)->CreateSurface(&ddsd, &out->directDrawSurface, NULL );
00810 if (hRet != DD_OK)
00811 LocalisedString::explainFailDirectDraw(hRet,L"loadImage CreateSurface");
00812 hRet = out->directDrawSurface->GetDC(&out->deviceInterface);
00813 if (hRet != DD_OK)
00814 LocalisedString::explainFailDirectDraw(hRet,L"loadImage GetDC");
00815
00816
00817 DDBLTFX ddbltfx;
00818 memset(&ddbltfx, 0, sizeof(ddbltfx));
00819 ddbltfx.dwSize = sizeof(ddbltfx);
00820 ddbltfx.dwFillColor = BACKGROUND_COLOR_MANILA;
00821
00822
00823 hRet = gi->window->BltFast(out, NULL, NULL, NULL, DDBLT_COLORFILL|DDBLT_WAITNOTBUSY, &ddbltfx);
00824 if (hRet != DD_OK)
00825 LocalisedString::explainFailDirectDraw(hRet,L"loadImage init Blt");
00826
00827 DDCOLORKEY ddck;
00828 memset(&ddck, 0, sizeof(ddck));
00829 ddck.dwColorSpaceHighValue = ddbltfx.dwFillColor;
00830 ddck.dwColorSpaceLowValue = ddck.dwColorSpaceHighValue;
00831 hRet = out->directDrawSurface->SetColorKey(DDCKEY_SRCBLT,&ddck);
00832 if (hRet != DD_OK)
00833 LocalisedString::explainFailDirectDraw(hRet,L"out SetColorKey");
00834
00835 RECT sizeImg={0,0,im.Width,im.Height};
00836 HDC hdc;
00837 hdc=out->deviceInterface;
00838
00839 HRESULT h=pImage->Draw(hdc, &sizeImg, NULL);
00840 if(h!=S_OK){
00841 const WCHAR* nameImg=name->c_str()+decal;
00842 LocalisedString::explainFailIImage(h,nameImg);
00843 }
00844
00845 pImage->Release();
00846 #endif
00847 return out;
00848
00849 };
00850
00851 void Element::setMustRedraw(){
00852 if(positionAbsolute.right==positionAbsolute.bottom&&
00853 positionAbsolute.bottom==0)
00854 return;
00855 positionAbsolute.right=positionAbsolute.left+this->getWidth();
00856 if(positionAbsolute.right>GetSystemMetrics(SM_CXSCREEN))
00857 positionAbsolute.right=GetSystemMetrics(SM_CXSCREEN);
00858 if(positionAbsolute.left<0)
00859 positionAbsolute.left=0;
00860 positionAbsolute.bottom=positionAbsolute.top+this->getHeight();
00861 if(positionAbsolute.bottom>GetSystemMetrics(SM_CYSCREEN))
00862 positionAbsolute.bottom=GetSystemMetrics(SM_CYSCREEN);
00863 if(positionAbsolute.top<gi->rs.top)
00864 positionAbsolute.top=gi->rs.top;
00865 if(positionAbsolute.bottom-positionAbsolute.top>0&&
00866 positionAbsolute.right-positionAbsolute.left>0){
00867 gi->window->addToRedraw(positionAbsolute,true);
00868 }
00869 }
00870
00871
00872 bool Element::run(bool isRightClick){
00873 if(isRightClick){
00874 getGestEvent()->messageTreatment(this,EVENT_RIGHT_CLICK);
00875
00876 }else{
00877 getGestEvent()->messageTreatment(this,EVENT_CLICK);
00878
00879 }
00880 return false;
00881 };
00882
00883 void Element::sendMsg(int wParam,void* lParam){
00884 gestEvent->messageProc(lParam,wParam);
00885 };
00886
00887 Element* Element::getElementByID(int id,int typeExpected){
00888 int nbElement=listElements.size();
00889 for(int i=0;i<nbElement;i++){
00890 if (listElements[i]->idElement==id){
00891 if(typeExpected<=0)
00892 return listElements[i];
00893 else{
00894 if (typeExpected==listElements[i]->typeElement)
00895 {
00896 return listElements[i];
00897 }
00898 }
00899 }
00900 }
00901 return NULL;
00902 };
00903
00904 void Element::redraw(){
00905 int nbElement=listElements.size();
00906 for(int i=0;i<nbElement;i++){
00907 listElements[i]->setMustRedraw();
00908 }
00909
00910 };
00911
00912 void Element::reloadAllSurface(){
00913 DWORD dwWidth = GetSystemMetrics(SM_CXSCREEN);
00914 DWORD dwHeight = GetSystemMetrics(SM_CYSCREEN);
00915 DDSURFACEDESC dd;
00916 ZeroMemory(&dd,sizeof(dd));
00917 dd.dwHeight=dwHeight;
00918 dd.dwWidth=dwWidth;
00919 DDBLTFX ddbl;
00920 ddbl.dwFillColor=DirectDrawWarp::background_color;
00921
00922 GlobalInformations* giGlobal=GlobalInformations::getInstance();
00923
00924 if(Section::scrollBar!=NULL){
00925 if(Section::scrollBar->directDrawSurf!=NULL){
00926 Section::scrollBar->directDrawSurf->ReleaseDC(Section::scrollBar->deviceInterface);
00927 Section::scrollBar->directDrawSurf->Release();
00928 }else{
00929 if(Section::scrollBar->deviceInterface!=NULL){
00930 if(DeleteDC(Section::scrollBar->deviceInterface)==0)
00931 LocalisedString::explainFailWinAPI(L"DeleteObject");
00932 if(DeleteObject (Section::scrollBar->bitmap)==0)
00933 LocalisedString::explainFailWinAPI(L"DeleteObject");
00934 }
00935 }
00936 delete Section::scrollBar;
00937 Section::scrollBar=NULL;
00938 }
00939 (*(giGlobal->ldDDraw))->RestoreAllSurfaces();
00940
00941 if(giGlobal->backBuffer!=NULL){
00942 DirectDrawWarp::deleteSurf(&giGlobal->backBuffer);
00943
00944 giGlobal->backBuffer=new DIRECTDRAW_GDI;
00945 DirectDrawWarp::createSurf(&dd,giGlobal->backBuffer);
00946 giGlobal->window->BltFast(giGlobal->backBuffer,NULL,NULL,NULL,DDBLT_COLORFILL,&ddbl);
00947 }
00948 if(giGlobal->background!=NULL){
00949 DirectDrawWarp::deleteSurf(&giGlobal->background);
00950
00951 giGlobal->background=new DIRECTDRAW_GDI;
00952 DirectDrawWarp::createSurf(&dd,giGlobal->background);
00953 giGlobal->window->BltFast(giGlobal->background,NULL,NULL,NULL,DDBLT_COLORFILL,&ddbl);
00954 giGlobal->window->setBackgroundImg(NULL);
00955 }
00956 if(giGlobal->primaryBuffer!=NULL){
00957
00958 giGlobal->primaryBuffer->width=dwWidth;
00959 giGlobal->primaryBuffer->height=dwHeight;
00960 }
00961
00962 giGlobal->rcUpdateRegion=giGlobal->rs;
00963 int nbElement=listElements.size();
00964 for(int i=0;i<nbElement;i++){
00965 listElements[i]->loadSurf();
00966 }
00967 };
00968
00969 void Element::sizeChanged(Element* src,int width,int height){
00970 setWidth(width);
00971 setHeight(height);
00972 }
00973
00974
00975 DIRECTDRAW_GDI* Element::CreateBitmapMask(DIRECTDRAW_GDI *hbmColour, COLORREF crTransparent)
00976 {
00977 DIRECTDRAW_GDI* out=new DIRECTDRAW_GDI;
00978 out->directDrawSurf=NULL;
00979
00980
00981 out->bitmap = CreateBitmap(hbmColour->width,hbmColour->height, 1, 1, NULL);
00982
00983
00984
00985 out->deviceInterface = CreateCompatibleDC(0);
00986
00987 out->oldObj=SelectObject(out->deviceInterface, out->bitmap);
00988
00989
00990
00991 SetBkColor(hbmColour->deviceInterface, crTransparent);
00992
00993
00994
00995
00996
00997 if(BitBlt(out->deviceInterface, 0, 0, hbmColour->width,hbmColour->height, hbmColour->deviceInterface, 0, 0, SRCCOPY)==0){
00998 LocalisedString::explainFailWinAPI(L"CreateBitmapMask BitBlt");
00999 }
01000
01001 return out;
01002 }