You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
768 lines
19 KiB
768 lines
19 KiB
/******************************Module*Header*******************************\
|
|
* Module Name: drawimage.cpp
|
|
*
|
|
* Created: 23 December 1999
|
|
* Author: Adrian Secchia [asecchia]
|
|
*
|
|
* Copyright (c) 1999,Microsoft Corporation
|
|
*
|
|
* This is the DrawImage unit test.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#include <windows.h>
|
|
#include <objbase.h>
|
|
#include <math.h> // sin & cos
|
|
|
|
// Define away IStream
|
|
#define IStream int
|
|
|
|
#include <gdiplus.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <tchar.h>
|
|
|
|
#include "drawimage.hpp"
|
|
#include "wndstuff.h"
|
|
|
|
using namespace Gdiplus;
|
|
#define USE_NEW_APIS 1
|
|
#define USE_NEW_APIS2 1
|
|
|
|
|
|
ImageAttributes *Img = NULL;
|
|
|
|
/***************************************************************************\
|
|
* DrawXXXX
|
|
*
|
|
* These routines are all the individual tests that this test
|
|
* suite will use.
|
|
\***************************************************************************/
|
|
|
|
// No fancy stuff - just put the whole image in the window.
|
|
// No rotation, stretching, etc.
|
|
|
|
#if 0
|
|
// cached bitmap in animated infinite loop
|
|
|
|
VOID DrawSimple(Graphics *g)
|
|
{
|
|
unsigned short filename[1024];
|
|
|
|
CachedBitmap *frame[32];
|
|
Bitmap *temp;
|
|
Graphics *gbmp;
|
|
|
|
Unit u;
|
|
RectF r;
|
|
|
|
|
|
for(int i=0; i<32; i++) {
|
|
wsprintf(filename, L"T%d.bmp", i);
|
|
temp = new Bitmap(filename);
|
|
temp->GetBounds(&r, &u);
|
|
// r.Width *=2;
|
|
// r.Height *=2;
|
|
|
|
frame[i] = new CachedBitmap(temp, g);
|
|
|
|
// gbmp = new Graphics(frame[i]);
|
|
|
|
// gbmp->SetInterpolationMode(InterpolationModeHighQualityBilinear);
|
|
|
|
/* Matrix *m = new Matrix(1.0f, 0.0f,
|
|
0.0f, -1.0f,
|
|
0.0f, r.Height);
|
|
gbmp->SetTransform(m);
|
|
*/
|
|
// gbmp->DrawImage(temp, 0, 0, (INT)r.Width, (INT)r.Height);
|
|
|
|
// delete gbmp;
|
|
delete temp;
|
|
// delete m;
|
|
}
|
|
RectF s = r;
|
|
|
|
i = 0;
|
|
int j;
|
|
|
|
while(++i) {
|
|
|
|
// for(j=0; j<3; j++)
|
|
// g->DrawImage(frame[i % 32], s, r.X, r.Y, r.Width, r.Height, UnitPixel);
|
|
g->DrawCachedBitmap(frame[i % 32], 10, 10);
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
VOID DrawSimple(Graphics *g)
|
|
{
|
|
|
|
Bitmap *image = new Bitmap(FileName);
|
|
|
|
Unit u;
|
|
RectF r;
|
|
|
|
image->GetBounds(&r, &u);
|
|
|
|
RectF s = r;
|
|
|
|
s.X = 31;
|
|
s.Y = 27;
|
|
|
|
s.Width *= 0.7f;
|
|
s.Height *= 0.7f;
|
|
|
|
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel);
|
|
g->SetClip(Rect(50, 70, 100, 10));
|
|
|
|
ImageAttributes img;
|
|
ColorMatrix flipRedBlue = {
|
|
0, 1, 0, 0, 0,
|
|
0, 0, 1, 0, 0,
|
|
1, 0, 0, 0, 0,
|
|
0, 0, 0, 1, 0,
|
|
0, 0, 0, 0, 1
|
|
};
|
|
img.SetColorMatrix(&flipRedBlue);
|
|
|
|
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, &img);
|
|
g->ResetClip();
|
|
|
|
delete image;
|
|
}
|
|
|
|
VOID DrawSpecialRotate(Graphics *g)
|
|
{
|
|
Bitmap *image = new Bitmap(FileName);
|
|
|
|
Unit u;
|
|
RectF r;
|
|
image->GetBounds(&r, &u);
|
|
RectF s = r;
|
|
|
|
ImageAttributes img;
|
|
|
|
ColorMatrix flipRedBlue = {
|
|
0, 1, 0, 0, 0,
|
|
1, 0, 0, 0, 0,
|
|
0, 0, 1, 0, 0,
|
|
0, 0, 0, 1, 0,
|
|
0, 0, 0, 0, 1
|
|
};
|
|
img.SetColorMatrix(&flipRedBlue);
|
|
|
|
g->SetCompositingQuality(CompositingQualityGammaCorrected);
|
|
|
|
Rect dstRect(0, 0, 50, 100);
|
|
Rect srcRect(12, -14, 50, 100);
|
|
|
|
g->TranslateTransform(s.Height, 0.0f);
|
|
g->RotateTransform(90);
|
|
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(s.Height, s.Width);
|
|
g->RotateTransform(270);
|
|
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(s.Width, s.Height+s.Width);
|
|
g->RotateTransform(180);
|
|
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(s.Width+2*s.Height, 0.0f);
|
|
g->ScaleTransform(-1.0, 1.0);
|
|
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(2*s.Height, s.Height*2);
|
|
g->ScaleTransform(1.0, -1.0);
|
|
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(s.Width+2*s.Height, 0.0f);
|
|
g->ScaleTransform(-1.0, 1.0);
|
|
g->RotateTransform(90);
|
|
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(s.Width+3*s.Height, 2*s.Width);
|
|
g->ScaleTransform(-1.0, 1.0);
|
|
g->RotateTransform(270);
|
|
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
|
|
g->ResetTransform();
|
|
|
|
|
|
|
|
//Rot180
|
|
g->TranslateTransform(400.0f, 500.0f);
|
|
g->RotateTransform(180);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(400.0f, 500.0f);
|
|
g->RotateTransform(180);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
|
|
g->ResetTransform();
|
|
|
|
//ID
|
|
g->TranslateTransform(400.0f, 500.0f);
|
|
g->RotateTransform(0);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(400.0f, 500.0f);
|
|
g->RotateTransform(0);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
|
|
g->ResetTransform();
|
|
|
|
//Rot270FlipX
|
|
g->TranslateTransform(600.0f, 500.0f);
|
|
g->ScaleTransform(-1.0f, 1.0f);
|
|
g->RotateTransform(270);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(600.0f, 500.0f);
|
|
g->ScaleTransform(-1.0f, 1.0f);
|
|
g->RotateTransform(270);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
|
|
g->ResetTransform();
|
|
|
|
//Rot270
|
|
g->TranslateTransform(600.0f, 500.0f);
|
|
g->RotateTransform(270);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(600.0f, 500.0f);
|
|
g->RotateTransform(270);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
|
|
g->ResetTransform();
|
|
|
|
//Rot90FlipX
|
|
g->TranslateTransform(600.0f, 500.0f);
|
|
g->ScaleTransform(-1.0f, 1.0f);
|
|
g->RotateTransform(90);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(600.0f, 500.0f);
|
|
g->ScaleTransform(-1.0f, 1.0f);
|
|
g->RotateTransform(90);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
|
|
g->ResetTransform();
|
|
|
|
//Rot90
|
|
g->TranslateTransform(600.0f, 500.0f);
|
|
g->RotateTransform(90);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(600.0f, 500.0f);
|
|
g->RotateTransform(90);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
|
|
g->ResetTransform();
|
|
|
|
// FlipX
|
|
g->TranslateTransform(600.0f, 300.0f);
|
|
g->ScaleTransform(-1.0f, 1.0f);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(600.0f, 300.0f);
|
|
g->ScaleTransform(-1.0f, 1.0f);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
|
|
g->ResetTransform();
|
|
|
|
// FlipY
|
|
g->TranslateTransform(600.0f, 300.0f);
|
|
g->ScaleTransform(1.0f, -1.0f);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
|
|
g->ResetTransform();
|
|
|
|
g->TranslateTransform(600.0f, 300.0f);
|
|
g->ScaleTransform(1.0f, -1.0f);
|
|
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
|
|
g->ResetTransform();
|
|
|
|
delete image;
|
|
}
|
|
|
|
|
|
|
|
|
|
VOID DrawCachedBitmap(Graphics *g)
|
|
{
|
|
Bitmap *image = new Bitmap(FileName);
|
|
|
|
Bitmap *bmp = new Bitmap(100, 100, PixelFormat32bppPARGB);
|
|
Graphics *gfx = new Graphics(bmp);
|
|
gfx->DrawImage(image, Rect(0,0,100,100), 0,0,100,100, UnitPixel);
|
|
gfx->SetCompositingMode(CompositingModeSourceCopy);
|
|
SolidBrush brush(Color(0x7f0000ff));
|
|
gfx->FillEllipse(&brush, 0, 0, 100, 100);
|
|
brush.SetColor(Color(0x00000000));
|
|
gfx->FillEllipse(&brush, 25, 25, 50, 50);
|
|
|
|
delete image;
|
|
delete gfx;
|
|
|
|
CachedBitmap *cb = new CachedBitmap(bmp, g);
|
|
|
|
int x;
|
|
for(int i=0; i<=40; i++)
|
|
{
|
|
x = i-20;
|
|
g->DrawCachedBitmap(cb, x*x, i*10);
|
|
}
|
|
|
|
delete cb;
|
|
delete bmp;
|
|
}
|
|
|
|
|
|
// Slightly rotated stretch.
|
|
VOID DrawStretchRotation(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
|
|
PointF dst[4];
|
|
dst[0].X = 20;
|
|
dst[0].Y = 0;
|
|
dst[1].X = 900;
|
|
dst[1].Y = 20;
|
|
dst[2].X = 0;
|
|
dst[2].Y = 700;
|
|
|
|
g->DrawImage(image, dst, 3);
|
|
delete image;
|
|
}
|
|
|
|
// Slightly rotated stretch.
|
|
VOID DrawShrinkRotation(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
|
|
PointF dst[4];
|
|
|
|
dst[0].X = 14.1521f;
|
|
dst[0].Y = 11.0205f;
|
|
dst[1].X = 25.4597f;
|
|
dst[1].Y = 10.5023f;
|
|
dst[2].X = 14.5403f;
|
|
dst[2].Y = 19.4908f;
|
|
|
|
|
|
g->DrawImage(image, dst, 3);
|
|
delete image;
|
|
}
|
|
|
|
// Rotated stretch with source cropping.
|
|
VOID DrawCropRotation(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
|
|
PointF dst[4];
|
|
dst[0].X = 20;
|
|
dst[0].Y = 0;
|
|
dst[1].X = 180;
|
|
dst[1].Y = 20;
|
|
dst[2].X = 0;
|
|
dst[2].Y = 140;
|
|
|
|
g->DrawImage(image, dst, 3, 0, 0, 488, 400, UnitPixel);
|
|
delete image;
|
|
}
|
|
|
|
// Draw multiple copybits with different source cropping and
|
|
// destination positions.
|
|
// Little squares are drawn in reverse order from their source position and
|
|
// only alternate squares from a checkerboard pattern are drawn.
|
|
// Note outcropping can occur along the bottom and right edge of the source -
|
|
// which would be the top and left row of squares in the output.
|
|
VOID DrawCopyCrop(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
const INT xs = 10;
|
|
const INT ys = 6;
|
|
const INT step = 50;
|
|
Rect s(0,0,step,step);
|
|
for(int i=0; i<xs; i++) for(int j=0; j<ys; j++) {
|
|
if(((i+j) & 0x1)==0x1) {
|
|
s.X = i*step-15;
|
|
s.Y = j*step-15;
|
|
g->DrawImage(image, s,
|
|
(xs-i-1)*step, (ys-j-1)*step, step, step, UnitPixel);
|
|
}
|
|
}
|
|
|
|
delete image;
|
|
}
|
|
|
|
|
|
// Pixel centering test. This test should show
|
|
// the correct pixel centering. The top left should be green and the bottom
|
|
// and right should be blending in the blend color
|
|
VOID DrawPixelCenter(Graphics *g)
|
|
{
|
|
WCHAR *filename = L"../data/3x3.bmp";
|
|
Image *image = new Bitmap(filename);
|
|
|
|
|
|
Color black(0xff,0,0,0);
|
|
Pen linepen(black, 1);
|
|
|
|
RectF r(100.0f, 100.0f, 300.0f, 300.0f);
|
|
|
|
for(int i=0; i<6; i++) {
|
|
g->DrawLine(&linepen, 100*i, 0, 100*i, 600);
|
|
g->DrawLine(&linepen, 0, 100*i, 600, 100*i);
|
|
}
|
|
|
|
g->DrawImage(image, r, 0.0f, 0.0f, 3.0f, 3.0f, UnitPixel, Img);
|
|
delete image;
|
|
}
|
|
|
|
// Draw with palette modification.
|
|
|
|
VOID DrawPalette(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName, uICM==IDM_ICM);
|
|
|
|
Unit u;
|
|
RectF r;
|
|
image->GetBounds(&r, &u);
|
|
RectF s = r;
|
|
s.X = 21;
|
|
s.Y = 30;
|
|
|
|
ColorPalette *palette = NULL;
|
|
INT size;
|
|
Status status;
|
|
|
|
// Whack the first entry in the palette.
|
|
|
|
size = image->GetPaletteSize();
|
|
if(size > 0) {
|
|
palette = (ColorPalette *)malloc(size);
|
|
if(palette) {
|
|
status = image->GetPalette(palette, size);
|
|
if(status == Ok) {
|
|
palette->Entries[0] = 0x7fff0000;
|
|
status = image->SetPalette(palette);
|
|
}
|
|
}
|
|
}
|
|
|
|
g->DrawImage(image, r, r.X, r.Y, r.Width, r.Height, UnitPixel);
|
|
|
|
free(palette);
|
|
delete image;
|
|
}
|
|
|
|
|
|
// Specify source rectangle crop area not at the origin.
|
|
// Draw off the top of the window (negative destination).
|
|
VOID DrawICM(Graphics *g)
|
|
{
|
|
Bitmap *image = new Bitmap(FileName, uICM==IDM_ICM);
|
|
|
|
// Our ICM profile is hacked to flip the red and blue color channels
|
|
// Apply a recolor matrix to flip them back so that if something breaks
|
|
// ICM, the picture will look blue instead of the familiar colors.
|
|
ColorMatrix flipRedBlue =
|
|
{0, 1, 0, 0, 0,
|
|
0, 0, 1, 0, 0,
|
|
1, 0, 0, 0, 0,
|
|
0, 0, 0, 1, 0,
|
|
0, 0, 0, 0, 1};
|
|
/*img->SetColorMatrix(&flipRedBlue);*/
|
|
Unit u;
|
|
RectF r;
|
|
image->GetBounds(&r, &u);
|
|
RectF s = r;
|
|
s.X = 21;
|
|
s.Y = 30;
|
|
g->DrawImage(image, r, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
|
|
|
|
/* CachedBitmap *cb = new CachedBitmap(image, g);
|
|
g->DrawCachedBitmap(cb, 100, 100);
|
|
delete cb;*/
|
|
delete image;
|
|
}
|
|
|
|
// Draw a non rotated outcropped image.
|
|
VOID DrawOutCrop(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
|
|
g->DrawImage(image, Rect(0,0,500,500), -500,-500,1500,1500, UnitPixel, Img);
|
|
delete image;
|
|
}
|
|
|
|
// Do a non-trivial crop with a world transform applied.
|
|
VOID DrawCropWT(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
|
|
g->TranslateTransform(0, 100.0f);
|
|
g->DrawImage(image, 0, 0, 100,100,600,400, UnitPixel);
|
|
g->ResetTransform();
|
|
delete image;
|
|
}
|
|
|
|
// Non-trivial cropping combined with a horizontal flip and a world transform
|
|
VOID DrawHFlip(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
|
|
PointF dst[4];
|
|
dst[0].X = 400;
|
|
dst[0].Y = 200;
|
|
dst[1].X = 0;
|
|
dst[1].Y = 200;
|
|
dst[2].X = 400;
|
|
dst[2].Y = 500;
|
|
|
|
g->TranslateTransform(0, 100.0f);
|
|
g->DrawImage(image, dst, 3, 100, 100, 600, 400, UnitPixel);
|
|
g->ResetTransform();
|
|
|
|
delete image;
|
|
}
|
|
|
|
// Non-trivial cropping combined with a vertical flip and a world transform
|
|
VOID DrawVFlip(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
|
|
PointF dst[4];
|
|
dst[0].X = 0;
|
|
dst[0].Y = 500;
|
|
dst[1].X = 400;
|
|
dst[1].Y = 500;
|
|
dst[2].X = 0;
|
|
dst[2].Y = 200;
|
|
|
|
g->TranslateTransform(0, 100.0f);
|
|
g->DrawImage(image, dst, 3, 100, 100, 600, 400, UnitPixel);
|
|
g->ResetTransform();
|
|
|
|
delete image;
|
|
}
|
|
|
|
|
|
// Draw stretched image.
|
|
VOID DrawStretchS(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
|
|
RectF r;
|
|
|
|
for(int i=6; i<15; i++)
|
|
{
|
|
g->DrawImage(image, (i+1)*i*10/2-200, 300, i*10, i*10);
|
|
}
|
|
|
|
g->DrawImage(image, 0, 0, 470, 200);
|
|
g->DrawImage(image, 500, 100, 300, 300);
|
|
g->DrawImage(image, 100, 500, 400, 300);
|
|
g->DrawImage(image, 500, 500, 300, 80);
|
|
delete image;
|
|
}
|
|
|
|
// Draw stretched image.
|
|
VOID DrawStretchB(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
g->DrawImage(image, 100, 100, 603, 603);
|
|
delete image;
|
|
}
|
|
|
|
|
|
// Draw a rotated outcropped image.
|
|
VOID DrawOutCropR(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
|
|
PointF dst[4];
|
|
dst[0].X = 20;
|
|
dst[0].Y = 0;
|
|
dst[1].X = 180;
|
|
dst[1].Y = 20;
|
|
dst[2].X = 0;
|
|
dst[2].Y = 140;
|
|
|
|
g->DrawImage(image, dst, 3, -50,-50,600,400, UnitPixel);
|
|
delete image;
|
|
}
|
|
|
|
// Simple no rotation, origin based source clip.
|
|
VOID DrawTest2(Graphics *g)
|
|
{
|
|
Image *image = new Bitmap(FileName);
|
|
g->DrawImage(image, 0, 0, 0, 0,100,100, UnitPixel);
|
|
delete image;
|
|
}
|
|
|
|
/***************************************************************************\
|
|
* DoTest
|
|
*
|
|
* Sets up the graphics according to the selected parameters on the menu
|
|
* and then invokes the appropriate test routine from above.
|
|
\***************************************************************************/
|
|
|
|
VOID
|
|
DoTest(
|
|
HWND hwnd
|
|
)
|
|
{
|
|
// Create a Graphics in the window.
|
|
// Graphics *g = Graphics::GetFromHwnd(hwnd, uICMBack==IDM_ICM_BACK);
|
|
|
|
HDC hdc = GetDC(hwnd);
|
|
SetICMMode(hdc, (uICMBack==IDM_ICM_BACK)?ICM_ON:ICM_OFF);
|
|
Graphics *g = new Graphics(hdc);
|
|
|
|
g->SetSmoothingMode(SmoothingModeNone);
|
|
|
|
// Choose the resampling mode.
|
|
switch(uResample) {
|
|
case IDM_BILINEAR:
|
|
g->SetInterpolationMode(InterpolationModeBilinear);
|
|
break;
|
|
case IDM_BICUBIC:
|
|
g->SetInterpolationMode(InterpolationModeBicubic);
|
|
break;
|
|
case IDM_NEARESTNEIGHBOR:
|
|
g->SetInterpolationMode(InterpolationModeNearestNeighbor);
|
|
break;
|
|
case IDM_HIGHBILINEAR:
|
|
g->SetInterpolationMode(InterpolationModeHighQualityBilinear);
|
|
break;
|
|
case IDM_HIGHBICUBIC:
|
|
g->SetInterpolationMode(InterpolationModeHighQualityBicubic);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
g->SetPixelOffsetMode(bPixelMode?PixelOffsetModeHalf:PixelOffsetModeNone);
|
|
|
|
Img = new ImageAttributes();
|
|
switch(uWrapMode)
|
|
{
|
|
case IDM_WRAPMODETILE:
|
|
Img->SetWrapMode(WrapModeTile, Color(0), FALSE);
|
|
break;
|
|
case IDM_WRAPMODEFLIPX:
|
|
Img->SetWrapMode(WrapModeTileFlipX, Color(0), FALSE);
|
|
break;
|
|
case IDM_WRAPMODEFLIPY:
|
|
Img->SetWrapMode(WrapModeTileFlipY, Color(0), FALSE);
|
|
break;
|
|
case IDM_WRAPMODEFLIPXY:
|
|
Img->SetWrapMode(WrapModeTileFlipXY, Color(0), FALSE);
|
|
break;
|
|
case IDM_WRAPMODECLAMP0:
|
|
Img->SetWrapMode(WrapModeClamp, Color(0), FALSE);
|
|
break;
|
|
case IDM_WRAPMODECLAMPFF:
|
|
Img->SetWrapMode(WrapModeClamp, Color(0xffff0000), FALSE);
|
|
break;
|
|
}
|
|
// Choose the test to run
|
|
switch(uCategory) {
|
|
case IDM_ALL:
|
|
DrawSimple(g);
|
|
DrawStretchRotation(g);
|
|
DrawShrinkRotation(g);
|
|
DrawCropRotation(g);
|
|
DrawCopyCrop(g);
|
|
DrawICM(g);
|
|
DrawTest2(g);
|
|
DrawOutCrop(g);
|
|
DrawOutCropR(g);
|
|
DrawCropWT(g);
|
|
DrawHFlip(g);
|
|
DrawVFlip(g);
|
|
DrawStretchB(g);
|
|
DrawCachedBitmap(g);
|
|
DrawStretchS(g);
|
|
DrawPalette(g);
|
|
DrawPixelCenter(g);
|
|
DrawSpecialRotate(g);
|
|
break;
|
|
|
|
case IDM_OUTCROPR:
|
|
DrawOutCropR(g);
|
|
break;
|
|
case IDM_OUTCROP:
|
|
DrawOutCrop(g);
|
|
break;
|
|
case IDM_SIMPLE:
|
|
DrawSimple(g);
|
|
break;
|
|
case IDM_STRETCHROTATION:
|
|
DrawStretchRotation(g);
|
|
break;
|
|
case IDM_SHRINKROTATION:
|
|
DrawShrinkRotation(g);
|
|
break;
|
|
case IDM_CROPROTATION: //who says programmers don't do real work??
|
|
DrawCropRotation(g);
|
|
break;
|
|
case IDM_PIXELCENTER:
|
|
DrawPixelCenter(g);
|
|
break;
|
|
case IDM_COPYCROP:
|
|
DrawCopyCrop(g);
|
|
break;
|
|
case IDM_DRAWPALETTE:
|
|
DrawPalette(g);
|
|
break;
|
|
case IDM_DRAWICM:
|
|
DrawICM(g);
|
|
break;
|
|
case IDM_DRAWIMAGE2:
|
|
DrawTest2(g);
|
|
break;
|
|
case IDM_STRETCHB:
|
|
DrawStretchB(g);
|
|
break;
|
|
case IDM_STRETCHS:
|
|
DrawStretchS(g);
|
|
break;
|
|
case IDM_CACHEDBITMAP:
|
|
DrawCachedBitmap(g);
|
|
break;
|
|
case IDM_CROPWT:
|
|
DrawCropWT(g);
|
|
break;
|
|
case IDM_HFLIP:
|
|
DrawHFlip(g);
|
|
break;
|
|
case IDM_VFLIP:
|
|
DrawVFlip(g);
|
|
break;
|
|
case IDM_SPECIALROTATE:
|
|
DrawSpecialRotate(g);
|
|
break;
|
|
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
delete Img;
|
|
Img = NULL;
|
|
delete g;
|
|
ReleaseDC(hwnd, hdc);
|
|
}
|
|
|
|
|