Пример #1
0
// description: load image from file using gdi+
NaImage * NaImage::Load(const wchar_t * filename)
{
	NaImage *pImage = new NaImage;
	HDC hDC = NaScreenModule::GetDesktopDC();
	pImage->m_hMemoryDC = ::CreateCompatibleDC(hDC);

	// initialize gdi+
	Gdiplus::GdiplusStartupInput gdiplusStartupInput;
	ULONG_PTR gdiplusToken;
	GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

	// load image
	Gdiplus::Image* pGdiImage = new Gdiplus::Image(filename);

	// converting to bitmap
	Gdiplus::Bitmap* pGdiBitmap = static_cast<Gdiplus::Bitmap*>(pGdiImage);
	pGdiBitmap->GetHBITMAP(Gdiplus::Color(0, 0, 0), &pImage->m_hBitmap);

	pImage->m_rc.left = 0;
	pImage->m_rc.top = 0;
	pImage->m_rc.right = pGdiImage->GetWidth();
	pImage->m_rc.bottom = pGdiImage->GetHeight();

	// shutdown gdi+
	delete pGdiImage;
	Gdiplus::GdiplusShutdown(gdiplusToken);

	return pImage;
}
BOOL  COBSButton::ChangeSubPic(STATE index, LPCTSTR lpszImage)
{
	if (m_hWnd == NULL || lpszImage == NULL)
	{
		return FALSE;
	}
	Gdiplus::Image* pImage = Gdiplus::Image::FromFile(lpszImage);
	if ((pImage == NULL) || (pImage->GetLastStatus() != Gdiplus::Ok))
	{
		if (pImage)
		{
			delete pImage;
			pImage = NULL;
		}
		return FALSE;
	}
	
	int nPos = pImage->GetWidth()*index;//¼ÆËã4ÕÅͼƬÐèÒª¶àÉÙÏñËØ
	
	Gdiplus::Graphics graph(m_hdcMemory);
	graph.SetSmoothingMode(Gdiplus::SmoothingModeNone);
	graph.DrawImage(pImage, nPos, 0, pImage->GetWidth(), pImage->GetHeight());

	return TRUE;
}
Пример #3
0
/**
  Blend 'A''B''C''D' sign onto the image.
*/
static void BlendSelSign( Gdiplus::Graphics *g, const Gdiplus::RectF &render_rect, int sel )
{
    CFileListManager &file_manager = GetInst( CFileListManager );
    Gdiplus::Image *img = CreateImgFromBuffer( file_manager.GetSelSign( sel ) );
    Gdiplus::PointF render_pos = GetRandPosInULRect( img->GetWidth(), img->GetHeight(), render_rect );
    img_alpha( g, img, render_pos.X, render_pos.Y, 255 );
    delete img;
}
Пример #4
0
BOOL LoadImage(const HINSTANCE& inst, DWORD res, const TCHAR* name, IMGINFO* img_info, const HDC* mdc)
{
	HRSRC src = FindResource(inst, MAKEINTRESOURCE(res), name);
	if (src == NULL)
		return FALSE;

	DWORD len = SizeofResource(inst, src);
	BYTE* byte = (BYTE*)LoadResource(inst, src);
	if (byte == NULL)
		return FALSE;
	
	HGLOBAL global = GlobalAlloc(GMEM_FIXED, len);
	BYTE* mem = (BYTE*)GlobalLock(global);
	CopyMemory(mem, byte, len);	
	IStream* stream = NULL;
	Gdiplus::Image* image = NULL;
	HRESULT hr = CreateStreamOnHGlobal(mem, FALSE, &stream);
	if (SUCCEEDED(hr))
	{
		image = Gdiplus::Image::FromStream(stream);
		img_info->hdc = CreateCompatibleDC(*mdc);
		HBITMAP hbitmap = CreateCompatibleBitmap(*mdc, image->GetWidth(), image->GetHeight());
		SelectObject(img_info->hdc, hbitmap);		
		Gdiplus::Graphics graphics(img_info->hdc);		
		Gdiplus::Rect rect;
		rect.X = 0.0F;
		rect.Y = 0.0F;
		rect.Width = image->GetWidth();
		rect.Height = image->GetHeight();
		Gdiplus::Status s = graphics.DrawImage(image, rect);		
		DeleteObject(hbitmap);
		img_info->image = image;
	}

	GlobalUnlock(mem);
	SAFE_RELEASE(stream);
	FreeResource(byte);

	if (SUCCEEDED(hr))
		return TRUE;
	else
		return FALSE;
}
Пример #5
0
//  ôóíêöèÿ îòêðûòèÿ ôàéëà äëÿ ïðîñìîòðà ñ âõîäÿùèì ïàðàìåòðîì - èìåíåì îòêðûâàåìîãî ãðàôè÷åñêîãî ôàéëà
void BrouseFile(AnsiString FN)
{   float ho=0;
float wo;
if (FN!=""){//åñëè èìÿ ôàéëà óêàçàíî òî âûïîëíèòü äåéñòâèÿ
Form1->Image1->Align=alClient;//ðàçâîðà÷èâàåì îáëàñòü ïðîñìîòðà íà âñþ äîñòóïíþ ïëîùàäü
Form1->Image1->Picture->Assign(0);//î÷èùàåì îáëàñòü ïðîñìîòðà
WCHAR buff[10001];
Graphics::TBitmap *Buf = new Graphics::TBitmap();//ñîçäàåì îáúåêò êëàññà TBitmap
Gdiplus::Image *image =new Gdiplus::Image (FN.WideChar(buff,10000)); //ñîçäàåì îáúåêò êëàññà Gdiplus::Image è çàãðóæàåì â íåãî èçîáðàæåíèå èç âûáðàííîãî ôàéëà
Buf->Width=image->GetWidth();//óêàçûâàåì øèðèíó è âûñîòó èçîáðàæåíèÿ
Buf->Height=image->GetHeight();
Gdiplus::Graphics graphics(Buf->Canvas->Handle);//ïåðåäàåì óêàçàòåëü íà îáúåêò Buf
graphics.DrawImage(image, 0, 0, image->GetWidth(), image->GetHeight());
//ïðîðèñîâûâàåì âçÿòîå èç ôàéëà èçîáðàæåíèå â îáúåêòå Buf
Form1->Image1->Picture->Assign(Buf);//âûâîäì ïðîðèñîâàííîå èçîáðàæåíèå â îáëàñòü ïðîñìîòðà
Form1->ScrollBox1->Refresh();//îáíîâëÿåì ðàçìåðíîñòü îáëàñòè ïðîñìîòðà
z_min=1;//èíèöèàëèçèðåì ïåðåìåííûå ìàñøàáèðîâàíèÿ
z_max=1;

Form1->StatusBar1->Panels->Items[1]->Text="Ôàéë - "+Form1->FileListBox1->Items->Strings[Form1->FileListBox1->ItemIndex];//âûâîäèì ñëóæåáíóþ èíôîðìàöèþ
Form1->StatusBar1->Panels->Items[2]->Text="Ðàçìåð - "+IntToStr(image->GetWidth())+"x"+IntToStr(image->GetHeight());
//
B->Assign(0);//î÷èùàåì ðåçåðâíûé îáúåêò êëàññà TBitmap
B->Width=Form1->Image1->Picture->Bitmap->Width;//çàäàåì ðàçìåðû ðåçåðâíîãî îáúåêòà
B->Height=Form1->Image1->Picture->Bitmap->Height;
B->Canvas->Draw(0,0,Form1->Image1->Picture->Bitmap);//ïðîðèñîâûâàåì èçîáðàæåíèå â ðåçåðâíîì îáúåêòå èç îáëàñòè ïðîñìîòðà
          //åñëè êàðòèíêà èçíà÷àëüíî áîëüøå îáëàñòè ïðîñìîòðà
          //òî îíà áóäåò àâòîìàòè÷åñêè óìåíüøåíà
          //äàëåå îïðåäåëÿåì êîýô. óìåíüøåíèÿ
 if ((B->Height>Form1->Image1->Height)||(B->Width>Form1->Image1->Width))  //åñëè ïàðìåòðû êàðòèíêè ïðåâûøàþò ïàðàìåòðû îáëàñòè
{
ho=float(Form1->Image1->Height)/float(B->Height);   //âû÷èñëÿåì ñîîòíîøåíèÿ âåëè÷èí
wo=float(Form1->Image1->Width)/float(B->Width);
if (ho>wo)   //îïåðåäåëÿåì áîëüøóþ èç âåëè÷èí, ÷òîáû èçîáðàæåíèå ïîìåñòèëîñü â îáëàñòè ïðîñìîòðà
{z_min=1+ho;}    //óñòàíàâëèâàåì êîýô.
else {z_min=1+wo;}
}
delete image;//î÷èùàåì ïàìÿòü
delete Buf;

}
}
Пример #6
0
cgSize cgGdiplusRender::GetImageSize( cgID image )
{
	cgSize size;
	Gdiplus::Image* pkImage = m_kImageStorage.Find(image);
	if (pkImage)
	{
		size.w = pkImage->GetWidth();
		size.h = pkImage->GetHeight();
	}

	return size;
}
Пример #7
0
/**
  generate some small images and render them on the backgroun.
*/
static void GenSmallImage( int img_count, Gdiplus::Graphics *g, const Gdiplus::RectF &render_rect, int sel )
{
#define RAND_ALPHA ( 100 + random( 55 ) )

    if( img_count < 1 )
    {
        return;
    }

    CFileListManager &file_manager = GetInst( CFileListManager );
    // render without alpha value
    Gdiplus::Image *img = CreateImgFromBuffer( file_manager.GetRandSmall() );
    Gdiplus::PointF render_pos = GetRandPosInULRect( img->GetWidth(), img->GetHeight(), render_rect );
    Gdiplus::RectF img_rect( render_pos.X, render_pos.Y, (float)img->GetWidth(), (float)img->GetHeight() );
    img_alpha( g, img, render_pos.X, render_pos.Y, img_count == 1 ? 255 : RAND_ALPHA );
    delete img;

    // render with random alpha value and random rotation degree
    g->SetClip( img_rect );
    for( int i = 1; i < img_count; ++ i )
    {
        img = CreateImgFromBuffer( file_manager.GetRandSmall() );
        img_rotate( g, img, render_pos.X, render_pos.Y, img->GetWidth() / 2, img->GetHeight() / 2,
                    random( 360 ), // [0-360)
                    RAND_ALPHA ); // [100-155)
        delete img;
    }
    g->ResetClip();

    // blend a 'X' sign onto the picture if it's not the answer
    if( img_count > 1 )
    {
        //BlendXSign( g, img_rect );
    }

    // blend 'A''B''C''D' sign.
    BlendSelSign( g, img_rect, sel );
}
Пример #8
0
void SetAspectRatio(Gdiplus::Image &image, RECT &rc)
{
  double dWidth = (rc.right - rc.left);
  double dHeight = (rc.bottom - rc.top);
  double dAspectRatio = dWidth / dHeight;
  double dImageWidth = image.GetWidth();
  double dImageHeight = image.GetHeight();
  double dImageAspectRatio = dImageWidth / dImageHeight;
  if (dImageAspectRatio > dAspectRatio) {
    double nNewHeight = (dWidth / dImageWidth*dImageHeight);
    double nCenteringFactor = (dHeight - nNewHeight) / 2;
    SetRect(&rc, 0, (int)nCenteringFactor, (int)dWidth, (int)(nNewHeight + nCenteringFactor));
  } else if (dImageAspectRatio < dAspectRatio) {
    double nNewWidth = (dHeight / dImageHeight*dImageWidth);
    double nCenteringFactor = (dWidth - nNewWidth) / 2;
    SetRect(&rc, (int)nCenteringFactor, 0, (int)(nNewWidth + nCenteringFactor), (int)(dHeight));
  }
}
BOOL COBSButton::Create(LPCTSTR lpszCaption, const RECT& rect, HWND hParentWnd, \
	UINT nID, LPCTSTR lpszImage,int nSubPic)
{
	if (m_hWnd)
		return FALSE;
	if (nSubPic>4||nSubPic<=0)
	{
		return FALSE;
	}
	m_hWnd = CreateWindow(TEXT("BUTTON"), lpszCaption, \
		WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_OWNERDRAW, \
		rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, \
		hParentWnd, (HMENU)nID, NULL, NULL);

	if (NULL == m_hWnd)
	{
		goto CREATE_FAIL;
	}
	SendMessage(m_hWnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
	m_OldProc = (WNDPROC)SetWindowLong(m_hWnd, GWLP_WNDPROC /*GWL_WNDPROC*/, (LONG)ButtonProc);
	SetWindowLong(m_hWnd, GWLP_USERDATA, (LONG)this);

	m_hFont = CreateFont(16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, 0, DEFAULT_CHARSET, \
		OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_SWISS, TEXT("Arial"));

	Gdiplus::Image* pImage = NULL;
	//¼ÓÔØͼƬ
	if (lpszImage != NULL)
	{

		
		pImage = Gdiplus::Image::FromFile(lpszImage);
		if ((pImage == NULL) || (pImage->GetLastStatus() != Gdiplus::Ok))
		{
			if (pImage)
			{
				delete pImage;
				pImage = NULL;
			}
			return FALSE;
		}
		RECT windowRect;
		GetWindowRect(m_hWnd, &windowRect);
		SIZE sizeWindow;
		sizeWindow.cx = (pImage->GetWidth() / nSubPic)*4;//¼ÆËã4ÕÅͼƬÐèÒª¶àÉÙÏñËØ
	    sizeWindow.cy = pImage->GetHeight();
		
		HDC hDC = GetDC(m_hWnd);
		m_hdcMemory = CreateCompatibleDC(hDC);
		if (m_hdcMemory == NULL) return FALSE;
		m_hFourStateBitmap = CreateCompatibleBitmap(hDC, sizeWindow.cx, sizeWindow.cy);
		if (m_hFourStateBitmap == NULL) return FALSE;
		m_hOldBmp = (HBITMAP)::SelectObject(m_hdcMemory, m_hFourStateBitmap);
		if (m_hOldBmp == NULL) return FALSE;
		Gdiplus::Graphics graph(m_hdcMemory);
		graph.SetSmoothingMode(Gdiplus::SmoothingModeNone);
		graph.DrawImage(pImage, 0, 0, sizeWindow.cx, sizeWindow.cy);

		if (NULL == m_hFourStateBitmap)
		{
			goto CREATE_FAIL;
		}
	}




	if (pImage)
	{
		delete pImage;
		pImage = NULL;
	}

	return TRUE;

CREATE_FAIL:
	if (m_hFourStateBitmap)
	{
		DeleteObject(m_hFourStateBitmap);
	}
	return FALSE;
}
Пример #10
0
static Image *ReadEMFImage(const ImageInfo *image_info,
  ExceptionInfo *exception)
{
  Gdiplus::Bitmap
    *bitmap;

  Gdiplus::BitmapData
     bitmap_data;

  Gdiplus::GdiplusStartupInput
    startup_input;

  Gdiplus::Graphics
    *graphics;

  Gdiplus::Image
    *source;

  Gdiplus::Rect
    rect;

  GeometryInfo
    geometry_info;

  Image
    *image;

  MagickStatusType
    flags;

  register Quantum
    *q;

  register ssize_t
    x;

  ssize_t
    y;

  ULONG_PTR
    token;

  unsigned char
    *p;

  wchar_t
    fileName[MagickPathExtent];

  assert(image_info != (const ImageInfo *) NULL);
  assert(image_info->signature == MagickSignature);
  if (image_info->debug != MagickFalse)
    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
      image_info->filename);
  assert(exception != (ExceptionInfo *) NULL);

  image=AcquireImage(image_info,exception);
  if (Gdiplus::GdiplusStartup(&token,&startup_input,NULL) != 
    Gdiplus::Status::Ok)
    ThrowReaderException(CoderError, "GdiplusStartupFailed");
  MultiByteToWideChar(CP_UTF8,0,image->filename,-1,fileName,MagickPathExtent);
  source=Gdiplus::Image::FromFile(fileName);
  if (source == (Gdiplus::Image *) NULL)
    {
      Gdiplus::GdiplusShutdown(token);
      ThrowReaderException(FileOpenError,"UnableToOpenFile");
    }

  image->resolution.x=source->GetHorizontalResolution();
  image->resolution.y=source->GetVerticalResolution();
  image->columns=(size_t) source->GetWidth();
  image->rows=(size_t) source->GetHeight();
  if (image_info->density != (char *) NULL)
    {
      flags=ParseGeometry(image_info->density,&geometry_info);
      image->resolution.x=geometry_info.rho;
      image->resolution.y=geometry_info.sigma;
      if ((flags & SigmaValue) == 0)
        image->resolution.y=image->resolution.x;
      if ((image->resolution.x > 0.0) && (image->resolution.y > 0.0))
        {
          image->columns=(size_t) floor((Gdiplus::REAL) source->GetWidth() /
            source->GetHorizontalResolution() * image->resolution.x + 0.5);
          image->rows=(size_t)floor((Gdiplus::REAL) source->GetHeight() /
            source->GetVerticalResolution() * image->resolution.y + 0.5);
        }
    }

  bitmap=new Gdiplus::Bitmap((INT) image->columns,(INT) image->rows,
    PixelFormat32bppARGB);
  graphics=Gdiplus::Graphics::FromImage(bitmap);
  graphics->SetInterpolationMode(Gdiplus::InterpolationModeHighQualityBicubic);
  graphics->SetSmoothingMode(Gdiplus::SmoothingModeHighQuality);
  graphics->SetTextRenderingHint(Gdiplus::TextRenderingHintClearTypeGridFit);
  graphics->Clear(Gdiplus::Color((BYTE) ScaleQuantumToChar(
    image->background_color.alpha),(BYTE) ScaleQuantumToChar(
    image->background_color.red),(BYTE) ScaleQuantumToChar(
    image->background_color.green),(BYTE) ScaleQuantumToChar(
    image->background_color.blue)));
  graphics->DrawImage(source,0,0,(INT) image->columns,(INT) image->rows);
  delete graphics;
  delete source;

  rect=Gdiplus::Rect(0,0,(INT) image->columns,(INT) image->rows);
  if (bitmap->LockBits(&rect,Gdiplus::ImageLockModeRead,PixelFormat32bppARGB,
    &bitmap_data) != Gdiplus::Ok)
  {
    delete bitmap;
    Gdiplus::GdiplusShutdown(token);
    ThrowReaderException(FileOpenError,"UnableToReadImageData");
  }

  image->alpha_trait=BlendPixelTrait;
  for (y=0; y < (ssize_t) image->rows; y++)
  {
    p=(unsigned char *) bitmap_data.Scan0+(y*abs(bitmap_data.Stride));
    if (bitmap_data.Stride < 0)
      q=GetAuthenticPixels(image,0,image->rows-y-1,image->columns,1,exception);
    else
      q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
    if (q == (Quantum *) NULL)
      break;

    for (x=0; x < (ssize_t) image->columns; x++)
    {
      SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
      SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
      SetPixelRed(image,ScaleCharToQuantum(*p++),q);
      SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
      q+=GetPixelChannels(image);
    }

    if (SyncAuthenticPixels(image,exception) == MagickFalse)
      break;
  }

  bitmap->UnlockBits(&bitmap_data);
  delete bitmap;
  Gdiplus::GdiplusShutdown(token);
  return(image);
}
Пример #11
0
int DrawSdk::Image::WriteScaledImageFile(WCHAR* scaledImageName, float scaleX, float scaleY, const WCHAR* format)
{
   int hr = S_OK;
 
//   // Starting the Gdiplus machine should be executed outside of this method
//   Gdiplus::GdiplusStartupInput gdiplusStartupInput;
//   ULONG_PTR gdiplusToken;
//   Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

   Gdiplus::ImageCodecInfo *pImageCodecInfo = NULL;

   CLSID *pClsid = NULL;

   HDC hdc = CreateCompatibleDC(NULL);
   

   // Get the encoder CLSID depending on the image format (image/jpeg, image/gif, image/png)
   UINT num = 0;
   UINT size = 0;

   Gdiplus::GetImageEncodersSize(&num, &size);
   if (size == 0)
      hr = -1;  // Failure

   if (SUCCEEDED(hr))
   {
      pImageCodecInfo = (Gdiplus::ImageCodecInfo*)(malloc(size));
      if (pImageCodecInfo == NULL)
         hr = -1;  // Failure
   }

   if (SUCCEEDED(hr))
   {
      Gdiplus::GetImageEncoders(num, size, pImageCodecInfo);

      for(int j = 0; j < num; ++j)
      {
         if( wcscmp(pImageCodecInfo[j].MimeType, format) == 0 )
         {
            pClsid = &pImageCodecInfo[j].Clsid;
            break;  // Success
         }    
      }

      if (pClsid == NULL)
         hr = -1;  // Failure
   }

   // Bugfix 5301: 
   // If 'gdipImage_' is NULL then it was not kept in memory and therefore 
   // a temporary Gdiplus::Image object is created for the rescaling. 
   // This avoids having too much image data in the memory.
   Gdiplus::Image *tmpImage = NULL;
   if (SUCCEEDED(hr) && gdipImage_ == NULL) {
       // convert char-String in WCHAR-String  
       int iStringLength = _tcslen(imageName_) + 1;
       WCHAR *wcFilename = (WCHAR *)malloc(iStringLength*sizeof(WCHAR));
#ifdef _UNICODE
       wcscpy(wcFilename, imageName_);
#else
       MultiByteToWideChar( CP_ACP, 0, imageName, iStringLength, 
           wcFilename, iStringLength);
#endif
       tmpImage = new Gdiplus::Image(wcFilename, FALSE);

       if (wcFilename)
           free(wcFilename);
   } else {
       tmpImage = gdipImage_;
   }


   if (SUCCEEDED(hr) && tmpImage != NULL)
   {
      // Resize the image by scaling factors
      Gdiplus::REAL destWidth  = scaleX * this->GetWidth();
      Gdiplus::REAL destHeight = scaleY * this->GetHeight();

      // If no correct size is defined in the object queue, use the real image size instead
      if ( (this->GetWidth() <= 0.0f) && (this->GetHeight() <= 0.0f) )
      {
         destWidth  = scaleX * tmpImage->GetWidth();
         destHeight = scaleY * tmpImage->GetHeight();
      }

      // At least we have to write one pixel
      if (destWidth < 1.0f)
         destWidth = 1.0f;
      if (destHeight < 1.0f)
         destHeight = 1.0f;

      Gdiplus::Bitmap scaledImage((int)(destWidth + 0.5f), (int)(destHeight + 0.5f));

      scaledImage.SetResolution(tmpImage->GetHorizontalResolution(), 
                                tmpImage->GetVerticalResolution());

      Gdiplus::Graphics grPhoto(&scaledImage);

      grPhoto.SetCompositingQuality(Gdiplus::CompositingQualityHighSpeed);
      grPhoto.SetCompositingMode(Gdiplus::CompositingModeSourceOver);
      grPhoto.SetInterpolationMode(Gdiplus::InterpolationModeHighQualityBicubic);

      Gdiplus::Rect destRect(0, 0, (int)(destWidth + 0.5f), (int)(destHeight + 0.5f));

      hr = grPhoto.DrawImage(tmpImage, destRect, 
                             0, 0, tmpImage->GetWidth(),tmpImage->GetHeight(), 
                             Gdiplus::UnitPixel);


      // Write the scaled image to a file
      if (SUCCEEDED(hr))
         hr = scaledImage.Save(scaledImageName, pClsid, NULL);
   }


   // Cleanup
   if (hdc)
	{
		::DeleteDC(hdc);
		hdc = NULL;
	}
   if (pImageCodecInfo)
   {
      free(pImageCodecInfo);
      pImageCodecInfo = NULL;
   }

   if (tmpImage != NULL && tmpImage != gdipImage_)
       delete tmpImage;

   
//   // Stop the Gdiplus machine --> this should be executed outside of this method (see above)
//   Gdiplus::GdiplusShutdown(gdiplusToken);

   return hr;
}
Пример #12
0
LRESULT
BlobMgmt::ShowImage()
{
#ifndef VC6
	HDC             hdc;
	RECT			rectwin;
	wyInt32         renderwidth, renderheight;
	PAINTSTRUCT     ps;
	LPSTREAM        stream = NULL;
	HGLOBAL         glbmem;
	void            *glbbuffer;
    wyWChar         tempfilename[MAX_PATH+1] = {0}, path[MAX_PATH + 1] = {0};
	wyString		tempstr;
	HANDLE          hfile = INVALID_HANDLE_VALUE;
	DWORD           byteswritten = 0;

	if(!m_piub->m_data || m_piub->m_datasize == 0)
	{
		VERIFY(hdc = BeginPaint(m_hwndimage, &ps));
		VERIFY(EndPaint(m_hwndimage, &ps));
		return 0;
	}
	/* allocate global memory and copy image data in it*/
	VERIFY(glbmem = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, m_piub->m_datasize));
	if(!glbmem)
        return 0;

	/* lock the global memory and get a pointer */
	glbbuffer = GlobalLock(glbmem);
	/* copy the memory to buffer */
	CopyMemory(glbbuffer, m_piub->m_data, m_piub->m_datasize);
	/* unlock it */
	VERIFY(GlobalUnlock(glbmem)== NO_ERROR);
	/* create the stream */
	VERIFY(CreateStreamOnHGlobal(glbmem, FALSE, &stream)== S_OK);
	/* prepare window for painting */
	VERIFY(hdc = BeginPaint(m_hwndimage, &ps));
	/* clear the window */
	PrepareScreen(ps.hdc);

    if(pGlobals->m_configdirpath.GetLength() || SUCCEEDED(SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, (LPWSTR)path)))
    {
		if(pGlobals->m_configdirpath.GetLength())
		{
			//wcscpy(path, pGlobals->m_configdirpath.GetAsWideChar());			
			wcsncpy(path, pGlobals->m_configdirpath.GetAsWideChar(), MAX_PATH);			
			path[MAX_PATH] = '\0';
		}
		
		else
		{
			wcscat(path, L"\\");
			wcscat(path, L"SQLyog");
		}
        
        VERIFY(GetTempFileName(path, L"img", 0, tempfilename));
 	    hfile = CreateFile(tempfilename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
								   NULL, NULL);
	    VERIFY(hfile != INVALID_HANDLE_VALUE);
	    VERIFY(WriteFile(hfile, m_piub->m_data, m_piub->m_datasize, &byteswritten, NULL));
	    VERIFY(CloseHandle(hfile));
    }
	tempstr.SetAs(tempfilename);
	
	WCHAR *wpath = GetWideString(tempstr.GetString());
	
	Gdiplus::Graphics	graphics(hdc);
	Gdiplus::Image		*image = new Gdiplus::Image(wpath);

	HeapFree(GetProcessHeap(), 0, wpath);
	/* in win95 image will be null so we exit */
	if(!image)
		goto ExitPara;

	/* the binary data might not be image so image.getlastatus will not return Ok */
	if(image->GetLastStatus()!= Gdiplus::Ok)
    {
		delete image;
		goto ExitPara;
	}

	/* get the window width and calculate the correct render stats */
	VERIFY(GetClientRect(m_hwndimage, &rectwin));

	renderheight =(((LONG)image->GetHeight())> rectwin.bottom)?(rectwin.bottom):(image->GetHeight());
	renderwidth  =(((LONG)image->GetWidth())> rectwin.right)?(rectwin.right):(image->GetWidth());

	graphics.DrawImage(image, 0, 0, renderwidth, renderheight);
	delete image;
	EndPaint(m_hwndimage, &ps);

ExitPara:
	/* free up stuff */
	VERIFY(DeleteFile(tempfilename));
	if(stream)
		stream->Release();

	VERIFY(GlobalFree(glbmem)== NULL);
#endif
	
	return 0;
}
Пример #13
0
BOOL ReadImageProperty(const TCHAR *lpszImage, PROPID propId, TCHAR *szProperty, int cchMax)
{
    Gdiplus::GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR token;
    Gdiplus::Status status = GdiplusStartup(&token, &gdiplusStartupInput, NULL);

    if(status != Gdiplus::Ok)
    {
        return FALSE;
    }

    BOOL bSuccess = FALSE;

    /* This object needs to be
    deleted before GdiplusShutdown
    is called. If it were stack
    allocated, it would go out of
    scope _after_ the call to
    GdiplusShutdown. By allocating
    it on the heap, the lifetime
    can be directly controlled. */
    Gdiplus::Image *image = new Gdiplus::Image(lpszImage, FALSE);

    if(image->GetLastStatus() == Gdiplus::Ok)
    {
        if(propId == PropertyTagImageWidth)
        {
            bSuccess = TRUE;
            StringCchPrintf(szProperty, cchMax, _T("%u pixels"), image->GetWidth());
        }
        else if(propId == PropertyTagImageHeight)
        {
            bSuccess = TRUE;
            StringCchPrintf(szProperty, cchMax, _T("%u pixels"), image->GetHeight());
        }
        else
        {
            UINT size = image->GetPropertyItemSize(propId);

            if(size != 0)
            {
                Gdiplus::PropertyItem *propertyItem = reinterpret_cast<Gdiplus::PropertyItem *>(malloc(size));

                if(propertyItem != NULL)
                {
                    status = image->GetPropertyItem(propId, size, propertyItem);

                    if(status == Gdiplus::Ok)
                    {
                        if(propertyItem->type == PropertyTagTypeASCII)
                        {
                            int iRes = MultiByteToWideChar(CP_ACP, 0, reinterpret_cast<LPCSTR>(propertyItem->value), -1,
                                                           szProperty, cchMax);

                            if(iRes != 0)
                            {
                                bSuccess = TRUE;
                            }
                        }
                    }

                    free(propertyItem);
                }
            }
        }
    }

    delete image;
    Gdiplus::GdiplusShutdown(token);

    return bSuccess;
}
Пример #14
0
void Graphics::DrawImage(Image* image, const Rect& rc, const ImageAttributes* attr) {
    Gdiplus::Graphics* g = reinterpret_cast<Gdiplus::Graphics*>(_private);
    Gdiplus::Image* gdiImage = reinterpret_cast<Gdiplus::Image*>(image->_private);

    if(attr!=0) {
        Gdiplus::ImageAttributes* ia = reinterpret_cast<Gdiplus::ImageAttributes*>(attr->_private);
        g->DrawImage(gdiImage, Gdiplus::Rect(rc.GetLeft(), rc.GetTop(), rc.GetWidth(), rc.GetHeight()), 0, 0, gdiImage->GetWidth(), gdiImage->GetHeight(), Gdiplus::UnitPixel, ia);
    }
    else {
        g->DrawImage(gdiImage, ToGDIRect<Rect, Gdiplus::Rect>(rc));
    }
}
Пример #15
0
int Image::GetHeight() {
    Gdiplus::Image* gdiImage = reinterpret_cast<Gdiplus::Image*>(_private);
    return gdiImage->GetHeight();
}
Пример #16
0
void CListViewCtrlEx::_DrawNormalItem( LPDRAWITEMSTRUCT lpdis, const TListItem *pItem )
{
    if (!pItem)
        return;

    int nItem = lpdis->itemID;

    CDCHandle dc;
    dc.Attach(lpdis->hDC);

    HFONT	hOldFont = dc.SelectFont(m_fontDef);

    BOOL bSelect = FALSE ;
    if ((lpdis->itemAction | ODA_SELECT) &&
            (lpdis->itemState & ODS_SELECTED))
    {
        bSelect = TRUE ;
    }

    if ( bSelect )
        dc.FillSolidRect( &lpdis->rcItem, RGB(185,219,255));
    else
        dc.FillSolidRect( &lpdis->rcItem, pItem->clrBg);

    // draw check box
    if( pItem->dwFlags&(LISTITEM_CHECKBOX|LISTITEM_RADIOBOX) )
        _DrawCheckBox(dc, lpdis->rcItem, _super::GetCheckState(nItem), pItem->dwFlags);

    COLORREF oldClr = dc.GetTextColor();
    for(int i=0; i<pItem->subItems.size(); ++i)
    {
        CRect	rcSubItem;
        DWORD	nMarginWidth = 0;
        CRect	rcBounds;
        GetSubItemRect(nItem, i, LVIR_LABEL, &rcSubItem);

        nMarginWidth = LEFT_MARGIN_TEXT_COLUMN+3;

        if(i==0)
        {
            if( pItem->dwFlags&(LISTITEM_CHECKBOX|LISTITEM_RADIOBOX) )
            {
                nMarginWidth+=rcSubItem.left;
            }
            else
            {
                rcSubItem.left -= 19;
                nMarginWidth+=5;
            }
        }

#define DT_FLAGS_DRAW_TEXT		(DT_SINGLELINE|DT_LEFT|DT_NOPREFIX|DT_END_ELLIPSIS|DT_VCENTER)

        rcSubItem.left += LEFT_MARGIN_TEXT_COLUMN;
        rcSubItem.right -= 3;
        const TListSubItem &subItem = pItem->subItems[i];
        if(subItem.type == SUBITEM_LINK)
        {
            dc.SelectFont(m_fontLink);
            dc.SetTextColor(COLOR_LIST_LINK);

            CRect	rcProbeItem;
            dc.DrawText( subItem.str, -1, &rcProbeItem, DT_SINGLELINE|DT_LEFT|DT_NOPREFIX|DT_VCENTER|DT_CALCRECT);
            dc.DrawText( subItem.str, -1, &rcSubItem, DT_FLAGS_DRAW_TEXT);

            DWORD nMaxWidth = rcProbeItem.Width()+nMarginWidth;
            _SetColumnNeedWidth(i,nMaxWidth);
        }
        else
        {
            if (subItem.type == SUBITEM_ICON && subItem.nImg != NULL)
            {
                dc.DrawIconEx( rcSubItem.left, rcSubItem.top + 3, (HICON)subItem.nImg, 16 , 16, 0, 0, DI_NORMAL );
                rcSubItem.left = rcSubItem.left + 18;
            }
            else if (subItem.type == SUBITEM_PNG)
            {
                Gdiplus::Image* pImg = BkPngPool::Get(subItem.nImg);
                if (pImg)
                {
                    Gdiplus::Graphics graphics(dc);

                    SIZE size = {0, 0};
                    if (pImg)
                    {
                        size.cx = pImg->GetWidth();
                        size.cy = pImg->GetHeight();
                    }

                    graphics.DrawImage(pImg, Gdiplus::Rect(rcSubItem.left, rcSubItem.top + 5, size.cx, size.cy));
                }
                rcSubItem.left = rcSubItem.left + 18;
            } else if(subItem.type==SUBITEM_COMBO)
            {
                CDC	dcTmp;
                dcTmp.CreateCompatibleDC(dc);
                HBITMAP hBmpOld	= dcTmp.SelectBitmap(m_bitmapCombo);
                dc.BitBlt(rcSubItem.right-20, rcSubItem.top + 3, 20, 20, dcTmp, 0, 0, SRCCOPY);
                dcTmp.SelectBitmap(hBmpOld);
                dcTmp.DeleteDC();
            }

            UINT uFormat = DT_SINGLELINE|DT_LEFT|DT_NOPREFIX|DT_PATH_ELLIPSIS|DT_VCENTER;
            if (i == 3)
            {
                if (pItem->nLevel == enumLevelRisk)
                {
                    rcSubItem.DeflateRect(2, 3);

                    CPen penBorder;
                    penBorder.CreatePen( PS_SOLID, 1, RGB(224, 0, 0) );
                    CBrush bshInterior;
                    bshInterior.CreateSolidBrush( RGB(224, 0, 0)  );

                    HPEN hOldPen = dc.SelectPen( penBorder );
                    HBRUSH hOldBrush = dc.SelectBrush( bshInterior );

                    dc.RoundRect( rcSubItem, CPoint( 3, 3 ) );
                    dc.SelectPen(hOldPen);
                    dc.SelectBrush(hOldBrush);
                    dc.SetTextColor( RGB(255, 255, 255) );
                }
                else if (pItem->nLevel == enumLevelUnknown)
                {
                    rcSubItem.DeflateRect(2, 3);

                    CPen penBorder;
                    penBorder.CreatePen( PS_SOLID, 1, RGB(250, 115, 5) );
                    CBrush bshInterior;
                    bshInterior.CreateSolidBrush( RGB(250, 115, 5)  );

                    HPEN hOldPen = dc.SelectPen( penBorder );
                    HBRUSH hOldBrush = dc.SelectBrush( bshInterior );

                    dc.RoundRect( rcSubItem, CPoint( 3, 3 ) );
                    dc.SelectPen(hOldPen);
                    dc.SelectBrush(hOldBrush);
                    dc.SetTextColor( RGB(255, 255, 255) );
                }
                else
                    dc.SetTextColor( subItem.clr );

                uFormat = DT_SINGLELINE|DT_CENTER|DT_NOPREFIX|DT_PATH_ELLIPSIS|DT_VCENTER;
            }
            else
                dc.SetTextColor( subItem.clr );

            dc.DrawText( subItem.str, -1, &rcSubItem, uFormat);
            if (subItem.type == SUBITEM_ICON || subItem.type == SUBITEM_PNG)
                rcSubItem.left = rcSubItem.left - 18;

            CRect	rcProbeItem;
            dc.DrawText( subItem.str, -1, &rcProbeItem, DT_SINGLELINE|DT_LEFT|DT_NOPREFIX|DT_VCENTER|DT_CALCRECT);
            DWORD nMaxWidth = rcProbeItem.Width()+nMarginWidth;
            _SetColumnNeedWidth(i,nMaxWidth);
        }
    }

    CPen	penx;
    penx.CreatePen(PS_SOLID,1,pItem->clrBtmGapLine);
    HPEN	penOld = dc.SelectPen(penx);
    dc.MoveTo( lpdis->rcItem.left, lpdis->rcItem.bottom-1 );
    CRect rcClient;
    GetClientRect(rcClient);

    dc.LineTo( lpdis->rcItem.left + rcClient.Width(), lpdis->rcItem.bottom-1);
    dc.SelectPen(penOld);

    dc.SelectFont(hOldFont);
    dc.SetTextColor(oldClr);
    dc.Detach();
}